roodi 1.2.0 → 1.3.0

data/History.txt

@@ -1,3 +1,12 @@
+= 1.3.0
+
+* added case missing else check.
+* updated checks to take a hash of options with built-in defaults.
+* added support for complete configuration via external file.
+* added support for passing in a custom config file via 'roodi -config=<filename> [pattern]'
+* added assignment in conditional check.
+* refactored checks to remove duplicate code.
+
 = 1.2.0
 
 * added module name check.

data/Manifest.txt

@@ -6,6 +6,8 @@ bin/roodi
 bin/roodi-describe
 lib/roodi.rb
 lib/roodi/checks.rb
+lib/roodi/checks/assignment_in_conditional_check.rb
+lib/roodi/checks/case_missing_else_check.rb
 lib/roodi/checks/check.rb
 lib/roodi/checks/class_line_count_check.rb
 lib/roodi/checks/class_name_check.rb
@@ -14,10 +16,12 @@ lib/roodi/checks/cyclomatic_complexity_check.rb
 lib/roodi/checks/cyclomatic_complexity_method_check.rb
 lib/roodi/checks/empty_rescue_body_check.rb
 lib/roodi/checks/for_loop_check.rb
+lib/roodi/checks/line_count_check.rb
 lib/roodi/checks/method_line_count_check.rb
 lib/roodi/checks/method_name_check.rb
 lib/roodi/checks/module_line_count_check.rb
 lib/roodi/checks/module_name_check.rb
+lib/roodi/checks/name_check.rb
 lib/roodi/checks/parameter_number_check.rb
 lib/roodi/core.rb
 lib/roodi/core/checking_visitor.rb
@@ -26,6 +30,8 @@ lib/roodi/core/parse_tree_runner.rb
 lib/roodi/core/parser.rb
 lib/roodi/core/visitable_sexp.rb
 roodi.yml
+spec/roodi/checks/assignment_in_conditional_check_spec.rb
+spec/roodi/checks/case_missing_else_check_spec.rb
 spec/roodi/checks/class_line_count_check_spec.rb
 spec/roodi/checks/class_name_check_spec.rb
 spec/roodi/checks/cyclomatic_complexity_block_check_spec.rb

data/README.txt

@@ -13,7 +13,7 @@ Roodi stands for Ruby Object Oriented Design Inferometer.  It parses your Ruby c
 == SYNOPSIS:
 
 To check one or more files using the default configuration that comes with Roodi, use:
-    roodi [patterns]
+    roodi [-config=file] [pattern ...]
 
 === EXAMPLE USAGE
 
@@ -26,22 +26,50 @@ Check one controller and one model file in a rails app:
 Check one controller and all model files in a rails app:
     roodi app/controller/sample_controller.rb "app/models/*.rb"
 
+Check all ruby files in a rails app with a custom configuration file:
+    roodi -config=my_roodi_config.yml "rails_app/**/*.rb"
 
-If you're writing a check, it is useful to see the structure of a file the way that Roodi tokenizes it (via ParesTree). Use:
+If you're writing a check, it is useful to see the structure of a file the way that Roodi tokenizes it (via ParseTree). Use:
     roodi-describe [filename]
 
