roodi1.9 2.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+doc
+pkg

data/History.txt

@@ -0,0 +1,88 @@
+= 2.0.1
+
+* Fixed a bug where roodi.yml was not being loaded.  Patch supplied by Rob Mitchell.
+
+= 2.0.0
+
+* Changed internal structure to use a more pure visitor like pattern.
+* Got *much* faster as a result of the change.
+* Design change fixed 'feature' where nested blocks would all get listed if the inner one exceeded complexity.
+* Outline for NPath complexity check is now possible.  Not working yet though.
+* Removed dependency on facets library.
+
+= 1.4.0
+
+* Upgraded from ParseTree to ruby_parser.
+
+= 1.3.7
+
+* Fixed a bug in the rake task where it always failed even if no errors existed.
+
+= 1.3.6
+
+* Added nil as a valid response for an empty rescue block
+
+= 1.3.5
+
+* Fixed bug in rake task
+
+= 1.3.4
+
+* Minor cleanup
+
+= 1.3.3
+
+* Added a rake task
+
+= 1.3.1
+
+* wrapped errors in an object to become more usable as an API.
+
+= 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.
+* added parameter number check.
+* added module line count check.
+* added class line count check.
+
+= 1.1.1
+
+* I'd initially published to Rubyforge under a 1.0.0 gem, and I've since tried to retrospectively fix up the version number system.  It turns out that Rubyforge caches old gems permanently, so I have to re-start at a larger number again.
+* class name check no longer gets confused about scoped class names like Module::Classname.
+
+= 0.5
+
+* expanded regex matching for method name check.
+* suppressed noisy output from ParseTree using facets API.
+* updated dependencies and version as a result of facets change.
+* made Roodi tolerant of being asked to parse files which aren't really Ruby files.
+* updated the documentation with usage examples.
+
+= 0.4
+
+* Added support back in for line numbers in error messages.
+* Re-enabled MethodLineCountCheck as part of the default check set.
+
+= 0.3
+
+* First version of Roodi to be published to Rubyforge.
+
+= 0.2
+
+* Now use ParseTree instead of JRuby, which makes the tool much more accessible.
+* Removed MagicNumberCheck
+* Line numbers no longer supported as a result of the move.
+
+= 0.1
+
+* A first version of a design checking tool for Ruby, with a few checks built in to get started.
+

data/Manifest.txt

@@ -0,0 +1,56 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/roodi
+bin/roodi-describe
+lib/roodi.rb
+lib/roodi/checks.rb
+lib/roodi/checks/abc_metric_method_check.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
+lib/roodi/checks/class_variable_check.rb
+lib/roodi/checks/control_coupling_check.rb
+lib/roodi/checks/cyclomatic_complexity_block_check.rb
+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/npath_complexity_check.rb
+lib/roodi/checks/npath_complexity_method_check.rb
+lib/roodi/checks/parameter_number_check.rb
+lib/roodi/core.rb
+lib/roodi/core/checking_visitor.rb
+lib/roodi/core/error.rb
+lib/roodi/core/parser.rb
+lib/roodi/core/runner.rb
+lib/roodi/core/visitable_sexp.rb
+lib/roodi_task.rb
+roodi.yml
+spec/roodi/checks/abc_metric_method_check_spec.rb
+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/class_variable_check_spec.rb
+spec/roodi/checks/control_coupling_check_spec.rb
+spec/roodi/checks/cyclomatic_complexity_block_check_spec.rb
+spec/roodi/checks/cyclomatic_complexity_method_check_spec.rb
+spec/roodi/checks/empty_rescue_body_check_spec.rb
+spec/roodi/checks/for_loop_check_spec.rb
+spec/roodi/checks/method_line_count_check_spec.rb
+spec/roodi/checks/method_name_check_spec.rb
+spec/roodi/checks/module_line_count_check_spec.rb
+spec/roodi/checks/module_name_check_spec.rb
+spec/roodi/checks/npath_complexity_method_check_spec.rb
+spec/roodi/checks/parameter_number_check_spec.rb
+spec/spec_helper.rb

data/README.md

