reek 1.2.3 → 1.2.4

data/lib/reek/code_parser.rb

@@ -91,7 +91,6 @@ module Reek
 
     def process_call(exp)
       @element.record_call_to(exp)
-      @element.check_for_attribute_declaration(exp)
       process_default(exp)
     end
 
@@ -120,20 +119,17 @@ module Reek
 
     def process_until(exp)
       count_clause(exp[2])
-      process_default(exp)
-      @element.count_statements(-1)
+      process_case(exp)
     end
 
     def process_for(exp)
       count_clause(exp[3])
-      process_default(exp)
-      @element.count_statements(-1)
+      process_case(exp)
     end
 
     def process_rescue(exp)
       count_clause(exp[1])
-      process_default(exp)
-      @element.count_statements(-1)
+      process_case(exp)
     end
 
     def process_resbody(exp)

data/lib/reek/detector_stack.rb

@@ -20,9 +20,7 @@ module Reek
     end
 
     def num_smells
-      total = 0
-      @detectors.each { |det| total += det.num_smells }
-      total
+      @detectors.inject(0) { |total, detector| total += detector.num_smells }
     end
 
     def has_smell?(patterns)
@@ -31,7 +29,7 @@ module Reek
     end
 
     def smelly?
-      # SMELL: Duplication: look at al those loops!
+      # SMELL: Duplication: look at all those loops!
       @detectors.each { |det| return true if det.smelly? }
       false
     end

data/lib/reek/help_command.rb

@@ -0,0 +1,14 @@
+
+module Reek
+
+  class HelpCommand
+    def initialize(parser)
+      @parser = parser
+    end
+    def execute(view)
+      view.output(@parser.to_s)
+      view.report_success
+    end
+  end
+
+end

data/lib/reek/masking_collection.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+#
+# A set of items that can be "masked" or "visible". If an item is added
+# more than once, only the "visible" copy is retained.
+#
+class MaskingCollection
+  def initialize
+    @visible_items = SortedSet.new
+    @masked_items = SortedSet.new
+  end
+  def add(item)
+    @visible_items.add(item)
+    @masked_items.delete(item) if @masked_items.include?(item)
+  end
+  def add_masked(item)
+    @masked_items.add(item) unless @visible_items.include?(item)
+  end
+  def num_visible_items
+    @visible_items.length
+  end
+  def num_masked_items
+    @masked_items.length
+  end
+  def each_item(&blk)
+    all = SortedSet.new(@visible_items)
+    all.merge(@masked_items)
+    all.each(&blk)
+  end
+  def each_visible_item(&blk)
+    @visible_items.each(&blk)
+  end
+end

data/lib/reek/method_context.rb

@@ -28,14 +28,26 @@ end
 module Reek
 
   module MethodParameters
-    def self.is_arg?(param)
-      return false if (Array === param and param[0] == :block)
+    def default_assignments
+      assignments = self[-1]
+      result = {}
+      return result unless is_assignment_block?(assignments)
+      assignments[1..-1].each do |exp|
+        result[exp[1]] = exp[2] if exp[0] == :lasgn
+      end
+      result
+    end
+    def is_arg?(param)
+      return false if is_assignment_block?(param)
       return !(param.to_s =~ /^\&/)
     end
+    def is_assignment_block?(param)
+      Array === param and param[0] == :block
+    end
 
     def names
       return @names if @names
-      @names = self[1..-1].select {|arg| MethodParameters.is_arg?(arg)}.map {|arg| Name.new(arg)}
+      @names = self[1..-1].select {|arg| is_arg?(arg)}.map {|arg| Name.new(arg)}
     end
 
     def length
@@ -57,7 +69,8 @@ module Reek
     attr_reader :refs
     attr_reader :num_statements
 
-    def initialize(outer, exp, record = true)
+    def initialize(outer, exp)
+      # SMELL: Unused Parameter
       super(outer, exp)
       @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
       @parameters ||= []
@@ -67,7 +80,7 @@ module Reek
       @calls = Hash.new(0)
       @depends_on_self = false
       @refs = ObjectRefs.new
-      @outer.record_method(self)
+      @outer.record_method(self)    # SMELL: these could be found by tree walking
     end
 
     def count_statements(num)
@@ -85,7 +98,6 @@ module Reek
     def record_call_to(exp)
       @calls[exp] += 1
       record_receiver(exp)
-      check_for_attribute_declaration(exp)
     end
 
     def record_receiver(exp)

data/lib/reek/module_context.rb

@@ -18,12 +18,9 @@ module Reek
       end
     end
 
-    attr_reader :attributes
-
     def initialize(outer, name, exp)
       super(outer, exp)
       @name = name
-      @attributes = Set.new
       @parsed_methods = []
     end
 
@@ -40,20 +37,10 @@ module Reek
       @parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
     end
 
-    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

data/lib/reek/reek_command.rb

@@ -0,0 +1,28 @@
+require 'reek/sniffer'
+
+module Reek
+
+  class ReekCommand
+
+    def initialize(sources, report_class, show_all)
+      @sniffer = sources.length > 0 ? sources.sniff : sniff_stdin
+      @report_class = report_class
+      @show_all = show_all
+    end
+
+    def sniff_stdin
+      Reek::Sniffer.new($stdin.to_reek_source('$stdin'))
+    end
+
+    def execute(view)
+      rpt = @report_class.new(@sniffer.sniffers, @show_all)
+      view.output(rpt.report)
+      if @sniffer.smelly?
+        view.report_smells
+      else
+        view.report_success
+      end
+    end
+  end
+
+end

data/lib/reek/singleton_method_context.rb

@@ -6,7 +6,7 @@ module Reek
   class SingletonMethodContext < MethodContext
 
     def initialize(outer, exp)
