reek 4.6.0 → 5.0.0

data/lib/reek/context/code_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../code_comment'
 require_relative '../ast/object_refs'
 require_relative 'statement_counter'
@@ -13,51 +14,19 @@ module Reek
     # code element. CodeContexts form a tree in the same way the code does,
     # with each context holding a reference to a unique outer context.
     #
-    # :reek:TooManyMethods: { max_methods: 19 }
-    # :reek:TooManyInstanceVariables: { max_instance_variables: 8 }
+    # @quality :reek:TooManyMethods { max_methods: 19 }
+    # @quality :reek:TooManyInstanceVariables { max_instance_variables: 8 }
     class CodeContext
       include Enumerable
       extend Forwardable
-      delegate each_node: :exp
-      delegate %i(name type) => :exp
+      delegate [:name, :type] => :exp
 
       attr_reader :children, :parent, :exp, :statement_counter
 
       # Initializes a new CodeContext.
       #
-      # @param _parent [CodeContext, nil] The parent context
       # @param exp [Reek::AST::Node] The code described by this context
-      #
-      # For example, given the following code:
-      #
-      #   class Omg
-      #     def foo(x)
-      #       puts x
-      #     end
-      #   end
-      #
-      # The {ContextBuilder} object first instantiates a {RootContext}, which has no parent.
-      #
-      # Next, it instantiates a {ModuleContext}, with +parent+ being the
-      # {RootContext} just created, and +exp+ looking like this:
-      #
-      #  (class
-      #    (const nil :Omg) nil
-      #    (def :foo
-      #      (args
-      #        (arg :x))
-      #      (send nil :puts
-      #        (lvar :x))))
-      #
-      # Finally, {ContextBuilder} will instantiate a {MethodContext}. This time,
-      # +parent+ is the {ModuleContext} created above, and +exp+ is:
-      #
-      #   (def :foo
-      #     (args
-      #       (arg :x))
-      #     (send nil :puts
-      #       (lvar :x)))
-      def initialize(_parent, exp)
+      def initialize(exp)
         @exp                = exp
         @children           = []
         @statement_counter  = StatementCounter.new
@@ -70,12 +39,12 @@ module Reek
       # @yield block that is executed for every node.
       #
       def local_nodes(type, ignored = [], &blk)
-        ignored += [:casgn, :class, :module]
-        each_node(type, ignored, &blk)
+        ignored |= [:class, :module]
+        exp.each_node(type, ignored, &blk)
       end
 
       # Iterate over `self` and child contexts.
-      # The main difference (among others) to `each_node` is that we are traversing
+      # The main difference (among others) to `local_nodes` is that we are traversing
       # `CodeContexts` here, not AST nodes (see `Reek::AST::Node`).
       #
       # @yield block that is executed for every node.
@@ -90,6 +59,44 @@ module Reek
         end
       end
 
+      # Link the present context to its parent.
+      #
+      # @param parent [Reek::AST::Node] The parent context of the code described by this context
+      #
+      # For example, given the following code:
+      #
+      #   class Omg
+      #     def foo(x)
+      #       puts x
+      #     end
+      #   end
+      #
+      # The {ContextBuilder} object first instantiates a {RootContext}, which has no parent.
+      #
+      # Next, it instantiates a {ModuleContext}, with +exp+ looking like this:
+      #
+      #  (class
+      #    (const nil :Omg) nil
+      #    (def :foo
+      #      (args
+      #        (arg :x))
+      #      (send nil :puts
+      #        (lvar :x))))
+      #
+      # It will then call #register_with_parent on the {ModuleContext}, passing
+      # in the parent {RootContext}.
+      #
+      # Finally, {ContextBuilder} will instantiate a {MethodContext}. This time,
+      # +exp+ is:
+      #
+      #   (def :foo
+      #     (args
+      #       (arg :x))
+      #     (send nil :puts
+      #       (lvar :x)))
+      #
+      # Then it will call #register_with_parent on the {MethodContext}, passing
+      # in the parent {ModuleContext}.
       def register_with_parent(parent)
         @parent = parent.append_child_context(self) if parent
       end
