reek 1.2.1 → 1.2.3

data/lib/reek/code_parser.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'sexp'
 require 'reek/block_context'
 require 'reek/class_context'
@@ -9,31 +8,12 @@ require 'reek/method_context'
 require 'reek/singleton_method_context'
 require 'reek/yield_call_context'
 
-#
-# Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
-# syntax tree more easily.
-#
-class Sexp
-  def children
-    find_all { |item| Sexp === item }
-  end
-
-  def is_language_node?
-    first.class == Symbol
-  end
-
-  def has_type?(type)
-    is_language_node? and first == type
-  end
-end
-
 module Reek
-
+  #
+  # Traverses a Sexp abstract syntax tree and fires events whenever
+  # it encounters specific node types.
+  #
   class CodeParser
-
-    #
-    # Creates a new Ruby code checker.
-    #
     def initialize(sniffer, ctx = StopContext.new)
       @sniffer = sniffer
       @element = ctx
@@ -50,42 +30,29 @@ module Reek
       exp[0..-1].each { |sub| process(sub) if Array === sub }
     end
 
-    def process_module(exp)
-      scope = ModuleContext.create(@element, exp)
-      push(scope) do
-        process_default(exp)
-        check_smells(:module)
-      end
-      scope
-    end
-
-    def process_class(exp)
-      scope = ClassContext.create(@element, exp)
+    def do_module_or_class(exp, context_class)
+      scope = context_class.create(@element, exp)
       push(scope) do
         process_default(exp) unless @element.is_struct?
-        check_smells(:class)
+        check_smells(exp[0])
       end
       scope
     end
 
-    def process_cvar(exp)
-      @element.record_class_variable(exp[1])
-    end
-
-    def process_cvasgn(exp)
-      process_cvar(exp)
+    def process_module(exp)
+      do_module_or_class(exp, ModuleContext)
     end
 
-    def process_cvdecl(exp)
-      process_cvar(exp)
+    def process_class(exp)
+      do_module_or_class(exp, ClassContext)
     end
 
     def process_defn(exp)
-      handle_context(MethodContext, :defn, exp)
+      handle_context(MethodContext, exp[0], exp)
     end
 
     def process_defs(exp)
-      handle_context(SingletonMethodContext, :defs, exp)
+      handle_context(SingletonMethodContext, exp[0], exp)
     end
 
     def process_args(exp) end
@@ -105,7 +72,12 @@ module Reek
 
     def process_iter(exp)
       process(exp[1])
-      handle_context(BlockContext, :iter, exp[2..-1])
+      scope = BlockContext.new(@element, exp)
+      push(scope) do
+        process_default(exp[2..-1])
+        check_smells(exp[0])
+      end
+      scope
     end
 
     def process_block(exp)
@@ -114,11 +86,12 @@ module Reek
     end
 
     def process_yield(exp)
-      handle_context(YieldCallContext, :yield, exp)
+      handle_context(YieldCallContext, exp[0], exp)
     end
 
     def process_call(exp)
       @element.record_call_to(exp)
+      @element.check_for_attribute_declaration(exp)
       process_default(exp)
     end
 
@@ -135,10 +108,9 @@ module Reek
     end
 
     def process_if(exp)
-      @element.record_conditional(exp[1])
       count_clause(exp[2])
       count_clause(exp[3])
-      handle_context(IfContext, :if, exp)
+      handle_context(IfContext, exp[0], exp)
       @element.count_statements(-1)
     end
 
@@ -154,12 +126,14 @@ module Reek
 
     def process_for(exp)
       count_clause(exp[3])
-      process_case(exp)
+      process_default(exp)
+      @element.count_statements(-1)
     end
 
     def process_rescue(exp)
       count_clause(exp[1])
-      process_case(exp)
+      process_default(exp)
+      @element.count_statements(-1)
     end
 
     def process_resbody(exp)
@@ -167,7 +141,6 @@ module Reek
     end
 
     def process_case(exp)
