reek 4.7.1 → 5.0.0

data/docs/Uncommunicative-Method-Name.md

@@ -21,8 +21,8 @@ Reek's _Uncommunicative Method Name_ detector supports the
 
 | Option         | Value       | Effect  |
 | ---------------|-------------|---------|
-| `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. |
+| `reject` | array of strings | The set of names that Reek uses to check for bad names. Defaults to single-letter names, names ending with a number or names containing upper case letters. |
+| `accept` | array of strings | The set of names that Reek will accept (and not report) even if they match one of the `reject` expressions. |
 
 An example configuration could look like this:
 
@@ -30,13 +30,15 @@ An example configuration could look like this:
 ---
 UncommunicativeMethodName:
   accept:
-    - !ruby/regexp /x/
+    - x
     - meth1
   reject:
-    - !ruby/regexp /helper/
+    - helper
     - foobar
 ```
 
+Reek will convert whatever you give it as a string to the corresponding regex, so "foobar" from above will be converted to /foobar/ internally. 
+
 Applying a configuration to a source file like this:
 
 ```Ruby
@@ -50,6 +52,43 @@ 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]
+  [4]:UncommunicativeMethodName: awesome_helper has the name 'awesome_helper'
+  [3]:UncommunicativeMethodName: foobar has the name 'foobar'
+```
+
+## Advanced configuration
+
+Sometimes just strings are not enough for configuration. E.g. consider this code sample:
+
+```Ruby
+class Klass
+  def foo; end
+  def foobar; end;
+end
 ```
+
+and now imagine that you want to reject the name "foo" but not "foobar". This wouldn't be possible with just using strings.
+For this reason Reek has a special syntax that allows you to use regexes by using a forward slash at the beginning and the end of the string.
+Everything within the forward slashes will be loaded as a regex.
+
+A possible configuration that allows "foobar" but rejects "foo" could look like this:
+
+```Yaml
+---
+UncommunicativeMethodName:
+  reject:
+    - "/^foo$/"
+```
+
+## Reek 4
+
+In Reek 4 you could also pass regexes to `accept` or `reject`, meaning this was perfectly valid as well:
+
+```yaml
+UncommunicativeMethodName:
+  accept:
+    - !ruby/regexp /foobar/
+```
+
+Support for this has been scrapped with Reek 5 to make the Reek configuration more yaml standard compliant.
+You can still pass in regexes, you just have to wrap them into a string. Please see "Advanced configuration" above.

data/docs/Uncommunicative-Module-Name.md

@@ -19,8 +19,8 @@ Reek's _Uncommunicative Module Name_ detector supports the [Basic Smell Options]
 
 | Option         | Value       | Effect  |
 | ---------------|-------------|---------|
-| `reject` | array of regular expressions or strings | The set of patterns or names that Reek uses to check for bad names. Defaults to `[/^.$/, /[0-9]$/]`. |
-| `accept` | array of regular expressions or strings | The set of patterns or names that Reek will accept (and not report) even if they match one of the `reject` expressions. Empty by default.|
+| `reject` | array of strings | The set of names that Reek uses to check for bad names. Defaults to single-letter names and names ending with a number. |
+| `accept` | array or strings | The set of 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:
 
@@ -28,17 +28,19 @@ An example configuration could look like this:
 ---
 UncommunicativeModuleName:
   accept:
-    - !ruby/regexp /lassy/
-    - M
+    - lassy
+    - Util
   reject:
-    - !ruby/regexp /Helper/
+    - Helper
 ```
 
+Reek will convert whatever you give it as a string to the corresponding regex, so "Helper" from above will be converted to /Helper/ internally. 
+
 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 Util; end # Should not be reported
 class BaseHelper; end # Should be reported
 ```
 
