reek 4.0.0.pre1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8309582de93065645810663cbed12c501ffe0b68
-  data.tar.gz: 73712e80702d432edc320bb5531846d3eefcf266
+  metadata.gz: d3d1f1d919181f67b1404d126a1dd1e92b6b36e3
+  data.tar.gz: cd338514426fb1ea540fc73a0192fb7e492edcbc
 SHA512:
-  metadata.gz: bce9a189c55a37b998dbe35a353fd3ab0ec8379a7c8e058712be3d8d3d5a2c0e111375ccb1b12f2146deea7225272a4cfcfe06c2e199d3d0aa75d8450a179cc7
-  data.tar.gz: dc7cca14a3c083bd41ce51f6cfbbd1da3339bd70c53282fa1f1d3d73102a3f06fa5718af8c61a339bab10210e558bf626d50e315a822ae3f3168dfefb4b2ddd5
+  metadata.gz: 706c68a4e8ce046d345b4e6f6acdcbe767d47becb217e01b62c10e7029e3490b7e8f2f98c8fadfd52264e68f855da40d1243ed536206ce168fe35ebb4baea9cf
+  data.tar.gz: a94a1759d26ec2cf3da345116ebb55736eff62963b750f414b3387f189ee4b46f7413b872e9c2ccbe24bdeab9b46370cb7175487dadb92af4155a03cfb6a83d3

data/.codeclimate.yml

@@ -1,7 +1,16 @@
----
 engines:
+  rubocop:
+    enabled: true
   reek:
     enabled: true
 ratings:
   paths:
-  - "**.rb"
+  - lib/**/*
+exclude_paths:
+- coverage/
+- docs/
+- features/
+- logo/
+- pkg/
+- spec/
+- tmp/

data/.gitignore

@@ -14,3 +14,4 @@ tags
 .tags*
 .DS_Store
 .idea/
+.rbenv-gemsets

data/.travis.yml

@@ -5,6 +5,7 @@ bundler_args: --without debugging
 script:
 - bundle exec rake
 - bundle exec ataru check
+- bundle exec mutant --include lib --require reek --use rspec --since master --jobs 4 "Reek*"
 rvm:
   - 2.1
   - 2.2

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change log
 
+## 4.0.0 (2016-03-21)
+
+* (troessner) Fix disabling UnusedPrivateMethod via `exclude` in configuration.
+* (troessner) Fix `accept` and `reject` configuration handling.
+* (troessner) Fix UnusedParameter detector for lvasgn.
+* (troessner) Remove deprecated method `from_map` from `AppConfiguration`.
+              The successor is `AppConfiguration.from_hash`.
+
 ## 4.0.0.pre1 (2016-03-01)
 
 * First pre-release for Reek 4.

data/Gemfile

@@ -12,6 +12,7 @@ group :development do
   gem 'rubocop',       '~> 0.37.0'
   gem 'yard',          '~> 0.8.7'
   gem 'simplecov',     '~> 0.11.1'
+  gem 'mutant-rspec',  '~> 0.8.8'
 
   platforms :mri do
     gem 'redcarpet', '~> 3.3.1'
@@ -19,6 +20,8 @@ group :development do
 end
 
 group :debugging do
+  # Fixing https://github.com/guard/guard/wiki/Add-Readline-support-to-Ruby-on-Mac-OS-X#option-4-using-a-pure-ruby-readline-implementation
+  gem 'rb-readline', '~> 0.5.3'
   gem 'pry'
   platforms :mri do
     gem 'pry-byebug'

data/README.md