+== CUSTOM CONFIGURATION
+
+To change the set of checks included, or to change the default values of the checks, you can provide your own config file.  The config file is a YAML file that lists the checks to be included.  Each check can optionally include a hash of options that are passed to the check to configure it.  For example, the default config file looks like this:
+
+    AssignmentInConditionalCheck:    { }
+    CaseMissingElseCheck:            { }
+    ClassLineCountCheck:             { line_count: 300 }
+    ClassNameCheck:                  { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+    CyclomaticComplexityBlockCheck:  { complexity: 4 }
+    CyclomaticComplexityMethodCheck: { complexity: 8 }
+    EmptyRescueBodyCheck:            { }
+    ForLoopCheck:                    { }
+    MethodLineCountCheck:            { line_count: 20 }
+    MethodNameCheck:                 { pattern: !ruby/regexp /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ }
+    ModuleLineCountCheck:            { line_count: 300 }
+    ModuleNameCheck:                 { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+    ParameterNumberCheck:            { parameter_count: 5 }
+
 == SUPPORTED CHECKS:
 
+* AssignmentInConditionalCheck - Check for an assignment inside a conditional.  It's probably a mistaken equality comparison.
+* CaseMissingElseCheck - Check that case statements have an else statement so that all cases are covered.
+* ClassLineCountCheck - Check that the number of lines in a class is below the threshold.
 * ClassNameCheck - Check that class names match convention.
 * CyclomaticComplexityBlockCheck - Check that the cyclomatic complexity of all blocks is below the threshold.
 * CyclomaticComplexityMethodCheck - Check that the cyclomatic complexity of all methods is below the threshold.
 * EmptyRescueBodyCheck - Check that there are no empty rescue blocks.
 * ForLoopCheck - Check that for loops aren't used (Use Enumerable.each instead)
-* MethodNameCheck - Check that method names match convention.
 * MethodLineCountCheck - Check that the number of lines in a method is below the threshold.
+* MethodNameCheck - Check that method names match convention.
+* ModuleLineCountCheck - Check that the number of lines in a module is below the threshold.
 * ModuleNameCheck - Check that module names match convention.
 * ParameterNumberCheck - Check that the number of parameters on a method is below the threshold.
 
+== SUGGESTED CHECKS:
+
+* BlockVariableShadowCheck - Check that a block variable does not have the same name as a method parameter or local variable.  It may be mistakenly referenced within the block.
+
 == LICENSE:
 
 (The MIT License)

data/lib/roodi.rb

@@ -2,5 +2,5 @@ require 'roodi/checks'
 require 'roodi/core'
 
 module Roodi
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/lib/roodi/checks.rb

@@ -1,3 +1,5 @@
+require 'roodi/checks/assignment_in_conditional_check'
+require 'roodi/checks/case_missing_else_check'
 require 'roodi/checks/class_line_count_check'
 require 'roodi/checks/class_name_check'
 require 'roodi/checks/cyclomatic_complexity_block_check'

data/lib/roodi/checks/assignment_in_conditional_check.rb

@@ -0,0 +1,32 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks a conditional to see if it contains an assignment.
+    # 
+    # A conditional containing an assignment is likely to be a mistyped equality check.  You
+    # should either fix the typo or factor out the assignment so that the code is clearer.
+    class AssignmentInConditionalCheck < Check
+      def initialize(options = {})
+        super()
+      end
+      
+      def interesting_nodes
+        [:if, :while]
+      end
+
+      def evaluate(node)
+        add_error("Found = in conditional.  It should probably be an ==") if has_assignment?(node[1])
+      end
+      
+      private
+      
+      def has_assignment?(node)
+        found_assignment = false
+        found_assignment = found_assignment || node.node_type == :lasgn
+        node.children.each { |child| found_assignment = found_assignment || has_assignment?(child) }
+        found_assignment
+      end
+    end
+  end
+end

data/lib/roodi/checks/case_missing_else_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks a case statement to make sure it has an 'else' clause.
+    # 
+    # It's usually a good idea to have an else clause in every case statement. Even if the 
+    # developer is sure that all currently possible cases are covered, this should be 
+    # expressed in the else clause. This way the code is protected aginst later changes, 
+    class CaseMissingElseCheck < Check
+      def interesting_nodes
+        [:case]
+      end
+  
+      def evaluate(node)
+        add_error "Case statement is missing an else clause." unless node.last
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_line_count_check.rb

@@ -1,29 +1,17 @@
-require 'roodi/checks/check'
+require 'roodi/checks/line_count_check'
 
 module Roodi
   module Checks
-    class ClassLineCountCheck < Check
-      def initialize(line_count = 300)
-        super()
-        @line_count = line_count
-      end
+    # Checks a class to make sure the number of lines it has is under the specified limit.
+    # 
+    # A class getting too large is a code smell that indicates it might be taking on too many 
+    # responsibilities.  It should probably be refactored into multiple smaller classes. 
+    class ClassLineCountCheck < LineCountCheck
+      DEFAULT_LINE_COUNT = 300
       
-      def interesting_nodes
-        [:class]
-      end
-
-      def evaluate(node)
-        line_count = count_lines(node)
-        add_error "Class \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
-      end
-  
-      private
-  
-      def count_lines(node)
-        count = 0
-        count = count + 1 if node.node_type == :newline
-        node.children.each {|node| count += count_lines(node)}
-        count
+      def initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:class], line_count, 'Class')
       end
     end
   end