@@ -103,17 +110,15 @@ module Reek
         self
       end
 
-      # :reek:TooManyStatements: { max_statements: 6 }
-      # :reek:FeatureEnvy
+      # @quality :reek:TooManyStatements { max_statements: 6 }
+      # @quality :reek:FeatureEnvy
       def record_call_to(exp)
         receiver = exp.receiver
         type = receiver ? receiver.type : :self
         line = exp.line
         case type
         when :lvar, :lvasgn
-          unless exp.object_creation_call?
-            refs.record_reference(name: receiver.name, line: line)
-          end
+          refs.record_reference(name: receiver.name, line: line) unless exp.object_creation_call?
         when :self
           refs.record_reference(name: :self, line: line)
         end

data/lib/reek/context/ghost_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code_context'
 require_relative 'singleton_method_context'
 
@@ -40,8 +41,6 @@ module Reek
                                             names: names
       end
 
-      def track_singleton_visibility(_visibility, _names); end
-
       def record_use_of_self
         parent.record_use_of_self
       end

data/lib/reek/context/method_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code_context'
 
 module Reek
@@ -6,14 +7,15 @@ module Reek
     #
     # A context wrapper for any method definition found in a syntax tree.
     #
-    # :reek:Attribute
+    # @quality :reek:Attribute
     class MethodContext < CodeContext
       attr_accessor :visibility
       attr_reader :refs
 
-      def initialize(context, exp)
+      def initialize(exp, parent_exp)
+        @parent_exp = parent_exp
         @visibility = :public
-        super
+        super exp
       end
 
       def references_self?
@@ -21,29 +23,24 @@ module Reek
       end
 
       def uses_param?(param)
-        # local_nodes(:lvasgn) catches:
+        # :lvasgn catches:
+        #
         #   def foo(bar); bar += 1; end
-        # In this example there is no `lvar` node present.
         #
-        # local_nodes(:lvar) catches:
+        # :lvar catches:
+        #
         #   def foo(bar); other(bar); end
         #   def foo(bar); tmp = other(bar); tmp[0]; end
         #
-        # Note that in the last example the `lvar` node for `bar` is part of an `lvasgn` node for `tmp`.
-        # This means that if we would just search for [:lvar, :lvasgn]
-        # (e.g. via Reek::AST::Node#find_nodes) this would fail for this example since we would
-        # stop at the `lvasgn` and not detect the contained `lvar`.
-        # Hence we first get all `lvar` nodes followed by all `lvasgn` nodes.
-        #
-        (local_nodes(:lvar) + local_nodes(:lvasgn)).find { |node| node.var_name == param.to_sym }
+        local_nodes([:lvar, :lvasgn]).find { |node| node.var_name == param.name }
       end
 
-      # :reek:FeatureEnvy
+      # @quality :reek:FeatureEnvy
       def unused_params
-        exp.arguments.select do |param|
-          next if param.anonymous_splat?
-          next if param.marked_unused?
-          !uses_param? param.plain_name
+        exp.arguments.reject do |param|
+          param.anonymous_splat? ||
+            param.marked_unused? ||
+            uses_param?(param)
         end
       end
 
@@ -79,6 +76,17 @@ module Reek
       def non_public_visibility?
         visibility != :public
       end
+
+      def full_comment
+        own = super
+        return own unless own.empty?
+        return parent_exp.full_comment if parent_exp
+        ''
+      end
+
+      private
+
+      attr_reader :parent_exp
     end
   end
 end

data/lib/reek/context/module_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code_context'
 require_relative 'attribute_context'
 require_relative 'method_context'
@@ -9,13 +10,11 @@ module Reek
     #
     # A context wrapper for any module found in a syntax tree.
     #
-    # :reek:FeatureEnvy
     class ModuleContext < CodeContext
       attr_reader :visibility_tracker
 
-      def initialize(context, exp)
+      def initialize(exp)
         super
