reek 0.2.2 → 0.2.3

data/History.txt

@@ -1,3 +1,14 @@
+== 0.2.3 2008-09-22
+
+* Minor enhancements:
+  * Only reports Feature Envy when the method isn't a Utility Function
+  * General improvements to assessing Feature Envy
+* Tweaks:
+  * Fixed: coping with parameterless yield call
+  * Fixed: copes with :self as an expression
+  * Fixed: displaying the receiver of many more kinds of Feature Envy
+  * Fixed: Large Class calculation for Object
+
 == 0.2.2 2008-09-15
 
 * Tweaks:

data/README.txt

@@ -9,7 +9,7 @@
 Reek is a tool that examines Ruby classes, modules and methods and
 reports any code smells it finds.
 
-=== SUPPORTED SMELLS:
+=== SUPPORTED CODE SMELLS:
 
 * Long Method
 * Large Class
@@ -28,8 +28,9 @@ reports any code smells it finds.
 
 == SYNOPSIS:
 
-  $ cd my_project/lib
-  $ reek
+  $ reek [options] [source_files]
+
+(See `reek --help` for details.)
 
 == REQUIREMENTS:
 
@@ -37,13 +38,23 @@ reports any code smells it finds.
 
 == INSTALL:
 
-* sudo gem install reek
+Get the latest version of the gem:
+
+    $ gem install reek
+
+Or get the latest unpackaged source code:
+
+    $ git clone git://github.com/kevinrutherford/reek.git
+
+or
+
+    $ git clone git://rubyforge.org/reek.git
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008 Kevin Rutherford, Rutherford Software
+Copyright (c) 2008 Kevin Rutherford, Rutherford Software Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/reek/checker.rb

@@ -7,16 +7,26 @@ require 'sexp_processor'
 module Reek
 
   class Checker < SexpProcessor
+
+    def self.parse_tree_for(code)   # :nodoc:
+      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)
       super()
-      @require_empty = false
       @smells = report
-      @description = ''
       @unsupported -= [:cfunc]
+      @default_method = :process_default
+      @require_empty = @warn_on_default = false
+    end
+
+    def process_default(exp)
+      exp[1..-1].each { |e| process(e) if Array === e}
+      s(exp)
     end
 
     def report(smell)  # :nodoc:
@@ -27,7 +37,7 @@ module Reek
     # Any smells found are saved in the +Report+ object that
     # was passed to this object's constructor.
     def check_source(code)
-      check_parse_tree ParseTree.new.parse_tree_for_string(code)
+      check_parse_tree(Checker.parse_tree_for(code))
     end
 
     # Analyses the given Ruby object +obj+ looking for smells.

data/lib/reek/method_checker.rb

@@ -2,6 +2,7 @@ $:.unshift File.dirname(__FILE__)
 
 require 'reek/checker'
 require 'reek/smells'
+require 'reek/object_refs'
 require 'set'
 
 module Reek
@@ -11,9 +12,10 @@ module Reek
     def initialize(smells, klass_name)
       super(smells)
       @class_name = @description = klass_name
-      @calls = Hash.new(0)
+      @refs = ObjectRefs.new
       @lvars = Set.new
       @num_statements = 0
+      @depends_on_self = false
     end
 
     def process_defn(exp)
@@ -31,7 +33,17 @@ module Reek
     end
 
     def process_attrset(exp)
-      @calls[:self] += 1 if /^@/ === exp[1].to_s
+      @depends_on_self = true if /^@/ === exp[1].to_s
+      s(exp)
+    end
+
+    def process_lit(exp)
+      val = exp[1]
+      @depends_on_self = true if val == :self
+      s(exp)
+    end
+
+    def process_lvar(exp)
       s(exp)
     end
 
@@ -50,53 +62,66 @@ module Reek
     end
 
     def process_yield(exp)
-      LongYieldList.check(exp[1], self)
-      process(exp[1])
+      args = exp[1]
+      if args
+        LongYieldList.check(args, self)
+        process(args)
+      end
       s(exp)
     end
 
     def process_call(exp)
-      record_receiver(exp[1])
-      process_actual_parameters(exp[3])
-      process(exp[3]) if exp.length > 3
+      receiver, meth, args = exp[1..3]
+      @refs.record_ref(receiver)
+      process(receiver)
+      process(args) if args
       s(exp)
     end
 
     def process_fcall(exp)
-      @calls[:self] += 1
-      process(exp[2]) if exp.length > 2
+      @depends_on_self = true
+      @refs.record_reference_to_self
+      process(exp[2]) if exp.length >= 3
       s(exp)
     end
 
     def process_cfunc(exp)
