simplabs-excellent 1.2.1 → 1.2.2

data/spec/checks/cyclomatic_complexity_block_check_spec.rb

@@ -9,17 +9,17 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityBlockCheck do
   describe '#evaluate' do
 
     it 'should find a simple block' do
-      content = <<-END
+      code = <<-END
         it 'should be a simple block' do
           call_foo
         end
       END
 
-      verify_content_complexity(content, 1)
+      verify_code_complexity(code, 1)
     end
 
     it 'should find a block with multiple paths' do
-      content = <<-END
+      code = <<-END
         it 'should be a complex block' do
           if some_condition
             call_foo
@@ -29,13 +29,13 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityBlockCheck do
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
   end
 
-  def verify_content_complexity(content, score)
-    @excellent.check_content(content)
+  def verify_code_complexity(code, score)
+    @excellent.check_code(code)
     warnings = @excellent.warnings
 
     warnings.should_not be_empty

data/spec/checks/cyclomatic_complexity_method_check_spec.rb

@@ -9,27 +9,27 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
   describe '#evaluate' do
 
     it 'should find an if block' do
-      content = <<-END
+      code = <<-END
         def method_name
           call_foo if some_condition
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find an unless block' do
-      content = <<-END
+      code = <<-END
         def method_name
           call_foo unless some_condition
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find an elsif block' do
-      content = <<-END
+      code = <<-END
         def method_name
           if first_condition then
             call_foo
@@ -41,21 +41,21 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 3)
+      verify_code_complexity(code, 3)
     end
 
     it 'should find a ternary operator' do
-      content = <<-END
+      code = <<-END
         def method_name
           value = some_condition ? 1 : 2
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find a while loop' do
-      content = <<-END
+      code = <<-END
         def method_name
           while some_condition do
             call_foo
@@ -63,11 +63,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find an until loop' do
-      content = <<-END
+      code = <<-END
         def method_name
           until some_condition do
             call_foo
@@ -75,11 +75,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find a for loop' do
-      content = <<-END
+      code = <<-END
         def method_name
           for i in 1..2 do
             call_method
@@ -87,11 +87,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find a rescue block' do
-      content = <<-END
+      code = <<-END
         def method_name
           begin
             call_foo
@@ -101,11 +101,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 2)
+      verify_code_complexity(code, 2)
     end
 
     it 'should find a case and when block' do
-      content = <<-END
+      code = <<-END
         def method_name
           case value
             when 1
@@ -116,7 +116,7 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 4)
+      verify_code_complexity(code, 4)
     end
 
     describe 'when processing operators' do
@@ -124,13 +124,13 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
       ['&&', 'and', '||', 'or'].each do |operator|
 
         it "should find #{operator}" do
-          content = <<-END
+          code = <<-END
             def method_name
               call_foo #{operator} call_bar
             end
           END
 
-          verify_content_complexity(content, 2)
+          verify_code_complexity(code, 2)
         end
 
       end
@@ -138,7 +138,7 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
     end
 
     it 'should deal with nested if blocks containing && and ||' do
-      content = <<-END
+      code = <<-END
         def method_name
           if first_condition then
             call_foo if second_condition && third_condition
@@ -147,11 +147,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 6)
+      verify_code_complexity(code, 6)
     end
 
     it 'should count stupid nested if and else blocks' do
-      content = <<-END
+      code = <<-END
         def method_name
           if first_condition then
             call_foo
@@ -166,11 +166,11 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
         end
       END
 
-      verify_content_complexity(content, 5)
+      verify_code_complexity(code, 5)
     end
 
     it 'should also work on singleton methods' do
-      content = <<-END
+      code = <<-END
         class Class
           def self.method_name
             if first_condition then
@@ -186,7 +186,7 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
           end
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
       warnings = @excellent.warnings
 
       warnings.should_not be_empty
@@ -197,8 +197,8 @@ describe Simplabs::Excellent::Checks::CyclomaticComplexityMethodCheck do
 
   end
 
-  def verify_content_complexity(content, score)
-    @excellent.check_content(content)
+  def verify_code_complexity(code, score)
+    @excellent.check_code(code)
     warnings = @excellent.warnings
 
     warnings.should_not be_empty

data/spec/checks/duplication_check_spec.rb

@@ -9,99 +9,99 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do
   describe '#evaluate' do
 
     it 'should accept multiple calls to new' do
-      content = <<-END
+      code = <<-END
         def double_thing
           @thing.new + @thing.new
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
       warnings = @excellent.warnings
 
       warnings.should be_empty
     end
 
     it 'should reject multiple calls to the same method and receiver' do
-      content = <<-END
+      code = <<-END
         def double_thing
           @other.thing + @other.thing
         end
       END
 
-      verify_warning_found(content, '@other.thing')
+      verify_warning_found(code, '@other.thing')
     end
 
     it 'should reject multiple calls to the same lvar' do
-      content = <<-END
+      code = <<-END
         def double_thing
           thing[1] + thing[2]
         end
       END
 
