tools/mangen/src/main/java/org/apache/felix/tool/mangen/RuleHandler.java

/*
 *   Copyright 2005 The Apache Software Foundation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 */
package org.apache.felix.tool.mangen;

import java.io.IOException;
import java.io.PrintStream;

import java.util.List;
import java.util.Iterator;
import java.util.Properties;
import java.util.StringTokenizer;

import java.util.jar.Attributes;

/**
 *
 * @version $Revision: 31 $
 * @author <A HREF="mailto:robw@ascert.com">Rob Walker</A> 
 */ 
public class RuleHandler
        extends GenericHandler
{
    //////////////////////////////////////////////////
    // STATIC VARIABLES
    //////////////////////////////////////////////////

    /** Classname prefix for basic rule classes */ 
    public static final String  RULE_PACKAGE = "org.apache.felix.tool.mangen.rule";
    /** Rule set property **/
    public static final String  RULESET_KEY = "mangen.rulesets";
    /** Default rule property prefix **/
    public static final String  RULE_KEY = "mangen-rule-";
    
    //////////////////////////////////////////////////
    // STATIC PUBLIC METHODS
    //////////////////////////////////////////////////
    
    /**
     * Initialise a set of rules to be run, based on the value of the
     * mangen.rule property if present, or the default rule key if not.
     */
    public static RuleHandler[] initRuleSets()
    {
        String rulesetStr = PropertyManager.getProperty(RULESET_KEY, RULE_KEY);
        
        StringTokenizer tok = new StringTokenizer(rulesetStr, ",");
        RuleHandler[] handlers = new RuleHandler[tok.countTokens()];
        for (int ix = 0; ix < handlers.length; ix++)
        {
            handlers[ix] = new RuleHandler(tok.nextToken().trim());
        }
        
        return handlers;
    }
     
    /**
     * Run each specified ruleset.
     */
    public static void runRuleSets(RuleHandler[] handlers, List jarList)
    {
        for (int ix = 0; ix < handlers.length; ix++)
        {
            handlers[ix].executeRules(jarList);
        }
    }
    
    /**
     *
     * Run reports for each specified ruleset.
     */
    public static void runRuleSetReports(RuleHandler[] handlers, PrintStream rpt, boolean header)
            throws IOException
    {
        for (int ix = 0; ix < handlers.length; ix++)
        {
            handlers[ix].runReports(rpt, header);
        }
    }
    
    //////////////////////////////////////////////////
    // INSTANCE VARIABLES
    //////////////////////////////////////////////////
    
    public boolean  isGlobalRule;
    
    //////////////////////////////////////////////////
    // CONSTRUCTORS
    //////////////////////////////////////////////////
    
    /**
     * Initialise a rule handler usng the default RULE_KEY. 
     */
    public RuleHandler()
    {
        this(RULE_KEY);
    }

    /**
     * Initialise the set of rules based on the RULE_KEY.<n> properties defined.
     * Each rule is either a full classname implementing the Rule interface, or a 
     * classname in RULE_PACKAGE. The actual work to process the properties and
     * create the rule objects is done by our parent class, GenericHandler. 
     */
    public RuleHandler(String key)
    {
        super(key, Rule.class, RULE_PACKAGE);
        // for now, safe to assume Property set based rules are global
        this.isGlobalRule = true;
    }

    /**
     * Initialise a rule handler based on a set of Manifest attributes.
     */
    public RuleHandler(Attributes atts)
    {
        super(atts, RULE_KEY, Rule.class, RULE_PACKAGE);
        // for now, safe to assume Attribute set based rules are local
        this.isGlobalRule = false;
    }
    
    //////////////////////////////////////////////////
    // ACCESSOR METHODS
    //////////////////////////////////////////////////

    //////////////////////////////////////////////////
    // PUBLIC INSTANCE METHODS
    //////////////////////////////////////////////////
    
    /**
     * Retrieve each defined rule and apply it. At present we take the approach that 
     * each rule will be applied in it's entirety before proceeding to the next rule. 
     * For simple rules, this will result in multiple passes over 
     * the jarList set for simowhich obviously incurs a processing overhead, but it is felt 
     * that this simpler approach will have fewer nasty side-effects for more complex 
     * rules that span multiple bundle jars.
     */
    public void executeRules(List jarList)
    {
        for(Iterator i = handlerList.iterator(); i.hasNext(); )
        {
            Rule rule = (Rule) i.next();
            
            if (isGlobalRule && !rule.isUsableGlobally())
            {
                throw new IllegalArgumentException("rule cannot be used globally: " 
                        + rule.getClass().getName());
            }
            
            if (!isGlobalRule && !rule.isUsableLocally())
            {
                throw new IllegalArgumentException("rule cannot be used locally: " 
                        + rule.getClass().getName());
            }
            
            rule.execute(jarList);
        }
    }
        
    /**
     * Run report for each rule. Bit of a hack for now! 
     */
    public void runReports(PrintStream rpt, boolean header)
            throws IOException
    {
        for(Iterator i = handlerList.iterator(); i.hasNext(); )
        {
            Rule rule = (Rule) i.next();
            
            if (header)
            {
                rpt.println("");
                rpt.println("============================================================");
                rpt.println("Rule:  " + rule.getClass().getName());        
                rpt.println("============================================================");
                rpt.println("");
            }
            else
            {
                rpt.println("Rule:  " + rule.getClass().getName());        
            }

            rule.report(rpt);
        }
    }
    
    //////////////////////////////////////////////////
    // INTERFACE METHODS
    //////////////////////////////////////////////////

    //////////////////////////////////////////////////
    // PROTECTED INSTANCE METHODS
    //////////////////////////////////////////////////
    
    //////////////////////////////////////////////////
    // PRIVATE INSTANCE METHODS
    //////////////////////////////////////////////////
    
    //////////////////////////////////////////////////
    // STATIC INNER CLASSES
    //////////////////////////////////////////////////

    //////////////////////////////////////////////////
    // NON-STATIC INNER CLASSES
    //////////////////////////////////////////////////
    
}