reek 0.3.0 → 0.3.1

data/lib/reek/smells/duplication.rb

@@ -0,0 +1,54 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+require 'reek/printer'
+
+module Reek
+  module Smells
+
+    #
+    # Duplication occurs when two fragments of code look nearly identical,
+    # or when two fragments of code have nearly identical effects
+    # at some conceptual level.
+    # 
+    # Currently +Duplication+ checks for repeated identical method calls
+    # within any one method definition. For example, the following method
+    # will report a warning:
+    # 
+    #   def double_thing()
+    #     @other.thing + @other.thing
+    #   end
+    #
+    class Duplication < Smell
+
+      #
+      # Checks the given +method+ for duplication.
+      # Any smells found are added to the +report+; returns true in that case,
+      # and false otherwise.
+      #
+      def self.examine(method, report)
+        look_for_duplicate_calls(method, report)
+      end
+
+      def self.look_for_duplicate_calls(method, report)  # :nodoc:
+        smell_reported = false
+        method.calls.select {|key,val| val > 1}.each do |call_exp|
+          call = call_exp[0]
+          report << new(method, call_exp[0]) unless call[2] == :new
+          smell_reported = true
+        end
+        return smell_reported
+      end
+
+      def initialize(context, call)
+        super(context)
+        @call = call
+      end
+
+      def detailed_report
+        "#{@context} calls #{Printer.print(@call)} more than once"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/feature_envy.rb

@@ -0,0 +1,65 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # Feature Envy occurs when a code fragment references another object
+    # more often than it references itself, or when several clients do
+    # the same series of manipulations on a particular type of object.
+    # 
+    # A simple example would be the following method, which "belongs"
+    # on the Item class and not on the Cart class:
+    # 
+    #  class Cart
+    #    def price
+    #      @item.price + @item.tax
+    #    end
+    #  end
+    #
+    # Feature Envy reduces the code's ability to communicate intent:
+    # code that "belongs" on one class but which is located in another
+    # can be hard to find, and may upset the "System of Names"
+    # in the host class.
+    # 
+    # Feature Envy also affects the design's flexibility: A code fragment
+    # that is in the wrong class creates couplings that may not be natural
+    # within the application's domain, and creates a loss of cohesion
+    # in the unwilling host class.
+    # 
+    # Currently +FeatureEnvy+ reports any method that refers to self less
+    # often than it refers to (ie. send messages to) some other object.
+    #
+    class FeatureEnvy < Smell
+
+      #
+      # Checks whether the given +method+ includes any code fragment that
+      # might "belong" on another class.
+      # Any smells found are added to the +report+; returns true in that case,
+      # and false otherwise.
+      #
+      def self.examine(method, report)
+        return false if method.name == 'initialize'
+        return false if method.refs.self_is_max?
+        smell_found = false
+        method.refs.max_keys.each do |r|
+          report << new(method, Printer.print(r))
+          smell_found = true
+        end
+        smell_found
+      end
+      
+      def initialize(context, receiver)
+        super(context)
+        @receiver = receiver
+      end
+
+      def detailed_report
+        "#{@context} refers to #{@receiver} more than self"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/large_class.rb

@@ -0,0 +1,35 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # A Large Class is a class or module that has a large number of
+    # instance variables, methods or lines of code.
+    # 
+    # Currently +LargeClass+ only reports classes having more than
+    # +MAX_ALLOWED+ public methods.
+    #
+    class LargeClass < Smell
+      MAX_ALLOWED = 25
+
+      def self.non_inherited_methods(klass)
+        return klass.instance_methods if klass.superclass.nil?
+        klass.instance_methods - klass.superclass.instance_methods
+      end
+
+      def recognise?(name)
+        klass = Object.const_get(name) rescue return
+        @num_methods = LargeClass.non_inherited_methods(klass).length
+        @num_methods > MAX_ALLOWED
+      end
+
+      def detailed_report
+        "#{@context} has #{@num_methods} methods"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/long_method.rb

@@ -0,0 +1,35 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # A Long Method is any method that has a large number of lines.
+    #
+    # Currently +LongMethod+ reports any method with more than
+    # +MAX_ALLOWED+ statements.
+    #
+    class LongMethod < Smell
+
+      MAX_ALLOWED = 5
+
+      def self.examine(method, report)
+        return if method.name == 'initialize'
+        num = method.num_statements
+        report << new(method, num) if num > MAX_ALLOWED
+      end
+
+      def initialize(context, num)
+        super(context)
+        @num_stmts = num
+      end
+
+      def detailed_report
+        "#{@context} has approx #{@num_stmts} statements"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/long_parameter_list.rb

@@ -0,0 +1,36 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # A Long Parameter List occurs when a method has more than one
+    # or two parameters, or when a method yields more than one or
+    # two objects to an associated block.
+    #
+    # Currently +LongParameterList+ reports any method with more
+    # than +MAX_ALLOWED+ parameters.
+    #
+    class LongParameterList < Smell
+      MAX_ALLOWED = 3
+
+      def self.count_parameters(exp)
+        result = exp.length - 1
+        result -= 1 if Array === exp[-1] and exp[-1][0] == :block
+        result
+      end
+
+      def recognise?(args)
+        @num_params = LongParameterList.count_parameters(args)
+        @num_params > MAX_ALLOWED
+      end
+
+      def detailed_report
+        "#{@context.to_s} has #{@num_params} parameters"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/long_yield_list.rb