-      verify_warning_found(content, 'thing.[]')
+      verify_warning_found(code, 'thing.[]')
     end
 
     it 'should reject multiple calls to the same singleton method' do
-      content = <<-END
+      code = <<-END
         def double_thing
           Class.thing[1] + Class.thing[2]
         end
       END
 
-      verify_warning_found(content, 'Class.thing')
+      verify_warning_found(code, 'Class.thing')
     end
 
     it 'should reject multiple calls to the same method without a receiver' do
-      content = <<-END
+      code = <<-END
         def double_thing
           thing + thing
         end
       END
 
-      verify_warning_found(content, 'thing')
+      verify_warning_found(code, 'thing')
     end
 
     it 'should reject multiple calls to the same method with the same parameters' do
-      content = <<-END
+      code = <<-END
         def double_thing
           thing(1) + thing(1)
         end
       END
 
-      verify_warning_found(content, 'thing')
+      verify_warning_found(code, 'thing')
     end
 
     it 'should reject multiple calls to the same method with different parameters' do
-      content = <<-END
+      code = <<-END
         def double_thing
           thing(1) + thing(2)
         end
       END
 
-      verify_warning_found(content, 'thing')
+      verify_warning_found(code, 'thing')
     end
 
     it 'should work with singleton methods on objects' do
-      content = <<-END
+      code = <<-END
         def object.double_thing
           thing(1) + thing(2)
         end
       END
 
-      verify_warning_found(content, 'thing', 'object.double_thing')
+      verify_warning_found(code, 'thing', 'object.double_thing')
     end
 
     it 'should work with singleton methods on classes' do
-      content = <<-END
+      code = <<-END
         def Class.double_thing
           thing(1) + thing(2)
         end
       END
 
-      verify_warning_found(content, 'thing', 'Class.double_thing')
+      verify_warning_found(code, 'thing', 'Class.double_thing')
     end
 
     it 'should work with singleton methods on classes' do
-      content = <<-END
+      code = <<-END
         class Class
           def self.double_thing
             thing(1) + thing(2)
@@ -109,11 +109,11 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do
         end
       END
 
-      verify_warning_found(content, 'thing', 'Class.double_thing', 2)
+      verify_warning_found(code, 'thing', 'Class.double_thing', 2)
     end
 
     it 'should also work with blocks' do
-      content = <<-END
+      code = <<-END
         def method
           double_thing do
             thing(1) + thing(2)
@@ -121,13 +121,13 @@ describe Simplabs::Excellent::Checks::DuplicationCheck do
         end
       END
 
-      verify_warning_found(content, 'thing', 'block', 2)
+      verify_warning_found(code, 'thing', 'block', 2)
     end
 
   end
 
-  def verify_warning_found(content, statement, method = 'double_thing', line = 1)
-    @excellent.check_content(content)
+  def verify_warning_found(code, statement, method = 'double_thing', line = 1)
+    @excellent.check_code(code)
     warnings = @excellent.warnings
 
     warnings.should_not be_empty

data/spec/checks/empty_rescue_body_check_spec.rb

@@ -9,156 +9,156 @@ describe Simplabs::Excellent::Checks::EmptyRescueBodyCheck do
   describe '#evaluate' do
 
     it 'should accept a rescue body with content and no parameter' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue
           puts "Recover from the call"
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept a rescue body with a return' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue
           return true
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it "should accept a virtual method call" do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue
           show_error
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
-    it 'should accept a rescue body with content and a parameter' do
-      content = <<-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_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept a rescue body with an assignment' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue Exception => e
           my_var = 1
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept a rescue body with an attribute assignment' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue Exception => e
           self.var = 1
         end
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept an inline rescue statement' do
-      content = <<-END
+      code = <<-END
         value = call_method rescue 1
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept an empty array as a statement' do
-      content = <<-END
+      code = <<-END
         value = call_method rescue []
       END
 
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept an empty hash as a statement' do
-      content = <<-END
+      code = <<-END
         value = call_method rescue {}
       END
 
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept a boolean as a statement' do
-      content = <<-END
+      code = <<-END
         value = call_method rescue false
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should accept nil as a statement' do
-      content = <<-END
+      code = <<-END
         value = call_method rescue nil
       END
-      @excellent.check_content(content)
+      @excellent.check_code(code)
 
       @excellent.warnings.should be_empty
     end
 
     it 'should reject an empty rescue block with no parameter' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue
         end
       END
 
-      verify_warning_found(content)
+      verify_warning_found(code)
     end
 
     it 'should reject an empty rescue block with a parameter' do
-      content = <<-END
+      code = <<-END
         begin
           call_method
         rescue Exception => e
         end
       END
 
-      verify_warning_found(content)
+      verify_warning_found(code)
     end
 
   end
 
-  def verify_warning_found(content)
-    @excellent.check_content(content)
+  def verify_warning_found(code)
+    @excellent.check_code(code)
     warnings = @excellent.warnings
 
     warnings.should_not be_empty