simplabs-excellent 1.0.0

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::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::ClassNameCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept camel case class names starting in capitals' do
+      content = <<-END
+        class GoodClassName; end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should be able to parse scoped class names' do
+      content = <<-END
+        class MyScope::GoodClassName 
+          def method
+          end
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should reject class names with underscores' do
+      content = <<-END
+        class Bad_ClassName
+        end
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should_not be_empty
+      errors[0].info.should        == { :class => :Bad_ClassName }
+      errors[0].line_number.should == 1
+      errors[0].message.should     == 'Bad class name Bad_ClassName.'
+    end
+
+  end
+
+end

data/spec/checks/class_variable_check_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ClassVariableCheck do
+
+  before(:each) do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::ClassVariableCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should reject class variables' do
+      content = <<-END
+        @@foo
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should_not be_empty
+      errors[0].info.should        == { :variable => :@@foo }
+      errors[0].line_number.should == 1
+      errors[0].message.should     == 'Class variable @@foo.'
+    end
+
+  end
+
+end

data/spec/checks/control_coupling_check_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::ControlCouplingCheck do
+
+  before(:each) do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::ControlCouplingCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should reject methods with if checks using a parameter' do
+      content = <<-END
+        def write(quoted, foo)
+          if quoted
+            write_quoted(@value)
+          else
+            puts @value
+          end
+        end
+      END
+      @excellent.check_content(content)
+      errors = @excellent.errors
+
+      errors.should_not be_empty
+      errors[0].info.should        == { :method => :write, :argument => :quoted }
+      errors[0].line_number.should == 2
+      errors[0].message.should     == 'Control of write is coupled to quoted.'
+    end
+
+  end
+
+end

data/spec/checks/cyclomatic_complexity_block_check_spec.rb

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

data/spec/checks/cyclomatic_complexity_method_check_spec.rb

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

data/spec/checks/empty_rescue_body_check_spec.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do
+
+  before do
+    @excellent = Simplabs::Excellent::Core::ParseTreeRunner.new(Simplabs::Excellent::Checks::EmptyRescueBodyCheck.new)
+  end
+
+  describe '#evaluate' do
+
+    it 'should accept a rescue body with content and no parameter' do
+      content = <<-END
+        begin
+          call_method
+        rescue
+          puts "Recover from the call"
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept a rescue body with a return' do
+      content = <<-END
+        begin
+          call_method
+        rescue
+          return true
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it "should accept a virtual method call" do
+      content = <<-END
+        begin
+          call_method
+        rescue
+          show_error
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept a rescue body with content and a parameter' do
+      content = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          puts "Recover from the call"
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept a rescue body with an assignment' do
+      content = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          my_var = 1
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept a rescue body with an attribute assignment' do
+      content = <<-END
+        begin
+          call_method
+        rescue Exception => e
+          self.var = 1
+        end
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should accept an inline rescue statement' do
+      content = <<-END
+        value = call_method rescue 1
+      END
+      @excellent.check_content(content)
+
+      @excellent.errors.should be_empty
+    end
+
+    it 'should reject an empty rescue block with no parameter' do
+      content = <<-END
+        begin
+          call_method
+        rescue
+        end
+      END
+
+      verify_error_found(content)
+    end
+
+    it 'should reject an empty rescue block with a parameter' do
+      content = <<-END
+        begin
+          call_method
+        rescue Exception => e
+        end
+      END
+
+      verify_error_found(content)
+    end
+
+  end
+
+  def verify_error_found(content)
+    @excellent.check_content(content)
+    errors = @excellent.errors
+
+    errors.should_not be_empty
+    errors[0].info.should        == {}
+    errors[0].line_number.should == 3
+    errors[0].message.should     == 'Rescue block is empty.'
+  end
+
+end