reek 4.7.1 → 4.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: baf611107a9ba063fb9882a312ae27c556f4a4f6
-  data.tar.gz: f56386a2775e1a178a1df9af568055c5ac63c80f
+  metadata.gz: a57753b0b855d7182054e7551940eac44cf57f60
+  data.tar.gz: 245074bd6e150589a1bc7a69830a34e3db600a83
 SHA512:
-  metadata.gz: d108db6dd4064eced4dfe277238771246120f73874f89ae3800e7bbef91b101d946861cb1793b7a138ce761bf4b26e854ee05b13ca5d39287c46b7c64027436a
-  data.tar.gz: 2005c56063bdc5a62f3ec3fe53b73d99158b8b124bdbbb45a3d8ff5ab64ab35e2863afdace05d05b5538855fdc80ed4ca138e073b415ac38f7d9dab95ccbc382
+  metadata.gz: 4c422c0a25421d8d0abc337766f7b2defae5f7044137c3e5fb7c34fffea7ee409d165f56922f433565fa8643d716cdbb3e9a3c7cec568bfa50bf15b2eed8b254
+  data.tar.gz: d4b77922d2745ab3d7f6f053931193b543f646e605a0b3a7f7a444ddf24d3462df4bf7732a248f14fd49f9253925afbf441d3fda578df736b130bfbf80db5096

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change log
 
+## 4.7.2 (2017-07-24)
+
+* (mvz) Also report unused uncommunicative parameter names
+* (mvz) Track visibility correctly when using method definition visibility modifiers
+* (mvz) Handle method comments when using method definition visibility modifiers
+
 ## 4.7.1 (2017-06-12)
 
 * (mvz) Improve IrresponsibleModule and fix some bugs along

data/features/configuration_files/directory_specific_directives.feature

@@ -41,7 +41,7 @@ Feature: Directory directives
     And a file named "web_app/app/models/user.rb" with:
       """
       class User < ActiveRecord::Base
-        def logged_in_with_role(r)
+        def logged_in_with_role(role)
           true
         end
       end
@@ -53,7 +53,7 @@ Feature: Directory directives
       [1]:InstanceVariableAssumption: UsersController assumes too much for instance variable '@user' [https://github.com/troessner/reek/blob/master/docs/Instance-Variable-Assumption.md]
     web_app/app/models/user.rb -- 2 warnings:
       [1]:IrresponsibleModule: User has no descriptive comment [https://github.com/troessner/reek/blob/master/docs/Irresponsible-Module.md]
-      [2]:UnusedParameters: User#logged_in_with_role has unused parameter 'r' [https://github.com/troessner/reek/blob/master/docs/Unused-Parameters.md]
+      [2]:UnusedParameters: User#logged_in_with_role has unused parameter 'role' [https://github.com/troessner/reek/blob/master/docs/Unused-Parameters.md]
     3 total warnings
     """
 
@@ -112,7 +112,7 @@ Feature: Directory directives
     And a file named "web_app/app/models/user.rb" with:
       """
       class User < ActiveRecord::Base
-        def logged_in_with_role(r)
+        def logged_in_with_role(role)
           true
         end
       end
@@ -125,7 +125,7 @@ Feature: Directory directives
       [1]:IrresponsibleModule: UsersController has no descriptive comment [https://github.com/troessner/reek/blob/master/docs/Irresponsible-Module.md]
       [4]:NestedIterators: UsersController#show contains iterators nested 2 deep [https://github.com/troessner/reek/blob/master/docs/Nested-Iterators.md]
     web_app/app/models/user.rb -- 1 warning:
-      [2]:UnusedParameters: User#logged_in_with_role has unused parameter 'r' [https://github.com/troessner/reek/blob/master/docs/Unused-Parameters.md]
+      [2]:UnusedParameters: User#logged_in_with_role has unused parameter 'role' [https://github.com/troessner/reek/blob/master/docs/Unused-Parameters.md]
     4 total warnings
     """
 

data/lib/reek/ast/node.rb

