excellent 1.5.4

data/lib/simplabs/excellent/parsing/module_context.rb

@@ -0,0 +1,29 @@
+require 'simplabs/excellent/parsing/scopeable'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ModuleContext < SexpContext #:nodoc:
+
+        include Scopeable
+
+        attr_reader :methods
+        attr_reader :line_count
+
+        def initialize(exp, parent)
+          super
+          @name, @full_name = get_names
+          @methods          = []
+          @line_count       = count_lines
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/parser.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'ruby_parser'
+require 'facets'
+require 'erb'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class Parser #:nodoc:
+
+        def parse(content, filename)
+          return silent_parse(content, filename)
+        rescue Exception
+          #continue on errors
+        end
+
+        private
+
+          def silent_parse(content, filename)
+            @parser ||= RubyParser.new
+            content = ::ERB.new(content, nil, '-').src if filename =~ /\.erb$/
+            sexp = @parser.parse(content, filename)
+            sexp
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/resbody_context.rb

@@ -0,0 +1,39 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class ResbodyContext < SexpContext #:nodoc:
+
+        STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :call, :str, :lit, :hash, :false, :true, :nil]
+
+        def initialize(exp, parent)
+          super
+          @contains_statements = contains_statements?
+        end
+
+        def has_statements?
+          @contains_statements
+        end
+
+        private
+
+          def contains_statements?(exp = @exp)
+            return true if STATEMENT_NODES.include?(exp.node_type)
+            return true if assigning_other_than_exception_to_local_variable?(exp)
+            return true if (exp[1][0] == :array && exp[2][0] == :array rescue false)
+            return true if exp.children.any? { |child| contains_statements?(child) }
+          end
+
+          def assigning_other_than_exception_to_local_variable?(exp)
+            exp.node_type == :lasgn && exp[2].to_a != [:gvar, :$!]
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/scopeable.rb

@@ -0,0 +1,34 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      module Scopeable #:nodoc:
+
+        private
+
+          def get_names
+            if @exp[1].is_a?(Sexp)
+              name = @exp[1].pop.to_s.strip
+              [name, "#{extract_prefixes}#{name}"]
+            else
+              [@exp[1].to_s, nil]
+            end
+          end
+
+          def extract_prefixes(exp = @exp[1].deep_clone, prefix = '')
+            prefix = "#{exp.pop}::#{prefix}" if exp.last.is_a?(Symbol)
+            if exp.last.is_a?(Sexp)
+              prefix = extract_prefixes(exp.last, prefix)
+            end
+            prefix
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/sexp_context.rb

@@ -0,0 +1,125 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      # For most nodes the Excellent processor processes, it will create the corresponding context that contains meta information of the processed
+      # node. This is the base class for all these contexts.
+      #
+      # === Example
+      #
+      # For a method like the following:
+      #
+      #  module Shop
+      #    class Basket
+      #      def buy_product(product)
+      #        other_method
+      #      end
+      #    end
+      #  end
+      #
+      # four context will be generated:
+      #
+      #  ModuleContext
+      #    name:      'Shop'
+      #    full_name: 'Shop'
+      #    parent:    nil
+      #  ClassContext
+      #    name:      'Basket'
+      #    full_name: 'Shop::Basket'
+      #    parent:    ModuleContext
+      #  MethodContext
+      #    name:       'buy_product'
+      #    full_name:  'Shop::Basket#buy_product'
+      #    parent:     ClassContext
+      #    parameters: [:product]
+      #  CallContext (other_method)
+      #    name:      nil
+      #    full_name: nil
+      #    parent:    MethodContext
+      #    method:    :other_method
+      #
+      # === Custom Processors
+      #
+      # The Excelent processor will also invoke custom processor methods on the contexts if they are defined. To process call nodes in the context for
+      # example, you could simply define a +process_call+ method in the context that will be invoked with each call Sexp (S-expression, see
+      # http://en.wikipedia.org/wiki/S_expression) that is processed by the Excellent processor.
+      #
+      #  def process_call(exp)
+      #    super
+      #    do_something()
+      #  end
+      #
+      # Custom <b>processor methods must always call +super+</b> since there might be several processor methods defined in several modules that are in the
+      # included in the context and all of these have to be invoked. Also <b>processor methods must not modify the passed Sexp</b> since other processor
+      # methods also need the complete Sexp. If you have to modify the Sexp in a processor method, deep clone it:
+      #
+      #  exp = exp.deep_clone
+      #
+      class SexpContext
+
+        # The parent context
+        attr_reader :parent
+
+        # The name of the code fragment the context is bound to (e.g. 'User' for a +class+)
+        attr_reader :name
+
+        # The file the code fragment was read from
+        attr_reader :file
+
+        # The line the code fragment is located at
+        attr_reader :line
+
+        # Initializes a SexpContext.
+        #
+        # Always call +super+ in inherited custom contexts!
+        #
+        # === Parameters
+        #
+        # * <tt>exp</tt> - The Sexp (S-expression, see http://en.wikipedia.org/wiki/S_expression) the context is created for.
+        # * <tt>parent</tt> - The parent context.
+        def initialize(exp, parent = nil)
+          @exp        = exp
+          @parent     = parent
+          @file       = exp.file
+          @line       = exp.line
+          @full_name  = nil
+        end
+
+        # Gets the full name of the code fragment the context is bound to. For a method +name+ might be '+add_product+' while +full_name+ might be
+        # 'Basket#add_product'.
+        def full_name
+          return @full_name if @full_name
+          return @name if @parent.blank?
+          "#{@parent.full_name}::#{@name}"
+        end
+
+        def method_missing(method, *args) #:nodoc:
+          return if method.to_s =~ /^process_[a-zA-Z0-9_]+$/
+          super
+        end
+
+        private
+
+          def count_lines(node = @exp, line_numbers = [])
+            count = 0
+            line_numbers << node.line
+            node.children.each { |child| count += count_lines(child, line_numbers) }
+            line_numbers.uniq.length
+          end
+
+          def has_assignment?(exp = @exp[1])
+            found_assignment = false
+            found_assignment = found_assignment || exp.node_type == :lasgn
+            exp.children.each { |child| found_assignment = found_assignment || has_assignment?(child) }
+            found_assignment
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/singleton_method_context.rb

