reek 1.4.0 → 1.5.0

data/lib/reek/smells/data_clump.rb

@@ -85,7 +85,7 @@ module Reek
     def initialize(ctx, min_clump_size, max_copies)
       @min_clump_size = min_clump_size
       @max_copies = max_copies
-      @candidate_methods = ctx.local_nodes(:defn).map do |defn_node|
+      @candidate_methods = ctx.node_instance_methods.map do |defn_node|
         CandidateMethod.new(defn_node)
       end
     end

data/lib/reek/smells/duplicate_method_call.rb

@@ -102,7 +102,6 @@ module Reek
         def calls
           result = Hash.new { |hash, key| hash[key] = FoundCall.new(key) }
           collect_calls(result)
-          collect_assignments(result)
           result.values.sort_by(&:call)
         end
 
@@ -112,19 +111,13 @@ module Reek
 
         private
 
-        def collect_assignments(result)
-          context.local_nodes(:attrasgn) do |asgn_node|
-            result[asgn_node].record(asgn_node) if asgn_node.args
-          end
-        end
-
         def collect_calls(result)
-          context.local_nodes(:call) do |call_node|
+          context.each_node(:send, [:mlhs]) do |call_node|
             next if call_node.method_name == :new
             next if !call_node.receiver && call_node.args.empty?
             result[call_node].record(call_node)
           end
-          context.local_nodes(:iter) do |call_node|
+          context.local_nodes(:block) do |call_node|
             result[call_node].record(call_node)
           end
         end

data/lib/reek/smells/module_initialize.rb

@@ -0,0 +1,38 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+    #
+    # a module is usually a mixin, so when initialize method is present it is
+    # hard to tell initialization order and parameters so having 'initialize'
+    # in a module is usually a bad idea
+    #
+    class ModuleInitialize < SmellDetector
+      SMELL_CLASS = smell_class_name
+      SMELL_SUBCLASS = SMELL_CLASS
+
+      def self.contexts      # :nodoc:
+        [:module]
+      end
+
+      #
+      # Checks whether module has method 'initialize'.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(module_ctx)
+        module_ctx.local_nodes(:def) do |node| # FIXME: also search for :defs?
+          if node.name.to_s == 'initialize'
+            return [
+              SmellWarning.new(SMELL_CLASS, module_ctx.full_name, [module_ctx.exp.line],
+                               'has initialize method',
+                               @source, SMELL_SUBCLASS, {})
+            ]
+          end
+        end
+        []
+      end
+    end
+  end
+end

data/lib/reek/smells/nested_iterators.rb

@@ -62,7 +62,7 @@ module Reek
       end
 
       def find_iters(exp, depth)
-        exp.unnested_nodes([:iter]).flat_map do |elem|
+        exp.find_nodes([:block]).flat_map do |elem|
           find_iters_for_iter_node(elem, depth)
         end
       end

data/lib/reek/smells/nil_check.rb

@@ -10,7 +10,7 @@ module Reek
       SMELL_SUBCLASS = name.split(/::/)[-1]
 
       def examine_context(ctx)
-        call_node_finder = NodeFinder.new(ctx, :call, NilCallNodeDetector)
+        call_node_finder = NodeFinder.new(ctx, :send, NilCallNodeDetector)
         case_node_finder = NodeFinder.new(ctx, :when, NilWhenNodeDetector)
         smelly_nodes = call_node_finder.smelly_nodes + case_node_finder.smelly_nodes
 
@@ -58,7 +58,7 @@ module Reek
         end
 
         def involves_nil?(call)
-          call.receiver.nil_node? || call.args.any?(&:nil_node?)
+          call.participants.any? { |it| it.type == :nil }
         end
 
         def comparison_methods
@@ -71,7 +71,7 @@ module Reek
         module_function
 
         def detect(node)
-          node.condition_list.any?(&:nil_node?)
+          node.condition_list.any? { |it| it.type == :nil }
         end
       end
     end

data/lib/reek/smells/repeated_conditional.rb

@@ -23,6 +23,7 @@ module Reek
     class RepeatedConditional < SmellDetector
       SMELL_CLASS = 'SimulatedPolymorphism'
       SMELL_SUBCLASS = name.split(/::/)[-1]
+      BLOCK_GIVEN_CONDITION = AST::Node.new(:send, [nil, :block_given?])
 
       def self.contexts      # :nodoc:
         [:class]
@@ -65,8 +66,8 @@ module Reek
       def conditional_counts(sexp)
         result = Hash.new { |hash, key| hash[key] = [] }
         collector = proc do |node|