@@ -12,11 +12,8 @@ module Reek
     # methods to ease the transition from Sexp to AST::Node.
     #
     class Node < ::Parser::AST::Node
-      attr_reader :parent
-
       def initialize(type, children = [], options = {})
         @comments = options.fetch(:comments, [])
-        @parent   = options.fetch(:parent, nil)
         super
       end
 

data/lib/reek/context/attribute_context.rb

@@ -11,10 +11,10 @@ module Reek
     class AttributeContext < CodeContext
       attr_accessor :visibility
 
-      def initialize(context, exp, send_expression)
+      def initialize(exp, send_expression)
         @visibility = :public
         @send_expression = send_expression
-        super context, exp
+        super exp
       end
 
       def full_comment

data/lib/reek/context/code_context.rb

@@ -26,39 +26,8 @@ module Reek
 
       # 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
@@ -91,6 +60,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

data/lib/reek/context/method_context.rb

@@ -12,9 +12,10 @@ module Reek
       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?
@@ -36,7 +37,7 @@ module Reek
         # 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) + local_nodes(:lvasgn)).find { |node| node.var_name == param.name }
       end
 
       # :reek:FeatureEnvy
@@ -44,7 +45,7 @@ module Reek
         exp.arguments.reject do |param|
           param.anonymous_splat? ||
             param.marked_unused? ||
-            uses_param?(param.plain_name)
+            uses_param?(param)
         end
       end
 
@@ -80,6 +81,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

@@ -13,9 +13,8 @@ module Reek
     class ModuleContext < CodeContext
       attr_reader :visibility_tracker
 
-      def initialize(context, exp)
+      def initialize(exp)
         super
-
         @visibility_tracker = VisibilityTracker.new
       end
 

data/lib/reek/context/root_context.rb

@@ -9,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

@@ -10,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_builder.rb

@@ -22,6 +22,7 @@ module Reek
   #
   # :reek:TooManyMethods: { max_methods: 31 }
   # :reek:UnusedPrivateMethod: { exclude: [ !ruby/regexp /process_/ ] }
+  # :reek:DataClump
   class ContextBuilder
     attr_reader :context_tree
 
@@ -58,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
@@ -71,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
@@ -91,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
@@ -103,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
@@ -119,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
@@ -134,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
@@ -151,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.
@@ -173,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
@@ -192,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
@@ -205,7 +206,7 @@ module Reek
     #
     #   def self.foo; end
     #
-    def process_self(_)
+    def process_self(_, _parent)
       current_context.record_use_of_self
     end
 
@@ -225,7 +226,7 @@ module Reek
     #
     # We record one reference to `self`.
     #
-    def process_zsuper(_)
+    def process_zsuper(_, _parent)
       current_context.record_use_of_self
     end
 
@@ -249,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
@@ -262,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
@@ -282,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)
@@ -308,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])
@@ -331,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)
@@ -354,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)
@@ -384,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)
@@ -412,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
@@ -434,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)
@@ -460,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
@@ -482,19 +483,19 @@ module Reek
     # yields to the given block and then restores the previous context.
     #
     # @param klass [Context::*Context] - context class
-    # @param exp - current expression
+    # @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
@@ -502,7 +503,7 @@ module Reek
     # @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

data/lib/reek/detector_repository.rb

@@ -35,31 +35,25 @@ module Reek
                    configuration: {})
       @configuration = configuration
       @smell_types   = smell_types
-      @detectors     = smell_types.map { |klass| klass.new configuration_for(klass) }
     end
 
     def examine(context)
-      smell_detectors_for(context.type).flat_map do |detector|
-        detector.run_for(context)
+      smell_detectors_for(context.type).flat_map do |klass|
+        detector = klass.new configuration: configuration_for(klass), context: context
+        detector.run
       end
     end
 
     private
 
-    attr_reader :configuration, :smell_types, :detectors
+    attr_reader :configuration, :smell_types
 
     def configuration_for(klass)
       configuration.fetch klass, {}
     end
 
     def smell_detectors_for(type)
