reek 1.2.7.1 → 1.2.7.2

data/lib/reek/core/code_parser.rb

@@ -1,5 +1,4 @@
 require 'sexp'
-require File.join(File.dirname(File.expand_path(__FILE__)), 'block_context')
 require File.join(File.dirname(File.expand_path(__FILE__)), 'class_context')
 require File.join(File.dirname(File.expand_path(__FILE__)), 'method_context')
 require File.join(File.dirname(File.expand_path(__FILE__)), 'module_context')
@@ -61,21 +60,6 @@ module Reek
         @element.record_use_of_self
       end
 
-      def process_lit(exp)
-        val = exp[1]
-        @element.record_depends_on_self if val == :self
-      end
-
-      def process_iter(exp)
-        process(exp[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)
         @element.count_statements(CodeParser.count_statements(exp))
         process_default(exp)
@@ -144,8 +128,7 @@ module Reek
       end
 
       def process_iasgn(exp)
-        @element.record_instance_variable(exp[1])
-        @element.record_depends_on_self
+        @element.record_use_of_self
         process_default(exp)
       end
 

data/lib/reek/core/detector_stack.rb

@@ -17,6 +17,10 @@ module Reek
         @detectors << clone
       end
 
+      def adopt(config)
+        @detectors[-1].configure_with(config)
+      end
+
       def listen_to(hooks)
         @detectors.each { |det| det.listen_to(hooks) }
       end

data/lib/reek/core/masking_collection.rb

@@ -12,6 +12,12 @@ module Reek
         @visible_items = SortedSet.new
         @masked_items = SortedSet.new
       end
+
+      def collect_from(sources, config)
+        sources.each { |src| Core::Sniffer.new(src, config).report_on(self) }
+        self
+      end
+
       def all_items
         all = SortedSet.new(@visible_items)
         all.merge(@masked_items)

data/lib/reek/core/method_context.rb

@@ -1,31 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'object_refs')
 
-#
-# Extensions to +Array+ needed by Reek.
-#
-class Array
-  def power_set
-    self.inject([[]]) { |cum, element| cum.cross(element) }
-  end
-
-  def bounded_power_set(lower_bound)
-    power_set.select {|ps| ps.length > lower_bound}
-  end
-
-  def cross(element)
-    result = []
-    self.each do |set|
-      result << set
-      result << (set + [element])
-    end
-    result
-  end
-
-  def intersection
-    self.inject { |res, elem| elem & res }
-  end
-end
-
 module Reek
   module Core
 
@@ -77,10 +51,7 @@ module Reek
         @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
         @parameters ||= []
         @parameters.extend(MethodParameters)
-        @name = exp[1].to_s
-        @scope_connector = '#'
         @num_statements = 0
-        @depends_on_self = false
         @refs = ObjectRefs.new
         @outer.record_method(self)    # SMELL: these could be found by tree walking
       end
@@ -89,44 +60,25 @@ module Reek
         @num_statements += num
       end
 
-      def depends_on_instance?
-        @depends_on_self
-      end
-
       def record_call_to(exp)
-        record_receiver(exp)
+        receiver, meth = exp[1..2]
+        receiver ||= [:self]
+        case receiver[0]
+        when :lvar
+          @refs.record_ref(receiver) unless meth == :new
+        when :self
+          record_use_of_self
+        end
       end
 
       def record_use_of_self
-        record_depends_on_self
         @refs.record_reference_to_self
       end
 
-      def record_instance_variable(sym)
-        record_use_of_self
-      end
-
-      def record_depends_on_self
-        @depends_on_self = true
-      end
-
       def envious_receivers
         return [] if @refs.self_is_max?
         @refs.max_keys
       end
-
-    private
-
-      def record_receiver(exp)
-        receiver, meth = exp[1..2]
-        receiver ||= [:self]
-        case receiver[0]
-        when :lvar
-          @refs.record_ref(receiver) unless meth == :new
-        when :self
-          record_use_of_self
-        end
-      end
     end
   end
 end

data/lib/reek/core/module_context.rb