data/lib/roodi/checks/class_name_check.rb

@@ -1,16 +1,20 @@
-require 'roodi/checks/check'
+require 'roodi/checks/name_check'
 
 module Roodi
   module Checks
-    class ClassNameCheck < Check
-      def interesting_nodes
-        [:class]
+    # Checks a class name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent nameing convention makes your code easier to read.
+    class ClassNameCheck < NameCheck
+      DEFAULT_PATTERN = /^[A-Z][a-zA-Z0-9]*$/
+      
+      def initialize(options = {})
+        pattern = options['pattern'] || DEFAULT_PATTERN
+        super([:class], pattern, 'Class')
       end
-  
-      def evaluate(node)
-        class_name = node[1].class == Symbol ? node[1] : node[1].last
-        pattern = /^[A-Z][a-zA-Z0-9]*$/
-        add_error "Class name \"#{node[1]}\" should match pattern #{pattern.inspect}" unless class_name.to_s =~ pattern
+      
+      def find_name(node)
+        node[1].class == Symbol ? node[1] : node[1].last
       end
     end
   end

data/lib/roodi/checks/cyclomatic_complexity_block_check.rb

@@ -2,8 +2,20 @@ require 'roodi/checks/cyclomatic_complexity_check'
 
 module Roodi
   module Checks
+    # Checks cyclomatic complexity of a block against a specified limit. 
+    # 
+    # The cyclomatic complexity is measured by the number of "if", "unless", "elsif", "?:", 
+    # "while", "until", "for", "rescue", "case", "when", "&&", "and", "||" and "or" 
+    # statements (plus one) in the body of the member. It is a measure of the minimum 
+    # number of possible paths through the source and therefore the number of required tests. 
+    #
+    # Generally, for a block, 1-2 is considered good, 3-4 ok, 5-8 consider re-factoring, and 8+ 
+    # re-factor now!
     class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck
