reek 1.2.6 → 1.2.7

data/lib/reek/core/code_parser.rb

@@ -0,0 +1,192 @@
+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')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'stop_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'singleton_method_context')
+
+module Reek
+  module Core
+
+    #
+    # Traverses a Sexp abstract syntax tree and fires events whenever
+    # it encounters specific node types.
+    #
+    class CodeParser
+      def initialize(sniffer, ctx = StopContext.new)
+        @sniffer = sniffer
+        @element = ctx
+      end
+
+      def process(exp)
+        meth = "process_#{exp[0]}"
+        meth = :process_default unless self.respond_to?(meth)
+        self.send(meth, exp)
+        @element
+      end
+
+      def process_default(exp)
+        exp[0..-1].each { |sub| process(sub) if Array === sub }
+      end
+
+      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(exp[0])
+        end
+        scope
+      end
+
+      def process_module(exp)
+        do_module_or_class(exp, ModuleContext)
+      end
+
+      def process_class(exp)
+        do_module_or_class(exp, ClassContext)
+      end
+
+      def process_defn(exp)
+        handle_context(MethodContext, exp[0], exp)
+      end
+
+      def process_defs(exp)
+        handle_context(SingletonMethodContext, exp[0], exp)
+      end
+
+      def process_args(exp) end
+
+      def process_zsuper(exp)
+        @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)
+      end
+
+      def process_call(exp)
+        @element.record_call_to(exp)
+        process_default(exp)
+      end
+
+      def process_attrasgn(exp)
+        process_call(exp)
+      end
+
+      def process_op_asgn1(exp)
+        process_call(exp)
+      end
+
+      def process_if(exp)
+        count_clause(exp[2])
+        count_clause(exp[3])
+        process_default(exp)
+        @element.count_statements(-1)
+      end
+
+      def process_while(exp)
+        process_until(exp)
+      end
+
+      def process_until(exp)
+        count_clause(exp[2])
+        process_case(exp)
+      end
+
+      def process_for(exp)
+        count_clause(exp[3])
+        process_case(exp)
+      end
+
+      def process_rescue(exp)
+        count_clause(exp[1])
+        process_case(exp)
+      end
+
+      def process_resbody(exp)
+        process_when(exp)
+      end
+
+      def process_case(exp)
+        process_default(exp)
+        @element.count_statements(-1)
+      end
+
+      def process_when(exp)
+        count_clause(exp[2])
+        process_default(exp)
+      end
+
+      def process_ivar(exp)
+        process_iasgn(exp)
+      end
+
+      def process_lasgn(exp)
+        @element.record_local_variable(exp[1])
+        process_default(exp)
+      end
+
+      def process_iasgn(exp)
+        @element.record_instance_variable(exp[1])
+        @element.record_depends_on_self
+        process_default(exp)
+      end
+
+      def process_self(exp)
+        @element.record_use_of_self
+      end
+
+      def count_clause(sexp)
+        if sexp and !sexp.has_type?(:block)
+          @element.count_statements(1)
+        end
+      end
+
+      def self.count_statements(exp)
+        stmts = exp[1..-1]
+        ignore = 0
+        ignore += 1 if stmts[1] == s(:nil)
+        stmts.length - ignore
+      end
+
+    private
+
+      def handle_context(klass, type, exp)
+        scope = klass.new(@element, exp)
+        push(scope) do
+          process_default(exp)
+          check_smells(type)
+        end
+        scope
+      end
+
+      def check_smells(type)
+        @sniffer.examine(@element, type)
+      end
+
+      def push(context)
+        orig = @element
+        @element = context
+        yield
+        @element = orig
+      end
+    end
+  end
+end

data/lib/reek/core/detector_stack.rb

@@ -0,0 +1,29 @@
+
+module Reek
+  module Core
+
+    #
+    # A list of smell detectors of the same class, but with differing
+    # configurations.
+    #
+    class DetectorStack
+
+      def initialize(default_detector)
+        @detectors = [default_detector]
+      end
+
+      def push(config)
+        clone = @detectors[-1].supersede_with(config)
+        @detectors << clone
+      end
+
+      def listen_to(hooks)
+        @detectors.each { |det| det.listen_to(hooks) }
+      end
+
+      def report_on(report)
+        @detectors.each { |det| det.report_on(report) }
+      end
+    end
+  end
+end

data/lib/reek/core/masking_collection.rb

@@ -0,0 +1,46 @@
+require 'set'
+
+module Reek
+  module Core
+
+    #
+    # 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 all_items
+        all = SortedSet.new(@visible_items)
+        all.merge(@masked_items)
+        all.to_a
+      end
+      def all_active_items
+        @visible_items
+      end
+      def found_smell(item)
+        @visible_items.add(item)
+        @masked_items.delete(item) if @masked_items.include?(item)
+      end
+      def found_masked_smell(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
+  end
+end

data/lib/reek/core/method_context.rb

@@ -0,0 +1,132 @@
+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
+
+    #
+    # The parameters in a method's definition.
+    #
+    module MethodParameters
+      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| is_arg?(arg)}.map {|arg| arg.to_s }
+      end
+
+      def length
+        names.length
+      end
+
+      def include?(name)
+        names.include?(name)
+      end
+    end
+
+    #
+    # A context wrapper for any method definition found in a syntax tree.
+    #
+    class MethodContext < CodeContext
+      attr_reader :parameters
+      attr_reader :refs
+      attr_reader :num_statements
+
+      def initialize(outer, exp)
+        super(outer, exp)
+        @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
+
+      def count_statements(num)
+        @num_statements += num
+      end
+
+      def depends_on_instance?
+        @depends_on_self
+      end
+
+      def record_call_to(exp)
+        record_receiver(exp)
+      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

@@ -0,0 +1,64 @@
+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')
+
+module Reek
+  module Core
+
+    #
+    # A context wrapper for any module found in a syntax tree.
+    #
+    class ModuleContext < CodeContext
+
+      class << self
+        def create(outer, exp)
+          res = resolve(exp[1], outer)
+          new(res[0], res[1], exp)
+        end
+
+        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
+
+        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
+    end
+  end
+end