reek 6.0.2 → 6.0.6

data/docs/Too-Many-Constants.md

@@ -1,37 +0,0 @@
-## Introduction
-
-_Too Many Constants_ is a case of [Large Class](Large-Class.md).
-
-## Example
-
-Given this configuration
-
-```yaml
-TooManyConstants:
-  max_constants: 3
-```
-
-and this code:
-
-```Ruby
-class Smelly
-  CONST_1 = :dummy
-  CONST_2 = :dummy
-  CONST_3 = :dummy
-  CONST_4 = :dummy
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 1 warning:
-  [1]:TooManyConstants: Smelly has 4 constants
-```
-## Configuration
-
-Reek's _Too Many Constants_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option                   | Value   | Effect  |
-| -------------------------|---------|---------|
-| `max_constants` | integer | The maximum number of constants that are permitted. Defaults to 5 |

data/docs/Too-Many-Instance-Variables.md

@@ -1,43 +0,0 @@
-## Introduction
-
-_Too Many Instance Variables_ is a case of [Large Class](Large-Class.md).
-
-## Example
-
-Given this configuration
-
-```yaml
-TooManyInstanceVariables:
-  max_instance_variables: 3
-```
-
-and this code:
-
-```Ruby
-class Smelly
-  def initialize
-    @arg_1 = :dummy
-    @arg_2 = :dummy
-    @arg_3 = :dummy
-    @arg_4 = :dummy
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 5 warnings:
-  [1]:TooManyInstanceVariables: Smelly has at least 4 instance variables
-```
-## Current Support in Reek
-
-Reek only counts the instance variables you use explicitly like in the example above. Class macros like `attr_accessor` are disregarded.
-
-## Configuration
-
-Reek's _Too Many Instance Variables_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option                   | Value   | Effect  |
-| -------------------------|---------|---------|
-| `max_instance_variables` | integer | The maximum number of instance variables that are permitted. Defaults to 4 |

data/docs/Too-Many-Methods.md

@@ -1,56 +0,0 @@
-## Introduction
-
-_Too Many Methods_ is a case of [Large Class](Large-Class.md).
-
-## Example
-
-Given this configuration
-
-```yaml
-TooManyMethods:
-  max_methods: 3
-```
-
-and this code:
-
-```Ruby
-class Smelly
-  def one; end
-  def two; end
-  def three; end
-  def four; end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 1 warning:
-  [1]:TooManyMethods: Smelly has at least 4 methods
-```
-## Current Support in Reek
-
-Reek counts all the methods it can find in a class — instance *and* class
-methods. So given `max_methods` from above is 4, this:
-
-```Ruby
-class Smelly
-  class << self
-    def one; end
-    def two; end
-  end
-
-  def three; end
-  def four; end
-end
-```
-
-would cause Reek to emit the same warning as in the example above.
-
-## Configuration
-
-Reek's _Too Many Methods_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option        | Value   | Effect  |
-| --------------|---------|---------|
-| `max_methods` | integer | The maximum number of methods that are permitted. Defaults to 15 |

data/docs/Too-Many-Statements.md

@@ -1,54 +0,0 @@
-# Too Many Statements
-
-## Introduction
-
-A method with _Too Many Statements_ is any method that has a large number of lines.
-
-## Current Support in Reek
-
-_Too Many Statements_ warns about any method that has more than 5 statements.
-Reek's smell detector for _Too Many Statements_ counts +1 for every simple
-statement in a method and +1 for every statement within a control structure
-(`if`, `else`, `case`, `when`, `for`, `while`, `until`, `begin`, `rescue`) but
-it doesn't count the control structure itself.
-
-So the following method would score +6 in Reek's statement-counting algorithm:
-
-```Ruby
-def parse(arg, argv, &error)
-  if !(val = arg) and (argv.empty? or /\A-/ =~ (val = argv[0]))
-    return nil, block, nil                                         # +1
-  end
-  opt = (val = parse_arg(val, &error))[1]                          # +2
-  val = conv_arg(*val)                                             # +3
-  if opt and !arg
-    argv.shift                                                     # +4
-  else
-    val[0] = nil                                                   # +5
-  end
-  val                                                              # +6
-end
-```
-
-(You might argue that the two assigments within the first @if@ should count as statements, and that perhaps the nested assignment should count as +2.)
-
-## Configuration
-
-Reek's _Too Many Statements_ detector supports the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option         | Value       | Effect  |
-| ---------------|-------------|---------|
-| `max_statements` |  integer | The maximum number of statements allowed in a method before a warning is issued. Defaults to 5. |
-
-_Too Many Statements_'s default configuration is:
-
-```yaml
----
-TooManyStatements:
-  enabled: true
-  exclude:
-  - initialize
-  max_statements: 5
-```
-
-By default, `initialize` is not checked for length; any class's constructor can be as long as necessary.

data/docs/Uncommunicative-Method-Name.md

@@ -1,94 +0,0 @@
-# Uncommunicative Method Name
-
-## Introduction
-
-An _Uncommunicative Method Name_ is a method 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 Method Name_ checks for:
-
-* single-character names
-* any name ending with a number
-* camelCaseMethodNames
-
-## Configuration
-
-Reek's _Uncommunicative Method 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 | 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
----
-UncommunicativeMethodName:
-  accept:
-    - x
-    - meth1
-  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 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'
-  [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

@@ -1,92 +0,0 @@
-# Uncommunicative Module Name
-
-## Introduction
-
-An _Uncommunicative Module Name_ is a module 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 Module Name_ checks for:
-
-* single-character names
-* any name ending with a number
-
-## Configuration
-
-Reek's _Uncommunicative Module 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 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:
-
-```Yaml
----
-UncommunicativeModuleName:
-  accept:
-    - lassy
-    - Util
-  reject:
-    - 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 Util; 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'
-```
-
-## 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-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.