reek 0.3.1 → 1.0.0

data/lib/reek/report.rb

@@ -1,52 +1,41 @@
-$:.unshift File.dirname(__FILE__)
-
 require 'set'
+require 'reek/smells/smell_detector'
 
 module Reek
-
-  class SortByContext
-    def self.compare(smell1, smell2)
-      smell1.detailed_report <=> smell2.detailed_report
-    end
-  end
-
-  class SortBySmell
-    def self.compare(smell1, smell2)
-      smell1.report <=> smell2.report
-    end
-  end
-
   class Report
-
-    SORT_ORDERS = {
-      :context => SortByContext,
-      :smell => SortBySmell
-    }
+    include Enumerable
 
     def initialize  # :nodoc:
-      @smells = SortedSet.new
+      @report = SortedSet.new
+    end
+
+    def each
+      @report.each { |smell| yield smell }
     end
 
     def <<(smell)  # :nodoc:
-      @smells << smell
+      @report << smell
+      true
     end
     
     def empty?  # :nodoc:
-      @smells.empty?
+      @report.empty?
     end
 
     def length  # :nodoc:
-      @smells.length
+      @report.length
     end
+    
+    alias size length
 
     def [](index)  # :nodoc:
-      @smells.to_a[index]
+      @report.to_a[index]
     end
 
-    # Creates a formatted report of all the smells recorded in
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
     # this report.
     def to_s
-      @smells.map {|smell| smell.report}.join("\n")
+      @report.map {|smell| smell.report}.join("\n")
     end
   end
 

data/lib/reek/sexp_formatter.rb

@@ -0,0 +1,52 @@
+module Reek
+  class SexpFormatter
+    def self.format(sexp)
+      return sexp.to_s unless Array === sexp
+      first = sexp[1]
+      case sexp[0]
+      when :array
+        format_all(sexp, ', ')
+      when :call
+        meth, args = sexp[2..3]
+        result = format(first)
+        if meth.to_s == '[]'
+          result += (args.nil? ? '[]' : "[#{format(args)}]")
+        else
+          result += ".#{meth}" + (args ? "(#{format(args)})" : '')
+        end
+        result
+      when :colon2
+        format_all(sexp, '::')
+      when :const, :cvar, :dvar
+        format(first)
+      when :dot2
+        format_all(sexp, '..')
+      when :dstr
+        '"' + format_all(sexp, '') + '"'
+      when :evstr
+        "\#\{#{format(first)}\}"
+      when :fcall, :vcall
+        args = sexp[2]
+        result = first.to_s
+        result += "(#{format(args)})" if args
+        result
+      when :iter
+        'block'
+      when :lasgn
+        format_all(sexp, '=')
+      when :nth_ref
+        "$#{first}"
+      when :str
+        first
+      when :xstr
+        "`#{first}`"
+      else
+        sexp[-1].to_s
+      end
+    end
+    
+    def self.format_all(sexp, glue)
+      sexp[1..-1].map {|arg| format(arg)}.join(glue)
+    end
+  end
+end

data/lib/reek/singleton_method_context.rb

@@ -0,0 +1,27 @@
+require 'reek/name'
+require 'reek/method_context'
+require 'reek/sexp_formatter'
+
+module Reek
+  class SingletonMethodContext < MethodContext
+
+    def initialize(outer, exp)
+      super(outer, exp, false)
+      @name = Name.new(exp[2])
+      @receiver = SexpFormatter.format(exp[1])
+      record_depends_on_self
+    end
+
+    def envious_receivers
+      []
+    end
+    
+    def outer_name
+      "#{@outer.outer_name}#{@receiver}.#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@receiver}.#{@name}"
+    end
+  end
+end

data/lib/reek/smell_warning.rb

@@ -0,0 +1,49 @@
+require 'reek/options'
+
+module Reek
+
+  #
+  # Reports a warning that a smell has been found.
+  #
+  class SmellWarning
+    include Comparable
+
+    def initialize(smell, context, warning)
+      @smell = smell
+      @context = context
+      @warning = warning
+    end
+
+    def hash  # :nodoc:
+      report.hash
+    end
+
+    def <=>(other)
+      report <=> other.report
+    end
+
+    alias eql? <=>  # :nodoc:
+
+    #
+    # Returns +true+ only if this is a warning about an instance of
+    # +smell_class+ and its report string matches all of the +patterns+.
+    #
+    def matches?(smell_class, patterns)
+      return false unless smell_class.to_s == @smell.class.class_name
+      rpt = report
+      return patterns.all? {|exp| exp === rpt}
+    end
+
+    #
+    # Returns a copy of the current report format (see +Options+)
+    # in which the following magic tokens have been substituted:
+    #
+    # * %s <-- the name of the smell that was detected
+    # * %c <-- a description of the +CodeContext+ containing the smell
+    # * %w <-- the specific problem that was detected
+    #
+    def report
+      Options[:format].gsub(/\%s/, @smell.smell_name).gsub(/\%c/, @context.to_s).gsub(/\%w/, @warning)
+    end
+  end
+end