-      enabled_detectors.select do |detector|
-        detector.contexts.include? type
-      end
-    end
-
-    def enabled_detectors
-      detectors.select { |detector| detector.config.enabled? }
+      smell_types.select { |detector| detector.contexts.include? type }
     end
   end
 end

data/lib/reek/smell_detectors/base_detector.rb

@@ -28,29 +28,22 @@ module Reek
       # in any configuration file.
       DEFAULT_EXCLUDE_SET = [].freeze
 
-      def initialize(config = {})
-        @config = SmellConfiguration.new self.class.default_config.merge(config)
+      def initialize(configuration: {}, context: nil)
+        @config = SmellConfiguration.new self.class.default_config.merge(configuration)
+        @context = context
       end
 
       def smell_type
         self.class.smell_type
       end
 
-      def contexts
-        self.class.contexts
-      end
-
-      def run_for(context)
-        return [] unless enabled_for?(context)
-        return [] if exception?(context)
+      def run
+        return [] unless enabled?
+        return [] if exception?
 
         sniff(context)
       end
 
-      def exception?(context)
-        context.matches?(value(EXCLUDE_KEY, context))
-      end
-
       def self.todo_configuration_for(smells)
         default_exclusions = default_config.fetch 'exclude'
         exclusions = default_exclusions + smells.map(&:context)
@@ -59,7 +52,13 @@ module Reek
 
       private
 
-      def enabled_for?(context)
+      attr_reader :context
+
+      def exception?
+        context.matches?(value(EXCLUDE_KEY, context))
+      end
+
+      def enabled?
         config.enabled? && config_for(context)[SmellConfiguration::ENABLED_KEY] != false
       end
 

data/lib/reek/smell_detectors/uncommunicative_parameter_name.rb

@@ -40,10 +40,12 @@ module Reek
       #
       def sniff(context)
         expression = context.exp
-        expression.parameter_names.select do |name|
-          sanitized_name = sanitize name
-          uncommunicative_parameter_name?(name: sanitized_name, context: context)
-        end.map do |name|
+
+        params = expression.parameters.select do |param|
+          uncommunicative_parameter?(parameter: param, context: context)
+        end
+
+        params.map(&:name).map do |name|
           smell_warning(
             context: context,
             lines: [expression.line],
@@ -54,11 +56,13 @@ module Reek
 
       private
 
-      def uncommunicative_parameter_name?(name:, context:)
-        !acceptable_name?(name: name, context: context) && context.uses_param?(name)
+      def uncommunicative_parameter?(parameter:, context:)
+        !acceptable_name?(parameter: parameter, context: context) &&
+          (context.uses_param?(parameter) || !parameter.marked_unused?)
       end
 
-      def acceptable_name?(name:, context:)
+      def acceptable_name?(parameter:, context:)
+        name = parameter.plain_name
         accept_patterns(context).any? { |accept_pattern| name.match accept_pattern } ||
           reject_patterns(context).none? { |reject_pattern| name.match reject_pattern }
       end
@@ -70,11 +74,6 @@ module Reek
       def accept_patterns(context)
         Array value(ACCEPT_KEY, context)
       end
-
-      # :reek:UtilityFunction
-      def sanitize(name)
-        name.to_s.gsub(/^[@\*\&]*/, '')
-      end
     end
   end
 end

data/lib/reek/smell_detectors/unused_private_method.rb

@@ -75,6 +75,7 @@ module Reek
 
       #
       # @param ctx [Context::ClassContext]
+      # @param method [Context::MethodContext]
       # @return [Boolean]
       #
       # :reek:FeatureEnvy

data/lib/reek/tree_dresser.rb

@@ -39,13 +39,13 @@ module Reek
     #
     # :reek:FeatureEnvy
     # :reek:TooManyStatements: { max_statements: 6 }
-    def dress(sexp, comment_map, parent: nil)
+    def dress(sexp, comment_map)
       return sexp unless sexp.is_a? ::Parser::AST::Node
       type = sexp.type
-      children = sexp.children.map { |child| dress(child, comment_map, parent: sexp) }
+      children = sexp.children.map { |child| dress(child, comment_map) }
       comments = comment_map[sexp]
       klass_map.klass_for(type).new(type, children,
-                                    location: sexp.loc, comments: comments, parent: parent)
+                                    location: sexp.loc, comments: comments)
     end
 
     private