-      @calls[:self] += 1
+      @depends_on_self = true
       s(exp)
     end
 
     def process_vcall(exp)
-      @calls[:self] += 1
+      @depends_on_self = true
       s(exp)
     end
 
     def process_ivar(exp)
       UncommunicativeName.check(exp[1], self, 'field')
-      @calls[:self] += 1
+      @depends_on_self = true
+      s(exp)
+    end
+
+    def process_gvar(exp)
       s(exp)
     end
 
     def process_lasgn(exp)
       @lvars << exp[1]
-      @calls[s(:lvar, exp[1])] += 1
       process(exp[2])
       s(exp)
     end
 
     def process_iasgn(exp)
-      @calls[:self] += 1
+      @depends_on_self = true
       process(exp[2])
       s(exp)
     end
 
+    def process_self(exp)
+      @depends_on_self = true
+      s(exp)
+    end
+
   private
 
     def self.count_statements(exp)
@@ -109,47 +134,29 @@ module Reek
       Array === exp and exp[0] == :gvar
     end
 
-    def record_receiver(exp)
-      receiver = MethodChecker.unpack_array(process(exp))
-      @calls[receiver] += 1 unless MethodChecker.is_global_variable?(receiver)
-    end
-
-    def self.unpack_array(receiver)
-      receiver = receiver[0] if Array === receiver and Array === receiver[0] and receiver.length == 1
-      receiver = :self if receiver == s(:self)
-      receiver
-    end
-
-    def is_override?
+    def self.is_override?(class_name, method_name)
       begin
-        klass = Object.const_get(@class_name)
+        klass = Object.const_get(class_name)
       rescue
         return false
       end
-      klass.superclass.instance_methods.include?(@description.to_s.split('#')[1])
+      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)
     end
 
     def check_method_properties
       @lvars.each {|lvar| UncommunicativeName.check(lvar, self, 'local variable') }
-      @calls[:self] += 1 if is_override?
-      UtilityFunction.check(@calls, self)
-      FeatureEnvy.check(@calls, self)
-      LongMethod.check(@num_statements, self)
-    end
-
-    def process_actual_parameters(exp)
-      return unless Array === exp and exp[0] == :array
-      exp[1..-1].each do |param|
-        if Array === param
-          if param.length == 1
-            @calls[:self] += 1 if param[0] == :self
-          else
-            @calls[param] += 1
-          end
-        else
-          @calls[:self] += 1 if param == :self
-        end
-      end
+      @depends_on_self = true if is_override?
+      FeatureEnvy.check(@refs, self) unless UtilityFunction.check(@depends_on_self, self)
+      LongMethod.check(@num_statements, self) unless method_name == 'initialize'
     end
   end
 end

data/lib/reek/object_refs.rb

@@ -0,0 +1,53 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'sexp'
+require 'reek/printer'
+
+module Reek
+
+  class ObjectRefs
+    SELF_REF = Sexp.from_array([:lit, :self])
+
+    def initialize
+      @refs = Hash.new(0)
+      record_reference_to_self
+    end
+    
+    def record_reference_to_self
+      record_ref(SELF_REF)
+    end
+
+    def record_ref(exp)
+      type = exp[0]
+      case type
+      when :gvar
+        return
+      when :self
+        record_reference_to_self
+      else
+        @refs[exp] += 1
+      end
+    end
+
+    def refs_to_self
+      @refs[SELF_REF]
+    end
+
+    def max_refs
+      @refs.values.max or 0
+    end
+
+    # TODO
+    # Should be moved to Hash; but Hash has 58 methods, and there's currently
+    # no way to turn off that report; which would therefore make the tests fail
+    def max_keys
+      max = max_refs
+      @refs.reject {|k,v| v != max}.keys
+    end
+
+    def self_is_max?
+      max_keys.length == 0 || @refs[SELF_REF] == max_refs
+    end
+  end
+end

data/lib/reek/printer.rb

@@ -13,38 +13,90 @@ module Reek
 
     def initialize
       super
-      @require_empty = false
+      @default_method = :process_default
+      @require_empty = @warn_on_default = false
       @report = ''
     end
 
     def print(sexp)
-      @report = sexp.inspect
+      @report = sexp.to_s
       return @report unless Array === sexp
-      begin
-        process(sexp)
-      rescue
-        raise "Error in print, parsing:\n #{sexp.inspect}"
-      end
+      process(sexp)
       @report
     end
 