@@ -46,5 +48,45 @@ 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]
+  [3]:UncommunicativeModuleName: BaseHelper has the name 'BaseHelper'
+```
+
+## Advanced configuration
+
+Sometimes just strings are not enough for configuration. E.g. consider this code sample:
+
+```Ruby
+class Klassy
+  # ...
+end
+
+class KlassyModule
+  # ...
+end
+```
+
+and now imagine that you want to reject the name "Klassy" but not "KlassyModule". This wouldn't be possible with just using strings.
+For this reason Reek has a special syntax that allows you to use regexes by using a forward slash at the beginning and the end of the string.
+Everything within the forward slashes will be loaded as a regex.
+
+A possible configuration that allows "KlassyModule" but rejects "Klassy" could look like this:
+
+```Yaml
+---
+UncommunicativeModuleName:
+  reject:
+    - "/^Klassy$/"
 ```
+
+## Reek 4
+
+In Reek 4 you could also pass regexes to `accept` or `reject`, meaning this was perfectly valid as well:
+
+```yaml
+UncommunicativeModuleName:
+  accept:
+    - !ruby/regexp /foobar/
+```
+
+Support for this has been scrapped with Reek 5 to make the Reek configuration more yaml standard compliant.
+You can still pass in regexes, you just have to wrap them into a string. Please see "Advanced configuration" above.

data/docs/Uncommunicative-Parameter-Name.md

@@ -20,8 +20,8 @@ Reek's _Uncommunicative Parameter Name_ detector supports the [Basic Smell Optio
 
 | Option   | Value       | Effect  |
 | ---------|-------------|---------|
-| `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. |
+| `reject` | array of strings | The set of names that Reek uses to check for bad names. Defaults to single-letter names, names containing an uppercase letter, names with a number at the end and '_'. |
+| `accept` | array of strings | The set of names that Reek will accept (and not report) even if they match one of the `reject` expressions. |
 
 
 An example configuration could look like this:
@@ -30,12 +30,14 @@ An example configuration could look like this:
 ---
 UncommunicativeParameterName:
   accept:
-    - !ruby/regexp /x/
+    - x
     - arg1
   reject:
-    - !ruby/regexp /foobar/
+    - foobar
 ```
 
+Reek will convert whatever you give it as a string to the corresponding regex, so "foobar" from above will be converted to /foobar/ internally. 
+
 Applying a configuration to a source file like this:
 
 ```Ruby
@@ -48,5 +50,41 @@ 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]
+  [3]:UncommunicativeParameterName: omg has the parameter name 'foobar'
+```
+
+## Advanced configuration
+
+Sometimes just strings are not enough for configuration. E.g. consider this code sample:
+
+```Ruby
+class Klass
+  def my_method(foo, foobar); end
+end
 ```
+
+and now imagine that you want to reject the name "foo" but not "foobar". This wouldn't be possible with just using strings.
+For this reason Reek has a special syntax that allows you to use regexes by using a forward slash at the beginning and the end of the string.
+Everything within the forward slashes will be loaded as a regex.
+
+A possible configuration that allows "foobar" but rejects "foo" could look like this:
+
+```Yaml
+---
+UncommunicativeParameterName:
+  reject:
+    - "/^foo$/"
+```
+
+## Reek 4
+
+In Reek 4 you could also pass regexes to `accept` or `reject`, meaning this was perfectly valid as well:
+
+```yaml
+UncommunicativeParameterName:
+  accept:
+    - !ruby/regexp /foobar/
+```
+
+Support for this has been scrapped with Reek 5 to make the Reek configuration more yaml standard compliant.
+You can still pass in regexes, you just have to wrap them into a string. Please see "Advanced configuration" above.

data/docs/Uncommunicative-Variable-Name.md

@@ -21,5 +21,76 @@ Reek's _Uncommunicative Variable Name_ detector supports the
 
 | 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. Defaults to `['_']`.|
+| `reject` | array of strings | The set of names that Reek uses to check for bad names. Defaults to single-letter names, names ending with a number or names containing upper case letters. |
+| `accept` | array of strings | Names that will be accepted (not reported) even if they match one of the `reject` expressions. Defaults to `_`.|
+
+An example configuration could look like this:
+
+```Yaml
+---
+UncommunicativeVariableName:
+  accept:
+    - x
+    - var1
+  reject:
+    - helper
+    - foobar
+```
+
+Reek will convert whatever you give it as a string to the corresponding regex, so "foobar" from above will be converted to /foobar/ internally. 
+
+Applying a configuration to a source file like this:
+
+```Ruby
+def omg
+  x = 5 # Should not be reported
+  var1 = true # Should not be reported
+  helper = 42 # Should be reported
+  foobar = false # Should be reported
+end
+```
+
+Reek would report:
+
+```
+smelly.rb -- 2 warnings:
+  [5]:UncommunicativeVariableName: omg has the variable name 'foobar' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+  [4]:UncommunicativeVariableName: omg has the variable name 'helper' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+```
+
+## Advanced configuration
+
+Sometimes just strings are not enough for configuration. E.g. consider this code sample:
+
+```Ruby
+def omg
+  foo = 42
+  foobar = 4242
+end
+```
+
+and now imagine that you want to reject the name "foo" but not "foobar". This wouldn't be possible with just using strings.
+For this reason Reek has a special syntax that allows you to use regexes by using a forward slash at the beginning and the end of the string.
+Everything within the forward slashes will be loaded as a regex.
+
+A possible configuration that allows "foobar" but rejects "foo" could look like this:
+
+```Yaml
+---
+UncommunicativeVariableName:
+  reject:
+    - "/^foo$/"
+```
+
+## Reek 4
+
+In Reek 4 you could also pass regexes to `accept` or `reject`, meaning this was perfectly valid as well:
+
+```yaml
+UncommunicativeVariableName:
+  accept:
+    - !ruby/regexp /write/
+```
+
+Support for this has been scrapped with Reek 5 to make the Reek configuration more yaml standard compliant.
+You can still pass in regexes, you just have to wrap them into a string. Please see "Advanced configuration" above.

data/docs/Unused-Private-Method.md

@@ -37,7 +37,7 @@ configuration option (which is part of the [Basic Smell Options](Basic-Smell-Opt
 for instance like this (an example from Reek's own codebase):
 
 ```Ruby