-      @element.record_conditional(exp[1])
       process_default(exp)
       @element.count_statements(-1)
     end

data/lib/reek/configuration.rb

@@ -13,19 +13,25 @@ module Reek
     # for other values in the current smell detector's configuration.
     OVERRIDES_KEY = 'overrides'
 
-    attr_reader :hash
-
     def initialize(hash)
-      @hash = hash
+      @options = hash
+    end
+
+    def adopt!(options)
+      @options.adopt!(options)
+    end
+
+    def deep_copy
+      @options.deep_copy     # SMELL: Open Secret -- returns a Hash
     end
 
     # SMELL: Getter
     def enabled?
-      @hash[ENABLED_KEY]
+      @options[ENABLED_KEY]
     end
 
     def overrides_for(context)
-      Overrides.new(@hash.fetch(OVERRIDES_KEY, {})).for_context(context)
+      Overrides.new(@options.fetch(OVERRIDES_KEY, {})).for_context(context)
     end
 
     # Retrieves the value, if any, for the given +key+.
@@ -34,7 +40,7 @@ module Reek
     #
     def value(key, context, fall_back)
       overrides_for(context).each { |conf| return conf[key] if conf.has_key?(key) }
-      return @hash.fetch(key, fall_back)
+      return @options.fetch(key, fall_back)
     end
   end
 

data/lib/reek/if_context.rb

@@ -5,8 +5,7 @@ module Reek
     attr_reader :if_expr
     
     def initialize(outer, exp)
-      @outer = outer
-      @exp = exp
+      super
       @if_expr = exp[1]
     end
     
@@ -18,7 +17,7 @@ module Reek
       @outer.outer_name
     end
 
-    def to_s
+    def to_s      # SMELL: should be unnecessary :(
       @outer.to_s
     end
   end

data/lib/reek/method_context.rb

@@ -1,5 +1,5 @@
 require 'reek/name'
-require 'reek/code_context'
+require 'reek/block_context'
 require 'reek/object_refs'
 
 class Array
@@ -51,7 +51,7 @@ module Reek
     end
   end
 
-  class MethodContext < CodeContext
+  class MethodContext < VariableContainer
     attr_reader :parameters
     attr_reader :calls
     attr_reader :refs
@@ -62,7 +62,6 @@ module Reek
       @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
       @parameters ||= []
       @parameters.extend(MethodParameters)
-      @local_variables = []
       @name = Name.new(exp[1])
       @num_statements = 0
       @calls = Hash.new(0)
@@ -85,6 +84,11 @@ module Reek
 
     def record_call_to(exp)
       @calls[exp] += 1
+      record_receiver(exp)
+      check_for_attribute_declaration(exp)
+    end
+
+    def record_receiver(exp)
       receiver, meth = exp[1..2]
       receiver ||= [:self]
       case receiver[0]
@@ -109,25 +113,17 @@ module Reek
       @depends_on_self = true
     end
 
-    def record_local_variable(sym)
-      @local_variables << Name.new(sym)
-    end
-
     def outer_name
       "#{@outer.outer_name}#{@name}/"
     end
 
-    def to_s
-      "#{@outer.outer_name}#{@name}"
-    end
-
     def envious_receivers
       return [] if @refs.self_is_max?
       @refs.max_keys
     end
 
     def variable_names
-      @parameters.names + @local_variables
+      @parameters.names + @local_variables.to_a
     end
   end
 end

data/lib/reek/module_context.rb

@@ -1,25 +1,30 @@
 require 'reek/code_context'
+require 'reek/code_parser'
+require 'reek/sniffer'
 
 module Reek
   class ModuleContext < CodeContext
 
-    def ModuleContext.create(outer, exp)
-      res = Name.resolve(exp[1], outer)
-      ModuleContext.new(res[0], res[1])
-    end
+    class << self
+      def create(outer, exp)
+        res = Name.resolve(exp[1], outer)
+        new(res[0], res[1], exp)
+      end
 
