reek 3.8.3 → 3.9.0

data/lib/reek/ast/sexp_extensions/self.rb

@@ -0,0 +1,12 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Utility methods for :self nodes.
+      module SelfNode
+        def name
+          :self
+        end
+      end
+    end
+  end
+end

data/lib/reek/ast/sexp_extensions/send.rb

@@ -3,14 +3,13 @@ module Reek
     module SexpExtensions
       # Utility methods for :send nodes.
       module SendNode
-        VISIBILITY_MODIFIERS = [:private, :public, :protected, :module_function]
         ATTR_DEFN_METHODS = [:attr_writer, :attr_accessor]
 
         def receiver
           children.first
         end
 
-        def method_name
+        def name
           children[1]
         end
 
@@ -35,22 +34,18 @@ module Reek
         end
 
         def object_creation_call?
-          method_name == :new
-        end
-
-        def visibility_modifier?
-          VISIBILITY_MODIFIERS.include?(method_name)
+          name == :new
         end
 
         def attribute_writer?
-          ATTR_DEFN_METHODS.include?(method_name) ||
+          ATTR_DEFN_METHODS.include?(name) ||
             attr_with_writable_flag?
         end
 
         # Handles the case where we create an attribute writer via:
         # attr :foo, true
         def attr_with_writable_flag?
-          method_name == :attr && args.any? && args.last.type == :true
+          name == :attr && args.any? && args.last.type == :true
         end
       end
 

data/lib/reek/ast/sexp_extensions/super.rb

@@ -3,7 +3,7 @@ module Reek
     module SexpExtensions
       # Utility methods for :super nodes.
       module SuperNode
-        def method_name
+        def name
           :super
         end
       end

data/lib/reek/ast/sexp_extensions/variables.rb

@@ -30,6 +30,11 @@ module Reek
         alias_method :var_name, :name
       end
 
+      # Utility methods for :gvar nodes.
+      module GvarNode
+        include VariableBase
+      end
+
       LvasgnNode = LvarNode
       CvasgnNode = CvarNode
       CvdeclNode = CvarNode

data/lib/reek/context/attribute_context.rb

@@ -5,8 +5,12 @@ module Reek
     #
     # A context wrapper for attribute definitions found in a syntax tree.
     #
+    # :reek:Attribute
     class AttributeContext < CodeContext
+      attr_accessor :visibility
+
       def initialize(context, exp, send_expression)
+        @visibility = :public
         @send_expression = send_expression
         super context, exp
       end
@@ -15,6 +19,14 @@ module Reek
         send_expression.full_comment || ''
       end
 
+      def instance_method?
+        true
+      end
+
+      def apply_current_visibility(current_visibility)
+        self.visibility = current_visibility
+      end
+
       private_attr_reader :send_expression
     end
   end

data/lib/reek/context/code_context.rb

@@ -1,6 +1,5 @@
 require_relative '../code_comment'
 require_relative '../ast/object_refs'
-require_relative 'visibility_tracker'
 require_relative 'statement_counter'
 
 require 'forwardable'
@@ -20,14 +19,14 @@ module Reek
       extend Forwardable
       delegate each_node: :exp
       delegate %i(name type) => :exp
-      delegate %i(visibility visibility= non_public_visibility?) => :visibility_tracker
 
-      attr_reader :children, :context, :exp, :statement_counter, :visibility_tracker
+      attr_reader :children, :parent, :exp, :statement_counter
+
       private_attr_reader :refs
 
       # Initializes a new CodeContext.
       #
-      # @param context [CodeContext, nil] The parent context
+      # @param parent [CodeContext, nil] The parent context
       # @param exp [Reek::AST::Node] The code described by this context
       #
       # For example, given the following code:
@@ -40,7 +39,7 @@ module Reek
       #
       # The {ContextBuilder} object first instantiates a {RootContext}, which has no parent.
       #
