reek 6.0.1 → 6.0.5

data/docs/Uncommunicative-Name.md

@@ -1,18 +0,0 @@
-# Uncommunicative Name
-
-## Introduction
-
-An _Uncommunicative Name_ is a name that doesn't communicate its intent well enough.
-
-Poor names make it hard for the reader to build a mental picture of what's
-going on in the code. They can also be mis-interpreted; and they hurt the flow
-of reading, because the reader must slow down to interpret the names.
-
-## Current Support in Reek
-
-Reek offers four checks in this category:
-
-* [Uncommunicative Method Name](Uncommunicative-Method-Name.md)
-* [Uncommunicative Module Name](Uncommunicative-Module-Name.md)
-* [Uncommunicative Parameter Name](Uncommunicative-Parameter-Name.md)
-* [Uncommunicative Variable Name](Uncommunicative-Variable-Name.md)

data/docs/Uncommunicative-Parameter-Name.md

@@ -1,90 +0,0 @@
-# Uncommunicative Parameter Name
-
-## Introduction
-
-An _Uncommunicative Parameter Name_ is a parameter name that doesn't
-communicate its intent well enough. This code smell is a case of
-[Uncommunicative Name](Uncommunicative-Name.md).
-
-## Current Support in Reek
-
-_Uncommunicative Parameter Name_ checks for:
-
-* single-character names
-* any name ending with a number
-* camelCaseParameterNames
-
-## Configuration
-
-Reek's _Uncommunicative Parameter Name_ detector supports the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option   | Value       | Effect  |
-| ---------|-------------|---------|
-| `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:
-
-```Yaml
----
-UncommunicativeParameterName:
-  accept:
-    - x
-    - arg1
-  reject:
-    - 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); 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'
-```
-
-## 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

@@ -1,96 +0,0 @@
-# Uncommunicative Variable Name
-
-## Introduction
-
-An _Uncommunicative Variable Name_ is a variable name that doesn't communicate
-its intent well enough. This code smell is a case of
-[Uncommunicative Name](Uncommunicative-Name.md).
-
-## Current Support in Reek
-
-_Uncommunicative Variable Name_ checks for:
-
-* single-character names
-* any name ending with a number
-* camelCaseVariableNames
-
-## Configuration
-
-Reek's _Uncommunicative Variable Name_ detector supports the
-[Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option         | Value       | Effect  |
-| ---------------|-------------|---------|
-| `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-Parameters.md

@@ -1,28 +0,0 @@
-## Introduction
-
-_Unused Parameter_ refers to methods with parameters that are unused in scope of the method.
-
-Having unused parameters in a method is code smell because leaving dead code in
-a method can never improve the method and it makes the code confusing to read.
-
-## Example
-
-Given:
-
-```Ruby
-class Klass
-  def unused_parameters(x,y,z)
-    puts x,y # but not z
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-[2]:UnusedParameters: Klass#unused_parameters has unused parameter 'z'
-```
-
-## Configuration
-
-_Unused Parameter_ offers the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Unused-Private-Method.md

