metric_fu-roodi 2.2.2 → 3.0.0

data/Rakefile

@@ -1,31 +0,0 @@
-#!/usr/bin/env rake
-require 'bundler/setup'
-require 'bundler/gem_tasks'
-begin
-  require 'spec/rake/spectask'
-  desc "Run all specs in spec directory"
-  Spec::Rake::SpecTask.new(:spec) do |t|
-    t.spec_files = FileList['spec/**/*_spec.rb']
-  end
-rescue LoadError
-  require 'rspec/core/rake_task'
-  desc "Run all specs in spec directory"
-  RSpec::Core::RakeTask.new(:spec)
-end
-
-require File.expand_path('lib/roodi',File.dirname(__FILE__))
-
-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 Roodi against all source files"
-task :roodi do
-  pattern = File.join(File.dirname(__FILE__), "**", "*.rb")
-  roodi(Dir.glob(pattern))
-end
-
-task :default => :spec

data/TODO.md

@@ -1,3 +0,0 @@
-* Fix failing tests
-* Look if https://github.com/martinjandrews/roodi is being actively developed again
-* Add travis

data/lib/roodi/checks.rb

@@ -1,18 +0,0 @@
-require 'roodi/checks/abc_metric_method_check'
-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/class_variable_check'
-require 'roodi/checks/control_coupling_check'
-require 'roodi/checks/cyclomatic_complexity_block_check'
-require 'roodi/checks/cyclomatic_complexity_method_check'
-require 'roodi/checks/empty_rescue_body_check'
-require 'roodi/checks/for_loop_check'
-require 'roodi/checks/method_line_count_check'
-require 'roodi/checks/method_name_check'
-require 'roodi/checks/missing_foreign_key_index_check'
-require 'roodi/checks/module_line_count_check'
-require 'roodi/checks/module_name_check'
-require 'roodi/checks/npath_complexity_method_check'
-require 'roodi/checks/parameter_number_check'

data/lib/roodi/checks/abc_metric_method_check.rb

@@ -1,79 +0,0 @@
-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
-      
-      attr_accessor :score
-
-      def initialize
-        super()
-        self.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

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

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

@@ -1,76 +0,0 @@
-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]
-
-      class << self
-      
-        def make(options = nil)
-          check = new
-          if options
-            options.each do |name, value|
-              check.send("#{name}=", value)
-            end
-          end
-          check
-        end
-
-      end
-
-      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

@@ -1,28 +0,0 @@
-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
-        super()
-        self.line_count = DEFAULT_LINE_COUNT
-      end
-
-      def interesting_nodes
-        [:class]
-      end
-
-      def message_prefix
-        'Class'
-      end
-
-    end
-  end
-end

data/lib/roodi/checks/class_name_check.rb

@@ -1,31 +0,0 @@
-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
-        super()
-        self.pattern = DEFAULT_PATTERN
-      end
-      
-      def interesting_nodes
-        [:class]
-      end
-
-      def message_prefix
-        '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

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

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

@@ -1,41 +0,0 @@
-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
-        super()
-        self.complexity = DEFAULT_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

data/lib/roodi/checks/cyclomatic_complexity_check.rb

@@ -1,50 +0,0 @@
-require 'roodi/checks/check'
-
-module Roodi
-  module Checks
-    class CyclomaticComplexityCheck < Check
-      
-      COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
-
-      attr_accessor :complexity
-
-      def initialize
-        super()
-        @count = 0
-        @counting = 0
-      end
-      
-      COMPLEXITY_NODE_TYPES.each do |type|
-        define_method "evaluate_start_#{type}" do |node|
-          @count = @count + 1 if counting?
-        end
-      end
-      
-      protected
-      
-      def count_complexity(node)
-        count_branches(node) + 1
-      end
-      
-      def increase_depth
-        @count = 1 unless counting?
-        @counting = @counting + 1
-      end
-
-      def decrease_depth
-        @counting = @counting - 1
-        if @counting <= 0
-          @counting = 0
-          evaluate_matching_end
-        end
-      end
-      
-      private
-      
-      def counting?
-        @counting > 0
-      end
-
-    end
-  end
-end