metric_fu-roodi 2.2.2 → 3.0.0

data/spec/roodi/checks/case_missing_else_check_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::CaseMissingElseCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::CaseMissingElseCheck.make)
-  end
-  
-  it "should accept case statements that do have an else" do
-    content = <<-END
-    case foo
-      when "bar": "ok"
-      else "good"
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should be_empty
-  end
-  
-  it "should reject case statements that do have an else" do
-    content = <<-END
-    case foo
-      when "bar": "ok"
-      when "bar": "bad"
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[1-2] - Case statement is missing an else clause./)
-  end
-end

data/spec/roodi/checks/class_line_count_check_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::ClassLineCountCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::ClassLineCountCheck.make({'line_count' => 1}))
-  end
-  
-  it "should accept classes with less lines than the threshold" do
-    content = <<-END
-    class ZeroLineClass
-    end
-    END
-    @roodi.check_content(content)
-    @roodi.errors.should be_empty
-  end
-
-  it "should accept classes with the same number of lines as the threshold" do
-    content = <<-END
-    Class OneLineClass
-      @foo = 1
-    end
-    END
-    @roodi.check_content(content)
-    @roodi.errors.should be_empty
-  end
-
-  it "should reject classes with more lines than the threshold" do
-    content = <<-END
-    class TwoLineClass
-      @foo = 1
-      @bar = 2
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should eql("dummy-file.rb:1 - Class \"TwoLineClass\" has 2 lines.  It should have 1 or less.")
-  end
-end

data/spec/roodi/checks/class_name_check_spec.rb

@@ -1,39 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::ClassNameCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::ClassNameCheck.make)
-  end
-  
-  it "should accept camel case class names starting in capitals" do
-    content = <<-END
-    class GoodClassName 
-    end
-    END
-    @roodi.check_content(content)
-    @roodi.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
-    # @roodi.print_content(content)
-    @roodi.check_content(content)
-    @roodi.errors.should be_empty
-  end
-
-  it "should reject class names with underscores" do
-    content = <<-END
-    class Bad_ClassName 
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should eql("dummy-file.rb:1 - Class name \"Bad_ClassName\" should match pattern /^[A-Z][a-zA-Z0-9]*$/")
-  end
-end

data/spec/roodi/checks/class_variable_check_spec.rb

@@ -1,17 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::ClassVariableCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::ClassVariableCheck.make)
-  end
-  
-  it "should reject class variables" do
-    content = <<-END
-    @@foo
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[1-2] - Don't use class variables. You might want to try a different design./)
-  end
-end

data/spec/roodi/checks/control_coupling_check_spec.rb

@@ -1,23 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::ControlCouplingCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::ControlCouplingCheck.make)
-  end
-  
-  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
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[2-3] - Method \"write\" uses the argument \"quoted\" for internal control./)
-  end
-end

data/spec/roodi/checks/cyclomatic_complexity_block_check_spec.rb

@@ -1,67 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::CyclomaticComplexityBlockCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::CyclomaticComplexityBlockCheck.make({'complexity' => 0}))
-  end
-
-  def verify_content_complexity(content, complexity)
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[2-4] - Block cyclomatic complexity is #{complexity}.  It should be 0 or less./)
-  end
-  
-  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
-        call_foo if some_condition
-      end
-    end
-    END
-    verify_content_complexity(content, 2)
-  end
-  
-  it "should evaluate real example 1 correctly" do
-    content = <<-END
-    def method_name
-      UNIXMbox.lock(@filename) {|f|
-          begin
-            f.each do |line|
-              if /\AFrom / === line
-                w.close if w
-                File.utime time, time, port.filename if time
-
-                port = @real.new_port
-                w = port.wopen
-                time = fromline2time(line)
-              else
-                w.print line if w
-              end
-            end
-          ensure
-            if w and not w.closed?
-              w.close
-              File.utime time, time, port.filename if time
-            end
-          end
-          f.truncate(0) unless @readonly
-          @updated = Time.now
-      }
-    end
-    END
-    verify_content_complexity(content, 9)
-  end
-end