-
         @visibility_tracker = VisibilityTracker.new
       end
 
@@ -44,9 +43,9 @@ module Reek
         AttributeContext
       end
 
-      def defined_instance_methods(visibility: :public)
+      def defined_instance_methods(visibility: :any)
         instance_method_children.select do |context|
-          context.visibility == visibility
+          visibility == :any || context.visibility == visibility
         end
       end
 
@@ -60,7 +59,7 @@ module Reek
       # @deprecated use `defined_instance_methods` instead
       #
       def node_instance_methods
-        local_nodes(:def)
+        local_nodes(:def).to_a
       end
 
       def descriptively_commented?
@@ -73,24 +72,25 @@ module Reek
       # However, if the module is empty, it is not considered a namespace module.
       #
       # @return true if the module is a namespace module
+      #
+      # @quality :reek:FeatureEnvy
       def namespace_module?
         return false if exp.type == :casgn
-        contents = exp.children.last
-        contents && contents.find_nodes([:def, :defs], [:casgn, :class, :module]).empty?
+        children = exp.direct_children
+        children.any? && children.all? { |child| [:casgn, :class, :module].include? child.type }
       end
 
       def track_visibility(visibility, names)
         visibility_tracker.track_visibility children: instance_method_children,
                                             visibility: visibility,
                                             names: names
-      end
-
-      def track_singleton_visibility(visibility, names)
         visibility_tracker.track_singleton_visibility children: singleton_method_children,
                                                       visibility: visibility,
                                                       names: names
       end
 
+      private
+
       def instance_method_children
         children.select(&:instance_method?)
       end

data/lib/reek/context/root_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code_context'
 require_relative 'method_context'
 
@@ -8,10 +9,6 @@ module Reek
     # A context wrapper representing the root of an abstract syntax tree.
     #
     class RootContext < CodeContext
-      def initialize(exp)
-        super(nil, exp)
-      end
-
       def type
         :root
       end

data/lib/reek/context/send_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code_context'
 
 module Reek
@@ -9,9 +10,9 @@ module Reek
     class SendContext < CodeContext
       attr_reader :name
 
-      def initialize(context, exp, name)
+      def initialize(exp, name)
         @name = name
-        super context, exp
+        super exp
       end
     end
   end

data/lib/reek/context/singleton_attribute_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'attribute_context'
 
 module Reek

data/lib/reek/context/singleton_method_context.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'method_context'
 
 module Reek

data/lib/reek/context/statement_counter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../ast/node'
 
 module Reek

data/lib/reek/context/visibility_tracker.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Reek
   module Context
     # Responsible for tracking visibilities in regards to CodeContexts.

data/lib/reek/context_builder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'context/attribute_context'
 require_relative 'context/class_context'
 require_relative 'context/ghost_context'
@@ -19,8 +20,9 @@ module Reek
   # counting. Ideally `ContextBuilder` would only build up the context tree and leave the
   # statement and reference counting to the contexts.
   #
-  # :reek:TooManyMethods: { max_methods: 31 }
-  # :reek:UnusedPrivateMethod: { exclude: [ !ruby/regexp /process_/ ] }
+  # @quality :reek:TooManyMethods { max_methods: 31 }
+  # @quality :reek:UnusedPrivateMethod { exclude: [ !ruby/regexp /process_/ ] }
+  # @quality :reek:DataClump
   class ContextBuilder
     attr_reader :context_tree
 
@@ -57,10 +59,10 @@ module Reek
     # RootContext -> children: 1 ModuleContext -> children: 1 MethodContext
     #
     # @return [Reek::Context::RootContext] tree of nested contexts
-    def build(exp)
+    def build(exp, parent_exp = nil)
       context_processor = "process_#{exp.type}"
       if context_processor_exists?(context_processor)
-        send(context_processor, exp)
+        send(context_processor, exp, parent_exp)
       else
         process exp
       end
@@ -70,12 +72,12 @@ module Reek
     # Handles every node for which we have no context_processor.
     #
     def process(exp)