data/lib/reek/smells/control_couple.rb

@@ -1,6 +1,6 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
 
 module Reek
   module Smells
@@ -33,21 +33,29 @@ module Reek
     # 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
+    class ControlCouple < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:if]
       end
 
-      def recognise?(cond)
-        @couple = cond
-        cond[0] == :lvar and @args.include?(@couple[1])
+      def self.default_config
+        super.adopt(EXCLUDE_KEY => ['initialize'])
       end
 
-      def detailed_report
-        "#{@context} is controlled by argument #{Printer.print(@couple)}"
+      def initialize(config = ControlCouple.default_config)
+        super
       end
-    end
 
+      #
+      # Checks whether the given conditional statement relies on a control couple.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(cond, report)
+        return unless cond.tests_a_parameter?
+        report << SmellWarning.new(self, cond,
+                    "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
+      end
+    end
   end
 end

data/lib/reek/smells/duplication.rb

@@ -1,7 +1,6 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
-require 'reek/printer'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
 
 module Reek
   module Smells
@@ -19,36 +18,33 @@ module Reek
     #     @other.thing + @other.thing
     #   end
     #
-    class Duplication < Smell
+    class Duplication < SmellDetector
 
-      #
-      # 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
+      # The name of the config field that sets the maximum number of
+      # identical calls to be permitted within any single method.
+      MAX_ALLOWED_CALLS_KEY = 'max_calls'
 
-      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
+      def self.default_config
+        super.adopt(MAX_ALLOWED_CALLS_KEY => 1)
       end
 
-      def initialize(context, call)
-        super(context)
-        @call = call
+      def initialize(config = Duplication.default_config)
+        super
+        @max_calls = config[MAX_ALLOWED_CALLS_KEY]
       end
 
-      def detailed_report
-        "#{@context} calls #{Printer.print(@call)} more than once"
+      def examine_context(method, report)
+        smelly_calls(method).each do |call|
+          report << SmellWarning.new(self, method,
+                      "calls #{SexpFormatter.format(call)} multiple times")
+        end
+      end
+      
+      def smelly_calls(method)   # :nodoc:
+        method.calls.select do |key,val|
+          val > @max_calls and key[2] != :new
+        end.map { |call_exp| call_exp[0] }
       end
     end
-
   end
 end

data/lib/reek/smells/feature_envy.rb

@@ -1,6 +1,6 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
 
 module Reek
   module Smells
@@ -32,34 +32,27 @@ module Reek
     # 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
+    class FeatureEnvy < SmellDetector
+
+      def self.default_config
+        super.adopt(EXCLUDE_KEY => ['initialize'])
+      end
+
+      def initialize(config = FeatureEnvy.default_config)
+        super
+      end
 
       #
-      # Checks whether the given +method+ includes any code fragment that
+      # Checks whether the given +context+ 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.
+      # Any smells found are added to the +report+.
       #
-      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
+      def examine_context(context, report)
+        context.envious_receivers.each do |ref|
+          report << SmellWarning.new(self, context,
+                      "refers to #{SexpFormatter.format(ref)} more than self")
         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

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -9,27 +8,43 @@ module Reek
     # 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.
+    # Currently +LargeClass+ only reports classes having more than a
+    # configurable number of methods. This includes public, protected and
+    # private methods, but excludes methods inherited from superclasses or
+    # included modules.
     #
-    class LargeClass < Smell
-      MAX_ALLOWED = 25
+    class LargeClass < SmellDetector
+
+      # The name of the config field that sets the maximum number of methods
+      # permitted in a class.
+      MAX_ALLOWED_METHODS_KEY = 'max_methods'
 
-      def self.non_inherited_methods(klass)
-        return klass.instance_methods if klass.superclass.nil?
-        klass.instance_methods - klass.superclass.instance_methods
+      def self.contexts      # :nodoc:
+        [:class]
       end
 
-      def recognise?(name)
-        klass = Object.const_get(name) rescue return
-        @num_methods = LargeClass.non_inherited_methods(klass).length
-        @num_methods > MAX_ALLOWED
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_METHODS_KEY => 25,
+          EXCLUDE_KEY => ['Array', 'Hash', 'Module', 'String']
+          )
       end
 
-      def detailed_report
-        "#{@context} has #{@num_methods} methods"
+      def initialize(config = LargeClass.default_config)
+        super
+        @max_methods = config[MAX_ALLOWED_METHODS_KEY]
       end
-    end
 
+      #
+      # Checks the length of the given +klass+.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(klass, report)
+        num_methods = klass.num_methods
+        return false if num_methods <= @max_methods
+        report << SmellWarning.new(self, klass,
+                    "has at least #{num_methods} methods")
+      end
+    end
   end
 end