data/lib/reek/version.rb

@@ -8,6 +8,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '4.7.1'.freeze
+    STRING = '4.7.2'.freeze
   end
 end

data/spec/reek/context/code_context_spec.rb

@@ -4,7 +4,7 @@ require_lib 'reek/context/module_context'
 
 RSpec.describe Reek::Context::CodeContext do
   context 'name recognition' do
-    let(:ctx)       { described_class.new(nil, exp) }
+    let(:ctx)       { described_class.new(exp) }
     let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
     let(:exp_name)  { 'random_name' }
     let(:full_name) { "::::::::::::::::::::#{exp_name}" }
@@ -43,9 +43,9 @@ RSpec.describe Reek::Context::CodeContext do
     end
 
     context 'when there is an outer' do
-      let(:ctx)        { described_class.new(outer, exp) }
+      let(:ctx)        { described_class.new(exp) }
       let(:outer_name) { 'another_random sting' }
-      let(:outer)      { described_class.new(nil, instance_double('Reek::AST::Node')) }
+      let(:outer)      { described_class.new(instance_double('Reek::AST::Node')) }
 
       before do
         ctx.register_with_parent outer
@@ -71,7 +71,7 @@ RSpec.describe Reek::Context::CodeContext do
       let(:ctx) do
         src = 'module Emptiness; end'
         ast = Reek::Source::SourceCode.from(src).syntax_tree
-        described_class.new(nil, ast)
+        described_class.new(ast)
       end
 
       it 'yields no calls' do
@@ -99,7 +99,7 @@ RSpec.describe Reek::Context::CodeContext do
       let(:ctx) do
         src = "module Loneliness; def calloo; puts('hello') end; end"
         ast = Reek::Source::SourceCode.from(src).syntax_tree
-        described_class.new(nil, ast)
+        described_class.new(ast)
       end
 
       it 'yields no ifs' do
@@ -149,7 +149,7 @@ RSpec.describe Reek::Context::CodeContext do
         end
       EOS
       ast = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = described_class.new(nil, ast)
+      ctx = described_class.new(ast)
       expect(ctx.each_node(:if, []).length).to eq(3)
     end
   end
@@ -166,7 +166,7 @@ RSpec.describe Reek::Context::CodeContext do
     end
     let(:expression) { Reek::Source::SourceCode.from(src).syntax_tree }
     let(:outer) { nil }
-    let(:context) { described_class.new(outer, expression) }
+    let(:context) { described_class.new(expression) }
     let(:sniffer) { class_double('Reek::SmellDetectors::BaseDetector') }
 
     before do
@@ -181,7 +181,7 @@ RSpec.describe Reek::Context::CodeContext do
     end
 
     context 'when there is an outer context' do