-      exp.children.grep(AST::Node).each(&method(:build))
+      exp.children.grep(AST::Node).each { |child| build(child, exp) }
     end
 
     # Handles `module` and `class` nodes.
     #
-    def process_module(exp)
+    def process_module(exp, _parent)
       inside_new_context(Context::ModuleContext, exp) do
         process(exp)
       end
@@ -90,7 +92,7 @@ module Reek
     #   class << self
     #   end
     #
-    def process_sclass(exp)
+    def process_sclass(exp, _parent)
       inside_new_context(Context::GhostContext, exp) do
         process(exp)
       end
@@ -102,9 +104,9 @@ module Reek
     #
     #   Foo = Class.new Bar
     #
-    def process_casgn(exp)
+    def process_casgn(exp, parent)
       if exp.defines_module?
-        process_module(exp)
+        process_module(exp, parent)
       else
         process(exp)
       end
@@ -118,8 +120,8 @@ module Reek
     #
     # Given the above example we would count 2 statements overall.
     #
-    def process_def(exp)
-      inside_new_context(current_context.method_context_class, exp) do
+    def process_def(exp, parent)
+      inside_new_context(current_context.method_context_class, exp, parent) do
         increase_statement_count_by(exp.body)
         process(exp)
       end
@@ -133,8 +135,8 @@ module Reek
     #
     # Given the above example we would count 2 statements overall.
     #
-    def process_defs(exp)
-      inside_new_context(Context::SingletonMethodContext, exp) do
+    def process_defs(exp, parent)
+      inside_new_context(Context::SingletonMethodContext, exp, parent) do
         increase_statement_count_by(exp.body)
         process(exp)
       end
@@ -150,14 +152,14 @@ module Reek
     # we also record to what the method call is referring to
     # which we later use for smell detectors like FeatureEnvy.
     #
-    def process_send(exp)
+    def process_send(exp, _parent)
+      process(exp)
       case current_context
       when Context::ModuleContext
         handle_send_for_modules exp
       when Context::MethodContext
         handle_send_for_methods exp
       end
-      process(exp)
     end
 
     # Handles `op_asgn` nodes a.k.a. Ruby's assignment operators.
@@ -172,7 +174,7 @@ module Reek
     #
     # We record one reference to `x` given the example above.
     #
-    def process_op_asgn(exp)
+    def process_op_asgn(exp, _parent)
       current_context.record_call_to(exp)
       process(exp)
     end
@@ -191,7 +193,7 @@ module Reek
     #
     # We record one reference to `self`.
     #
-    def process_ivar(exp)
+    def process_ivar(exp, _parent)
       current_context.record_use_of_self
       process(exp)
     end
@@ -204,7 +206,7 @@ module Reek
     #
     #   def self.foo; end
     #
-    def process_self(_)
+    def process_self(_exp, _parent)
       current_context.record_use_of_self
     end
 
@@ -224,7 +226,7 @@ module Reek
     #
     # We record one reference to `self`.
     #
-    def process_zsuper(_)
+    def process_zsuper(_exp, _parent)
       current_context.record_use_of_self
     end
 
@@ -248,7 +250,7 @@ module Reek
     #
     # We record one reference to `self`.
     #
-    def process_super(exp)
+    def process_super(exp, _parent)
       current_context.record_use_of_self
       process(exp)
     end
@@ -261,7 +263,7 @@ module Reek
     #
     # Counts non-empty blocks as one statement.
     #
-    def process_block(exp)
+    def process_block(exp, _parent)
       increase_statement_count_by(exp.block)
       process(exp)
     end
@@ -281,7 +283,7 @@ module Reek
     # At the end we subtract one statement because the surrounding context was already counted
     # as one (e.g. via `process_def`).
     #
-    def process_begin(exp)
+    def process_begin(exp, _parent)
       increase_statement_count_by(exp.children)
       decrease_statement_count
       process(exp)
@@ -307,7 +309,7 @@ module Reek
     # `children[1]` refers to the `if` body (so `puts 'bingo'` from above) and
     # `children[2]` to the `else` body (so `3` from above), which might be nil.
     #