-          condition = node.condition
-          next if condition.nil? || condition == s(:call, nil, :block_given?)
+          next unless (condition = node.condition)
+          next if condition == BLOCK_GIVEN_CONDITION
           result[condition].push(condition.line)
         end
         [:if, :case].each { |stmt| sexp.local_nodes(stmt, &collector) }

data/lib/reek/smells/smell_detector.rb

@@ -25,7 +25,7 @@ module Reek
 
       class << self
         def contexts
-          [:defn, :defs]
+          [:def, :defs]
         end
 
         def default_config

data/lib/reek/smells/too_many_instance_variables.rb

@@ -45,7 +45,7 @@ module Reek
       private
 
       def check_num_ivars(ctx)  # :nodoc:
-        count = ctx.local_nodes(:iasgn).map { |iasgn| iasgn[1] }.uniq.length
+        count = ctx.local_nodes(:ivasgn).map { |ivasgn| ivasgn[1] }.uniq.length
         return [] if count <= @max_allowed_ivars
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
                                  "has at least #{count} instance variables",

data/lib/reek/smells/too_many_methods.rb

@@ -47,7 +47,7 @@ module Reek
       private
 
       def check_num_methods(ctx)  # :nodoc:
-        actual = ctx.local_nodes(:defn).length
+        actual = ctx.node_instance_methods.length
         return [] if actual <= @max_allowed_methods
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
                                  "has at least #{actual} methods",

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -41,10 +41,6 @@ module Reek
         )
       end
 
-      def self.contexts      # :nodoc:
-        [:defn, :defs]
-      end
-
       #
       # Checks the given +context+ for uncommunicative names.
       #

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -41,10 +41,6 @@ module Reek
         )
       end
 
-      def self.contexts      # :nodoc:
-        [:defn, :defs]
-      end
-
       #
       # Checks the given +context+ for uncommunicative names.
       #

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -42,7 +42,7 @@ module Reek
       end
 
       def self.contexts      # :nodoc:
-        [:module, :class, :defn, :defs]
+        [:module, :class, :def, :defs]
       end
 
       #
@@ -76,11 +76,11 @@ module Reek
       end
 
       def find_assignment_variable_names(exp, accumulator)
-        assignment_nodes = exp.each_node(:lasgn, [:class, :module, :defs, :defn])
+        assignment_nodes = exp.each_node(:lvasgn, [:class, :module, :defs, :def])
 
         case exp.first
         when :class, :module
-          assignment_nodes += exp.each_node(:iasgn, [:class, :module])
+          assignment_nodes += exp.each_node(:ivasgn, [:class, :module])
         end
 
         assignment_nodes.each { |asgn| accumulator[asgn[1]].push(asgn.line) }
@@ -90,11 +90,12 @@ module Reek
         arg_search_exp = case exp.first
                          when :class, :module
                            exp
-                         when :defs, :defn
+                         when :defs, :def
                            exp.body
                          end
 
-        args_nodes = arg_search_exp.each_node(:args, [:class, :module, :defs, :defn])
+        return unless arg_search_exp
+        args_nodes = arg_search_exp.each_node(:args, [:class, :module, :defs, :def])
 
         args_nodes.each do |args_node|
           recursively_record_variable_names(accumulator, args_node)
@@ -102,11 +103,12 @@ module Reek
       end
 
       def recursively_record_variable_names(accumulator, exp)
-        exp[1..-1].each do |subexp|
-          if subexp.is_a? Symbol
-            record_variable_name(exp, subexp, accumulator)
-          elsif subexp.first == :masgn
+        exp.children.each do |subexp|
+          case subexp.type
+          when :mlhs
             recursively_record_variable_names(accumulator, subexp)
+          else
+            record_variable_name(exp, subexp.name, accumulator)
           end
         end
       end

data/lib/reek/smells/utility_function.rb

@@ -46,7 +46,7 @@ module Reek
 
       class << self
         def contexts      # :nodoc:
-          [:defn]
+          [:def]
         end
 
         def default_config
@@ -77,7 +77,7 @@ module Reek
       end
 
       def num_helper_methods(method_ctx)
-        method_ctx.local_nodes(:call).length
+        method_ctx.local_nodes(:send).length
       end
     end
   end

data/lib/reek/source/ast_node.rb

@@ -0,0 +1,40 @@
+require 'parser'
+
+module Reek
+  module Source
+    # Base class for AST nodes extended with utility methods. Contains some
+    # methods to ease the transition from Sexp to AST::Node.
+    class AstNode < Parser::AST::Node
+      attr_reader :comments
+
+      def initialize(type, children = [], options = {})
+        @comments = options.fetch(:comments, [])
+        super
+      end
+
+      def comments
+        @comments.map(&:text).join("\n")
+      end
+
+      # @deprecated
+      def [](index)
+        elements[index]
+      end
+
+      def line
+        loc.line
+      end
+
+      # @deprecated
+      def first
+        type
+      end
+
+      private
+
+      def elements
+        [type, *children]
+      end
+    end
+  end
+end