@@ -9,6 +9,8 @@
 [![Gem Version](https://badge.fury.io/rb/reek.svg)](https://badge.fury.io/rb/reek)
 [![Dependency Status](https://gemnasium.com/troessner/reek.png)](https://gemnasium.com/troessner/reek)
 [![Inline docs](https://inch-ci.org/github/troessner/reek.png)](https://inch-ci.org/github/troessner/reek)
+[![Code Climate](https://codeclimate.com/github/troessner/reek/badges/gpa.svg)](https://codeclimate.com/github/troessner/reek)
+[![codebeat](https://codebeat.co/badges/42fed4ff-3e55-4aed-8ecc-409b4aa539b3)](https://codebeat.co/projects/github-com-troessner-reek)
 
 ## Quickstart
 

data/docs/Attribute.md

@@ -24,7 +24,7 @@ Reek would emit the following warning:
 reek test.rb
 
 test.rb -- 1 warning:
-  [2]:Klass declares the writable attribute dummy (Attribute)
+  [2]:Attribute: Klass#dummy is a writable attribute
 ```
 
 ## Support in Reek

data/docs/Uncommunicative-Method-Name.md

@@ -20,5 +20,35 @@ Reek's Uncommunicative Method Name detector supports the [Basic Smell Options](B
 
 | Option         | Value       | Effect  |
 | ---------------|-------------|---------|
-| `reject` | array of regular expressions | The set of regular expressions that Reek uses to check for bad names. Defaults to `[/^[a-z]$/, /[0-9]$/, /[A-Z]/]`. |
-| `accept` | array of strings or regular expressions | Name that will be accepted (not reported) even if they match one of the `reject` expressions. |
+| `reject` | array of regular expressions or strings | The set of patterns / names that Reek uses to check for bad names. Defaults to `[/^[a-z]$/, /[0-9]$/, /[A-Z]/]`. |
+| `accept` | array of regular expressions or strings | The set of patterns / names that Reek will accept (and not report) even if they match one of the `reject` expressions. |
+
+An example configuration could look like this:
+
+```Yaml
+---
+UncommunicativeMethodName:
+  accept:
+    - !ruby/regexp /x/
+    - meth1
+  reject:
+    - !ruby/regexp /helper/
+    - foobar
+```
+
+Applying a configuration to a source file like this:
+
+```Ruby
+def x; end # Should not be reported
+def meth1; end # Should not be reported
+def foobar; end # Should be reported
+def awesome_helper; end # Should be reported
+```
+
+Reek would report:
+
+```
+smelly.rb -- 2 warnings:
+  [4]:UncommunicativeMethodName: awesome_helper has the name 'awesome_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+  [3]:UncommunicativeMethodName: foobar has the name 'foobar' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+```

data/docs/Uncommunicative-Module-Name.md

@@ -19,5 +19,32 @@ Reek's `Uncommunicative Module Name` detector supports the [Basic Smell Options]
 
 | Option         | Value       | Effect  |
 | ---------------|-------------|---------|
-| `reject` | array of regular expressions | The set of regular expressions that Reek uses to check for bad names. Defaults to `[/^.$/, /[0-9]$/]`. |
-| `accept` | array of names as strings | List of names that will be accepted (not reported) even if they match one of the `reject` expressions. Empty by default.|
+| `reject` | array of regular expressions or strings | The set of patterns / names that Reek uses to check for bad names. Defaults to `[/^.$/, /[0-9]$/]`. |
+| `accept` | array of regular expressions or strings | The set of patterns / names that Reek will accept (and not report) even if they match one of the `reject` expressions. Empty by default.|
+
+An example configuration could look like this:
+
+```Yaml
+---
+UncommunicativeModuleName:
+  accept:
+    - !ruby/regexp /lassy/
+    - M
+  reject:
+    - !ruby/regexp /Helper/
+```
+
+Applying a configuration to a source file like this:
+
+```Ruby
+class Classy1; end # Should not be reported
+class M; end # Should not be reported
+class BaseHelper; end # Should be reported
+```
+
+Reek would report:
+
+```
+smelly.rb -- 1 warning:
+  [3]:UncommunicativeModuleName: BaseHelper has the name 'BaseHelper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Module-Name.md]
+```

data/docs/Uncommunicative-Parameter-Name.md

@@ -20,5 +20,33 @@ Reek's Uncommunicative Parameter Name detector supports the [Basic Smell Options
 
 | Option         | Value       | Effect  |
 | ---------------|-------------|---------|
-| `reject` | array of regular expressions | The set of regular expressions that Reek uses to check for bad names. Defaults to `[/^.$/, /[0-9]$/, /[A-Z]/]@. |
-| `accept` | array of strings or regular expressions | Name that will be accepted (not reported) even if they match one of the `reject` expressions. |
+| `reject` | array of regular expressions or strings | The set of patterns / names that Reek uses to check for bad names. Defaults to `[/^.$/, /[0-9]$/, /[A-Z]/, /^_/]. |
+| `accept` | array of regular expressions or strings | The set of patterns / names that Reek will accept (and not report) even if they match one of the `reject` expressions. |
+
+
+An example configuration could look like this:
+
+```Yaml
+---
+UncommunicativeParameterName:
+  accept:
+    - !ruby/regexp /x/
+    - arg1
+  reject:
+    - !ruby/regexp /foobar/
+```
+
+Applying a configuration to a source file like this:
+
+```Ruby
+def omg(x); x; end # Should not be reported
+def omg(arg1); arg1; end # Should not be reported
+def omg(foobar); foobar; end # Should be reported
+```
+
+Reek would report:
+
+```
+smelly.rb -- 1 warning:
+  [3]:UncommunicativeParameterName: omg has the parameter name 'foobar' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+```

data/features/configuration_files/accept_setting.feature

@@ -0,0 +1,70 @@
+Feature: `accept` configuration setting
+  In order to have a more fine-grained control over what Reek reports
+  As a user
+  I want to be able to accept specific patterns and names to exclude them from reporting
+
+  Scenario: Accept names as list and as single item
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        accept:
+          - m1
+          - m2
+      UncommunicativeParameterName:
+        accept:
+          - a1
+          - a2
+      UncommunicativeModuleName:
+        accept: C1
+      """
+    And a file named "smelly.rb" with:
+      """
+      # Should not report UncommunicativeModuleName
+      class C1
+        # Should not report UncommunicativeMethodName and UncommunicativeParameterName
+        def m1(a1); a1; end
+        # Should not report UncommunicativeMethodName and UncommunicativeParameterName
+        def m2(a2); a2; end
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def m3(a3); a3; end
+      end
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 2 warnings:
+      [8]:UncommunicativeMethodName: C1#m3 has the name 'm3' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [8]:UncommunicativeParameterName: C1#m3 has the parameter name 'a3' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+    """
+
+  Scenario: Accept regexes as list and as single item
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        accept:
+          - !ruby/regexp /oobar/
+      UncommunicativeParameterName:
+        accept:
+          - !ruby/regexp /ola/
+      UncommunicativeModuleName:
+        accept: !ruby/regexp /lassy/
+      """
+    And a file named "smelly.rb" with:
+      """
+      # Should not report UncommunicativeModuleName
+      class Classy1
+        # Should not report UncommunicativeMethodName and UncommunicativeParameterName
+        def foobar1(hola1); hola1; end
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def m2(a2); a2; end
+      end
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 2 warnings:
+      [6]:UncommunicativeMethodName: Classy1#m2 has the name 'm2' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [6]:UncommunicativeParameterName: Classy1#m2 has the parameter name 'a2' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+    """

data/features/configuration_files/exclude_directives.feature

@@ -0,0 +1,34 @@
+Feature: Exclude directives
+  In order to have a more fine-grained control over what Reek reports
+  As a user
+  I want to be able to exclude specific contexts from reporting
+
+  Scenario: Exclude multiple contexts
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        exclude:
+          - "Smelly#x"
+      UnusedPrivateMethod:
+        enabled: true
+        exclude:
+          - "Smelly#foobar"
+      """
+    And a file named "smelly.rb" with:
+      """
+      class Smelly
+        # Should report IrresponsibleModule
+        def foo(arg); end # Should report UnusedParameter
+        def x; end        # Should not report UncommunicativeMethodName
+        private
+        def foobar; end   # Should not report UnusedPrivateMethod
+      end
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 2 warnings:
+      [1]:IrresponsibleModule: Smelly has no descriptive comment [https://github.com/troessner/reek/blob/master/docs/Irresponsible-Module.md]
+      [3]:UnusedParameters: Smelly#foo has unused parameter 'arg' [https://github.com/troessner/reek/blob/master/docs/Unused-Parameters.md]
+    """

data/features/configuration_files/mix_accept_reject_setting.feature

@@ -0,0 +1,81 @@
+Feature: Mix `accept` and `reject` configuration settings
+  In order to have a more fine-grained control over what Reek reports
+  As a user
+  I want to be able to mix the `accept` and `reject` setting
+
+  Scenario: UncommunicativeMethodName
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        accept:
+          - !ruby/regexp /x/
+          - meth1
+        reject:
+          - !ruby/regexp /helper/
+          - foobar
+      """
+    And a file named "smelly.rb" with:
+      """
+      def x; end # Should not be reported
+      def meth1; end # Should not be reported
+      def foobar; end # Should be reported
+      def awesome_helper; end # Should be reported
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 2 warnings:
+      [4]:UncommunicativeMethodName: awesome_helper has the name 'awesome_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [3]:UncommunicativeMethodName: foobar has the name 'foobar' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+    """
+
+  Scenario: UncommunicativeModuleName
+    Given a file named "config.reek" with:
+      """
+      ---
+      IrresponsibleModule:
+        enabled: false
+      UncommunicativeModuleName:
+        accept:
+          - !ruby/regexp /lassy/
+          - M
+        reject:
+          - !ruby/regexp /Helper/
+      """
+    And a file named "smelly.rb" with:
+      """
+      class Classy1; end # Should not be reported
+      class M; end # Should not be reported
+      class BaseHelper; end # Should be reported
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 1 warning:
+      [3]:UncommunicativeModuleName: BaseHelper has the name 'BaseHelper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Module-Name.md]
+    """
+
+  Scenario: UncommunicativeParameterName
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeParameterName:
+        accept:
+          - !ruby/regexp /x/
+          - arg1
+        reject:
+          - !ruby/regexp /foobar/
+      """
+    And a file named "smelly.rb" with:
+      """
+      def omg(x); x; end # Should not be reported
+      def omg(arg1); arg1; end # Should not be reported
+      def omg(foobar); foobar; end # Should be reported
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 1 warning:
+      [3]:UncommunicativeParameterName: omg has the parameter name 'foobar' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+    """

data/features/configuration_files/reject_setting.feature

@@ -0,0 +1,78 @@
+Feature: `reject` configuration setting
+  In order to have a more fine-grained control over what Reek reports
+  As a user
+  I want to be able to reject specific patterns and names to include them into reporting
+
+  Scenario: reject names as list and as single item
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        reject:
+          - awesome_helper
+          - little_helper
+      UncommunicativeParameterName:
+        reject:
+          - solid_argument
+          - nifty_argument
+      UncommunicativeModuleName:
+        reject: Dummy
+      """
+    And a file named "smelly.rb" with:
+      """
+      # Should report UncommunicativeModuleName
+      class Dummy
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def awesome_helper(solid_argument); solid_argument; end
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def little_helper(nifty_argument); nifty_argument; end
+        # Should not report UncommunicativeMethodName and UncommunicativeParameterName
+        def meth(argument); argument; end
+      end
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 5 warnings:
+      [4]:UncommunicativeMethodName: Dummy#awesome_helper has the name 'awesome_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [6]:UncommunicativeMethodName: Dummy#little_helper has the name 'little_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [2]:UncommunicativeModuleName: Dummy has the name 'Dummy' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Module-Name.md]
+      [4]:UncommunicativeParameterName: Dummy#awesome_helper has the parameter name 'solid_argument' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+      [6]:UncommunicativeParameterName: Dummy#little_helper has the parameter name 'nifty_argument' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+    """
+
+  Scenario: reject regexes as list and as single item
+    Given a file named "config.reek" with:
+      """
+      ---
+      UncommunicativeMethodName:
+        reject: !ruby/regexp /helper/
+      UncommunicativeParameterName:
+        reject:
+          - !ruby/regexp /solid/
+          - !ruby/regexp /nifty/
+      UncommunicativeModuleName:
+        reject: !ruby/regexp /ummy/
+      """
+    And a file named "smelly.rb" with:
+      """
+      # Should report UncommunicativeModuleName
+      class Dummy
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def awesome_helper(solid_argument); solid_argument; end
+        # Should report UncommunicativeMethodName and UncommunicativeParameterName
+        def little_helper(nifty_argument); nifty_argument; end
+        # Should not report UncommunicativeMethodName and UncommunicativeParameterName
+        def meth(argument); argument; end
+      end
+      """
+    When I run `reek -c config.reek smelly.rb`
+    Then it reports:
+    """
+    smelly.rb -- 5 warnings:
+      [4]:UncommunicativeMethodName: Dummy#awesome_helper has the name 'awesome_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [6]:UncommunicativeMethodName: Dummy#little_helper has the name 'little_helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
+      [2]:UncommunicativeModuleName: Dummy has the name 'Dummy' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Module-Name.md]
+      [4]:UncommunicativeParameterName: Dummy#awesome_helper has the parameter name 'solid_argument' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+      [6]:UncommunicativeParameterName: Dummy#little_helper has the parameter name 'nifty_argument' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Parameter-Name.md]
+    """

data/features/configuration_files/unused_private_method.feature

@@ -0,0 +1,66 @@
+Feature: Unused Private Method detector
+  This detector is a little special in the sense that it takes class contexts but analyzes
+  methods (and thus, is configured in regards to methods) so we need to make sure
+  that our configuration handling still works.
+
+  Scenario: Differentiate between contexts when excluding them
+    Given a file named "config.reek" with:
+      """
+      ---
+      IrresponsibleModule:
+        enabled: false
+      UnusedPrivateMethod:
+        enabled: true
+        exclude:
+          - "Outer::Awesome#foobar"
+      """
+    And a file named "sample.rb" with:
+      """
+      module Outer
+        class Smelly
+          private
+          def foobar; end # Should report UnusedPrivateMethod
+        end
+        class Awesome
+          private
+          def foobar; end # Should not report UnusedPrivateMethod
+        end
+      end
+      """
+    When I run `reek -c config.reek sample.rb`
+    Then it reports:
+    """
+    sample.rb -- 1 warning:
+      [4]:UnusedPrivateMethod: Outer::Smelly has the unused private instance method `foobar` [https://github.com/troessner/reek/blob/master/docs/Unused-Private-Method.md]
+    """
+
+  Scenario: Use regexes for excluding contexts
+    Given a file named "config.reek" with:
+      """
+      ---
+      IrresponsibleModule:
+        enabled: false
+      UnusedPrivateMethod:
+        enabled: true
+        exclude:
+          - !ruby/regexp /(.*)wesome#foo(.*)/
+      """
+    And a file named "sample.rb" with:
+      """
+      module Outer
+        class Smelly
+          private
+          def foobar; end # Should report UnusedPrivateMethod
+        end
+        class Awesome
+          private
+          def foobar; end # Should not report UnusedPrivateMethod
+        end
+      end
+      """
+    When I run `reek -c config.reek sample.rb`
+    Then it reports:
+    """
+    sample.rb -- 1 warning:
+      [4]:UnusedPrivateMethod: Outer::Smelly has the unused private instance method `foobar` [https://github.com/troessner/reek/blob/master/docs/Unused-Private-Method.md]
+    """

data/lib/reek/configuration/app_configuration.rb

@@ -29,36 +29,6 @@ module Reek
         end
       end
 
-      # Instantiate a configuration by passing everything in.
-      #
-      # @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
-            load_values map.fetch(:directory_directives, {})
-            load_values map.fetch(:default_directive, {})
-            load_values EXCLUDE_PATHS_KEY => map.fetch(:excluded_paths, [])
-          end
-        end
-      end
-
       # Instantiate a configuration by passing everything in.
       #
       # Loads the configuration from a hash of the form that is loaded from a

data/lib/reek/context/method_context.rb

@@ -21,7 +21,21 @@ module Reek
       end
 
       def uses_param?(param)
-        local_nodes(:lvar).find { |node| node.var_name == param.to_sym }
+        # local_nodes(:lvasgn) catches:
+        #   def foo(bar); bar += 1; end
+        # In this example there is no `lvar` node present.
+        #
+        # local_nodes(: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 }
       end
 
       # :reek:FeatureEnvy

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -16,18 +16,19 @@ module Reek
     # Currently +UncommunicativeMethodName+ checks for
     # * 1-character names
     # * names ending with a number
+    # * names containing a capital letter (assuming camelCase)
     #
     # See {file:docs/Uncommunicative-Method-Name.md} for details.
     class UncommunicativeMethodName < SmellDetector
       REJECT_KEY = 'reject'.freeze
       ACCEPT_KEY = 'accept'.freeze
       DEFAULT_REJECT_PATTERNS = [/^[a-z]$/, /[0-9]$/, /[A-Z]/].freeze
-      DEFAULT_ACCEPT_NAMES = [].freeze
+      DEFAULT_ACCEPT_PATTERNS = [].freeze
 
       def self.default_config
         super.merge(
           REJECT_KEY => DEFAULT_REJECT_PATTERNS,
-          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
+          ACCEPT_KEY => DEFAULT_ACCEPT_PATTERNS
         )
       end
 
@@ -50,16 +51,16 @@ module Reek
       private
 
       def acceptable_name?(name:, context:)
-        accept_names(context).any? { |accept_name| name == accept_name } ||
-          reject_patterns(context).none? { |pattern| name.match pattern }
+        accept_patterns(context).any? { |accept_pattern| name.match accept_pattern } ||
+          reject_patterns(context).none? { |reject_pattern| name.match reject_pattern }
       end
 
       def reject_patterns(context)
-        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+        Array value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
       end
 
-      def accept_names(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
+      def accept_patterns(context)
+        Array value(ACCEPT_KEY, context, DEFAULT_ACCEPT_PATTERNS)
       end
     end
   end