-      let(:outer) { described_class.new(nil, instance_double('Reek::AST::Node')) }
+      let(:outer) { described_class.new(instance_double('Reek::AST::Node')) }
 
       before do
         allow(outer).to receive(:config_for).with(sniffer).and_return(
@@ -196,9 +196,9 @@ RSpec.describe Reek::Context::CodeContext do
   end
 
   describe '#register_with_parent' do
-    let(:context) { described_class.new(nil, instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
+    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
 
     it "appends the element to the parent context's list of children" do
       first_child.register_with_parent context
@@ -209,9 +209,9 @@ RSpec.describe Reek::Context::CodeContext do
   end
 
   describe '#each' do
-    let(:context) { described_class.new(nil, instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
+    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
 
     it 'yields each child' do
       first_child.register_with_parent context

data/spec/reek/context/ghost_context_spec.rb

@@ -4,53 +4,53 @@ require_lib 'reek/context/ghost_context'
 
 RSpec.describe Reek::Context::GhostContext do
   let(:exp) { instance_double('Reek::AST::Node') }
-  let(:parent) { Reek::Context::CodeContext.new(nil, exp) }
+  let(:parent) { Reek::Context::CodeContext.new(exp) }
 
   describe '#register_with_parent' do
     it 'does not append itself to its parent' do
-      ghost = described_class.new(parent, nil)
+      ghost = described_class.new(nil)
       ghost.register_with_parent(parent)
       expect(parent.children).not_to include ghost
     end
   end
 
   describe '#append_child_context' do
-    let(:ghost) { described_class.new(parent, nil) }
+    let(:ghost) { described_class.new(nil) }
 
     before do
       ghost.register_with_parent(parent)
     end
 
     it 'appends the child to the grandparent context' do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(parent.children).to include child
     end
 
     it "sets the child's parent to the grandparent context" do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(child.parent).to eq parent
     end
 
     it 'appends the child to the list of children' do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(ghost.children).to include child
     end
 
     context 'if the grandparent is also a ghost' do
-      let(:child_ghost) { described_class.new(ghost, nil) }
+      let(:child_ghost) { described_class.new(nil) }
 
       before do
         child_ghost.register_with_parent(ghost)
       end
 
       it 'sets the childs parent to its remote ancestor' do
-        child = Reek::Context::CodeContext.new(child_ghost, sexp(:foo))
+        child = Reek::Context::CodeContext.new(sexp(:foo))
         child.register_with_parent(child_ghost)
 
         expect(child.parent).to eq parent

data/spec/reek/context/method_context_spec.rb

@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 require_lib 'reek/context/method_context'
 
 RSpec.describe Reek::Context::MethodContext do
-  let(:method_context) { described_class.new(nil, exp) }
+  let(:method_context) { described_class.new(exp, nil) }
 
   describe '#matches?' do
     let(:exp) { instance_double('Reek::AST::SexpExtensions::ModuleNode').as_null_object }
@@ -31,7 +31,7 @@ RSpec.describe Reek::Context::MethodContext do
   describe '#default_assignments' do
     def assignments_from(src)
       exp = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::MethodContext.new(nil, exp)
+      ctx = Reek::Context::MethodContext.new(exp, nil)
       ctx.default_assignments
     end
 

data/spec/reek/context/module_context_spec.rb

@@ -32,9 +32,9 @@ RSpec.describe Reek::Context::ModuleContext do
     let(:first_def) { instance_double('Reek::AST::SexpExtensions::DefNode', name: :foo) }
     let(:second_def) { instance_double('Reek::AST::SexpExtensions::DefNode') }
 
-    let(:context) { described_class.new(nil, main_exp) }
-    let(:first_child) { Reek::Context::MethodContext.new(context, first_def) }
-    let(:second_child) { Reek::Context::MethodContext.new(context, second_def) }
+    let(:context) { described_class.new(main_exp) }
+    let(:first_child) { Reek::Context::MethodContext.new(first_def, main_exp) }
+    let(:second_child) { Reek::Context::MethodContext.new(second_def, main_exp) }
 
     it 'sets visibility on subsequent child contexts' do
       context.append_child_context first_child

data/spec/reek/context_builder_spec.rb

@@ -220,6 +220,26 @@ RSpec.describe Reek::ContextBuilder do
       described_class.new(syntax_tree(code)).context_tree
     end
 
+    it 'marks instance methods when using a def modifier' do
+      code = <<-EOS
+        class Foo
+          private def bar
+          end
+
+          def baz
+          end
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      aggregate_failures do
+        expect(method_contexts[0].visibility).to eq :private
+        expect(method_contexts[1].visibility).to eq :public
+      end
+    end
+
     it 'does not mark class methods with instance visibility' do
       code = <<-EOS
         class Foo

data/spec/reek/smell_detectors/irresponsible_module_spec.rb

@@ -49,17 +49,6 @@ RSpec.describe Reek::SmellDetectors::IrresponsibleModule do
       expect(src).not_to reek_of(:IrresponsibleModule)
     end
 
-    it "does not report re-opened #{scope} in the same file" do
-      src = <<-EOS
-        # This comment describes Alfa
-        #{scope} Alfa; end
-
-        #{scope} Alfa; def bravo; end; end
-      EOS
-
-      expect(src).not_to reek_of(:IrresponsibleModule)
-    end
-
     it "reports a #{scope} with an empty comment" do
       src = <<-EOS
         #

data/spec/reek/smell_detectors/uncommunicative_parameter_name_spec.rb

@@ -32,15 +32,6 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
   { 'alfa.' => 'with a receiver',
     '' => 'without a receiver' }.each do |host, description|
     context "in a method definition #{description}" do
-      it 'does not recognise *' do
-        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
-      end
-
-      it 'does not report unused parameters' do
-        src = "def #{host}bravo(x); charlie; end"
-        expect(src).not_to reek_of(:UncommunicativeParameterName)
-      end
-
       it 'does not report two-letter parameter names' do
         src = "def #{host}bravo(ab); charlie(ab); end"
         expect(src).not_to reek_of(:UncommunicativeParameterName)
@@ -56,6 +47,26 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
         expect(src).to reek_of(:UncommunicativeParameterName, name: 'param2')
       end
 
+      it 'reports unused parameters' do
+        src = "def #{host}bravo(x); charlie; end"
+        expect(src).to reek_of(:UncommunicativeParameterName)
+      end
+
+      it 'reports splat parameters' do
+        expect("def #{host}bravo(*a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
+      it 'reports double splat parameters' do
+        expect("def #{host}bravo(**a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
+      it 'reports block parameters' do
+        expect("def #{host}bravo(&a); charlie(a); end").
+          to reek_of(:UncommunicativeParameterName, name: 'a')
+      end
+
       it 'does not report unused anonymous parameter' do
         src = "def #{host}bravo(_); charlie; end"
         expect(src).not_to reek_of(:UncommunicativeParameterName)
@@ -63,12 +74,20 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeParameterName do
 
       it 'reports used anonymous parameter' do
         src = "def #{host}bravo(_); charlie(_) end"
-        expect(src).to reek_of(:UncommunicativeParameterName)
+        expect(src).to reek_of(:UncommunicativeParameterName, name: '_')
       end
 
       it 'reports used parameters marked as unused' do
         src = "def #{host}bravo(_unused) charlie(_unused) end"
-        expect(src).to reek_of(:UncommunicativeParameterName)
+        expect(src).to reek_of(:UncommunicativeParameterName, name: '_unused')
+      end
+
+      it 'does not report anonymous splat' do
+        expect("def #{host}bravo(*); end").not_to reek_of(:UncommunicativeParameterName)
+      end
+
+      it 'does not report anonymous double splat' do
+        expect("def #{host}bravo(**); end").not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports names inside array decomposition' do

data/spec/reek/smell_detectors/unused_private_method_spec.rb

@@ -103,6 +103,17 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
         to reek_of(:UnusedPrivateMethod, name: 'bravo', lines: [3]).
         and reek_of(:UnusedPrivateMethod, name: 'charlie', lines: [4])
     end
+
+    it 'reports instance methods defined as private with a modifier' do
+      source = <<-EOF
+        class Alfa
+          private def bravo; end
+        end
+      EOF
+
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo')
+    end
   end
 
   describe 'configuring the detector via source code comment' do

data/spec/reek/smell_detectors/utility_function_spec.rb

@@ -221,6 +221,18 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when private is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            private def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
     end
 
     context 'protected methods' do
@@ -236,6 +248,46 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when protected is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            protected def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
+    end
+  end
+
+  describe 'disabling with a comment' do
+    it 'disables the method following the comment' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
+    end
+
+    it 'disables a method when it has a visibility modifier' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          private def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reek
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 4.7.2
 platform: ruby
 authors:
 - Kevin Rutherford
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-12 00:00:00.000000000 Z
+date: 2017-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-engine-rb
@@ -443,7 +443,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Code smell detector for Ruby