-      def initialize(complexity = 4)
+      DEFAULT_COMPLEXITY = 4
+      
+      def initialize(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
         super(complexity)
       end
       

data/lib/roodi/checks/cyclomatic_complexity_check.rb

@@ -2,15 +2,8 @@ require 'roodi/checks/check'
 
 module Roodi
   module Checks
-    # Checks cyclomatic complexity against a specified limit. The complexity is
-    # measured by the number of "if", "unless", "elsif", "?:", "while", "until", 
-    # "for", "rescue", "case", "when", "&&", "and", "||" and "or" statements (plus 
-    # one) in the body of the member. It is a measure of the minimum number of 
-    # possible paths through the source and therefore the number of required tests. 
-    # Generally 1-4 is considered good, 5-7 ok, 8-10 consider re-factoring, and 
-    # 11+ re-factor now!
     class CyclomaticComplexityCheck < Check
-      def initialize(complexity = 8)
+      def initialize(complexity)
         super()
         @complexity = complexity
       end

data/lib/roodi/checks/cyclomatic_complexity_method_check.rb

@@ -2,8 +2,20 @@ require 'roodi/checks/cyclomatic_complexity_check'
 
 module Roodi
   module Checks
+    # Checks cyclomatic complexity of a method against a specified limit. 
+    # 
+    # The cyclomatic complexity is measured by the number of "if", "unless", "elsif", "?:", 
+    # "while", "until", "for", "rescue", "case", "when", "&&", "and", "||" and "or" 
+    # statements (plus one) in the body of the member. It is a measure of the minimum 
+    # number of possible paths through the source and therefore the number of required tests. 
+    #
+    # Generally, for a method, 1-4 is considered good, 5-8 ok, 9-10 consider re-factoring, and 
+    # 11+ re-factor now!
     class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck
-      def initialize(complexity = 8)
+      DEFAULT_COMPLEXITY = 8
+      
+      def initialize(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
         super(complexity)
       end
       

data/lib/roodi/checks/empty_rescue_body_check.rb

@@ -2,6 +2,10 @@ require 'roodi/checks/check'
 
 module Roodi
   module Checks
+    # Checks the body of a rescue block to make sure it's not empty..
+    # 
+    # When the body of a rescue block is empty, exceptions can get caught and swallowed without
+    # any feedback to the user.
     class EmptyRescueBodyCheck < Check
       def interesting_nodes
         [:resbody]

data/lib/roodi/checks/for_loop_check.rb

@@ -2,6 +2,11 @@ require 'roodi/checks/check'
 
 module Roodi
   module Checks
+    # Checks to make sure for loops are not being used..
+    # 
+    # Using a for loop is not idiomatic use of Ruby, and is usually a sign that someone with 
+    # more experience in a different programming language is trying out Ruby.  Use 
+    # Enumerable.each with a block instead.
     class ForLoopCheck < Check
       def interesting_nodes
         [:for]

data/lib/roodi/checks/line_count_check.rb

@@ -0,0 +1,32 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class LineCountCheck < Check
+      def initialize(interesting_nodes, line_count, message_prefix)
+        super()
+        @interesting_nodes = interesting_nodes
+        @line_count = line_count
+        @message_prefix = message_prefix
+      end
+
+      def interesting_nodes
+        @interesting_nodes
+      end
+
+      def evaluate(node)
+        line_count = count_lines(node)
+        add_error "#{@message_prefix} \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
+      end
+
+      protected
+  
+      def count_lines(node)
+        count = 0
+        count = count + 1 if node.node_type == :newline
+        node.children.each {|node| count += count_lines(node)}
+        count
+      end
+    end
+  end
+end

data/lib/roodi/checks/method_line_count_check.rb

@@ -1,29 +1,18 @@
-require 'roodi/checks/check'
+require 'roodi/checks/line_count_check'
 
 module Roodi
   module Checks
-    class MethodLineCountCheck < Check
-      def initialize(line_count = 20)
-        super()
-        @line_count = line_count
-      end
+    # Checks a method to make sure the number of lines it has is under the specified limit.
+    # 
+    # A method getting too large is a code smell that indicates it might be doing more than one 
+    # thing and becoming hard to test.  It should probably be refactored into multiple methods 
+    # that each do a single thing well. 
+    class MethodLineCountCheck < LineCountCheck
+      DEFAULT_LINE_COUNT = 20
       
-      def interesting_nodes
-        [:defn]
-      end
-
-      def evaluate(node)
-        line_count = count_lines(node)
-        add_error "Method name \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
-      end
-  
-      private
-  
-      def count_lines(node)
-        count = 0
-        count = count + 1 if node.node_type == :newline
-        node.children.each {|node| count += count_lines(node)}
-        count
+      def initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:defn], line_count, 'Method')
       end
     end
   end

data/lib/roodi/checks/method_name_check.rb

@@ -1,15 +1,20 @@
-require 'roodi/checks/check'
+require 'roodi/checks/name_check'
 
 module Roodi
   module Checks
-    class MethodNameCheck < Check
-      def interesting_nodes
-        [:defn]
+    # Checks a method name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent nameing convention makes your code easier to read.
+    class MethodNameCheck < NameCheck
+      DEFAULT_PATTERN = /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+      
+      def initialize(options = {})
+        pattern = options['pattern'] || DEFAULT_PATTERN
+        super([:defn], pattern, 'Method')
       end