@@ -0,0 +1,123 @@
+roodi
+=====
+
+* http://roodi.rubyforge.org
+
+DESCRIPTION:
+============
+
+Roodi stands for Ruby Object Oriented Design Inferometer.  It parses your Ruby code and warns you about design issues you have based on the checks that is has configured.
+
+INSTALL:
+========
+
+```
+gem install roodi1.9
+```
+
+SYNOPSIS:
+=========
+
+To check one or more files using the default configuration that comes with Roodi, use:
+
+``` bash
+    roodi1.9 [-config=file] [pattern ...]
+```
+
+EXAMPLE USAGE
+=============
+
+Check all ruby files in a rails app:
+```
+    roodi1.9 "rails_app/**/*.rb"
+```
+
+Check one controller and one model file in a rails app:
+```
+   roodi1.9 app/controller/sample_controller.rb app/models/sample.rb
+```
+
+Check one controller and all model files in a rails app:
+```
+   roodi1.9 app/controller/sample_controller.rb "app/models/*.rb"
+```
+
+Check all ruby files in a rails app with a custom configuration file:
+```
+   roodi1.9 -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 ruby_parser). Use:
+```
+   roodi1.9-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)
+* 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)
+
+Copyright (c) 2008 Marty Andrews
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,40 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+begin
+  require "bundler"
+  require "bundler/gem_tasks"
+  Bundler.setup
+rescue LoadError
+  $stderr.puts "You need to have Bundler installed to be able build this gem."
+end
+
+# require 'hoe'
+# require 'rake'
+# require 'spec/rake/spectask'
+# require 'roodi'
+# 
+# Hoe.new('roodi', Roodi::VERSION) do |p|
+#   p.developer('Marty Andrews', 'marty@cogentconsulting.com.au')
+#   p.extra_deps = ['ruby_parser']
+#   p.remote_rdoc_dir = ''
+# end
+# 
+# def roodi(ruby_files)
+#   roodi = Roodi::Core::Runner.new
+#   ruby_files.each { |file| roodi.check_file(file) }
+#   roodi.errors.each {|error| puts error}
+#   puts "\nFound #{roodi.errors.size} errors."
+# end
+# 
+# desc "Run all specs"
+# Spec::Rake::SpecTask.new('spec') do |t|
+#   t.spec_files = FileList['spec/**/*spec.rb']
+# end
+# 
+# desc "Run Roodi against all source files"
+# task :roodi do
+#   pattern = File.join(File.dirname(__FILE__), "**", "*.rb")
+#   roodi(Dir.glob(pattern))
+# end
+# 
+# task :default => :spec

data/bin/roodi1.9

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+require 'roodi'
+
+runner = Roodi::Core::Runner.new
+
+config_param = ARGV.detect {|arg| arg =~ /-config=.*/}
+runner.config = config_param.split("=")[1] if config_param
+ARGV.delete config_param
+
+ARGV.each do |arg|
+  Dir.glob(arg).each { |file| runner.check_file(file) }
+end
+
+runner.errors.each {|error| puts error}
+
+puts "\nFound #{runner.errors.size} errors."
+
+exit runner.errors.size

data/bin/roodi1.9-describe

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'roodi'
+
+roodi = Roodi::Core::Runner.new
+roodi.print_file(ARGV[0])

data/lib/roodi/checks/abc_metric_method_check.rb

@@ -0,0 +1,77 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # TODO:  Add summary
+    # 
+    # TODO:  Add detail
+    class AbcMetricMethodCheck < Check
+      # ASSIGNMENTS = [:attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn]
+      ASSIGNMENTS = [:lasgn]
+      # BRANCHES = [:if, :else, :while, :until, :for, :rescue, :case, :when, :and, :or]
+      BRANCHES = [:vcall, :call]
+      # CONDITIONS = [:and, :or]
+      CONDITIONS = [:==, :<=, :>=, :<, :>]
+      #  =  *=  /=  %=  +=  <<=  >>=  &=  |=  ^=
+      OPERATORS = [:*, :/, :%, :+, :<<, :>>, :&, :|, :^]
+      DEFAULT_SCORE = 10
+      
+      def initialize(options = {})
+        super()
+        @score = options['score'] || DEFAULT_SCORE
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate_start(node)
+        method_name = node[1]
+        a = count_assignments(node)
+        b = count_branches(node)
+        c = count_conditionals(node)
+        score = Math.sqrt(a*a + b*b + c*c)
+        add_error "Method name \"#{method_name}\" has an ABC metric score of <#{a},#{b},#{c}> = #{score}.  It should be #{@score} or less." unless score <= @score
+      end
+      
+      private
+
+      def count_assignments(node)
+        count = 0
+        count = count + 1 if assignment?(node)
+        node.children.each {|node| count += count_assignments(node)}
+        count
+      end
+      
+      def count_branches(node)
+        count = 0
+        count = count + 1 if branch?(node)
+        node.children.each {|node| count += count_branches(node)}
+        count
+      end
+
+      def count_conditionals(node)
+        count = 0
+        count = count + 1 if conditional?(node)
+        node.children.each {|node| count += count_conditionals(node)}
+        count
+      end
+      
+      def assignment?(node)
+        ASSIGNMENTS.include?(node.node_type)
+      end
+      
+      def branch?(node)
+        BRANCHES.include?(node.node_type) && !conditional?(node) && !operator?(node)
+      end
+      
+      def conditional?(node)
+        (:call == node.node_type) && CONDITIONS.include?(node[2]) 
+      end
+      
+      def operator?(node)
+        (:call == node.node_type) && OPERATORS.include?(node[2]) 
+      end      
+    end
+  end
+end