data/lib/reek/source/ast_node_class_map.rb

@@ -0,0 +1,37 @@
+require 'reek/source/ast_node'
+require 'reek/source/sexp_node'
+require 'reek/source/sexp_extensions'
+
+module Reek
+  module Source
+    # Maps AST node types to sublasses of AstNode extended with the relevant
+    # utility modules.
+    class AstNodeClassMap
+      def initialize
+        @klass_map = {}
+      end
+
+      def klass_for(type)
+        @klass_map[type] ||=
+          begin
+            klass = Class.new(AstNode)
+            klass.send :include, extension_map[type] if extension_map[type]
+            klass.send :include, SexpNode
+          end
+      end
+
+      def extension_map
+        @extension_map ||=
+          begin
+            assoc = SexpExtensions.constants.map do |const|
+              [
+                const.to_s.sub(/Node$/, '').downcase.to_sym,
+                SexpExtensions.const_get(const)
+              ]
+            end
+            Hash[assoc]
+          end
+      end
+    end
+  end
+end

data/lib/reek/source/reference_collector.rb

@@ -6,7 +6,7 @@ module Reek
     # of an abstract syntax tree.
     #
     class ReferenceCollector
-      STOP_NODES = [:class, :module, :defn, :defs]
+      STOP_NODES = [:class, :module, :def, :defs]
 
       def initialize(ast)
         @ast = ast
@@ -14,10 +14,10 @@ module Reek
 
       def num_refs_to_self
         result = 0
-        [:self, :zsuper, :ivar, :iasgn].each do |node_type|
+        [:self, :zsuper, :ivar, :ivasgn].each do |node_type|
           @ast.look_for(node_type, STOP_NODES) { result += 1 }
         end
-        @ast.look_for(:call, STOP_NODES) do |call|
+        @ast.look_for(:send, STOP_NODES) do |call|
           result += 1 unless call.receiver
         end
         result

data/lib/reek/source/sexp_extensions.rb

@@ -3,51 +3,104 @@ require 'reek/source/sexp_node'
 module Reek
   module Source
     module SexpExtensions
-      class MethodParameter
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
+      # Base module for utility methods for argument nodes.
+      module ArgNodeBase
+        def name
+          children.first
         end
 
+        # Other is a symbol?
         def ==(other)
-          @name == other
+          name == other
+        end
+
+        def marked_unused?
+          plain_name.start_with?('_')
+        end
+
+        def plain_name
+          name.to_s
         end
 
         def block?
-          @name.to_s =~ /^&/
+          false
+        end
+
+        def optional_argument?
+          false
         end
 
         def anonymous_splat?
-          @name == :*
+          false
         end
+      end
 
-        def marked_unused?
-          plain_name.start_with?('_')
+      # Utility methods for :arg nodes.
+      module ArgNode
+        include ArgNodeBase
+      end
+
+      # Utility methods for :optarg nodes.
+      module OptargNode
+        include ArgNodeBase
+
+        def optional_argument?
+          true
         end
+      end
 
-        def plain_name
-          @plain_name ||= @name.to_s.sub(/^[*&]+/, '')
+      # Utility methods for :kwoptarg nodes.
+      module KwoptargNode
+        include ArgNodeBase
+
+        def optional_argument?
+          true
         end
       end
 
-      module AndNode
-        def condition() self[1] end
+      # Utility methods for :blockarg nodes.
+      module BlockargNode
+        include ArgNodeBase
+        def block?
+          true
+        end
+      end
 
-        def body
-          self[2]
+      # Utility methods for :restarg nodes.
+      module RestargNode
+        include ArgNodeBase
+        def anonymous_splat?
+          !name
         end
       end
 
-      # Utility methods for :or nodes
-      module OrNode
+      # Utility methods for :kwrestarg nodes.
+      module KwrestargNode
+        include ArgNodeBase
+        def anonymous_splat?
+          !name
+        end
+      end
+
+      # Base module for utility methods for :and and :or nodes.
+      module LogicOperatorBase
         def condition() self[1] end
 
-        def body
-          self[2]
+        def body_nodes(type, ignoring = [])
+          self[2].find_nodes type, ignoring
         end
       end
 