@@ -1,6 +1,7 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'code_context')
-require File.join( File.dirname( File.expand_path(__FILE__)), 'code_parser')
-require File.join( File.dirname( File.expand_path(__FILE__)), 'sniffer')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_parser')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'sniffer')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source', 'sexp_formatter')
 
 module Reek
   module Core
@@ -12,8 +13,8 @@ module Reek
 
       class << self
         def create(outer, exp)
-          res = resolve(exp[1], outer)
-          new(res[0], res[1], exp)
+          res = Source::SexpFormatter.format(exp[1])
+          new(outer, res, exp)
         end
 
         def from_s(src)
@@ -21,41 +22,14 @@ module Reek
           sniffer = Sniffer.new(source)
           CodeParser.new(sniffer).do_module_or_class(source.syntax_tree, self)
         end
-
-        def resolve(exp, context)
-          unless Array === exp
-            return resolve_string(exp.to_s, context)
-          end
-          name = exp[1]
-          case exp[0]
-          when :colon2
-            return [resolve(name, context)[0], exp[2].to_s]
-          when :const
-            return [ModuleContext.create(context, exp), name.to_s]
-          when :colon3
-            return [StopContext.new, name.to_s]
-          else
-            return [context, name.to_s]
-          end
-        end
-
-        def resolve_string(str, context)
-          return [context, str.to_s] unless str =~ /::/
-          resolve(RubyParser.new.parse(str), context)
-        end
       end
 
       def initialize(outer, name, exp)
         super(outer, exp)
         @name = name
-        @scope_connector = '::'
         @parsed_methods = []
       end
 
-      def parameterized_methods(min_clump_size)
-        @parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
-      end
-
       def record_method(meth)
         @parsed_methods << meth
       end

data/lib/reek/core/object_refs.rb

@@ -1,51 +1,51 @@
 module Reek
   module Core
 
-  #
-  # Manages and counts the references out of a method to other objects.
-  #
-  class ObjectRefs  # :nodoc:
-    def initialize
-      @refs = Hash.new(0)
-    end
+    #
+    # Manages and counts the references out of a method to other objects.
+    #
+    class ObjectRefs  # :nodoc:
+      def initialize
+        @refs = Hash.new(0)
+      end
 
-    def record_reference_to_self
-      record_ref(SELF_REF)
-    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
+      def record_ref(exp)
+        type = exp[0]
+        case type
+        when :gvar
+          return
+        when :self
+          record_reference_to_self
+        else
+          @refs[exp] += 1
+        end
       end
-    end
 
-    def refs_to_self
-      @refs[SELF_REF]
-    end
+      def refs_to_self
+        @refs[SELF_REF]
+      end
 
-    def max_refs
-      @refs.values.max or 0
-    end
+      def max_refs
+        @refs.values.max or 0
+      end
 
-    def max_keys
-      max = max_refs
-      @refs.reject {|key,val| val != max}
-    end
+      def max_keys
+        max = max_refs
+        @refs.reject {|key,val| val != max}
+      end
 
-    def self_is_max?
-      max_keys.length == 0 || @refs[SELF_REF] == max_refs
-    end
+      def self_is_max?
+        max_keys.length == 0 || @refs[SELF_REF] == max_refs
+      end
 
-  private
+    private
 
-    SELF_REF = Sexp.from_array([:lit, :self])
+      SELF_REF = Sexp.from_array([:lit, :self])
 
-  end
+    end
   end
 end

data/lib/reek/core/singleton_method_context.rb

@@ -1,31 +1,20 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'method_context')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
 
 module Reek
   module Core
 
-  #
-  # A context wrapper for any singleton method definition found in a syntax tree.
-  #
-  class SingletonMethodContext < MethodContext
+    #
+    # A context wrapper for any singleton method definition found in a syntax tree.
+    #
+    class SingletonMethodContext < MethodContext
 
-    def initialize(outer, exp)
-      super(outer, exp)
-      @name = exp[2].to_s
-      @receiver = Source::SexpFormatter.format(exp[1])
-      @scope_connector = ""
-      record_depends_on_self
-    end
-
-    def envious_receivers
-      []
-    end
+      def initialize(outer, exp)
+        super(outer, exp)
+      end
 