data/spec/roodi/checks/cyclomatic_complexity_method_check_spec.rb

@@ -1,200 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::CyclomaticComplexityMethodCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::CyclomaticComplexityMethodCheck.make({'complexity' => 0}))
-  end
-
-  def verify_content_complexity(content, complexity)
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should eql("dummy-file.rb:1 - Method name \"method_name\" cyclomatic complexity is #{complexity}.  It should be 0 or less.")
-  end
-  
-  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
-
-  it "should find the && symbol" do
-    content = <<-END
-    def method_name
-      call_foo && call_bar
-    end
-    END
-    verify_content_complexity(content, 2)
-  end
-
-  it "should find the and symbol" do
-    content = <<-END
-    def method_name
-      call_foo and call_bar
-    end
-    END
-    verify_content_complexity(content, 2)
-  end
-
-  it "should find the || symbol" do
-    content = <<-END
-    def method_name
-      call_foo || call_bar
-    end
-    END
-    verify_content_complexity(content, 2)
-  end
-
-  it "should find the or symbol" do
-    content = <<-END
-    def method_name
-      call_foo or call_bar
-    end
-    END
-    verify_content_complexity(content, 2)
-  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
-
-  it "should count only a single method" do
-    content = <<-END
-    def method_name_1
-      call_foo if some_condition
-    end
-    def method_name_2
-      call_foo if some_condition
-    end
-    END
-    
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should eql("dummy-file.rb:1 - Method name \"method_name_1\" cyclomatic complexity is 2.  It should be 0 or less.")
-    errors[1].to_s.should eql("dummy-file.rb:4 - Method name \"method_name_2\" cyclomatic complexity is 2.  It should be 0 or less.")
-  end
-
-end

data/spec/roodi/checks/empty_rescue_body_check_spec.rb

@@ -1,154 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Roodi::Checks::EmptyRescueBodyCheck do
-  before(:each) do
-    @roodi = Roodi::Core::Runner.new(Roodi::Checks::EmptyRescueBodyCheck.make)
-  end
-  
-  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
-    @roodi.check_content(content)
-    @roodi.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
-    @roodi.check_content(content)
-    @roodi.errors.should be_empty
-  end
-
-  it "should accept a method call that Ruby won't tell apart from a variable (a vcall)" do
-    content = <<-END
-    begin
-      call_method
-    rescue
-      show_error
-    end
-    END
-    @roodi.check_content(content)
-    @roodi.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
-    @roodi.check_content(content)
-    @roodi.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
-    @roodi.check_content(content)
-    @roodi.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
-    @roodi.check_content(content)
-    @roodi.errors.should be_empty
-  end
-
-  it "should reject an empty rescue block with no parameter" do
-    content = <<-END
-    begin
-      call_method
-    rescue
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[3-4] - Rescue block should not be empty./)
-  end
-
-  it "should accept a rescue block with an explicit nil" do
-    content = <<-END
-    call_method rescue nil
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should be_empty
-  end
-
-  it "should reject an empty rescue block with a parameter" do
-    content = <<-END
-    begin
-      call_method
-    rescue Exception => e
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should_not be_empty
-    errors[0].to_s.should match(/dummy-file.rb:[3-4] - Rescue block should not be empty./)
-  end
-
-  it "should accept a rescue block that returns true" do
-    content = <<-END
-    begin
-      call_method
-    rescue Exception => e
-      true
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should be_empty
-  end
-
-  it "should accept a rescue block that returns false" do
-    content = <<-END
-    begin
-      call_method
-    rescue Exception => e
-      false
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should be_empty
-  end
-
-  it "should accept a rescue block that has only a next statement" do
-    content = <<-END
-    begin
-      call_method
-    rescue Exception => e
-      next
-    end
-    END
-    @roodi.check_content(content)
-    errors = @roodi.errors
-    errors.should be_empty
-  end
-
-end