@@ -0,0 +1,55 @@
+require 'simplabs/excellent/parsing/cyclomatic_complexity_measure'
+require 'simplabs/excellent/parsing/abc_measure'
+
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class SingletonMethodContext < MethodContext #:nodoc:
+
+        include CyclomaticComplexityMeasure
+        include AbcMeasure
+
+        attr_reader :parameters
+        attr_reader :calls
+
+        def initialize(exp, parent)
+          super
+          @name = exp[2].to_s
+          @full_name = get_full_name
+          @calls = Hash.new(0)
+        end
+
+        def full_name
+          return @full_name if @full_name
+          parent = @parent.is_a?(BlockContext) ? @parent.parent : @parent
+          return @name if parent.blank?
+          "#{parent.full_name}.#{@name}"
+        end
+
+        def record_call_to(exp)
+          @calls[exp] += 1
+        end
+
+        private
+
+          def get_full_name
+            if @exp[1].is_a?(Sexp)
+              if @exp[1].node_type == :call
+                return "#{@exp[1][2]}.#{@name}"
+              elsif @exp[1].node_type == :const
+                return "#{@exp[1][1]}.#{@name}"
+              end
+            end
+            nil
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/until_context.rb

@@ -0,0 +1,24 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class UntilContext < SexpContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @contains_assignment = has_assignment?
+        end
+
+        def tests_assignment?
+          @contains_assignment
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/parsing/while_context.rb

@@ -0,0 +1,24 @@
+module Simplabs
+
+  module Excellent
+
+    module Parsing
+
+      class WhileContext < SexpContext #:nodoc:
+
+        def initialize(exp, parent)
+          super
+          @contains_assignment = has_assignment?
+        end
+
+        def tests_assignment?
+          @contains_assignment
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/rake.rb

@@ -0,0 +1 @@
+require 'simplabs/excellent/rake/excellent_task'

data/lib/simplabs/excellent/rake/excellent_task.rb

@@ -0,0 +1,61 @@
+require 'rake'
+require 'simplabs/excellent'
+
+module Simplabs
+
+  module Excellent
+
+    module Rake #:nodoc:
+
+      # A special rake task for Excellent.
+      class ExcellentTask < ::Rake::TaskLib
+
+        # The Name of the task, defaults to <tt>:excellent</tt>.
+        attr_accessor :name
+
+        # Specifies whether to output HTML; defaults to false. Assign a file name to output HTML to that file.
+        attr_accessor :html
+
+        # The paths to process (specify file names or directories; will recursively process all ruby files if a directory is given).
+        attr_accessor :paths
+
+        # Initializes an ExcellentTask with the name +name+.
+        def initialize(name = :excellent)
+          @name  = name
+          @paths = nil || []
+          @html  = false
+          yield self if block_given?
+          define
+        end
+
+        def paths=(paths) #:nodoc:
+          if paths.is_a?(String)
+            @paths = [paths] 
+          elsif paths.is_a?(Array)
+            @paths = paths
+          else
+            raise ArgumentError.new('Specify paths either as a String or as an Array!')
+          end
+        end
+
+        private
+
+          def define
+            unless ::Rake.application.last_comment
+              desc 'Analyse the code with Excellent'
+            end
+            task name do
+              paths = @paths.join(' ')
+              format = @html ? " html:#{@html}" : ''
+              system("excellent#{format} #{paths}")
+              $stdout.puts("\nWrote Excellent result to #{@html}\n\n") if @html
+            end
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/runner.rb