data/lib/roodi/checks/assignment_in_conditional_check.rb

@@ -0,0 +1,34 @@
+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_start(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
+        if (node.node_type == :and or node.node_type == :or)
+          node.children.each { |child| found_assignment = found_assignment || has_assignment?(child) }
+        end
+        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_start(node)
+        add_error "Case statement is missing an else clause." unless node.last
+      end
+    end
+  end
+end

data/lib/roodi/checks/check.rb

@@ -0,0 +1,61 @@
+require 'roodi/core/error'
+
+module Roodi
+  module Checks
+    class Check
+      NODE_TYPES = [:defn, :module, :resbody, :lvar, :cvar, :class, :if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+      def initialize
+        @errors = []
+      end
+  
+      NODE_TYPES.each do |node|
+        start_node_method = "evaluate_start_#{node}"
+        end_node_method = "evaluate_end_#{node}"
+        define_method(start_node_method) { |node| return } unless self.respond_to?(start_node_method)
+        define_method(end_node_method) { |node| return } unless self.respond_to?(end_node_method)
+      end
+
+      def position(offset = 0)
+        "#{@line[2]}:#{@line[1] + offset}"
+      end
+
+      def start_file(filename)
+      end
+      
+      def end_file(filename)
+      end
+      
+      def evaluate_start(node)
+      end
+
+      def evaluate_end(node)
+      end
+
+      def evaluate_node(position, node)
+        @node = node
+        eval_method = "evaluate_#{position}_#{node.node_type}"
+        self.send(eval_method, node)
+      end
+
+      def evaluate_node_start(node)
+        evaluate_node(:start, node)
+        evaluate_start(node)
+      end
+  
+      def evaluate_node_end(node)
+        evaluate_node(:end, node)
+        evaluate_end(node)
+      end
+  
+      def add_error(error, filename = @node.file, line = @node.line)
+        @errors ||= []
+        @errors << Roodi::Core::Error.new("#{filename}", "#{line}", error)
+      end
+  
+      def errors
+        @errors
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_line_count_check.rb

@@ -0,0 +1,18 @@
+require 'roodi/checks/line_count_check'
+
+module Roodi
+  module Checks
+    # 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 initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:class], line_count, 'Class')
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_name_check.rb

@@ -0,0 +1,21 @@
+require 'roodi/checks/name_check'
+
+module Roodi
+  module Checks
+    # Checks a class name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent naming 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 find_name(node)
+        node[1].class == Symbol ? node[1] : node[1].last
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_variable_check.rb

@@ -0,0 +1,24 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks to make sure class variables are not being used..
+    # 
+    # Class variables in Ruby have a complicated inheritance policy, and their use 
+    # can lead to mistakes.  Often an alternate design can be used to solve the 
+    # problem instead.
+    #
+    # This check is looking for a code smell rather than a definite error.  If you're 
+    # sure that you're doing the right thing, try turning this check off in your 
+    # config file.
+    class ClassVariableCheck < Check
+      def interesting_nodes
+        [:cvar]
+      end
+
+      def evaluate_start(node)
+        add_error "Don't use class variables. You might want to try a different design."
+      end
+    end
+  end
+end

data/lib/roodi/checks/control_coupling_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class ControlCouplingCheck < Check
+      def interesting_nodes
+        [:defn, :lvar]
+      end
+
+      def evaluate_start_defn(node)
+        @method_name = node[1]
+        @arguments = node[2][1..-1]
+      end
+        
+      def evaluate_start_lvar(node)
+        add_error "Method \"#{@method_name}\" uses the argument \"#{node[1]}\" for internal control." if @arguments.detect {|each| each == node[1]}
+      end
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_block_check.rb

@@ -0,0 +1,39 @@
+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
+      DEFAULT_COMPLEXITY = 4
+      
+      def initialize(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
+        super(complexity)
+      end
+      
+      def interesting_nodes
+        [:iter] + COMPLEXITY_NODE_TYPES
+      end
+
+      def evaluate_start_iter(node)
+        increase_depth
+      end
+
+      def evaluate_end_iter(node)
+        decrease_depth
+      end
+      
+      def evaluate_matching_end
+        add_error "Block cyclomatic complexity is #{@count}.  It should be #{@complexity} or less." unless @count <= @complexity
+      end
+    end
+  end
+end