excellent 1.5.4

data/spec/checks/cyclomatic_complexity_block_check_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::CyclomaticComplexityBlockCheck do
+
+  before(:each) do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::CyclomaticComplexityBlockCheck.new({ :threshold => 0 }))
+  end
+
+  describe '#evaluate' do
+
+    it 'should find a simple block' do
+      code = <<-END
+        it 'should be a simple block' do
+          call_foo
+        end
+      END
+
+      verify_code_complexity(code, 1)
+    end
+
+    it 'should find a block with multiple paths' do
+      code = <<-END
+        it 'should be a complex block' do
+          if some_condition
+            call_foo
+          else
+            call_bar
+          end
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+  end
+
+  def verify_code_complexity(code, score)
+    @excellent.check_code(code)
+    warnings = @excellent.warnings
+
+    warnings.should_not be_empty
+    warnings[0].info.should        == { :block => 'block', :score => score }
+    warnings[0].line_number.should == 1
+    warnings[0].message.should     == "block has cyclomatic complexity of #{score}."
+  end
+
+end

data/spec/checks/cyclomatic_complexity_method_check_spec.rb

@@ -0,0 +1,210 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck.new({ :threshold => 0 }))
+  end
+
+  describe '#evaluate' do
+
+    it 'should find an if block' do
+      code = <<-END
+        def method_name
+          call_foo if some_condition
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find an unless block' do
+      code = <<-END
+        def method_name
+          call_foo unless some_condition
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find an elsif block' do
+      code = <<-END
+        def method_name
+          if first_condition then
+            call_foo
+          elsif second_condition then
+            call_bar
+          else
+            call_bam
+          end
+        end
+      END
+
+      verify_code_complexity(code, 3)
+    end
+
+    it 'should find a ternary operator' do
+      code = <<-END
+        def method_name
+          value = some_condition ? 1 : 2
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find a while loop' do
+      code = <<-END
+        def method_name
+          while some_condition do
+            call_foo
+          end
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find an until loop' do
+      code = <<-END
+        def method_name
+          until some_condition do
+            call_foo
+          end
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find a for loop' do
+      code = <<-END
+        def method_name
+          for i in 1..2 do
+            call_method
+          end
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find a rescue block' do
+      code = <<-END
+        def method_name
+          begin
+            call_foo
+          rescue Exception
+            call_bar
+          end
+        end
+      END
+
+      verify_code_complexity(code, 2)
+    end
+
+    it 'should find a case and when block' do
+      code = <<-END
+        def method_name
+          case value
+            when 1
+              call_foo
+            when 2
+              call_bar
+          end
+        end
+      END
+
+      verify_code_complexity(code, 4)
+    end
+
+    describe 'when processing operators' do
+
+      ['&&', 'and', '||', 'or'].each do |operator|
+
+        it "should find #{operator}" do
+          code = <<-END
+            def method_name
+              call_foo #{operator} call_bar
+            end
+          END
+
+          verify_code_complexity(code, 2)
+        end
+
+      end
+
+    end
+
+    it 'should deal with nested if blocks containing && and ||' do
+      code = <<-END
+        def method_name
+          if first_condition then
+            call_foo if second_condition && third_condition
+            call_bar if fourth_condition || fifth_condition
+          end
+        end
+      END
+
+      verify_code_complexity(code, 6)
+    end
+
+    it 'should count stupid nested if and else blocks' do
+      code = <<-END
+        def method_name
+          if first_condition then
+            call_foo
+          else
+            if second_condition then
+              call_bar
+            else
+              call_bam if third_condition
+            end
+            call_baz if fourth_condition
+          end
+        end
+      END
+
+      verify_code_complexity(code, 5)
+    end
+
+    it 'should also work on singleton methods' do
+      code = <<-END
+        class Class
+          def self.method_name
+            if first_condition then
+              call_foo
+            else
+              if second_condition then
+                call_bar
+              else
+                call_bam if third_condition
+              end
+              call_baz if fourth_condition
+            end
+          end
+        end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == { :method => 'Class.method_name', :score => 5 }
+      warnings[0].line_number.should == 2
+      warnings[0].message.should     == "Class.method_name has cyclomatic complexity of 5."
+    end
+
+  end
+
+  def verify_code_complexity(code, score)
+    @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 cyclomatic complexity of #{score}."
+  end
+
+end

data/spec/checks/empty_rescue_body_check_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::EmptyRescueBodyCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept a rescue body with content and no parameter' do
+      code = <<-END
+        begin
+          call_method
+        rescue
+          puts "Recover from the call"
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept a rescue body with a return' do
+      code = <<-END
+        begin
+          call_method
+        rescue
+          return true
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it "should accept a virtual method call" do
+      code = <<-END
+        begin
+          call_method
+        rescue
+          show_error
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept a rescue body with code and a parameter' do
+      code = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          puts "Recover from the call"
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept a rescue body with an assignment' do
+      code = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          my_var = 1
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept a rescue body with an attribute assignment' do
+      code = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          self.var = 1
+        end
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept an inline rescue statement' do
+      code = <<-END
+        value = call_method rescue 1
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept an empty array as a statement' do
+      code = <<-END
+        value = call_method rescue []
+      END
+
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept an empty hash as a statement' do
+      code = <<-END
+        value = call_method rescue {}
+      END
+
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept a boolean as a statement' do
+      code = <<-END
+        value = call_method rescue false
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should accept nil as a statement' do
+      code = <<-END
+        value = call_method rescue nil
+      END
+      @excellent.check_code(code)
+
+      @excellent.warnings.should be_empty
+    end
+
+    it 'should reject an empty rescue block with no parameter' do
+      code = <<-END
+        begin
+          call_method
+        rescue
+        end
+      END
+
+      verify_warning_found(code)
+    end
+
+    it 'should reject an empty rescue block with a parameter' do
+      code = <<-END
+        begin
+          call_method
+        rescue Exception => e
+        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        == {}
+    warnings[0].line_number.should == 3
+    warnings[0].message.should     == 'Rescue block is empty.'
+  end
+
+end

data/spec/checks/flog_block_check_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::FlogBlockCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Runner.new(Simplabs::Excellent::Checks::FlogBlockCheck.new({ :threshold => 0 }))
+  end
+
+  describe '#evaluate' do
+
+    it 'should calculate the score correctly' do
+      code = <<-END
+        method_name do
+          puts 'test'
+        end
+      END
+      @excellent.check_code(code)
+      warnings = @excellent.warnings
+
+      warnings.should_not be_empty
+      warnings[0].info.should        == { :block => 'block', :score => 3 }
+      warnings[0].line_number.should == 1
+      warnings[0].message.should     == "block has flog score of 3."
+    end
+
+  end
+
+end