reek 1.2.2 → 1.2.3

data/lib/reek/adapters/source.rb

@@ -1,4 +1,6 @@
+require 'ruby_parser'
 require 'reek/adapters/config_file'
+require 'reek/tree_dresser'
 
 module Reek
 
@@ -17,7 +19,8 @@ module Reek
     def configure(sniffer) end
 
     def syntax_tree
-      RubyParser.new.parse(@source, @desc) || s()
+      ast = RubyParser.new.parse(@source, @desc) || s()
+      TreeDresser.new.dress(ast)
     end
   end
 

data/lib/reek/adapters/spec.rb

@@ -88,11 +88,9 @@ module Reek
     end
 
     class ShouldReekOnlyOf < ShouldReekOf        # :nodoc:
-      include ReekMatcher
-
       def matches?(actual)
         @sniffer = actual.sniff
-        @sniffer.smells_only_of?(@klass, @patterns)
+        @sniffer.num_smells == 1 and @sniffer.has_smell?(@klass, @patterns)
       end
       def failure_message_for_should
         "Expected #{@sniffer.desc} to reek only of #{@klass}, but got:\n#{report}"

data/lib/reek/block_context.rb

@@ -21,15 +21,25 @@ module Reek
     end
   end
 
-  class BlockContext < CodeContext
+  class VariableContainer < CodeContext
+
+    def initialize(outer, exp)
+      super
+      @local_variables = Set.new
+    end
+
+    def record_local_variable(sym)
+      @local_variables << Name.new(sym)
+    end
+  end
+
+  class BlockContext < VariableContainer
 
     def initialize(outer, exp)
       super
       @name = Name.new('block')
-      @parameters = exp[0] if exp
-      @parameters ||= []
+      @parameters = exp[2] || []
       @parameters.extend(ParameterSet)
-      @local_variables = Set.new
     end
 
     def inside_a_block?
@@ -43,10 +53,6 @@ module Reek
     def nested_block?
       @outer.inside_a_block?
     end
-    
-    def record_local_variable(sym)
-      @local_variables << Name.new(sym)
-    end
 
     def outer_name
       "#{@outer.outer_name}#{@name}/"

data/lib/reek/class_context.rb

@@ -1,5 +1,5 @@
 require 'set'
-require 'reek/code_context'
+require 'reek/module_context'
 
 class Class
   def is_overriding_method?(name)
@@ -11,40 +11,14 @@ class Class
 end
 
 module Reek
-  class ClassContext < CodeContext
+  class ClassContext < ModuleContext
 
-    def ClassContext.create(outer, exp)
-      res = Name.resolve(exp[1], outer)
-      ClassContext.new(res[0], res[1], exp[2])
-    end
-
-    def ClassContext.from_s(src)
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      CodeParser.new(sniffer).process_class(source.syntax_tree)
-    end
+    attr_reader :parsed_methods
 
-    attr_reader :conditionals, :parsed_methods, :class_variables, :attributes
-
-    # SMELL: inconsistent with other contexts (not linked to the sexp)
-    def initialize(outer, name, superclass = nil)
-      super(outer, nil)
-      @name = name
-      @superclass = superclass
-      @parsed_methods = []
+    def initialize(outer, name, exp)
+      super
+      @superclass = exp[2]
       @instance_variables = Set.new
-      @conditionals = []
-      @attributes = Set.new
-      @class_variables = Set.new
-    end
-
-    def myself
-      @myself ||= @outer.find_module(@name)
-    end
-
-    def find_module(modname)
-      return nil unless myself
-      @myself.const_or_nil(modname.to_s)
     end
 
     def is_overriding_method?(name)
@@ -56,50 +30,16 @@ module Reek
       @superclass == [:const, :Struct]
     end
 
-    def num_methods
-      @parsed_methods.length
-    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 record_attribute(attr)
-      @attributes << Name.new(attr)
-    end
-
-    def record_class_variable(cvar)
-      @class_variables << Name.new(cvar)
-    end
-
     def record_instance_variable(sym)
       @instance_variables << Name.new(sym)
     end
 
-    def record_method(meth)
-      @parsed_methods << meth
-    end
-
     def outer_name
       "#{@outer.outer_name}#{@name}#"
     end
 
-    def to_s
-      "#{@outer.outer_name}#{@name}"
-    end
-
     def variable_names
       @instance_variables
     end
-
-    def record_conditional(exp)
-      @conditionals << exp
-    end
-
-    def parameterized_methods(min_clump_size)
-      parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
-    end
   end
 end

data/lib/reek/code_context.rb

@@ -23,6 +23,16 @@ module Reek
       @myself = nil
     end
 
+    def each(type, ignoring, &blk)
+      if block_given?
+        @exp.look_for(type, ignoring, &blk)
+      else
+        result = []
+        @exp.look_for(type, ignoring) {|exp| result << exp}
+        result
+      end
+    end
+
     # SMELL: Temporary Field -- @name isn't always initialized
     def matches?(strings)
       me = @name.to_s

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,7 +86,7 @@ module Reek
     end
 
     def process_yield(exp)
-      handle_context(YieldCallContext, :yield, exp)
+      handle_context(YieldCallContext, exp[0], exp)
     end
 
     def process_call(exp)
@@ -136,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
 
@@ -155,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)
@@ -168,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)
@@ -114,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