-# :reek:UnusedPrivateMethod { exclude: [ !ruby/regexp /process_/ ] }
+# :reek:UnusedPrivateMethod { exclude: [ process_ ] }
 class ContextBuilder
   def process_begin
     # ....
@@ -78,13 +78,13 @@ end
 ## Known limitations
 
 * Method calls via dynamic dispatch (e.g. via `send`) is something Reek (or any other
-  static tool for that matter) can not detect.
+  static tool for that matter) cannot detect.
 * Method calls via callback like [Rails filters](http://guides.rubyonrails.org/action_controller_overview.html#filters)
   will trigger this as well, e.g.:
 
 ```Ruby
   class BankController < ActionController::Base
-    before_filter :audit
+    before_action :audit
 
     private
     def audit

data/docs/defaults.reek.yml

@@ -0,0 +1,129 @@
+---
+detectors:
+  Attribute:
+    enabled: true
+    exclude: []
+  BooleanParameter:
+    enabled: true
+    exclude: []
+  ClassVariable:
+    enabled: true
+    exclude: []
+  ControlParameter:
+    enabled: true
+    exclude: []
+  DataClump:
+    enabled: true
+    exclude: []
+    max_copies: 2
+    min_clump_size: 2
+  DuplicateMethodCall:
+    enabled: true
+    exclude: []
+    max_calls: 1
+    allow_calls: []
+  FeatureEnvy:
+    enabled: true
+    exclude: []
+  InstanceVariableAssumption:
+    enabled: true
+    exclude: []
+  IrresponsibleModule:
+    enabled: true
+    exclude: []
+  LongParameterList:
+    enabled: true
+    exclude: []
+    max_params: 3
+    overrides:
+      initialize:
+        max_params: 5
+  LongYieldList:
+    enabled: true
+    exclude: []
+    max_params: 3
+  ManualDispatch:
+    enabled: true
+    exclude: []
+  MissingSafeMethod:
+    enabled: true
+    exclude: []
+  ModuleInitialize:
+    enabled: true
+    exclude: []
+  NestedIterators:
+    enabled: true
+    exclude: []
+    max_allowed_nesting: 1
+    ignore_iterators:
+    - tap
+  NilCheck:
+    enabled: true
+    exclude: []
+  RepeatedConditional:
+    enabled: true
+    exclude: []
+    max_ifs: 2
+  SubclassedFromCoreClass:
+    enabled: true
+    exclude: []
+  TooManyConstants:
+    enabled: true
+    exclude: []
+    max_constants: 5
+  TooManyInstanceVariables:
+    enabled: true
+    exclude: []
+    max_instance_variables: 4
+  TooManyMethods:
+    enabled: true
+    exclude: []
+    max_methods: 15
+  TooManyStatements:
+    enabled: true
+    exclude:
+    - initialize
+    max_statements: 5
+  UncommunicativeMethodName:
+    enabled: true
+    exclude: []
+    reject:
+    - "/^[a-z]$/"
+    - "/[0-9]$/"
+    - "/[A-Z]/"
+    accept: []
+  UncommunicativeModuleName:
+    enabled: true
+    exclude: []
+    reject:
+    - "/^.$/"
+    - "/[0-9]$/"
+    accept: []
+  UncommunicativeParameterName:
+    enabled: true
+    exclude: []
+    reject:
+    - "/^.$/"
+    - "/[0-9]$/"
+    - "/[A-Z]/"
+    - "/^_/"
+    accept: []
+  UncommunicativeVariableName:
+    enabled: true
+    exclude: []
+    reject:
+    - "/^.$/"
+    - "/[0-9]$/"
+    - "/[A-Z]/"
+    accept:
+    - "/^_$/"
+  UnusedParameters:
+    enabled: true
+    exclude: []
+  UnusedPrivateMethod:
+    enabled: false
+    exclude: []
+  UtilityFunction:
+    enabled: true
+    exclude: []
+    public_methods_only: false

data/docs/yard_plugin.rb

@@ -13,4 +13,5 @@ end
 
 YARD::Templates::Template.extra_includes << LocalLinkHelper
 YARD::Tags::Library.define_tag('Guaranteed public API', :public)
+YARD::Tags::Library.define_tag('Code quality configuration', :quality)
 YARD::Templates::Engine.register_template_path File.join(File.dirname(__FILE__), 'templates')

data/features/command_line_interface/basic_usage.feature

@@ -10,6 +10,6 @@ Feature: The Reek CLI maintains backwards compatibility
     And it reports:
     """
     smelly.rb -- 2 warnings:
-      [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-      [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+      [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+      [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
     """

data/features/command_line_interface/options.feature

@@ -37,13 +37,14 @@ Feature: Reek can be controlled using command-line options
       reek -s lib
       cat my_class.rb | reek
 
-      See https://wiki.github.com/troessner/reek for detailed help.
+      See https://github.com/troessner/reek for detailed help.
 
       Configuration:
           -c, --config FILE                Read configuration options from FILE
               --smell SMELL                Only look for a specific smell.
-                                           Call it like this: reek --smell PrimaDonnaMethod source.rb
-                                           Check out https://github.com/troessner/reek/blob/master/docs/Code-Smells.md for a list of smells
+                                           Call it like this: reek --smell MissingSafeMethod source.rb
+                                           Check out https://github.com/troessner/reek/blob/v5.0.0/docs/Code-Smells.md for a list of smells
+              --stdin-filename FILE        When passing code in via pipe, assume this filename when checking file or directory rules in the config.
 
       Generate a todo list:
           -t, --todo                       Generate a todo list
@@ -60,7 +61,7 @@ Feature: Reek can be controlled using command-line options
       Text format options:
               --[no-]color                 Use colors for the output (default: true)
           -V, --[no-]empty-headings        Show headings for smell-free source files (default: false)
-          -U, --[no-]wiki-links            Show link to related wiki page for each smell (default: true)
+          -U, --[no-]documentation         Show link to related documentation page for each smell (default: true)
           -n, --[no-]line-numbers          Show line numbers in the output (default: true)
           -s, --single-line                Show location in editor-compatible single-line-per-smell format
           -P, --[no-]progress              Show progress of each source as it is examined (default: true)
@@ -76,5 +77,46 @@ Feature: Reek can be controlled using command-line options
 
       Utility options:
           -h, --help                       Show this message
+          -l, --list                       List all available smell detectors
           -v, --version                    Show version
       """
+
+  Scenario: List all available smell detectors
+    When I run reek --list
+    Then it succeeds
+    And it reports:
+      """
+      All available smell detectors:
+
+      Attribute
+      BooleanParameter
+      ClassVariable
+      ControlParameter
+      DataClump
+      DuplicateMethodCall
+      FeatureEnvy
+      InstanceVariableAssumption
+      IrresponsibleModule
+      LongParameterList
+      LongYieldList
+      ManualDispatch
+      MissingSafeMethod
+      ModuleInitialize
+      NestedIterators
+      NilCheck
+      RepeatedConditional
+      SubclassedFromCoreClass
+      TooManyConstants
+      TooManyInstanceVariables
+      TooManyMethods
+      TooManyStatements
+      UncommunicativeMethodName
+      UncommunicativeModuleName
+      UncommunicativeParameterName
+      UncommunicativeVariableName
+      UnusedParameters
+      UnusedPrivateMethod
+      UtilityFunction
+
+      Check out https://github.com/troessner/reek/blob/v5.0.0/docs/Code-Smells.md for a details on each detector
+      """

data/features/command_line_interface/show_progress.feature

@@ -15,8 +15,8 @@ Feature: Show progress
       .S
 
       mixed_files/dirty.rb -- 2 warnings:
-        [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
       2 total warnings
       """
 
@@ -27,7 +27,7 @@ Feature: Show progress
     And it reports:
       """
       mixed_files/dirty.rb -- 2 warnings:
-        [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
       2 total warnings
       """

data/features/command_line_interface/smell_selection.feature

@@ -11,5 +11,5 @@ Feature: Smell selection
     And it reports:
       """
       smelly.rb -- 1 warning:
-        UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        UncommunicativeVariableName: Smelly#x has the variable name 'y'
       """

data/features/command_line_interface/smells_count.feature

@@ -9,8 +9,8 @@ Feature: Reports total number of code smells
     And it reports:
       """
       smelly.rb -- 2 warnings:
-        [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
       """
 
   Scenario: Output total number of smells when inspecting multiple files
@@ -20,11 +20,11 @@ Feature: Reports total number of code smells
     And it reports:
       """
       smelly/dirty_one.rb -- 2 warnings:
-        [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
       smelly/dirty_two.rb -- 2 warnings:
-        [4]:UncommunicativeMethodName: Smelly#x has the name 'x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [4]:UncommunicativeMethodName: Smelly#x has the name 'x'
+        [5]:UncommunicativeVariableName: Smelly#x has the variable name 'y'
       4 total warnings
       """
 

data/features/command_line_interface/stdin.feature

@@ -27,17 +27,39 @@ Feature: Reek reads from $stdin when no files are given
     And it reports:
       """
       STDIN -- 3 warnings:
-        [1]:IrresponsibleModule: Turn has no descriptive comment [https://github.com/troessner/reek/blob/master/docs/Irresponsible-Module.md]
-        [1]:UncommunicativeMethodName: Turn#y has the name 'y' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Method-Name.md]
-        [1]:UncommunicativeVariableName: Turn has the variable name '@x' [https://github.com/troessner/reek/blob/master/docs/Uncommunicative-Variable-Name.md]
+        [1]:IrresponsibleModule: Turn has no descriptive comment
+        [1]:UncommunicativeMethodName: Turn#y has the name 'y'
+        [1]:UncommunicativeVariableName: Turn has the variable name '@x'
       """
 
   Scenario: syntax error causes the source to be ignored
     When I pass "= invalid syntax =" to reek
-    Then the exit status indicates smells
-    And it reports:
+    Then it succeeds
+    And it reports the error "Parser::SyntaxError: unexpected token tEQL"
+
+  Scenario: providing a filename to use for the config to match against
+    Given a file named "web_app/config.reek" with:
       """
-      STDIN -- 2 warnings:
-        [2]:Syntax: This file has unexpected token $end [https://github.com/troessner/reek/blob/master/docs/Syntax.md]
-        [1]:Syntax: This file has unexpected token tEQL [https://github.com/troessner/reek/blob/master/docs/Syntax.md]
+      ---
+      directories:
+        "web_app/app/controllers":
+          IrresponsibleModule:
+            enabled: false
+          NestedIterators:
+            enabled: false
+          InstanceVariableAssumption:
+            enabled: false
       """
+    When I pass a stdin to reek --config web_app/config.reek --stdin-filename web_app/app/controllers/users_controller with:
+      """
+      class UsersController < ApplicationController
+        def show
+          respond_with do |format|
+            format.json { |json| @user.to_custom_json }
+            format.xml { |xml| @user.to_fancy_xml }
+          end
+        end
+      end
+      """
+    Then it succeeds
+    And it reports nothing