-      super(outer, exp, false)
+      super(outer, exp)
       @name = Name.new(exp[2])
       @receiver = SexpFormatter.format(exp[1])
       record_depends_on_self

data/lib/reek/smell_warning.rb

@@ -21,7 +21,9 @@ module Reek
       sort_key <=> other.sort_key
     end
 
-    alias eql? <=>  # :nodoc:
+    def eql?(other)
+      (self <=> other) == 0
+    end
 
     #
     # Returns +true+ only if this is a warning about an instance of
@@ -49,9 +51,9 @@ module Reek
 
     def report_on(report)
       if @is_masked
-        report.record_masked_smell(self)
+        report.found_masked_smell(self)
       else
-        report << self
+        report.found_smell(self)
       end
     end
   end

data/lib/reek/smells/attribute.rb

@@ -18,6 +18,8 @@ module Reek
     #
     class Attribute < SmellDetector
 
+      ATTRIBUTE_METHODS = [:attr, :attr_reader, :attr_writer, :attr_accessor]
+
       def self.contexts      # :nodoc:
         [:class, :module]
       end
@@ -39,10 +41,24 @@ module Reek
         # 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|
+        attributes_in(mod).each do |attr|
           found(mod, "declares the attribute #{attr}")
         end
       end
+
+      #
+      # Collects the names of the class variables declared and/or used
+      # in the given module.
+      #
+      def attributes_in(mod)
+        result = Set.new
+        mod.local_nodes(:call) do |call_node|
+          if ATTRIBUTE_METHODS.include?(call_node.method_name)
+            call_node.arg_names.each {|arg| result << arg }
+          end
+        end
+        result
+      end
     end
   end
 end

data/lib/reek/smells/class_variable.rb

@@ -35,7 +35,7 @@ module Reek
         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)
+          mod.local_nodes(stmt_type, &collector)
         end
         result
       end

data/lib/reek/smells/control_couple.rb

@@ -34,24 +34,27 @@ module Reek
     # because it includes at least two different code paths.
     #
     class ControlCouple < SmellDetector
-      include ExcludeInitialize
 
       def self.contexts      # :nodoc:
-        [:if]
+        [:if, :defn, :defs]
       end
 
       #
       # Checks whether the given conditional statement relies on a control couple.
       # Remembers any smells found.
       #
-      def examine_context(cond)
-        return unless cond.tests_a_parameter?
-        # 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 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)}")
+      def examine_context(ctx)
+        case ctx
+        when IfContext
+          return unless ctx.tests_a_parameter?
+          found(ctx, "is controlled by argument #{SexpFormatter.format(ctx.if_expr)}")
+        when MethodContext
+          ctx.parameters.default_assignments.each do |param, value|
+            next unless [:true, :false].include?(value[0])
+            found(ctx, "is controlled by argument #{param.to_s}")
+          end
+        else
+        end
       end
     end
   end

data/lib/reek/smells/large_class.rb

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

data/lib/reek/smells/long_method.rb

@@ -25,8 +25,6 @@ module Reek
         )
       end
 
-      attr_reader :max_statements
-
       def initialize(config = LongMethod.default_config)
         super(config)
       end

data/lib/reek/smells/simulated_polymorphism.rb

@@ -63,8 +63,8 @@ module Reek
           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)
+        klass.local_nodes(:if, &collector)
+        klass.local_nodes(:case, &collector)
         result
       end
     end

data/lib/reek/sniffer.rb

@@ -166,9 +166,7 @@ private
     end
 
     def num_smells
-      total = 0
-      @sniffers.each {|sniffer| total += sniffer.num_smells}
-      total
+      @sniffers.inject(0) {|total, sniffer| total += sniffer.num_smells}
     end
 
     def sniff

data/lib/reek/tree_dresser.rb

@@ -32,43 +32,55 @@ module Reek
     end
   end
 
-  module CvarNode
-    def name
-      self[1]
+  module SexpExtensions
+    module CaseNode
+      def condition
+        self[1]
+      end
+    end
+
+    module CallNode
+      def receiver() self[1] end
+      def method_name() self[2] end
+      def args() self[3] end
+      def arg_names
+        args[1..-1].map {|arg| arg[1]}
+      end
     end
-  end
 
-  module IfNode
-    def condition
-      self[1]
+    module CvarNode
+      def name() self[1] end
     end
-  end
 
-  module CaseNode
-    def condition
-      self[1]
+    CvasgnNode = CvarNode
+    CvdeclNode = CvarNode
+
+    module DefnNode
+      def method_name() self[1] end
+      def parameters() self[2] end
+    end
+
+    module IfNode
+      def condition
+        self[1]
+      end
     end
   end
 
   class TreeDresser
-    # SMELL: Duplication
-    # Put these into a new module and build the mapping automagically
-    # based on the node type
-    EXTENSIONS = {
-      :cvar => CvarNode,
-      :cvasgn => CvarNode,
-      :cvdecl => CvarNode,
-      :if => IfNode,
-      :case => CaseNode,
-    }
 
     def dress(sexp)
       sexp.extend(SexpNode)
-      if EXTENSIONS.has_key?(sexp[0])
-        sexp.extend(EXTENSIONS[sexp[0]])
+      module_name = extensions_for(sexp.sexp_type)
+      if Reek::SexpExtensions.const_defined?(module_name)
+        sexp.extend(Reek::SexpExtensions.const_get(module_name))
       end
       sexp[0..-1].each { |sub| dress(sub) if Array === sub }
       sexp
     end
+
+    def extensions_for(node_type)
+      "#{node_type.to_s.capitalize}Node"
+    end
   end
 end