-      # Next, it instantiates a {ModuleContext}, with +context+ being the
+      # Next, it instantiates a {ModuleContext}, with +parent+ being the
       # {RootContext} just created, and +exp+ looking like this:
       #
       #  (class
@@ -52,18 +51,16 @@ module Reek
       #        (lvar :x))))
       #
       # Finally, {ContextBuilder} will instantiate a {MethodContext}. This time,
-      # +context+ is the {ModuleContext} created above, and +exp+ is:
+      # +parent+ is the {ModuleContext} created above, and +exp+ is:
       #
       #   (def :foo
       #     (args
       #       (arg :x))
       #     (send nil :puts
       #       (lvar :x)))
-      def initialize(context, exp)
-        @context            = context
+      def initialize(_parent, exp)
         @exp                = exp
         @children           = []
-        @visibility_tracker = VisibilityTracker.new
         @statement_counter  = StatementCounter.new
         @refs               = AST::ObjectRefs.new
       end
@@ -93,18 +90,17 @@ module Reek
         end
       end
 
-      alias_method :parent, :context
+      def register_with_parent(parent)
+        @parent = parent.append_child_context(self) if parent
+      end
 
-      # Register a child context. The child's parent context should be equal to
-      # the current context.
-      #
-      # This makes the current context responsible for setting the child's
-      # visibility.
+      # Register a context as a child context of this context. This is
+      # generally used by a child context to register itself with its parent.
       #
       # @param child [CodeContext] the child context to register
       def append_child_context(child)
-        visibility_tracker.set_child_visibility(child)
         children << child
+        self
       end
 
       # :reek:TooManyStatements: { max_statements: 6 }
@@ -136,24 +132,30 @@ module Reek
       end
 
       def full_name
-        exp.full_name(context ? context.full_name : '')
+        exp.full_name(parent ? parent.full_name : '')
       end
 
       def config_for(detector_class)
