reek 3.5.0 → 3.6.0

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

@@ -0,0 +1,23 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Base module for utility methods for nodes that can contain argument
+      # nodes nested through :mlhs nodes.
+      module NestedAssignables
+        def components
+          children.flat_map(&:components)
+        end
+      end
+
+      # Utility methods for :args nodes.
+      module ArgsNode
+        include NestedAssignables
+      end
+
+      # Utility methods for :mlhs nodes.
+      module MlhsNode
+        include NestedAssignables
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Reek
+  module AST
+    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
+          children[1]
+        end
+
+        def args
+          children[2..-1]
+        end
+
+        def participants
+          ([receiver] + args).compact
+        end
+
+        def arg_names
+          args.map { |arg| arg.children.first }
+        end
+
+        def module_creation_call?
+          object_creation_call? && module_creation_receiver?
+        end
+
+        def module_creation_receiver?
+          receiver && [:Class, :Struct].include?(receiver.simple_name)
+        end
+
+        def object_creation_call?
+          method_name == :new
+        end
+
+        def visibility_modifier?
+          VISIBILITY_MODIFIERS.include?(method_name)
+        end
+
+        def attribute_writer?
+          ATTR_DEFN_METHODS.include?(method_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
+        end
+      end
+
+      Op_AsgnNode = SendNode
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Utility methods for :super nodes.
+      module SuperNode
+        def method_name
+          :super
+        end
+      end
+
+      ZsuperNode = SuperNode
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Utility methods for :sym nodes.
+      module SymNode
+        def name
+          children.first
+        end
+
+        def full_name(outer)
+          "#{outer}##{name}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Base module for utility methods for nodes representing variables.
+      module VariableBase
+        def name
+          children.first
+        end
+      end
+
+      # Utility methods for :cvar nodes.
+      module CvarNode
+        include VariableBase
+      end
+
+      # Utility methods for :ivar nodes.
+      module IvarNode
+        include VariableBase
+      end
+
+      # Utility methods for :ivasgn nodes.
+      module IvasgnNode
+        include VariableBase
+      end
+
+      # Utility methods for :lvar nodes.
+      module LvarNode
+        include VariableBase
+
+        alias_method :var_name, :name
+      end
+
+      LvasgnNode = LvarNode
+      CvasgnNode = CvarNode
+      CvdeclNode = CvarNode
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Utility methods for :when nodes.
+      module WhenNode
+        def condition_list
+          children[0..-2]
+        end
+
+        def body
+          children.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Reek
+  module AST
+    module SexpExtensions
+      # Utility methods for :yield nodes.
+      module YieldNode
+        def args
+          children
+        end
+
+        def arg_names
+          args.map { |arg| arg[1] }
+        end
+      end
+    end
+  end
+end

data/lib/reek/cli/application.rb

@@ -32,10 +32,6 @@ module Reek
         status
       end
 
-      def output(text)
-        print text
-      end
-
       def report_success
         self.status = STATUS_SUCCESS
       end

data/lib/reek/cli/options.rb

@@ -12,15 +12,13 @@ module Reek
     # :reek:TooManyInstanceVariables: { max_instance_variables: 6 }
     # :reek:Attribute: { enabled: false }
     class Options
-      attr_accessor :argv,
-                    :colored,
+      attr_reader :argv, :parser, :smells_to_detect
+      attr_accessor :colored,
                     :config_file,
                     :location_format,
-                    :parser,
                     :report_format,
                     :show_empty,
                     :show_links,
-                    :smells_to_detect,
                     :sorting
 
       def initialize(argv = [])

data/lib/reek/configuration/app_configuration.rb

@@ -9,8 +9,9 @@ require_relative './excluded_paths'
 module Reek
   module Configuration
     #
-    # Reek's singleton configuration instance.
+    # Reek's application configuration.
     #
+    # @public
     class AppConfiguration
       include ConfigurationValidator
       EXCLUDE_PATHS_KEY = 'exclude_paths'
@@ -21,6 +22,8 @@ module Reek
       # @param path [Pathname] the path to the config file
       #
       # @return [AppConfiguration]
+      #
+      # @public
       def self.from_path(path = nil)
         allocate.tap do |instance|
           instance.instance_eval { find_and_load(path: path) }
@@ -29,16 +32,24 @@ module Reek
 
       # Instantiate a configuration by passing everything in.
       #
-      # @param map [Hash] can have the following 3 keys:
-      # 1.) directory_directives [Hash] for instance:
-      #   { Pathname("spec/samples/three_clean_files/") =>
-      #     { Reek::Smells::UtilityFunction => { "enabled" => false } } }
-      # 2.) default_directive [Hash] for instance:
-      #   { Reek::Smells::IrresponsibleModule => { "enabled" => false } }
-      # 3.) excluded_paths [Array] for instance:
-      #   [ Pathname('spec/samples/two_smelly_files') ]
+      # @deprecated This method will be removed in Reek 4.0.
+      #
+      # @param [Hash] map a hash with three possible keys representing
+      # different types of directives.
+      # @option map [Hash] :directory_directives Directory specific configuration
+      #   for instance:
+      #     { Pathname("spec/samples/three_clean_files/") =>
+      #       { Reek::Smells::UtilityFunction => { "enabled" => false } } }
+      # @option map [Hash] :default_directive Default configuration
+      #   for instance:
+      #     { Reek::Smells::IrresponsibleModule => { "enabled" => false } }
+      # @option map [Array] :excluded_paths list of paths to exclude from analysis
+      #   for instance:
+      #     [ Pathname('spec/samples/two_smelly_files') ]
       #
       # @return [AppConfiguration]
+      #
+      # @public
       def self.from_map(map = {})
         allocate.tap do |instance|
           instance.instance_eval do
@@ -49,6 +60,23 @@ module Reek
         end
       end
 
+      # Instantiate a configuration by passing everything in.
+      #
+      # Loads the configuration from a hash of the form that is loaded from a
+      # +.reek+ config file.
+      # @param [Hash] hash The configuration hash to load.
+      #
+      # @return [AppConfiguration]
+      #
+      # @public
+      def self.from_hash(hash = {})
+        allocate.tap do |instance|
+          instance.instance_eval do
+            load_values hash
+          end
+        end
+      end
+
       def self.default
         from_path nil
       end

data/lib/reek/configuration/configuration_file_finder.rb

@@ -5,7 +5,7 @@ module Reek
     # Raised when config file is not properly readable.
     class ConfigFileException < StandardError; end
     #
-    # ConfigurationFileFinder is responsible for finding reek's configuration.
+    # ConfigurationFileFinder is responsible for finding Reek's configuration.
     #
     # There are 3 ways of passing `reek` a configuration file:
     # 1. Using the cli "-c" switch
@@ -24,18 +24,21 @@ module Reek
 
       # :reek:ControlParameter
       def find(path: nil, current: Pathname.pwd, home: Pathname.new(Dir.home))
-        path || find_by_dir(current) || find_by_dir(home)
+        path || find_by_dir(current) || find_in_dir(home)
       end
 
-      # :reek:NestedIterators: { max_allowed_nesting: 2 }
       def find_by_dir(start)
         start.ascend do |dir|
-          files = dir.children.select(&:file?).sort
-          found = files.find { |file| file.to_s.end_with?('.reek') }
+          found = find_in_dir(dir)
           return found if found
         end
       end
 
+      def find_in_dir(dir)
+        files = dir.children.select(&:file?).sort
+        files.find { |file| file.to_s.end_with?('.reek') }
+      end
+
       # :reek:TooManyStatements: { max_statements: 6 }
       def load_from_file(path)
         return {} unless path

data/lib/reek/configuration/directory_directives.rb

@@ -50,8 +50,8 @@ module Reek
 
       def error_message_for_invalid_smell_type(klass)
         "You are trying to configure smell type #{klass} but we can't find one with that name.\n" \
-          "Please make sure you spelled it right (see 'config/defaults.reek' in the reek\n" \
-          'repository for a list of all available smell types.'
+          "Please make sure you spelled it right. (See 'defaults.reek' in the Reek\n" \
+          'repository for a list of all available smell types.)'
       end
     end
   end

data/lib/reek/context/attribute_context.rb

@@ -0,0 +1,21 @@
+require_relative 'code_context'
+
+module Reek
+  module Context
+    #
+    # A context wrapper for attribute definitions found in a syntax tree.
+    #
+    class AttributeContext < CodeContext
+      def initialize(context, exp, send_expression)
+        @send_expression = send_expression
+        super context, exp
+      end
+
+      def full_comment
+        send_expression.full_comment || ''
+      end
+
+      private_attr_reader :send_expression
+    end
+  end
+end

data/lib/reek/context/code_context.rb

@@ -117,10 +117,6 @@ module Reek
         end
       end
 
-      def num_methods
-        0
-      end
-
       def full_name
         exp.full_name(context ? context.full_name : '')
       end
@@ -180,11 +176,11 @@ module Reek
       end
 
       def config
-        @config ||= if exp
-                      CodeComment.new(exp.full_comment || '').config
-                    else
-                      {}
-                    end
+        @config ||= CodeComment.new(full_comment).config
+      end
+
+      def full_comment
+        exp.full_comment || ''
       end
 
       def context_config_for(detector_class)

data/lib/reek/rake/task.rb

@@ -8,13 +8,13 @@ require 'English'
 
 module Reek
   #
-  # Defines a task library for running reek.
+  # Defines a task library for running Reek.
   # (Classes here will be configured via the Rakefile, and therefore will
   # possess a :reek:attribute or two.)
   #
   # @public
   module Rake
-    # A Rake task that runs reek on a set of source files.
+    # A Rake task that runs Reek on a set of source files.
     #
     # Example:
     #
@@ -39,11 +39,11 @@ module Reek
     # :reek:TooManyInstanceVariables: { max_instance_variables: 6 }
     # :reek:Attribute
     class Task < ::Rake::TaskLib
-      # Name of reek task. Defaults to :reek.
+      # Name of Reek task. Defaults to :reek.
       # @public
       attr_writer :name
 
-      # Path to reek's config file.
+      # Path to Reek's config file.
       # Setting the REEK_CFG environment variable overrides this.
       # @public
       attr_accessor :config_file
@@ -105,7 +105,7 @@ module Reek
       def run_task
         puts "\n\n!!! Running 'reek' rake command: #{command}\n\n" if verbose
         system(*command)
-        abort("\n\n!!! `reek` has found smells - exiting!") if sys_call_failed? && fail_on_error
+        abort("\n\n!!! Reek has found smells - exiting!") if sys_call_failed? && fail_on_error
       end
 
       def command

data/lib/reek/smells/nested_iterators.rb

@@ -10,6 +10,16 @@ module Reek
     #
     # See {file:docs/Nested-Iterators.md} for details.
     class NestedIterators < SmellDetector
+      # Struct for conveniently associating iterators with their depth (that is, their nesting).
+      Iterator = Struct.new :exp, :depth do
+        include Comparable
+        def <=>(other)
+          depth <=> other.depth
+        end
+      end
+
+      private_attr_accessor :ignore_iterators
+
       # The name of the config field that sets the maximum depth
       # of nested iterators to be permitted within any single method.
       MAX_ALLOWED_NESTING_KEY = 'max_allowed_nesting'
@@ -28,47 +38,84 @@ module Reek
       end
 
       #
-      # Checks whether the given +block+ is inside another.
+      # Attempts to find the deepest nested iterator and warns if it's depth
+      # is bigger than our allowed maximum.
       #
       # @return [Array<SmellWarning>]
       #
+      # :reek:TooManyStatements: { max_statements: 6 }
       def examine_context(ctx)
-        exp, depth = *find_deepest_iterator(ctx)
+        configure_ignore_iterators(ctx)
+        deepest_iterator = find_deepest_iterator ctx
+        return [] unless deepest_iterator
+        depth = deepest_iterator.depth
+        return [] unless depth > max_nesting(ctx)
 
-        if depth && depth > value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
-          [smell_warning(
-            context: ctx,
-            lines: [exp.line],
-            message: "contains iterators nested #{depth} deep",
-            parameters: { name: ctx.full_name, count: depth })]
-        else
-          []
-        end
+        [smell_warning(
+          context: ctx,
+          lines: [deepest_iterator.exp.line],
+          message: "contains iterators nested #{depth} deep",
+          parameters: { name: ctx.full_name, count: depth })]
       end
 
       private
 
-      private_attr_accessor :ignore_iterators
-
+      #
+      # @return [Iterator|nil]
+      #
       def find_deepest_iterator(ctx)
-        self.ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
-
-        find_iters(ctx.exp, 1).sort_by { |item| item[1] }.last
+        exp = ctx.exp
+        return nil unless exp.find_nodes([:block])
+        scout(parent: exp, exp: exp, depth: 0).
+          flatten.
+          sort.
+          last
       end
 
-      def find_iters(exp, depth)
-        return [] unless exp
-        exp.find_nodes([:block]).flat_map do |elem|
-          find_iters_for_iter_node(elem, depth)
+      # A little digression into parser's sexp is necessary here:
+      #
+      # Given
+      #   foo.each() do ... end
+      # this will end up as:
+      #
+      # "foo.each() do ... end" -> the iterator below
+      # "each()"                -> the "call" below
+      # "do ... end"            -> the "block" below
+      #
+      # @param parent [AST::Node] The parent iterator
+      #
+      # @param exp [AST::Node]
+      #   The given expression to analyze.
+      #   Will be nil on empty blocks so we'll return just the parent iterator
+      #
+      # @param depth [Integer]
+      #
+      # @return [Array<Iterator>]
+      #
+      def scout(parent: raise, exp: raise, depth: raise)
+        return [Iterator.new(parent, depth)] unless exp
+        iterators = exp.find_nodes([:block])
+        return [Iterator.new(parent, depth)] if iterators.empty?
+        iterators.map do |iterator|
+          # 1st case: we recurse down the given block of the iterator. In this case
+          # we need to check if we should increment the depth.
+          # 2nd case: we recurse down the associated call of the iterator. In this case
+          # the depth stays the same.
+          scout(parent: iterator, exp: iterator.block, depth: increment_depth(iterator, depth)) +
+            scout(parent: iterator, exp: iterator.call, depth: depth)
         end
       end
 
-      def find_iters_for_iter_node(exp, depth)
-        ignored = ignored_iterator? exp
-        result = find_iters(exp.call, depth) +
-          find_iters(exp.block, depth + (ignored ? 0 : 1))
-        result << [exp, depth] unless ignored
-        result
+      def configure_ignore_iterators(ctx)
+        self.ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
+      end
+
+      def increment_depth(iterator, depth)
+        ignored_iterator?(iterator) ? depth : depth + 1
+      end
+
+      def max_nesting(ctx)
+        value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
       end
 
       # :reek:FeatureEnvy