reek 0.3.0 → 0.3.1

data/History.txt

@@ -1,4 +1,14 @@
-== 0.2.x 2008-??-??
+== 0.3.1 2008-11-17
+
+* Minor enhancements:
+  * Uncommunicative Name now checks instance variables more thoroughly
+  * Uncommunicative Name now warns about names of the form 'x2'
+  * Added check for duplicated calls within a method
+  * Reduced scope of Feature Envy warnings to cover only overuse of lvars
+  * Added rdoc comments explaining what each smell is about
+  * Chained iterators are no longer mis-reported as nested
+
+== 0.3.0 2008-11-02
 
 * Minor enhancements:
   * New smell: first naive checks for Control Couple

data/README.txt

@@ -20,6 +20,7 @@ Reek currently includes very naive checks for the following smells:
 * Utility Function
 * Nested Iterators
 * Control Couple
+* Duplication
 
 == FEATURES/PROBLEMS:
 

data/lib/reek.rb

@@ -6,21 +6,20 @@ require 'reek/report'
 module Reek # :doc:
 
   #
-  # Analyse the given source files, looking for code smells.
+  # Analyse the given source, looking for code smells.
+  # The source can be a filename or a String containing Ruby code.
   # Returns a +Report+ listing the smells found.
   #
-  def self.analyse(*files)  # :doc:
+  def self.analyse(src)  # :doc:
     report = Report.new
-    files.each do |file|
-      source = Reek.read(file)
-      FileChecker.new(report).check_source(source)
-    end
+    source = Reek.get_source(src)
+    FileChecker.new(report).check_source(source)
     report
   end
 
 private
 
-  def self.read(file)
-    File.exists?(file) ? IO.readlines(file).join : file
+  def self.get_source(src)
+    File.exists?(src) ? IO.readlines(src).join : src
   end
-end
+end

data/lib/reek/checker.rb

@@ -12,8 +12,6 @@ module Reek
       ParseTree.new.parse_tree_for_string(code)
     end
 
-    attr_accessor :description
-
     # Creates a new Ruby code checker. Any smells discovered by
     # +check_source+ or +check_object+ will be stored in +report+.
     def initialize(report)
@@ -29,6 +27,11 @@ module Reek
       s(exp)
     end
 
+    def process_defn(exp)  # :nodoc:
+      Reek::MethodChecker.new(@smells, @description).process(exp)
+      s(exp)
+    end  
+
     def report(smell)  # :nodoc:
       @smells << smell
     end
@@ -56,3 +59,8 @@ module Reek
     end
   end
 end
+
+# SMELL:
+# This is here to resolve a circular dependency -- MethodChecker inherits
+# Checker, which calls MethodChecker. Yuk!
+require 'reek/method_checker'

data/lib/reek/class_checker.rb

@@ -1,11 +1,13 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'reek/checker'
-require 'reek/method_checker'
+require 'reek/smells/large_class'
 
 module Reek
 
   class ClassChecker < Checker
+    
+    attr_accessor :description
 
     def initialize(report)
       super(report)
@@ -15,14 +17,9 @@ module Reek
     def process_class(exp)  # :nodoc:
       @description = exp[1].to_s
       superclass = exp[2]
-      LargeClass.check(@description, self)
+      Smells::LargeClass.check(@description, self)
       exp[3..-1].each { |defn| process(defn) } unless superclass == [:const, :Struct]
       s(exp)
     end
-
-    def process_defn(exp)  # :nodoc:
-      Reek::MethodChecker.new(@smells, @description).process(exp)
-      s(exp)
-    end  
   end
 end

data/lib/reek/file_checker.rb

@@ -2,7 +2,6 @@ $:.unshift File.dirname(__FILE__)
 
 require 'reek/checker'
 require 'reek/class_checker'
-require 'reek/method_checker'
 
 module Reek
 
@@ -17,10 +16,5 @@ module Reek
       Reek::ClassChecker.new(@smells).process(exp)
       s(exp)
     end
-
-    def process_defn(exp)  # :nodoc:
-      Reek::MethodChecker.new(@smells, @description).process(exp)
-      s(exp)
-    end  
   end
 end

data/lib/reek/method_checker.rb

@@ -1,7 +1,13 @@
 $:.unshift File.dirname(__FILE__)
 
 require 'reek/checker'
-require 'reek/smells'
+require 'reek/smells/control_couple'
+require 'reek/smells/feature_envy'
+require 'reek/smells/long_parameter_list'
+require 'reek/smells/long_yield_list'
+require 'reek/smells/nested_iterators'
+require 'reek/smells/utility_function'
+require 'reek/smells/smells'
 require 'reek/object_refs'
 require 'set'
 
@@ -9,27 +15,37 @@ module Reek
 
   class MethodChecker < Checker
 