-
-      def evaluate(node)
-        pattern = /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
-        add_error "Method name \"#{node[1]}\" should match pattern #{pattern.inspect}" unless node[1].to_s =~ pattern
+      
+      def find_name(node)
+        node[1]
       end
     end
   end

data/lib/roodi/checks/module_line_count_check.rb

@@ -1,29 +1,17 @@
-require 'roodi/checks/check'
+require 'roodi/checks/line_count_check'
 
 module Roodi
   module Checks
-    class ModuleLineCountCheck < Check
-      def initialize(line_count = 300)
-        super()
-        @line_count = line_count
-      end
+    # Checks a module to make sure the number of lines it has is under the specified limit.
+    # 
+    # A module getting too large is a code smell that indicates it might be taking on too many 
+    # responsibilities.  It should probably be refactored into multiple smaller modules. 
+    class ModuleLineCountCheck < LineCountCheck
+      DEFAULT_LINE_COUNT = 300
       
-      def interesting_nodes
-        [:module]
-      end
-
-      def evaluate(node)
-        line_count = count_lines(node)
-        add_error "Module \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
-      end
-  
-      private
-  
-      def count_lines(node)
-        count = 0
-        count = count + 1 if node.node_type == :newline
-        node.children.each {|node| count += count_lines(node)}
-        count
+      def initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:module], line_count, 'Module')
       end
     end
   end

data/lib/roodi/checks/module_name_check.rb

@@ -1,16 +1,20 @@
-require 'roodi/checks/check'
+require 'roodi/checks/name_check'
 
 module Roodi
   module Checks
-    class ModuleNameCheck < Check
-      def interesting_nodes
-        [:module]
+    # Checks a module name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent nameing convention makes your code easier to read.
+    class ModuleNameCheck < NameCheck
+      DEFAULT_PATTERN = /^[A-Z][a-zA-Z0-9]*$/
+      
+      def initialize(options = {})
+        pattern = options['pattern'] || DEFAULT_PATTERN
+        super([:module], pattern, 'Module')
       end
-  
-      def evaluate(node)
-        class_name = node[1].class == Symbol ? node[1] : node[1].last
-        pattern = /^[A-Z][a-zA-Z0-9]*$/
-        add_error "Module name \"#{node[1]}\" should match pattern #{pattern.inspect}" unless class_name.to_s =~ pattern
+      
+      def find_name(node)
+        node[1].class == Symbol ? node[1] : node[1].last
       end
     end
   end

data/lib/roodi/checks/name_check.rb

@@ -0,0 +1,23 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class NameCheck < Check
+      def initialize(interesting_nodes, pattern, message_prefix)
+        super()
+        @interesting_nodes = interesting_nodes
+        @pattern = pattern
+        @message_prefix = message_prefix
+      end
+
+      def interesting_nodes
+        @interesting_nodes
+      end
+
+      def evaluate(node)
+        name = find_name(node)
+        add_error "#{@message_prefix} name \"#{name}\" should match pattern #{@pattern.inspect}" unless name.to_s =~ @pattern
+      end
+    end
+  end
+end

data/lib/roodi/checks/parameter_number_check.rb

@@ -2,10 +2,17 @@ require 'roodi/checks/check'
 
 module Roodi
   module Checks
+    # Checks a method to make sure the number of parameters it has is under the specified limit.
+    # 
+    # A method taking too many parameters is a code smell that indicates it might be doing too 
+    # much, or that the parameters should be grouped into one or more objects of their own.  It
+    # probably needs some refactoring. 
     class ParameterNumberCheck < Check
-      def initialize(parameter_count = 5)
+      DEFAULT_PARAMETER_COUNT = 5
+      
+      def initialize(options = {})
         super()
-        @parameter_count = parameter_count
+        @parameter_count = options['parameter_count'] || DEFAULT_PARAMETER_COUNT
       end
       
       def interesting_nodes