+    def process_default(exp)
+      @report = exp.inspect
+      s(exp)
+    end
+
+    def process_array(exp)
+      @report = Printer.print(exp[1])
+      s(exp)
+    end
+
     def process_lvar(exp)
+      @report = exp[1].to_s
+      s(exp)
+    end
+
+    def process_lit(exp)
+      @report = exp[1].to_s
+      s(exp)
+    end
+
+    def process_str(exp)
       @report = exp[1].inspect
       s(exp)
     end
 
+    def process_xstr(exp)
+      @report = "`#{exp[1]}`"
+      s(exp)
+    end
+
     def process_dvar(exp)
-      @report = exp[1].inspect
+      @report = Printer.print(exp[1])
       s(exp)
     end
 
     def process_gvar(exp)
-      @report = exp[1].inspect
+      @report = exp[1].to_s
+      s(exp)
+    end
+
+    def process_ivar(exp)
+      @report = exp[1].to_s
+      s(exp)
+    end
+
+    def process_vcall(exp)
+      meth, args = exp[1..2]
+      @report = meth.to_s
+      @report += "(#{Printer.print(args)})" if args
+      s(exp)
+    end
+
+    def process_fcall(exp)
+      meth, args = exp[1..2]
+      @report = meth.to_s
+      @report += "(#{Printer.print(args)})" if args
+      s(exp)
+    end
+
+    def process_cvar(exp)
+      @report = Printer.print(exp[1])
       s(exp)
     end
 
     def process_const(exp)
-      @report = exp[1].inspect
+      @report = Printer.print(exp[1])
+      s(exp)
+    end
+
+    def process_colon2(exp)
+      mod, member = exp[1..2]
+      @report = "#{Printer.print(mod)}::#{Printer.print(member)}"
       s(exp)
     end
 
@@ -54,8 +106,9 @@ module Reek
     end
 
     def process_call(exp)
-      @report = "#{exp[1]}.#{exp[2]}"
-      @report += "(#{exp[3]})" if exp.length > 3
+      receiver, meth, args = exp[1..3]
+      @report = "#{Printer.print(receiver)}.#{meth}"
+      @report += "(#{Printer.print(args)})" if args
       s(exp)
     end
   end

data/lib/reek/smells.rb

@@ -18,12 +18,9 @@ module Reek
 
     def self.check(exp, context, arg=nil)
       smell = new(context, arg)
-      if smell.recognise?(exp)
-        context.report(smell)
-        true
-      else
-        false
-      end
+      return false unless smell.recognise?(exp)
+      context.report(smell)
+      true
     end
     
     def recognise?(stuff)
@@ -99,34 +96,21 @@ module Reek
   end
 
   class FeatureEnvy < Smell
-    
-    # TODO
-    # Should be moved to Hash; but Hash has 58 methods, and there's currently
-    # no way to turn off that report; which would therefore make the tests fail
-    def self.max_keys(calls)
-      max = calls.values.max or return [:self]
-      calls.keys.select { |key| calls[key] == max }
-    end
-
-    def initialize(context, *receivers)
-      super(context)
-      @receivers = receivers
-    end
 
-    def recognise?(calls)
-      @receivers = FeatureEnvy.max_keys(calls)
-      return !(@receivers.include?(:self))
+    def recognise?(refs)
+      @refs = refs
+      !refs.self_is_max?
     end
 
     def detailed_report
-      receiver = @receivers.map {|r| Printer.print(r)}.sort.join(' and ')
+      receiver = @refs.max_keys.map {|r| Printer.print(r)}.sort.join(' and ')
       "#{@context} uses #{receiver} more than self"
     end
   end
 
   class UtilityFunction < Smell
-    def recognise?(calls)
-      calls[:self] == 0
+    def recognise?(depends_on_self)
+      !depends_on_self
     end
 
     def detailed_report
@@ -137,9 +121,14 @@ module Reek
   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 = klass.instance_methods.length - klass.superclass.instance_methods.length
+      @num_methods = LargeClass.non_inherited_methods(klass).length
       @num_methods > MAX_ALLOWED
     end
 
@@ -154,11 +143,15 @@ module Reek
       @symbol_type = symbol_type
     end
 
+    def self.effective_length(name)
+      return 500 if name == '*'
+      name = name[1..-1] while /^@/ === name
+      name.length
+    end
+
     def recognise?(symbol)
       @symbol = symbol.to_s
-      return false if @symbol == '*'
-      min_len = (/^@/ === @symbol) ? 3 : 2;
-      @symbol.length < min_len
+      UncommunicativeName.effective_length(@symbol) < 2
     end
 
     def detailed_report