@@ -0,0 +1,20 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    class LongYieldList < LongParameterList
+      def recognise?(args)
+        @num_params = args.length
+        Array === args and @num_params > MAX_ALLOWED
+      end
+
+      def detailed_report
+        "#{@context} yields #{@num_params} parameters"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/nested_iterators.rb

@@ -0,0 +1,24 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # A Nested Iterator occurs when a block contains another block.
+    #
+    # +NestedIterators+ reports failing methods only once.
+    #
+    class NestedIterators < Smell
+      def recognise?(already_in_iter)
+        already_in_iter && @context
+      end
+
+      def detailed_report
+        "#{@context} has nested iterators"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/smell.rb

@@ -0,0 +1,56 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/options'
+
+module Reek
+  module Smells
+
+    class Smell
+      include Comparable
+
+      def self.convert_camel_case(class_name)
+        class_name.gsub(/([a-z])([A-Z])/) { |s| "#{$1} #{$2}"}
+      end
+
+      def initialize(context, arg=nil)
+        @context = context
+      end
+
+      def self.check(exp, context, arg=nil)
+        smell = new(context, arg)
+        return false unless smell.recognise?(exp)
+        context.report(smell)
+        true
+      end
+
+      def recognise?(stuff)
+        @context != nil
+      end
+
+      def hash  # :nodoc:
+        report.hash
+      end
+
+      def <=>(other)  # :nodoc:
+        Options[:sort_order].compare(self, other)
+      end
+
+      alias eql? <=>
+
+      def name
+        Smell.convert_camel_case(self.class.name.split(/::/)[2])
+      end
+
+      def report
+        "[#{name}] #{detailed_report}"
+      end
+
+      alias inspect report
+
+      def to_s
+        report
+      end
+    end
+
+  end
+end

data/lib/reek/smells/smells.rb

@@ -0,0 +1,24 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/control_couple'
+require 'reek/smells/duplication'
+require 'reek/smells/feature_envy'
+require 'reek/smells/long_method'
+require 'reek/smells/long_parameter_list'
+require 'reek/smells/long_yield_list'
+require 'reek/smells/nested_iterators'
+require 'reek/smells/uncommunicative_name'
+require 'reek/smells/utility_function'
+
+module Reek
+  
+  SMELLS = {
+    :defn => [
+      Smells::UncommunicativeName,
+      Smells::LongMethod,
+      Smells::Duplication,
+      Smells::UtilityFunction,
+      Smells::FeatureEnvy
+      ]
+  }
+end

data/lib/reek/smells/uncommunicative_name.rb

@@ -0,0 +1,72 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # An Uncommunicative Name is a name that doesn't communicate its intent
+    # well enough.
+    # 
+    # Poor names make it hard for the reader to build a mental picture
+    # of what's going on in the code. They can also be mis-interpreted;
+    # and they hurt the flow of reading, because the reader must slow
+    # down to interpret the names.
+    #
+    # Currently +UncommunicativeName+ checks for
+    # * 1-character names
+    # * names consisting of a single character followed by a number
+    #
+    class UncommunicativeName < Smell
+
+      #
+      # Checks the given +method+ for uncommunicative method name,
+      # parameter names, local variable names and instance variable names.
+      # Any smells found are added to the +report+; returns true in that case,
+      # and false otherwise.
+      #
+      def self.examine(method, report)
+        smell_reported = consider(method.name, method, report, 'method')
+        method.parameters.each do |param|
+          smell_reported = consider(param, method, report, 'parameter') || smell_reported
+        end
+        method.local_variables.each do |lvar|
+          smell_reported = consider(lvar, method, report, 'local variable') || smell_reported
+        end
+        method.instance_variables.each do |ivar|
+          smell_reported = consider(ivar, method, report, 'field') || smell_reported
+        end
+        smell_reported
+      end
+
+      def self.consider(sym, method, report, type)  # :nodoc:
+        name = sym.to_s
+        if is_bad_name?(name)
+          report << new(name, method, type)
+          return true
+        end
+        return false
+      end
+
+      def self.is_bad_name?(name)
+        return false if name == '*'
+        name = name[1..-1] while /^@/ === name
+        return true if name.length < 2
+        return true if /^.[0-9]$/ === name
+        false
+      end
+
+      def initialize(name, context, symbol_type)
+        super(context, symbol_type)
+        @bad_name = name
+        @symbol_type = symbol_type
+      end
+
+      def detailed_report
+        "#{@context} uses the #{@symbol_type} name '#{@bad_name}'"
+      end
+    end
+
+  end
+end

data/lib/reek/smells/utility_function.rb

@@ -0,0 +1,34 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    # 
+    # A Utility Function is any instance method that has no
+    # dependency on the state of the instance.
+    #
+    class UtilityFunction < Smell
+
+      #
+      # Checks whether the given +method+ is a utility function.
+      # Any smells found are added to the +report+; returns true in that case,
+      # and false otherwise.
+      #
+      def self.examine(method, report)
+        return false if method.name == 'initialize'
+        if method.num_statements > 0 and !method.depends_on_self
+          report << new(method)
+          true
+        end
+        false
+      end
+
+      def detailed_report
+        "#{@context} doesn't depend on instance state"
+      end
+    end
+
+  end
+end