data/lib/roodi/core.rb

@@ -1,6 +1 @@
-# require 'roodi/core/checking_visitor'
-# require 'roodi/core/iterator_visitor'
 require 'roodi/core/parse_tree_runner'
-# require 'roodi/core/printing_visitor'
-# require 'roodi/core/runner'
-# require 'roodi/core/tree_walker'

data/lib/roodi/core/parse_tree_runner.rb

@@ -11,6 +11,8 @@ module Roodi
     class ParseTreeRunner
       DEFAULT_CONFIG = File.join(File.dirname(__FILE__), "..", "..", "..", "roodi.yml")
       
+      attr_writer :config
+      
       def initialize(*checks)
         @config = DEFAULT_CONFIG
         @checks = checks unless checks.empty?
@@ -63,9 +65,11 @@ module Roodi
 
       def load_checks
         check_objects = []
-        check_config = YAML.load_file @config
-        checks = check_config["checks"]
-        checks.each { |check| check_objects << eval("Roodi::Checks::#{check['name']}.new") }
+        checks = YAML.load_file @config
+        checks.each do |check| 
+          klass = eval("Roodi::Checks::#{check[0]}")
+          check_objects << (check[1].empty? ? klass.new : klass.new(check[1]))
+        end
         check_objects
       end
     end

data/roodi.yml

@@ -1,13 +1,14 @@
-checks:
-- { name: ClassLineCountCheck }
-- { name: ClassNameCheck }
-- { name: CyclomaticComplexityBlockCheck }
-- { name: CyclomaticComplexityMethodCheck }
-- { name: EmptyRescueBodyCheck }
-- { name: ForLoopCheck }
-- { name: MethodLineCountCheck }
-- { name: MethodNameCheck }
-- { name: ModuleLineCountCheck }
-- { name: ModuleNameCheck }
-- { name: ParameterNumberCheck }
-
+AssignmentInConditionalCheck:    { }
+CaseMissingElseCheck:            { }
+ClassLineCountCheck:             { line_count: 300 }
+ClassNameCheck:                  { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+CyclomaticComplexityBlockCheck:  { complexity: 4 }
+CyclomaticComplexityMethodCheck: { complexity: 8 }
+EmptyRescueBodyCheck:            { }
+ForLoopCheck:                    { }
+MethodLineCountCheck:            { line_count: 20 }
+MethodNameCheck:                 { pattern: !ruby/regexp /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ }
+ModuleLineCountCheck:            { line_count: 300 }
+ModuleNameCheck:                 { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+ParameterNumberCheck:            { parameter_count: 5 }
+ 

data/spec/roodi/checks/assignment_in_conditional_check_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Roodi::Checks::AssignmentInConditionalCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::AssignmentInConditionalCheck.new)
+  end
+  
+  it "should accept an assignment before an if clause" do
+    content = <<-END
+    count = count + 1 if some_condition
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should be_empty
+  end
+
+  it "should reject an assignment inside an if clause" do
+    content = <<-END
+    call_foo if bar = bam
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Found = in conditional.  It should probably be an ==")
+  end
+
+  it "should reject an assignment inside an unless clause" do
+    content = <<-END
+    call_foo unless bar = bam
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Found = in conditional.  It should probably be an ==")
+  end
+
+  it "should reject an assignment inside a while clause" do
+    content = <<-END
+    call_foo while bar = bam
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Found = in conditional.  It should probably be an ==")
+  end
+
+  it "should reject an assignment inside an unless clause" do
+    content = <<-END
+    call_foo while bar = bam
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Found = in conditional.  It should probably be an ==")
+  end
+
+  it "should reject an assignment inside a a ternary operator check clause" do
+    content = <<-END
+    call_foo (bar = bam) ? baz : bad
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Found = in conditional.  It should probably be an ==")
+  end
+end

data/spec/roodi/checks/case_missing_else_check_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Roodi::Checks::CaseMissingElseCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CaseMissingElseCheck.new)
+  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].should eql("dummy-file.rb:1 - Case statement is missing an else clause.")
+  end
+end