+    attr_reader :local_variables, :name, :parameters, :num_statements
+    attr_reader :instance_variables     # TODO: should be on the class
+    attr_reader :calls, :depends_on_self, :refs
+
     def initialize(smells, klass_name)
       super(smells)
-      @class_name = @description = klass_name
+      @class_name = klass_name
       @refs = ObjectRefs.new
-      @lvars = Set.new
+      @local_variables = Set.new
+      @instance_variables = Set.new
+      @parameters = []
+      @calls = Hash.new(0)
       @num_statements = 0
       @depends_on_self = false
     end
+    
+    def description
+      "#{@class_name}##{@name}"
+    end
 
     def process_defn(exp)
-      @description = "#{@class_name}##{exp[1]}"
-      UncommunicativeName.check(exp[1], self, 'method')
-      process(exp[2])
+      name, args = exp[1..2]
+      @name = name.to_s
+      process(args)
       check_method_properties
       s(exp)
     end
 
     def process_args(exp)
-      LongParameterList.check(exp, self)
-      exp.each { |arg| UncommunicativeName.check(arg, self, 'parameter') }
-      @args = exp[1..-1]
+      Smells::LongParameterList.check(exp, self)
+      @parameters = exp[1..-1]
       s(exp)
     end
 
@@ -49,10 +65,8 @@ module Reek
     end
 
     def process_iter(exp)
-      NestedIterators.check(@inside_an_iter, self)
-      @inside_an_iter = true
-      exp[1..-1].each { |s| process(s) }
-      @inside_an_iter = false
+      Smells::NestedIterators.check(@inside_an_iter, self)
+      cascade_iter(exp)
       s(exp)
     end
 
@@ -65,16 +79,16 @@ module Reek
     def process_yield(exp)
       args = exp[1]
       if args
-        LongYieldList.check(args, self)
+        Smells::LongYieldList.check(args, self)
         process(args)
       end
       s(exp)
     end
 
     def process_call(exp)
+      @calls[exp] += 1
       receiver, meth, args = exp[1..3]
-      @refs.record_ref(receiver)
-      process(receiver)
+      deal_with_receiver(receiver, meth)
       process(args) if args
       s(exp)
     end
@@ -97,15 +111,15 @@ module Reek
     end
 
     def process_if(exp)
-      process(exp[1])
-      process(exp[2])
-      process(exp[3]) if exp[3]
-      ControlCouple.check(exp[1], self, @args)
+      cond, then_part, else_part = exp[1..3]
+      deal_with_conditional(cond, then_part)
+      process(else_part) if else_part
+      Smells::ControlCouple.check(cond, self, @parameters)
       s(exp)
     end
 
     def process_ivar(exp)
-      UncommunicativeName.check(exp[1], self, 'field')
+      @instance_variables << exp[1]
       @depends_on_self = true
       s(exp)
     end
@@ -115,12 +129,13 @@ module Reek
     end
 
     def process_lasgn(exp)
-      @lvars << exp[1]
+      @local_variables << exp[1]
       process(exp[2])
       s(exp)
     end
 
     def process_iasgn(exp)
+      @instance_variables << exp[1]
       @depends_on_self = true
       process(exp[2])
       s(exp)
@@ -153,20 +168,31 @@ module Reek
       return false unless klass.superclass
       klass.superclass.instance_methods.include?(method_name)
     end
-    
-    def method_name
-      @description.to_s.split('#')[1]
-    end
 
     def is_override?
-      MethodChecker.is_override?(@class_name, method_name)
+      MethodChecker.is_override?(@class_name, @name)
     end
 
     def check_method_properties
-      @lvars.each {|lvar| UncommunicativeName.check(lvar, self, 'local variable') }
       @depends_on_self = true if is_override?
-      FeatureEnvy.check(@refs, self) unless UtilityFunction.check(@depends_on_self, self, @num_statements)
-      LongMethod.check(@num_statements, self) unless method_name == 'initialize'
+      SMELLS[:defn].each {|smell| smell.examine(self, @smells) }
+    end
+
+    def cascade_iter(exp)
+      process(exp[1])
+      @inside_an_iter = true
+      exp[2..-1].each { |s| process(s) }
+      @inside_an_iter = false
+    end
+
+    def deal_with_conditional(cond, then_part)
+      process(cond)
+      process(then_part)
+    end
+
+    def deal_with_receiver(receiver, meth)
+      @refs.record_ref(receiver) if (receiver[0] == :lvar and meth != :new)
+      process(receiver)
     end
   end
 end

data/lib/reek/object_refs.rb

@@ -7,8 +7,6 @@ require 'reek/printer'
 module Reek
 
   class ObjectRefs
-    SELF_REF = Sexp.from_array([:lit, :self])
-
     def initialize
       @refs = Hash.new(0)
       record_reference_to_self