@@ -0,0 +1,143 @@
+require 'pp'
+require 'yaml'
+require 'simplabs/excellent/parsing/parser'
+require 'simplabs/excellent/parsing/code_processor'
+
+module Simplabs
+
+  module Excellent
+
+    # The Runner is the interface to invoke parsing and processing of source code. You can pass either a String containing the code to process or the
+    # name of a file to read the code to process from.
+    class Runner
+
+      DEFAULT_CONFIG = {
+        :AssignmentInConditionalCheck         => { },
+        :CaseMissingElseCheck                 => { },
+        :ClassLineCountCheck                  => { :threshold      => 300 },
+        :ClassNameCheck                       => { :pattern         => /^[A-Z][a-zA-Z0-9]*$/ },
+        :SingletonVariableCheck               => { },
+        :GlobalVariableCheck                  => { },
+        :EmptyRescueBodyCheck                 => { },
+        :MethodLineCountCheck                 => { :line_count      => 20 },
+        :MethodNameCheck                      => { :pattern         => /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ },
+        :ModuleLineCountCheck                 => { :line_count      => 300 },
+        :ModuleNameCheck                      => { :pattern         => /^[A-Z][a-zA-Z0-9]*$/ },
+        :ParameterNumberCheck                 => { :parameter_count => 3 },
+        :'Rails::AttrProtectedCheck'          => { },
+        :'Rails::AttrAccessibleCheck'         => { },
+        :'Rails::InstanceVarInPartialCheck'   => { },
+        :'Rails::ValidationsCheck'            => { },
+        :'Rails::ParamsHashInViewCheck'       => { },
+        :'Rails::SessionHashInViewCheck'      => { },
+        :'Rails::CustomInitializeMethodCheck' => { }
+      }
+
+      attr_accessor :config #:nodoc:
+
+      # Initializes a Runner
+      #
+      # ==== Parameters
+      #
+      # * <tt>checks</tt> - The checks to apply - pass instances of the various check classes. If no checks are specified, all checks will be applied.
+      def initialize(*checks)
+        @config = DEFAULT_CONFIG
+        @checks = checks unless checks.empty?
+        @parser = Parsing::Parser.new
+      end
+
+      # Processes the +code+ and sets the file name of the warning to +filename+
+      #
+      # ==== Parameters
+      #
+      # * <tt>filename</tt> - The name of the file the code was read from.
+      # * <tt>code</tt> - The code to process (String).
+      def check(filename, code)
+        @checks ||= load_checks
+        @processor ||= Parsing::CodeProcessor.new(@checks)
+        node = parse(filename, code)
+        @processor.process(node)
+      end
+
+      # Processes the +code+, setting the file name of the warnings to '+dummy-file.rb+'
+      #
+      # ==== Parameters
+      #
+      # * <tt>code</tt> - The code to process (String).
+      def check_code(code)
+        check('dummy-file.rb', code)
+      end
+  
+      # Processes the file +filename+. The code will be read from the file.
+      #
+      # ==== Parameters
+      #
+      # * <tt>filename</tt> - The name of the file to read the code from.
+      def check_file(filename)
+        check(filename, File.read(filename))
+      end
+
+      # Processes the passed +paths+
+      #
+      # ==== Parameters
+      #
+      # * <tt>paths</tt> - The paths to process (specify file names or directories; will recursively process all ruby files if a directory is given).
+      # * <tt>formatter</tt> - The formatter to use. If a formatter is specified, its +start+, +file+, +warning+ and +end+ methods will be called
+      def check_paths(paths, formatter = nil)
+        formatter.start if formatter
+        collect_files(paths).each do |path|
+          check_file(path)
+          format_file_and_warnings(formatter, path) if formatter
+        end
+        formatter.end if formatter
+      end
+
+      # Gets the warnings that were produced by the checks.
+      def warnings
+        @checks ||= []
+        @checks.collect { |check| check.warnings }.flatten
+      end
+
+      private
+
+        def parse(filename, code)
+          @parser.parse(code, filename)
+        end
+
+        def load_checks
+          check_objects = []
+          DEFAULT_CONFIG.each_pair do |key, value| 
+            klass = eval("Simplabs::Excellent::Checks::#{key.to_s}")
+            check_objects << (value.empty? ? klass.new : klass.new(value))
+          end
+          check_objects
+        end
+
+        def collect_files(paths)
+          files = []
+          paths.each do |path|
+            if File.file?(path)
+              files << path
+            elsif File.directory?(path)
+              files += Dir.glob(File.join(path, '**/*.{rb,erb}'))
+            else
+              raise ArgumentError.new("#{path} is neither a File nor a directory!")
+            end
+          end
+          files
+        end
+
+        def format_file_and_warnings(formatter, filename)
+          warnings = @checks.map { |check| check.warnings_for(filename) }.flatten
+          if warnings.length > 0
+            formatter.file(filename) do |formatter|
+              warnings.sort { |x, y| x.line_number <=> y.line_number }.each { |warning| formatter.warning(warning) }
+            end
+          end
+        end
+
+    end
+
+  end
+
+end