FlexPMD/flex-pmd-java/flex-pmd-core/src/main/java/com/adobe/ac/pmd/FlexPmdViolations.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 com.adobe.ac.pmd;

import java.io.File;
import java.io.Serializable;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;

import net.sourceforge.pmd.PMDException;
import net.sourceforge.pmd.Rule;
import net.sourceforge.pmd.RuleReference;
import net.sourceforge.pmd.RuleSet;

import com.adobe.ac.pmd.files.FileSetUtils;
import com.adobe.ac.pmd.files.IFlexFile;
import com.adobe.ac.pmd.files.impl.FileUtils;
import com.adobe.ac.pmd.nodes.IPackage;
import com.adobe.ac.pmd.rules.core.IFlexAstRule;
import com.adobe.ac.pmd.rules.core.IFlexRule;
import com.adobe.ac.utils.StackTraceUtils;

public class FlexPmdViolations implements Serializable
{
   private static final Logger                            LOGGER;

   /**
    * 
    */
   private static final long                              serialVersionUID = -3683680443330143504L;

   static
   {
      LOGGER = Logger.getLogger( FlexPmdViolations.class.getName() );
   }

   private Map< String, IPackage >                        asts;
   private Map< String, IFlexFile >                       files;
   private boolean                                        hasBeenComputed;
   private final Map< String, IFlexRule >                 rules;
   private final Map< IFlexRule, Long >                   ruleSpeeds;
   private final Map< IFlexFile, List< IFlexViolation > > violations;

   public FlexPmdViolations()
   {
      violations = new LinkedHashMap< IFlexFile, List< IFlexViolation > >();
      rules = new LinkedHashMap< String, IFlexRule >();
      ruleSpeeds = new LinkedHashMap< IFlexRule, Long >();
      hasBeenComputed = false;
   }

   public final void computeViolations( final File source,
                                        final List< File > sourceList,
                                        final RuleSet ruleSet,
                                        final String packageToExclude ) throws PMDException
   {
      hasBeenComputed = true;

      if ( ruleSet != null )
      {
         computeRules( ruleSet );
         computeFiles( source,
                       sourceList,
                       packageToExclude,
                       ruleSet.getExcludePatterns() );
         computeAsts();
         processRules();
         sortViolations();
      }
   }

   public final Map< IFlexFile, List< IFlexViolation >> getViolations()
   {
      return violations;
   }

   public final boolean hasViolationsBeenComputed()
   {
      return hasBeenComputed;
   }

   private void computeAsts() throws PMDException
   {
      LOGGER.info( "computing Asts" );

      final long startTime = System.currentTimeMillis();
      asts = FileSetUtils.computeAsts( files );

      LOGGER.info( "computed Asts in "
            + ( System.currentTimeMillis() - startTime ) + " ms" );
   }

   private void computeFiles( final File source,
                              final List< File > sourceList,
                              final String packageToExclude,
                              final List< String > excludePatterns ) throws PMDException
   {
      LOGGER.info( "computing FilesList" );

      final long startTime = System.currentTimeMillis();

      files = FileUtils.computeFilesList( source,
                                          sourceList,
                                          packageToExclude,
                                          excludePatterns );
      LOGGER.info( "computed FilesList in "
            + ( System.currentTimeMillis() - startTime ) + " ms" );
   }

   private void computeRules( final RuleSet ruleSet )
   {
      LOGGER.info( "computing RulesList" );

      final long startTime = System.currentTimeMillis();
      Set< String > excludes = new HashSet< String >( ruleSet.getExcludePatterns() );

      for ( Rule rule : ruleSet.getRules() )
      {
         while ( rule instanceof RuleReference )
         {
            excludes = ( ( RuleReference ) rule ).getRuleSetReference().getExcludes();
            rule = ( ( RuleReference ) rule ).getRule();
         }
         final IFlexRule flexRule = ( IFlexRule ) rule;

         if ( excludes != null
               && !excludes.isEmpty() )
         {
            flexRule.setExcludes( excludes );
         }
         rules.put( flexRule.getRuleName(),
                    flexRule );
      }

      LOGGER.info( "computed RulesList in "
            + ( System.currentTimeMillis() - startTime ) + " ms" );
   }

   private void processFile( final IFlexRule currentRule,
                             final IFlexFile currentFile )
   {
      try
      {
         final String fullyQualifiedName = currentFile.getFullyQualifiedName();
         final IPackage ast = currentRule instanceof IFlexAstRule ? asts.get( fullyQualifiedName )
                                                                 : null;
         final List< IFlexViolation > foundViolations = currentRule.processFile( currentFile,
                                                                                 ast,
                                                                                 files );

         if ( !foundViolations.isEmpty() )
         {
            if ( violations.containsKey( currentFile ) )
            {
               violations.get( currentFile ).addAll( foundViolations );
            }
            else
            {
               violations.put( currentFile,
                               foundViolations );
            }
         }
      }
      catch ( final Exception e )
      {
         LOGGER.warning( StackTraceUtils.print( currentFile.getFullyQualifiedName(),
                                                e ) );
      }
   }

   private void processRule( final IFlexRule currentRule )
   {
      LOGGER.fine( "Processing "
            + currentRule.getRuleName() + "..." );

      for ( final Entry< String, IFlexFile > currentFileEntry : files.entrySet() )
      {
         processFile( currentRule,
                      currentFileEntry.getValue() );
      }
   }

   private void processRule( final String currentRuleName,
                             final IFlexRule currentRule )
   {
      final long startTime = System.currentTimeMillis();

      processRule( currentRule );
      final long ellapsedTime = System.currentTimeMillis()
            - startTime;

      if ( LOGGER.isLoggable( Level.FINE ) )
      {
         LOGGER.fine( "rule "
               + currentRuleName + " computed in " + ellapsedTime + "ms" );
      }
      if ( LOGGER.isLoggable( Level.FINER ) )
      {
         ruleSpeeds.put( currentRule,
                         ellapsedTime );
      }
   }

   private void processRules()
   {
      for ( final Entry< String, IFlexRule > currentRuleEntry : rules.entrySet() )
      {
         processRule( currentRuleEntry.getKey(),
                      currentRuleEntry.getValue() );
      }
   }

   private void sortViolations()
   {
      for ( final Entry< String, IFlexFile > entry : files.entrySet() )
      {
         if ( violations.containsKey( entry.getValue() ) )
         {
            Collections.sort( violations.get( entry.getValue() ) );
         }
      }
   }
}