@@ -49,5 +47,10 @@ module Reek
     def self_is_max?
       max_keys.length == 0 || @refs[SELF_REF] == max_refs
     end
+
+  private
+    
+    SELF_REF = Sexp.from_array([:lit, :self])
+
   end
 end

data/lib/reek/printer.rb

@@ -31,7 +31,7 @@ module Reek
     end
 
     def process_array(exp)
-      @report = Printer.print(exp[1])
+      @report = exp[1..-1].map {|arg| Printer.print(arg)}.join(', ')
       s(exp)
     end
 
@@ -78,10 +78,7 @@ module Reek
     end
 
     def process_fcall(exp)
-      meth, args = exp[1..2]
-      @report = meth.to_s
-      @report += "(#{Printer.print(args)})" if args
-      s(exp)
+      process_vcall(exp)
     end
 
     def process_cvar(exp)
@@ -105,12 +102,53 @@ module Reek
       s(exp)
     end
 
+    def process_nth_ref(exp)
+      @report = "$#{exp[1]}"
+      s(exp)
+    end
+
+    def process_lasgn(exp)
+      @report = "#{exp[1]}=#{Printer.print(exp[2])}"
+      s(exp)
+    end
+
+    def process_str(exp)
+      @report = exp[1]
+      s(exp)
+    end
+
+    def process_dstr(exp)
+      @report = '"' + exp[1..-1].map {|sub| Printer.print(sub)}.join + '"'
+      s(exp)
+    end
+
+    def process_evstr(exp)
+      @report = "\#\{#{Printer.print(exp[1])}\}"
+      s(exp)
+    end
+
+    def process_true(exp)
+      @report = 'true'
+      s(exp)
+    end
+
     def process_call(exp)
       receiver, meth, args = exp[1..3]
-      @report = "#{Printer.print(receiver)}.#{meth}"
-      @report += "(#{Printer.print(args)})" if args
+      @report = "#{Printer.print(receiver)}"
+      if meth.to_s == '[]'
+        @report += Printer.format_array_args(args)
+      else
+        @report += ".#{meth}" + (args ? "(#{Printer.print(args)})" : '')
+      end
       s(exp)
     end
+
+private
+    
+    def Printer.format_array_args(args)
+      args_str = args ? Printer.print(args) : ''
+      "[#{args_str}]"
+    end
   end
   
 end

data/lib/reek/rake_task.rb

@@ -54,7 +54,7 @@ module Reek
     # Array of commandline options to pass to ruby. Defaults to [].
     attr_accessor :ruby_opts
 
-    # Whether or not to fail Rake when an error occurs (typically when specs fail).
+    # Whether or not to fail Rake when an error occurs (typically when smells are found).
     # Defaults to true.
     attr_accessor :fail_on_error
 
@@ -76,6 +76,8 @@ module Reek
       define
     end
 
+private
+    
     def define # :nodoc:
       desc "Check for code smells" unless ::Rake.application.last_comment
       task(name) { run_task }
@@ -98,9 +100,9 @@ module Reek
     end
 
     def cmd_words
-      [self.class.ruby_exe] +
+      [RakeTask.ruby_exe] +
           ruby_options +
-          [ %Q|"#{self.class.reek_script}"| ] +
+          [ %Q|"#{RakeTask.reek_script}"| ] +
           [sort_option] +
           source_file_list.collect { |fn| %["#{fn}"] }
     end

data/lib/reek/smells/control_couple.rb

@@ -0,0 +1,53 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'reek/smells/smell'
+
+module Reek
+  module Smells
+
+    #
+    # Control Coupling occurs when a method or block checks the value of
+    # a parameter in order to decide which execution path to take. The
+    # offending parameter is often called a Control Couple.
+    # 
+    # A simple example would be the <tt>quoted</tt> parameter
+    # in the following method:
+    # 
+    #  def write(quoted)
+    #    if quoted
+    #      write_quoted(@value)
+    #    else
+    #      puts @value
+    #    end
+    #  end
+    # 
+    # Control Coupling is a kind of duplication, because the calling method
+    # already knows which path should be taken.
+    # 
+    # Control Coupling reduces the code's flexibility by creating a
+    # dependency between the caller and callee:
+    # any change to the possible values of the controlling parameter must
+    # be reflected on both sides of the call.
+    # 
+    # A Control Couple also reveals a loss of simplicity: the called
+    # method probably has more than one responsibility,
+    # because it includes at least two different code paths.
+    #
+    class ControlCouple < Smell
+      def initialize(context, args)
+        super
+        @args = args
+      end
+
+      def recognise?(cond)
+        @couple = cond
+        cond[0] == :lvar and @args.include?(@couple[1])
+      end
+
+      def detailed_report
+        "#{@context} is controlled by argument #{Printer.print(@couple)}"
+      end
+    end
+
+  end
+end