-    def ModuleContext.from_s(src)
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      CodeParser.new(sniffer).process_module(source.syntax_tree)
+      def from_s(src)
+        source = src.to_reek_source
+        sniffer = Sniffer.new(source)
+        CodeParser.new(sniffer).do_module_or_class(source.syntax_tree, self)
+      end
     end
 
-    attr_reader :class_variables
+    attr_reader :attributes
 
-    def initialize(outer, name)
-      super(outer, nil)
+    def initialize(outer, name, exp)
+      super(outer, exp)
       @name = name
-      @class_variables = Set.new
+      @attributes = Set.new
+      @parsed_methods = []
     end
 
     def myself
@@ -31,12 +36,26 @@ module Reek
       @myself.const_or_nil(modname.to_s)
     end
 
-    def outer_name
-      "#{@outer.outer_name}#{@name}::"
+    def parameterized_methods(min_clump_size)
+      @parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
     end
 
-    def record_class_variable(cvar)
-      @class_variables << Name.new(cvar)
+    def record_attribute(attr)
+      @attributes << Name.new(attr)
+    end
+
+    def record_method(meth)
+      @parsed_methods << meth
+    end
+
+    def check_for_attribute_declaration(exp)
+      if [:attr, :attr_reader, :attr_writer, :attr_accessor].include? exp[2]
+        exp[3][1..-1].each {|arg| record_attribute(arg[1])}
+      end
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}::"
     end
 
     def variable_names

data/lib/reek/name.rb

@@ -1,3 +1,5 @@
+require 'ruby_parser'
+
 module Reek
   class Name
     include Comparable

data/lib/reek/object_refs.rb

@@ -1,6 +1,3 @@
-require 'rubygems'
-require 'sexp_processor'
-
 module Reek
 
   class ObjectRefs  # :nodoc:

data/lib/reek/sexp_formatter.rb

@@ -1,5 +1,3 @@
-require 'rubygems'
-require 'ruby_parser'
 require 'ruby2ruby'
 
 module Reek

data/lib/reek/smells/attribute.rb

@@ -0,0 +1,48 @@
+require 'reek/smells/smell_detector'
+
+module Reek
+  module Smells
+
+    #
+    # A class that publishes a getter or setter for an instance variable
+    # invites client classes to become too intimate with its inner workings,
+    # and in particular with its representation of state.
+    #
+    # Currently this detector raises a warning for every +attr+,
+    # +attr_reader+, +attr_writer+ and +attr_accessor+ -- including those
+    # that are private.
+    #
+    # TODO:
+    # * eliminate private attributes
+    # * catch attributes declared "by hand"
+    #
+    class Attribute < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:class, :module]
+      end
+
+      def self.default_config
+        super.adopt(SmellConfiguration::ENABLED_KEY => false)
+      end
+
+      def initialize(config = Attribute.default_config)
+        super(config)
+      end
+
+      #
+      # Checks whether the given class declares any attributes.
+      # Remembers any smells found.
+      #
+      def examine_context(mod)
+        # SMELL: Duplication
+        # MethodContext, ClassContext and ModuleContext all know which
+        # calls constitute attribute declarations. Need a method on
+        # ModuleContext: each_public_call.select [names] {...}
+        mod.attributes.each do |attr|
+          found(mod, "declares the attribute #{attr}")
+        end
+      end
+    end
+  end
+end

data/lib/reek/smells/class_variable.rb

@@ -18,14 +18,27 @@ module Reek
       end
 
       #
-      # Checks whether the given class declares any class variables.
+      # Checks whether the given class or module declares any class variables.
       # Remembers any smells found.
       #
-      def examine_context(klass)
-        klass.class_variables.each do |cvar|
-          found(klass, "declares the class variable #{cvar}")
+      def examine_context(mod)
+        class_variables_in(mod).each do |cvar_name|
+          found(mod, "declares the class variable #{cvar_name}")
         end
       end