-    def process_if(exp)
+    def process_if(exp, _parent)
       children = exp.children
       increase_statement_count_by(children[1])
       increase_statement_count_by(children[2])
@@ -330,7 +332,7 @@ module Reek
     #
     # `children[1]` below refers to the `while` body (so `puts 'bingo'` from above)
     #
-    def process_while(exp)
+    def process_while(exp, _parent)
       increase_statement_count_by(exp.children[1])
       decrease_statement_count
       process(exp)
@@ -353,7 +355,7 @@ module Reek
     #
     # `children[2]` below refers to the `while` body (so `puts i` from above)
     #
-    def process_for(exp)
+    def process_for(exp, _parent)
       increase_statement_count_by(exp.children[2])
       decrease_statement_count
       process(exp)
@@ -383,7 +385,7 @@ module Reek
     # `exp` would be the whole method body wrapped under a `rescue` node.
     # See `process_resbody` for additional reference.
     #
-    def process_rescue(exp)
+    def process_rescue(exp, _parent)
       increase_statement_count_by(exp.children.first)
       decrease_statement_count
       process(exp)
@@ -411,7 +413,7 @@ module Reek
     # `exp` would be the whole `rescue` body.
     # See `process_rescue` for additional reference.
     #
-    def process_resbody(exp)
+    def process_resbody(exp, _parent)
       increase_statement_count_by(exp.children[1..-1].compact)
       process(exp)
     end
@@ -433,7 +435,7 @@ module Reek
     # At the end we subtract one statement because the surrounding context was already counted
     # as one (e.g. via `process_def`).
     #
-    def process_case(exp)
+    def process_case(exp, _parent)
       increase_statement_count_by(exp.else_body)
       decrease_statement_count
       process(exp)
@@ -459,7 +461,7 @@ module Reek
     #
     # Counts the `when` body.
     #
-    def process_when(exp)
+    def process_when(exp, _parent)
       increase_statement_count_by(exp.body)
       process(exp)
     end
@@ -468,7 +470,7 @@ module Reek
       self.class.private_method_defined?(name)
     end
 
-    # :reek:ControlParameter
+    # @quality :reek:ControlParameter
     def increase_statement_count_by(sexp)
       current_context.statement_counter.increase_by sexp
     end
@@ -480,37 +482,35 @@ module Reek
     # Stores a reference to the current context, creates a nested new one,
     # yields to the given block and then restores the previous context.
     #
-    # @param klass [Context::*Context] - context class
-    # @param exp - current expression
+    # @param klass [Context::*Context] context class
+    # @param args arguments for the class initializer
     # @yield block
     #
-    def inside_new_context(klass, exp)
-      new_context = append_new_context(klass, exp)
+    def inside_new_context(klass, *args)
+      new_context = append_new_context(klass, *args)
 
       orig, self.current_context = current_context, new_context
       yield
       self.current_context = orig
     end
 
-    # Append a new child context to the current context but does not change the
-    # current context.
+    # Appends a new child context to the current context but does not change
+    # the current context.
     #
-    # @param klass [Context::*Context] - context class
-    # @param args - arguments for the class initializer
+    # @param klass [Context::*Context] context class
+    # @param args arguments for the class initializer
     #
-    # @return [Context::*Context] - the context that was appended
+    # @return [Context::*Context] the context that was appended
     #
     def append_new_context(klass, *args)
-      klass.new(current_context, *args).tap do |new_context|
+      klass.new(*args).tap do |new_context|
         new_context.register_with_parent(current_context)
       end
     end
 
     def handle_send_for_modules(exp)
-      method_name = exp.name
-      arg_names = exp.arg_names
-      current_context.track_visibility(method_name, arg_names)
-      current_context.track_singleton_visibility(method_name, arg_names)
+      arg_names = exp.args.map { |arg| arg.children.first }
+      current_context.track_visibility(exp.name, arg_names)
       register_attributes(exp)
     end