data/spec/roodi/checks/class_line_count_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::ClassLineCountCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ClassLineCountCheck.new(1))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ClassLineCountCheck.new({'line_count' => 1}))
   end
   
   it "should accept classes with less lines than the threshold" do

data/spec/roodi/checks/cyclomatic_complexity_block_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::CyclomaticComplexityBlockCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityBlockCheck.new(0))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityBlockCheck.new({'complexity' => 0}))
   end
 
   def verify_content_complexity(content, complexity)

data/spec/roodi/checks/cyclomatic_complexity_method_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::CyclomaticComplexityMethodCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityMethodCheck.new(0))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityMethodCheck.new({'complexity' => 0}))
   end
 
   def verify_content_complexity(content, complexity)

data/spec/roodi/checks/method_line_count_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::MethodLineCountCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::MethodLineCountCheck.new(1))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::MethodLineCountCheck.new({'line_count' => 1}))
   end
   
   it "should accept methods with less lines than the threshold" do
@@ -34,6 +34,6 @@ describe Roodi::Checks::MethodLineCountCheck do
     @roodi.check_content(content)
     errors = @roodi.errors
     errors.should_not be_empty
-    errors[0].should eql("dummy-file.rb:1 - Method name \"two_line_method\" has 2 lines.  It should have 1 or less.")
+    errors[0].should eql("dummy-file.rb:1 - Method \"two_line_method\" has 2 lines.  It should have 1 or less.")
   end
 end

data/spec/roodi/checks/module_line_count_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::ModuleLineCountCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ModuleLineCountCheck.new(1))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ModuleLineCountCheck.new({'line_count' => 1}))
   end
   
   it "should accept modules with less lines than the threshold" do

data/spec/roodi/checks/parameter_number_check_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Roodi::Checks::ParameterNumberCheck do
   before(:each) do
-    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ParameterNumberCheck.new(1))
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ParameterNumberCheck.new({'parameter_count' => 1}))
   end
   
   it "should accept methods with less lines than the threshold" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: roodi
 version: !ruby/object:Gem::Version 
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Marty Andrews
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-09-11 00:00:00 +10:00
+date: 2008-09-19 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,6 +63,8 @@ files:
 - bin/roodi-describe
 - lib/roodi.rb
 - lib/roodi/checks.rb
+- lib/roodi/checks/assignment_in_conditional_check.rb
+- lib/roodi/checks/case_missing_else_check.rb
 - lib/roodi/checks/check.rb
 - lib/roodi/checks/class_line_count_check.rb
 - lib/roodi/checks/class_name_check.rb
@@ -71,10 +73,12 @@ files:
 - lib/roodi/checks/cyclomatic_complexity_method_check.rb
 - lib/roodi/checks/empty_rescue_body_check.rb
 - lib/roodi/checks/for_loop_check.rb
+- lib/roodi/checks/line_count_check.rb
 - lib/roodi/checks/method_line_count_check.rb
 - lib/roodi/checks/method_name_check.rb
 - lib/roodi/checks/module_line_count_check.rb
 - lib/roodi/checks/module_name_check.rb
+- lib/roodi/checks/name_check.rb
 - lib/roodi/checks/parameter_number_check.rb
 - lib/roodi/core.rb
 - lib/roodi/core/checking_visitor.rb
@@ -83,6 +87,8 @@ files:
 - lib/roodi/core/parser.rb
 - lib/roodi/core/visitable_sexp.rb
 - roodi.yml
+- spec/roodi/checks/assignment_in_conditional_check_spec.rb
+- spec/roodi/checks/case_missing_else_check_spec.rb
 - spec/roodi/checks/class_line_count_check_spec.rb
 - spec/roodi/checks/class_name_check_spec.rb
 - spec/roodi/checks/cyclomatic_complexity_block_check_spec.rb