excellent 1.7.2 → 2.0.0

data/spec/checks/case_missing_else_check_spec.rb

@@ -1,46 +0,0 @@
-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 == 1
-      warnings[0].message.should     == 'Case statement is missing else clause.'
-    end
-
-  end
-
-end

data/spec/checks/class_line_count_check_spec.rb

@@ -1,62 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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, 2)
-      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, 3) # this should actually be line 2
-    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, 2)
-    end
-
-  end
-
-  def verify_warning_found(code, line)
-    @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 == line
-    warnings[0].message.should     == 'write is coupled to quoted.'
-  end
-
-end

data/spec/checks/cyclomatic_complexity_block_check_spec.rb

@@ -1,47 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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