-        context_config_for(detector_class).merge(
+        parent_config_for(detector_class).merge(
           configuration_via_code_commment[detector_class.smell_type] || {})
       end
 
-      def track_visibility(visibility, names)
-        visibility_tracker.track_visibility children: children,
-                                            visibility: visibility,
-                                            names: names
-      end
-
       def number_of_statements
         statement_counter.value
       end
 
+      def singleton_method?
+        false
+      end
+
+      def instance_method?
+        false
+      end
+
+      def apply_current_visibility(_current_visibility)
+        # Nothing to do by default
+      end
+
       private
 
       def configuration_via_code_commment
@@ -164,8 +166,8 @@ module Reek
         exp.full_comment || ''
       end
 
-      def context_config_for(detector_class)
-        context ? context.config_for(detector_class) : {}
+      def parent_config_for(detector_class)
+        parent ? parent.config_for(detector_class) : {}
       end
     end
   end

data/lib/reek/context/ghost_context.rb

@@ -0,0 +1,54 @@
+require_relative 'code_context'
+require_relative 'singleton_method_context'
+
+module Reek
+  module Context
+    # Semi-transparent context to represent a metaclass while building the
+    # context tree. This context will not be part of the resulting tree, but
+    # will track context and visibility separately while building is in
+    # progress.
+    class GhostContext < ModuleContext
+      attr_reader :children
+
+      def register_with_parent(parent)
+        @parent = parent
+      end
+
+      def append_child_context(child)
+        real_parent = parent.append_child_context(child)
+        super
+        real_parent
+      end
+
+      # Return the correct class for child method contexts (representing nodes
+      # of type `:def`). For GhostContext, this is the class that represents
+      # singleton methods.
+      def method_context_class
+        SingletonMethodContext
+      end
+
+      # Return the correct class for child attribute contexts. For
+      # GhostContext, this is the class that represents singleton attributes.
+      def attribute_context_class
+        SingletonAttributeContext
+      end
+
+      def track_visibility(visibility, names)
+        visibility_tracker.track_visibility children: children,
+                                            visibility: visibility,
+                                            names: names
+      end
+
+      def track_singleton_visibility(_visibility, _names)
+      end
+
+      def record_use_of_self
+        parent.record_use_of_self
+      end
+
+      def statement_counter
+        parent.statement_counter
+      end
+    end
+  end
+end

data/lib/reek/context/method_context.rb

@@ -5,9 +5,16 @@ module Reek
     #
     # A context wrapper for any method definition found in a syntax tree.
     #
+    # :reek:Attribute
     class MethodContext < CodeContext
+      attr_accessor :visibility
       attr_reader :refs
 
+      def initialize(context, exp)
+        @visibility = :public
+        super
+      end
+
       def references_self?
         exp.depends_on_instance?
       end
@@ -34,8 +41,28 @@ module Reek
           exp.parameters.select(&:optional_argument?).map(&:children)
       end
 
+      def method_context_class
+        self.class
+      end
+
       def singleton_method?
-        exp.singleton_method? || visibility == :module_function
+        false
+      end
+
+      def instance_method?
+        true
+      end
+
+      def apply_current_visibility(current_visibility)
+        self.visibility = current_visibility
+      end
+
+      def module_function?
+        visibility == :module_function
+      end
+
+      def non_public_visibility?
+        visibility != :public
       end
     end
   end

data/lib/reek/context/module_context.rb

@@ -1,6 +1,7 @@
 require_relative 'code_context'
+require_relative 'attribute_context'
 require_relative 'method_context'
-require_relative '../ast/sexp_formatter'
+require_relative 'visibility_tracker'
 
 module Reek
   module Context
@@ -9,6 +10,39 @@ module Reek
     #
     # :reek:FeatureEnvy
     class ModuleContext < CodeContext
+      attr_reader :visibility_tracker
+
+      def initialize(context, exp)
+        super
+
+        @visibility_tracker = VisibilityTracker.new
+      end
+
+      # Register a child context. The child's parent context should be equal to
+      # the current context.
+      #
+      # This makes the current context responsible for setting the child's
+      # visibility.
+      #
+      # @param child [CodeContext] the child context to register
+      def append_child_context(child)
+        visibility_tracker.set_child_visibility(child)
+        super
+      end
+
+      # Return the correct class for child method contexts (representing nodes
+      # of type `:def`). For ModuleContext, this is the class that represents
+      # instance methods.
+      def method_context_class
+        MethodContext
+      end
+
+      # Return the correct class for child attribute contexts. For
+      # ModuleContext, this is the class that represents instance attributes.
+      def attribute_context_class
+        AttributeContext
+      end
+
       def defined_instance_methods(visibility: :public)
         each.select do |context|
           context.is_a?(Context::MethodContext) &&
@@ -44,6 +78,26 @@ module Reek
         contents = exp.children.last
         contents && contents.find_nodes([:def, :defs], [:casgn, :class, :module]).empty?
       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
+
+      def instance_method_children
+        children.select(&:instance_method?)
+      end
+
+      def singleton_method_children
+        children.select(&:singleton_method?)
+      end
     end
   end
 end

data/lib/reek/context/root_context.rb

@@ -1,4 +1,5 @@
 require_relative 'code_context'
+require_relative 'method_context'
 
 module Reek
   module Context
@@ -17,6 +18,13 @@ module Reek
       def full_name
         ''
       end
+
+      # Return the correct class for child method contexts (representing nodes
+      # of type `:def`). For RootContext, this is the class that represents
+      # instance methods.
+      def method_context_class
+        MethodContext
+      end
     end
   end
 end

data/lib/reek/context/singleton_attribute_context.rb

@@ -0,0 +1,15 @@
+require_relative 'attribute_context'
+
+module Reek
+  module Context
+    #
+    # A context wrapper for any singleton attribute definition found in a
+    # syntax tree.
+    #
+    class SingletonAttributeContext < AttributeContext
+      def instance_method?
+        false
+      end
+    end
+  end
+end