reek 4.8.2 → 5.0.0

data/docs/Reek-Driven-Development.md

@@ -14,7 +14,7 @@ Reek::Rake::Task.new do |t|
 end
 ```
 
-Now the command `reek` will run Reek on your source code (and in this case, it fails if it finds any smells). For more detailed information about Reek's integration with Rake, see [Rake Task](Rake-Task.md) in this wiki.
+Now the command `reek` will run Reek on your source code (and in this case, it fails if it finds any smells). For more detailed information about Reek's integration with Rake, see [Rake Task](Rake-Task.md).
 
 ## reek/spec
 

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
@@ -53,3 +55,40 @@ smelly.rb -- 2 warnings:
   [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
 ```
 
@@ -48,3 +50,43 @@ Reek would report:
 smelly.rb -- 1 warning:
   [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
@@ -50,3 +52,39 @@ Reek would report:
 smelly.rb -- 1 warning:
   [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
     # ....

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')