excellent 1.5.4

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

@@ -0,0 +1,122 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::AbcMetricMethodCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::AbcMetricMethodCheck.new({ :threshold => 0 }))
+  end
+
+  describe '#evaluate' do
+
+    describe 'when processing assignments' do
+
+      it "should find =" do
+        code = <<-END
+          def method_name
+            foo = 1
+          end
+        END
+
+        verify_code_score(code, 1, 0, 0)
+      end
+
+      ['*=', '/=', '%=', '+=', '<<=', '>>=', '&=', '|=', '^=', '-=', '**='].each do |assignment|
+
+        it "should find #{assignment}" do
+          code = <<-END
+            def method_name
+              foo #{assignment} 1
+            end
+          END
+
+          # these special assignments have score 2 since before the value is assigned, a method is called on the old value
+          verify_code_score(code, 1, 0, 1)
+        end
+
+      end
+
+    end
+
+    describe 'when processing branches' do
+
+      it 'should find a virtual method call' do
+        code = <<-END
+          def method_name
+            call_foo
+          end
+        END
+
+        verify_code_score(code, 0, 1, 0)
+      end
+
+      it 'should find an explicit method call' do
+        code = <<-END
+          def method_name
+            @object.call_foo
+          end
+        END
+
+        verify_code_score(code, 0, 1, 0)
+      end
+
+      it 'should exclude a condition' do
+        code = <<-END
+          def method_name
+            @object.call_foo < 10
+          end
+        END
+
+        verify_code_score(code, 0, 1, 1)
+      end
+
+    end
+
+    describe 'when processing conditions' do
+
+      ['==', '!=', '<=', '>=', '<', '>', '<=>', '=~'].each do |conditional|
+
+        it "should find #{conditional}" do
+          code = <<-END
+            def method_name
+              @foo #{conditional} @bar
+            end
+          END
+
+          verify_code_score(code, 0, 0, 1)
+        end
+
+      end 
+
+    end
+
+    it 'should also work on singleton methods' do
+      code = <<-END
+        class Class
+          def self.method_name
+            foo = 1
+          end
+        end
+      END
+      @excellent.check_code(code)
+      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_code_score(code, a, b, c)
+    score = Math.sqrt(a*a + b*b + c*c)
+    @excellent.check_code(code)
+    warnings = @excellent.warnings
+
+    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

data/spec/checks/assignment_in_conditional_check_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::AssignmentInConditionalCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::AssignmentInConditionalCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept an assignment before an if clause' do
+      code = <<-END
+        count = count += 1 if @some_condition
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept block parameters in an if clause' do
+      code = <<-END
+        return true if exp.children.any? { |child| contains_statements?(child) }
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should reject assignments of results of blocks in an if clause' do
+      code = <<-END
+        return true if value = exp.children.find { |child| contains_statements?(child) }
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an assignment inside an if clause' do
+      code = <<-END
+        call_foo if bar = bam
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an assignment inside an unless clause' do
+      code = <<-END
+        call_foo unless bar = bam
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an assignment inside a while clause' do
+      code = <<-END
+        call_foo while bar = bam
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an assignment inside an until clause' do
+      code = <<-END
+        call_foo until bar = bam
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an assignment inside a ternary operator check clause' do
+      code = <<-END
+        call_foo (bar = bam) ? baz : bad
+      END
+
+      #RubyParser sets line number 2 here
+      verify_warning_found(code, 2)
+    end
+
+  end
+
+  def verify_warning_found(code, line_number = nil)
+    @excellent.check_code(code)
+    warnings = @excellent.warnings
+
+    warnings.should_not be_empty
+    warnings[0].info.should        == {}
+    warnings[0].line_number.should == (line_number || 1)
+    warnings[0].message.should     == 'Assignment in condition.'
+  end
+
+end

