simplabs-excellent 1.0.1 → 1.2.1

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/runner.rb

@@ -0,0 +1,105 @@
+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          => { },
+        :CyclomaticComplexityBlockCheck  => { :complexity      => 4 },
+        :CyclomaticComplexityMethodCheck => { :complexity      => 8 },
+        :EmptyRescueBodyCheck            => { },
+        :ForLoopCheck                    => { },
+        :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 },
+        :FlogMethodCheck                 => { },
+        :FlogBlockCheck                  => { },
+        :FlogClassCheck                  => { },
+        :'Rails::AttrProtectedCheck'     => { },
+        :'Rails::AttrAccessibleCheck'    => { }
+      }
+
+      attr_accessor :config #:nodoc:
+
+      # Initializes a Runner
+      #
+      # ==== Parameters
+      #
+      # * <tt>checks</tt> - The checks to apply - passed 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
+
+      # 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
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/warning.rb

@@ -0,0 +1,53 @@
+require 'simplabs/excellent/extensions/string'
+
+module Simplabs
+
+  module Excellent
+
+    # The warnings returned by Excellent provide information about the +file+ the *possibly* problematic code was found in as well as the +line+ of the
+    # occurence, a warning message and a Hash with specific information about the warning.
+    #
+    # Warnings also provide the message template that was used to generate the message. The message template contains tokens like <tt>{{token}}</tt> that
+    # correspond to the valeus in the +info+ hash, e.g.:
+    #
+    #  '{{method}} has abc score of {{score}}.'
+    #  { :method => 'User#full_name', :score => 10 }
+    class Warning
+
+      # The check that produced the warning
+      attr_reader :check
+
+      # The name of the file the check found the problematic code in
+      attr_reader :filename
+
+      # The file number where the check found the problematic code
+      attr_reader :line_number
+
+      # The warning message
+      attr_reader :message
+
+      # Additional info for the warning (see above)
+      attr_reader :info
+
+      # The template used to produce the warning (see above)
+      attr_reader :message_template
+
+      def initialize(check, message, filename, line_number, info) #:nodoc:
+        @check       = check.to_s.underscore.to_sym
+        @info        = info
+        @filename    = filename
+        @line_number = line_number.to_i
+
+        @message = ''
+        if !message.nil?
+          @message_template = message
+          @info.each { |key, value| message.gsub!(/\{\{#{key}\}\}/, value.to_s) }
+          @message = message
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/checks/abc_metric_method_check_spec.rb

@@ -3,14 +3,24 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do
 
   before do
-    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::AbcMetricMethodCheck.new({ :threshold => 0 }))
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::AbcMetricMethodCheck.new({ :threshold => 0 }))
   end
 
   describe '#evaluate' do
 
     describe 'when processing assignments' do
 
-      ['=', '*=', '/=', '%=', '+=', '<<=', '>>=', '&=', '|=', '^=', '-=', '**='].each do |assignment|
+      it "should find =" do
+        content = <<-END
+          def method_name
+            foo = 1
+          end
+        END
+
+        verify_content_score(content, 1, 0, 0)
+      end
+
+      ['*=', '/=', '%=', '+=', '<<=', '>>=', '&=', '|=', '^=', '-=', '**='].each do |assignment|
 
         it "should find #{assignment}" do
           content = <<-END
@@ -19,7 +29,8 @@ describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do
             end
           END
 
-          verify_content_score(content, 1, 0, 0)
+          # these special assignments have score 2 since before the value is assigned, a method is called on the old value
+          verify_content_score(content, 1, 0, 1)
         end
 
       end
@@ -78,17 +89,34 @@ describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do
 
     end
 
+    it 'should also work on singleton methods' do
+      content = <<-END
+        class Class
+          def self.method_name
+            foo = 1
+          end
+        end
+      END
+      @excellent.check_content(content)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == { :method => 'Class.method_name', :score => 1.0 }
+      warnings[0].line_number.should == 2
+      warnings[0].message.should     == "Class.method_name has abc score of 1.0."
+    end
+
   end
 
   def verify_content_score(content, a, b, c)
     score = Math.sqrt(a*a + b*b + c*c)
     @excellent.check_content(content)
-    errors = @excellent.errors
+    warnings = @excellent.warnings
 
-    errors.should_not be_empty
-    errors[0].info[:method].should == :method_name
-    errors[0].info[:score].should  == score
-    errors[0].message.should       == "Method method_name has abc score of #{score}."
+    warnings.should_not be_empty
+    warnings[0].info.should        == { :method => 'method_name', :score => score }
+    warnings[0].line_number.should == 1
+    warnings[0].message.should     == "method_name has abc score of #{score}."
   end
 
 end