+
+      #
+      # Collects the names of the class variables declared and/or used
+      # in the given module.
+      #
+      def class_variables_in(mod)
+        result = Set.new
+        collector = proc { |cvar_node| result << cvar_node.name }
+        [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
+          mod.each(stmt_type, [:class, :module], &collector)
+        end
+        result
+      end
     end
   end
 end

data/lib/reek/smells/control_couple.rb

@@ -34,19 +34,12 @@ module Reek
     # because it includes at least two different code paths.
     #
     class ControlCouple < SmellDetector
+      include ExcludeInitialize
 
       def self.contexts      # :nodoc:
         [:if]
       end
 
-      def self.default_config
-        super.adopt(EXCLUDE_KEY => ['initialize'])
-      end
-
-      def initialize(config = ControlCouple.default_config)
-        super
-      end
-
       #
       # Checks whether the given conditional statement relies on a control couple.
       # Remembers any smells found.
@@ -56,8 +49,8 @@ module Reek
         # SMELL: Duplication
         # This smell is reported once for each conditional that tests the
         # same parameter. Which means that the same smell can recur within
-        # a single sniffer. Which in turn means that the sniffer can't count
-        # its smells without knowing which are duplicates.
+        # a single detector. Which in turn means that SmellDetector must
+        # use a Set to hold smells found.
         found(cond, "is controlled by argument #{SexpFormatter.format(cond.if_expr)}")
       end
     end

data/lib/reek/smells/data_clump.rb

@@ -20,7 +20,7 @@ module Reek
     class DataClump < SmellDetector
 
       def self.contexts      # :nodoc:
-        [:class]
+        [:class, :module]
       end
 
       # The name of the config field that sets the maximum allowed
@@ -44,14 +44,14 @@ module Reek
       end
 
       #
-      # Checks the given ClassContext for multiple identical conditional tests.
+      # Checks the given class or module for multiple identical parameter sets.
       # Remembers any smells found.
       #
-      def examine_context(klass)
-        max_copies = value(MAX_COPIES_KEY, klass, DEFAULT_MAX_COPIES)
-        min_clump_size = value(MIN_CLUMP_SIZE_KEY, klass, DEFAULT_MIN_CLUMP_SIZE)
-        MethodGroup.new(klass, min_clump_size, max_copies).clumps.each do |clump, occurs|
-          found(klass, "takes parameters #{DataClump.print_clump(clump)} to #{occurs} methods")
+      def examine_context(ctx)
+        max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
+        min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
+        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.each do |clump, occurs|
+          found(ctx, "takes parameters #{DataClump.print_clump(clump)} to #{occurs} methods")
         end
       end
 
@@ -68,15 +68,15 @@ module Reek
       methods.map {|meth| meth.parameters.names.sort}.intersection
     end
 
-    def initialize(klass, min_clump_size, max_copies)
-      @klass = klass
+    def initialize(ctx, min_clump_size, max_copies)
+      @ctx = ctx
       @min_clump_size = min_clump_size
       @max_copies = max_copies
     end
 
     def clumps
       results = Hash.new(0)
-      @klass.parameterized_methods(@min_clump_size).bounded_power_set(@max_copies).each do |methods|
+      @ctx.parameterized_methods(@min_clump_size).bounded_power_set(@max_copies).each do |methods|
         clump = MethodGroup.intersection_of_parameters_of(methods)
         if clump.length >= @min_clump_size
           results[clump] = [methods.length, results[clump]].max

data/lib/reek/smells/feature_envy.rb

@@ -33,14 +33,7 @@ module Reek
     # often than it refers to (ie. send messages to) some other object.
     #
     class FeatureEnvy < SmellDetector
-
-      def self.default_config
-        super.adopt(EXCLUDE_KEY => ['initialize'])
-      end
-
-      def initialize(config = FeatureEnvy.default_config)
-        super
-      end
+      include ExcludeInitialize
 
       #
       # Checks whether the given +context+ includes any code fragment that

data/lib/reek/smells/large_class.rb

@@ -45,9 +45,9 @@ module Reek
       end
 
       def check_num_methods(klass)  # :nodoc:
-        count = klass.num_methods
-        return if count <= value(MAX_ALLOWED_METHODS_KEY, klass, DEFAULT_MAX_METHODS)
-        found(klass, "has at least #{count} methods")
+        actual = klass.each(:defn, [:class, :module]).length
+        return if actual <= value(MAX_ALLOWED_METHODS_KEY, klass, DEFAULT_MAX_METHODS)
+        found(klass, "has at least #{actual} methods")
       end
 
       def check_num_ivars(klass)  # :nodoc:

data/lib/reek/smells/simulated_polymorphism.rb

@@ -47,12 +47,26 @@ module Reek
       # Remembers any smells found.
       #
       def examine_context(klass)
-        counts = Hash.new(0)
-        klass.conditionals.each {|cond| counts[cond] += 1}
-        counts.each do |key, val|
+        conditional_counts(klass).each do |key, val|
           found(klass, "tests #{SexpFormatter.format(key)} at least #{val} times") if val > value(MAX_IDENTICAL_IFS_KEY, klass, DEFAULT_MAX_IFS)
         end
       end
+
+      #
+      # Returns a Hash listing all of the conditional expressions in
+      # the given syntax tree together with the number of times each
+      # occurs. Ignores nested classes and modules.
+      #
+      def conditional_counts(klass)
+        result = Hash.new(0)
+        collector = proc { |node|
+          condition = node.condition
+          result[condition] += 1 unless condition == s(:call, nil, :block_given?, s(:arglist))
+        }
+        klass.each(:if, [:class, :module], &collector)
+        klass.each(:case, [:class, :module], &collector)
+        result
+      end
     end
   end
 end

data/lib/reek/smells/smell_detector.rb

@@ -10,6 +10,15 @@ end
 module Reek
   module Smells
 
+    module ExcludeInitialize
+      def self.default_config
+        super.adopt(EXCLUDE_KEY => ['initialize'])
+      end
+      def initialize(config = self.class.default_config)
+        super
+      end
+    end
+
     class SmellDetector
 
       # The name of the config field that lists the names of code contexts
@@ -70,11 +79,11 @@ module Reek
       end
 
       def configure_with(config)
-        @config.hash.adopt!(config)
+        @config.adopt!(config)
       end
 
       def copy
-        self.class.new(@config.hash.deep_copy)
+        self.class.new(@config.deep_copy)
       end
 
       def supersede_with(config)

data/lib/reek/smells/utility_function.rb

@@ -30,7 +30,7 @@ module Reek
         super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
       end
 
-      def initialize(config = Duplication.default_config)
+      def initialize(config = UtilityFunction.default_config)
         super(config)
       end
 

data/lib/reek/sniffer.rb

@@ -1,6 +1,7 @@
 require 'reek/detector_stack'
 
 # SMELL: Duplication -- all these should be found automagically
+require 'reek/smells/attribute'
 require 'reek/smells/class_variable'
 require 'reek/smells/control_couple'
 require 'reek/smells/data_clump'
@@ -49,6 +50,7 @@ module Reek
     def self.smell_classes
       # SMELL: Duplication -- these should be loaded by listing the files
       [
+        Smells::Attribute,
         Smells::ClassVariable,
         Smells::ControlCouple,
         Smells::DataClump,
@@ -123,10 +125,6 @@ module Reek
       stack.has_smell?(patterns)
     end
 
-    def smells_only_of?(klass, patterns)
-      num_smells == 1 and has_smell?(klass, patterns)
-    end
-
     def sniff
       self
     end
@@ -173,10 +171,6 @@ private
       total
     end
 
-    def smells_only_of?(klass, patterns)
-      num_smells == 1 and has_smell?(klass, patterns)
-    end
-
     def sniff
       self
     end

data/lib/reek/stop_context.rb

@@ -5,11 +5,11 @@ module Reek
       @refs = ObjectRefs.new
       @myself = Object
     end
+
     def method_missing(method, *args)
       nil
     end
 
-
     def count_statements(num)
       0
     end