data/spec/checks/case_missing_else_check_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::CaseMissingElseCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::CaseMissingElseCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept case statements that do have an else clause' do
+      code = <<-END
+        case foo
+          when "bar": "ok"
+          else "good"
+          end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should be_empty
+    end
+
+    it 'should reject case statements that do not have an else clause' do
+      code = <<-END
+        case foo
+          when "bar": "ok"
+          when "bar": "bad"
+          end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == {}
+      warnings[0].line_number.should == 2
+      warnings[0].message.should     == 'Case statement is missing else clause.'
+    end
+
+  end
+
+end

data/spec/checks/class_line_count_check_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ClassLineCountCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::ClassLineCountCheck.new({ :threshold => 3 }))
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept classes with less lines than the threshold' do
+      code = <<-END
+        class OneLineClass; end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept classes with the same number of lines as the threshold' do
+      code = <<-END
+        class ThreeLineClass
+          @foo = 1
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should not count blank lines' do
+      code = <<-END
+        class ThreeLineClass
+
+          @foo = 1
+
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should reject classes with more lines than the threshold' do
+      code = <<-END
+        class FourLineClass
+          @foo = 1
+          @bar = 2
+        end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == { :class => 'FourLineClass', :count => 4 }
+      warnings[0].line_number.should == 1
+      warnings[0].message.should     == 'FourLineClass has 4 lines.'
+    end
+
+  end
+
+end

data/spec/checks/class_name_check_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ClassNameCheck do
+
+  before(:each) do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::ClassNameCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept camel case class names starting in capitals' do
+      code = <<-END
+        class GoodClassName; end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should be able to parse scoped class names' do
+      code = <<-END
+        class Outer::Inner::GoodClassName 
+          def method
+          end
+        end
+      END
+      @excellent.check_code(code)
+s
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should reject class names with underscores' do
+      code = <<-END
+        class Bad_ClassName
+        end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == { :class => 'Bad_ClassName' }
+      warnings[0].line_number.should == 1
+      warnings[0].message.should     == 'Bad class name Bad_ClassName.'
+    end
+
+  end
+
+end

data/spec/checks/control_coupling_check_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ControlCouplingCheck do
+
+  before(:each) do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::ControlCouplingCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept methods that just print out the parameter' do
+      code = <<-END
+        def write(quoted)
+          pp quoted
+        end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should be_empty
+    end
+
+    it 'should accept methods with ternary operators using an instance variable' do
+      code = <<-END
+        def write(quoted)
+          @quoted ? write_quoted('1') : write_quoted('2')
+        end
+      END
+
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should be_empty
+    end
+
+    it 'should accept methods with ternary operators using a local variable' do
+      code = <<-END
+        def write(quoted)
+          test = false
+          test ? write_quoted('1') : write_quoted('2')
+        end
+      END
+
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should be_empty
+    end
+
+    %w(if unless).each do |conditional|
+
+      it "should reject methods with #{conditional} checks using a parameter" do
+        code = <<-END
+          def write(quoted)
+            #{conditional} quoted
+              write_quoted('test')
+            end
+          end
+        END
+
+        verify_warning_found(code)
+      end
+
+    end
+
+    it 'should reject methods with ternary operators using a parameter' do
+      code = <<-END
+        def write(quoted)
+          quoted ? write_quoted('1') : write_quoted('2')
+        end
+      END
+
+      verify_warning_found(code)
+    end
+
+    it "should reject methods with case statements using a parameter" do
+      code = <<-END
+        def write(quoted)
+          case quoted
+            when 1
+              write_quoted('1')
+            when 2
+              write_quoted('2')
+          end
+        end
+      END
+
+      verify_warning_found(code)
+    end
+
+  end
+
+  def verify_warning_found(code)
+    @excellent.check_code(code)
+    warnings = @excellent.warnings
+
+    warnings.should_not be_empty
+    warnings[0].info.should        == { :method => 'write', :argument => 'quoted' }
+    warnings[0].line_number.should == 1
+    warnings[0].message.should     == 'write is coupled to quoted.'
+  end
+
+end