-    def full_name
-      outer = @outer ? @outer.full_name : ''
-      prefix = outer == '' ? '' : "#{outer}#"
-      "#{prefix}#{@receiver}.#{@name}"
+      def envious_receivers
+        []
+      end
     end
   end
-  end
 end

data/lib/reek/core/sniffer.rb

@@ -65,7 +65,8 @@ module Reek
         ]
       end
 
-      def initialize(src)
+      def initialize(src, config_strategy = ActiveSmellsOnly.new)   # SMELL: open secret -- need a Strategy
+        @config_strategy = config_strategy
         @already_checked_for_smells = false
         @typed_detectors = nil
         @detectors = Hash.new
@@ -83,7 +84,7 @@ module Reek
       end
 
       def configure(klass, config)
-        @detectors[klass].push(config)
+        @config_strategy.configure(@detectors[klass], config)
       end
 
       def report_on(report)

data/lib/reek/examiner.rb

@@ -4,8 +4,28 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'source')
 
 module Reek
 
+  class ActiveSmellsOnly
+    def configure(detectors, config)
+      detectors.adopt(config)
+    end
+
+    def smells_in(sources)
+      Core::MaskingCollection.new.collect_from(sources, self).all_active_items.to_a
+    end
+  end
+
+  class ActiveAndMaskedSmells
+    def configure(detectors, config)
+      detectors.push(config)
+    end
+
+    def smells_in(sources)
+      Core::MaskingCollection.new.collect_from(sources, self).all_items
+    end
+  end
+
   #
-  # Finds the code smells in Ruby source code.
+  # Finds the active code smells in Ruby source code.
   #
   class Examiner
 
@@ -27,62 +47,50 @@ module Reek
     #   and if it is an Array, it is assumed to be a list of file paths,
     #   each of which is opened and parsed for source code.
     #
-    def initialize(source)
-      sniffers = case source
+    # @param [#smells_in]
+    #   The +collector+ will be asked to examine the sources and report
+    #   an array of SmellWarning objects. The default collector is an
+    #   instance of ActiveSmellsOnly, which completely ignores all smells
+    #   that have been masked by configuration options.
+    #
+    def initialize(source, collector = ActiveSmellsOnly.new)
+      sources = case source
       when Array
         @description = 'dir'
-        Source::SourceLocator.new(source).all_sources.map {|src| Core::Sniffer.new(src)}
+        Source::SourceLocator.new(source).all_sources
       when Source::SourceCode
         @description = source.desc
-        [Core::Sniffer.new(source)]
+        [source]
       else
         src = source.to_reek_source
         @description = src.desc
-        [Core::Sniffer.new(src)]
+        [src]
       end
-      @warnings = Core::MaskingCollection.new
-      sniffers.each {|sniffer| sniffer.report_on(@warnings)}
+      @smells = collector.smells_in(sources)
     end
 
     #
-    # Returns an Array of SmellWarning objects, one for each non-masked smell
+    # Returns an Array of SmellWarning objects, one for each active smell
     # in the source.
     #
     # @return [Array<SmellWarning>]
     #
-    def all_active_smells
-      @warnings.all_active_items.to_a
-    end
-
-    #
-    # Returns an Array of SmellWarning objects, one for each smell
-    # in the source; includes active smells and masked smells.
-    #
-    # @return [Array<SmellWarning>]
-    #
-    def all_smells
-      @warnings.all_items
+    def smells
+      @smells
     end
 
     #
     # Returns the number of non-masked smells in the source.
     #
-    def num_active_smells
-      @warnings.num_visible_items
-    end
-
-    #
-    # Returns the number of masked smells in the source.
-    #
-    def num_masked_smells
-      @warnings.num_masked_items
+    def num_smells
+      @smells.length
     end
 
     #
     # True if and only if there are non-masked code smells in the given source.
     #
     def smelly?
-      not all_active_smells.empty?
+      not @smells.empty?
     end
   end
 end