@@ -1,101 +0,0 @@
-## Introduction
-
-Classes should use their private methods. Otherwise this is dead
-code which is confusing and bad for maintenance.
-
-The _Unused Private Method_ detector reports unused private instance
-methods and instance methods only - class methods are ignored.
-
-## Example
-
-Given:
-
-```Ruby
-class Car
-  private
-  def drive; end
-  def start; end
-end
-```
-
-Reek would emit the following warning:
-
-```
-2 warnings:
-  [3]:Car has the unused private instance method `drive` (UnusedPrivateMethod)
-  [4]:Car has the unused private instance method `start` (UnusedPrivateMethod)
-```
-
-## Configuration
-
-_Unused Private Method_ offers the [Basic Smell Options](Basic-Smell-Options.md).
-
-Private methods that are called via dynamic dispatch
-will trigger a false alarm since detecting something like this is far out of
-scope for Reek. In this case you can disable this detector via the `exclude`
-configuration option (which is part of the [Basic Smell Options](Basic-Smell-Options.md))
-for instance like this (an example from Reek's own codebase):
-
-```Ruby
-# :reek:UnusedPrivateMethod { exclude: [ process_ ] }
-class ContextBuilder
-  def process_begin
-    # ....
-  end
-end
-```
-
-Note that disabling this detector via comment works on a class scope, not
-a method scope (like you can see above).
-
-Another simple example would be:
-
-```Ruby
-class Alfa
-  private
-  def bravo
-  end
-end
-```
-
-This would report:
-
->>
-ruby.rb -- 1 warning:
-  [3]:UnusedPrivateMethod: Alfa has the unused private instance method 'bravo'
-
-If you want to suppress this warning you can do this via source comment like this:
-
-```Ruby
-# :reek:UnusedPrivateMethod: { exclude: bravo }
-class Alfa
-  private
-  def bravo
-  end
-end
-```
-
-## Known limitations
-
-* Method calls via dynamic dispatch (e.g. via `send`) is something Reek (or any other
-  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_action :audit
-
-    private
-    def audit
-      # ....
-    end
-  end
-```
-* Reek works on a per-file base. This means that using something like the [template pattern](https://en.wikipedia.org/wiki/Template_method_pattern)
-  with private methods will trigger this detector.
-  We do believe though that using private methods to fill out a template in a
-  superclass is not a good idea in general so this probably isn't really a problem
-  but still worth mentioning it.
-
-

data/docs/Utility-Function.md

@@ -1,56 +0,0 @@
-# Utility Function
-
-## Introduction
-
-A _Utility Function_ is any instance method that has no dependency on the state of the instance.
-
-_Utility Function_ is heavily related to _[Feature Envy](Feature-Envy.md)_, please check out the explanation there why _Utility Function_ is something you should care about.
-
-## Example
-
-Given
-
-```Ruby
-class UtilityFunction
-  def showcase(argument)
-    argument.to_s + argument.to_i
-  end
-end
-```
-
-Reek would report:
-
-```
-test.rb -- 2 warnings:
-  [2]:UtilityFunction#showcase doesn't depend on instance state (UtilityFunction)
-```
-
-## Current Support in Reek
-
-_Utility Function_ will warn about any method that:
-
-* is non-empty
-* does not override an inherited method
-* calls at least one method on another object
-* doesn't use any of self's instance variables
-* doesn't use any of self's methods
-
-## Differences to _Feature Envy_
-
-_[Feature Envy](Feature-Envy.md)_ is only triggered if there are some references to self and _Utility Function_ is triggered if there are no references to self.
-
-## Configuration
-
-Reek's _Utility Function_ detector supports the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option                | Value       | Effect  |
-| ----------------------|-------------|---------|
-| `public_methods_only` | Boolean | Disable this smell detector for non-public methods (which means "private" and "protected") |
-
-A sample configuration file would look like this:
-
-```Yaml
----
-UtilityFunction:
-  public_methods_only: true
-```

data/docs/Versioning-Policy.md

@@ -1,7 +0,0 @@
-# Versioning Policy
-
-* CLI interface: Adding options is a non-breaking change, and would warrant an update of the minor version. Removing options is a breaking change and requires a major version update (we did this going to Reek 2). Adding a report format probably also warrents a minor version upgrade.
-* API: We haven't really defined a 'public' API for using Reek programmatically, and we've only just started testing it. So, this is basically a blank slate at the moment. We will work on this as a part of the Reek 3 release.
-* List of detected smells: Adding a smell warrants a minor release, removing a smell is a breaking change. This makes sense if you consider that the CLI allows running a single smell detector.
-* Consistency of detected smells: This is very hard to guarantee. If we fix a bug in one of the detectors, some fragrant code may become smelly, or vice versa. Right now we don't bother with this.
-* Smell configuration: The detectors are quite tolerant regarding configuration options that they don't recognize, so we regard any change here as only requiring a minor release.

data/docs/YAML-Reports.md

@@ -1,93 +0,0 @@
-# YAML Reports
-
-## Introduction
-
-Reek's `--yaml` option writes on $stdout a YAML dump of the smells found. Each reported smell has a number of standard fields and a number of fields that are specific to the smell's type. The common fields are as follows:
-
-| Field         | Type       | Value  |
-| ---------------|-------------|---------|
-| source | string | The name of the source file containing the smell, or `$stdin` |
-| lines | array | The source file line number(s) that contribute to this smell |
-| context | string | The name of the class, module or method containing the smell |
-| class | string | The class to which this smell belongs |
-| subclass | string | This smell's subclass within the above class |
-| message | string | The message that would have been printed in a standard Reek report |
-| is_active | boolean | `false` if the smell is masked by a config file; `true` otherwise |
-
-All of these fields are grouped into hashes `location`, `smell` and `status` (see the examples below).
-
-## Examples
-
-Duplication:
-
-<pre>
-- !ruby/object:Reek::SmellWarning 
-  location: 
-    source: spec/samples/masked/dirty.rb
-    lines: 
-    - 5
-    - 7
-    context: Dirty#a
-  smell: 
-    class: Duplication
-    subclass: DuplicateMethodCall
-    occurrences: 2
-    call: puts(@s.title)
-    message: calls puts(@s.title) twice
-  status:
-    is_active: true
-</pre>
-
-[Nested Iterators](Nested-Iterators.md):
-
-<pre>
-- !ruby/object:Reek::SmellWarning 
-  location: 
-    source: spec/samples/masked/dirty.rb
-    lines: 
-    - 5
-    context: Dirty#a
-  smell: 
-    class: NestedIterators
-    subclass: ""
-    depth: 2
-    message: contains iterators nested 2 deep
-  status:
-    is_active: true
-</pre>
-
-[Uncommunicative Method Name](Uncommunicative-Method-Name.md):
-
-<pre>
-- !ruby/object:Reek::SmellWarning 
-  location: 
-    source: spec/samples/masked/dirty.rb
-    lines: 
-    - 3
-    context: Dirty#a
-  smell: 
-    class: UncommunicativeName
-    subclass: UncommunicativeMethodName
-    method_name: a
-    message: has the name 'a'
-  status:
-    is_active: false
-</pre>
-
-[Uncommunicative Variable Name](Uncommunicative-Variable-Name.md):
-
-<pre>
-- !ruby/object:Reek::SmellWarning 
-  location: 
-    source: spec/samples/masked/dirty.rb
-    lines: 
-    - 5
-    context: Dirty#a
-  smell: 
-    class: UncommunicativeName
-    subclass: UncommunicativeVariableName
-    variable_name: x
-    message: has the variable name 'x'
-  status:
-    is_active: true
-</pre>