+      module AndNode
+        include LogicOperatorBase
+      end
+
+      # Utility methods for :or nodes
+      module OrNode
+        include LogicOperatorBase
+      end
+
+      # Utility methods for :attrasgn nodes
       module AttrasgnNode
         def args() self[3] end
       end
@@ -56,20 +109,28 @@ module Reek
       module CaseNode
         def condition() self[1] end
 
-        def body
-          self[2..-1].extend SexpNode
+        def body_nodes(type, ignoring = [])
+          children[1..-1].compact.flat_map { |child| child.find_nodes(type, ignoring) }
+        end
+
+        def else_body
+          children.last
         end
       end
 
       # Utility methods for :when nodes
       module WhenNode
         def condition_list
-          self[1][1..-1]
+          children[0..-2]
+        end
+
+        def body
+          children.last
         end
       end
 
-      # Utility methods for :call nodes
-      module CallNode
+      # Utility methods for :send nodes
+      module SendNode
         def receiver() self[1] end
         def method_name() self[2] end
         def args() self[3..-1] end
@@ -83,34 +144,49 @@ module Reek
         end
       end
 
-      module CvarNode
+      # Base module for utility methods for nodes representing variables.
+      module VariableBase
         def name() self[1] end
       end
 
+      # Utility methods for :cvar nodes.
+      module CvarNode
+        include VariableBase
+      end
+
       CvasgnNode = CvarNode
       CvdeclNode = CvarNode
 
+      # Utility methods for :ivar nodes.
+      module IvarNode
+        include VariableBase
+      end
+
+      # Utility methods for :ivasgn nodes.
+      module IvasgnNode
+        include VariableBase
+      end
+
       module LvarNode
         def var_name() self[1] end
       end
 
-      module MethodNode
+      # Base module for utility methods for :def and :defs nodes.
+      module MethodNodeBase
         def arguments
-          @arguments ||= parameters.reject(&:block?)
+          parameters.reject(&:block?)
         end
 
         def arg_names
-          @arg_names ||= arguments.map(&:name)
+          arguments.map(&:name)
         end
 
         def parameters
-          @parameters ||= argslist[1..-1].map do |param|
-            MethodParameter.new(param.is_a?(Sexp) ? param[1] : param)
-          end
+          argslist.children
         end
 
         def parameter_names
-          @parameter_names ||= parameters.map(&:name)
+          parameters.map(&:name)
         end
 
         def name_without_bang
@@ -120,16 +196,25 @@ module Reek
         def ends_with_bang?
           name[-1] == '!'
         end
+
+        def body_nodes(types, ignoring = [])
+          if body
+            body.find_nodes(types, ignoring)
+          else
+            []
+          end
+        end
       end
 
-      module DefnNode
+      # Utility methods for :def nodes.
+      module DefNode
         def name() self[1] end
         def argslist() self[2] end
 
         def body
-          self[3..-1].extend SexpNode
+          self[3]
         end
-        include MethodNode
+        include MethodNodeBase
         def full_name(outer)
           prefix = outer == '' ? '' : "#{outer}#"
           "#{prefix}#{name}"
@@ -142,9 +227,10 @@ module Reek
         def argslist() self[3] end
 
         def body
-          self[4..-1].extend SexpNode
+          self[4]
         end
-        include MethodNode
+
+        include MethodNodeBase
         def full_name(outer)
           prefix = outer == '' ? '' : "#{outer}#"
           "#{prefix}#{SexpNode.format(receiver)}.#{name}"
@@ -155,12 +241,13 @@ module Reek
       module IfNode
         def condition() self[1] end
 
-        def body
-          self[2..-1].extend SexpNode
+        def body_nodes(type, ignoring = [])
+          children[1..-1].compact.flat_map { |child| child.find_nodes(type, ignoring) }
         end
       end
 
-      module IterNode
+      # Utility methods for :block nodes.
+      module BlockNode
         def call() self[1] end
         def args() self[2] end
         def block() self[3] end
@@ -171,36 +258,23 @@ module Reek
         end
       end
 
-      # Utility methods for :nil nodes
-      module NilNode
-        def nil_node?
-          true
-        end
-      end
-
       module LitNode
         def value() self[1] end
       end
 
-      module Colon2Node
-        def name
-          self[2]
-        end
-
+      # Utility methods for :const nodes.
+      module ConstNode
         def simple_name
-          if name.is_a? Colon2Node
-            name.simple_name
-          else
-            name
-          end
+          children.last
         end
       end
 
+      # Utility methods for :module nodes.
       module ModuleNode
         def name() self[1] end
 
         def simple_name
-          name.is_a?(Sexp) ? name.simple_name : name
+          name.is_a?(AST::Node) ? name.simple_name : name
         end
 
         def full_name(outer)