reek 6.0.3 → 6.1.0

data/docs/Smell-Suppression.md

@@ -1,96 +0,0 @@
-## Introduction
-
-In some cases, it might be necessary to suppress one or more of Reek's smell
-warnings for a particular method or class.
-
-Possible reasons for this could be:
-
-* The code is outside of your control and you can't fix it
-* Reek is not the police. You might have legit reasons why your source code
-  is good as it is.
-
-## How to disable smell detection
-
-There are always the [Basic Smell Options](Basic-Smell-Options.md)
-you can use in your configuration file.
-
-But in this document we would like to focus on a completely different
-way - via special comments.
-
-A simple example:
-
-```ruby
-# This method smells of :reek:NestedIterators
-def smelly_method foo
-  foo.each {|bar| bar.each {|baz| baz.qux}}
-end
-```
-
-The method `smelly_method` will not be reported. The general pattern is to put
-the string ':reek:', followed by the smell class, in a comment before the
-method or class.
-
-## Extended examples
-
-Multiple smells may be configured for the same method or class:
-
-```ruby
-# :reek:LongParameterList and :reek:NestedIterators
-def many_parameters_it_has foo, bar, baz, qux
-  foo.each {|bar| bar.each {|baz| baz.qux(qux)}}
-end
-```
-
-Or across several lines which is arguably more readable:
-
-```ruby
-# :reek:LongParameterList
-# :reek:NestedIterators
-def many_parameters_it_has foo, bar, baz, qux
-  foo.each {|bar| bar.each {|baz| baz.qux(qux)}}
-end
-```
-
-It is also possible to specify options for a particular smell detector in hash-style:
-
-```ruby
-# :reek:LongParameterList { max_params: 4 }
-def many_parameters_it_has foo, bar, baz, qux
-  # ...
-end
-```
-
-Every configuration setting that you can pass via configuration file you can
-also use via comment.
-
-E.g.:
-
-```ruby
-# :reek:TooManyStatements { max_statements: 6 }
-def too_many
-  # ...
-end
-
-# :reek:NestedIterators { max_allowed_nesting: 2 }
-def quax
-  foo.each {|bar| bar.each {|baz| baz.qux(qux)}}
-end
-
-# :reek:DuplicateMethodCall { max_calls: 3 }
-def quax
-  foo.to_i + foo.to_i + foo.to_i
-end
-```
-
-Keep in mind that there are also smell detectors that operate on a class or
-module level, e.g.:
-
-```ruby
-# :reek:TooManyInstanceVariables { max_instance_variables: 8 }
-class Klass
-  # ...
-end
-```
-
-To see what smell detector takes what special configuration just check out the
-dedicated documentation for this smell detector.

data/docs/Style-Guide.md

@@ -1,19 +0,0 @@
-# Style guide
-
-## Instance variables and getters / setters
-
-We use instance vars only:
-
-- in the constructor
-- for [memoization](http://gavinmiller.io/2013/basics-of-ruby-memoization/)
-
-For everything else we use proper getters / setters.
-
-If possible those should be private.
-
-## Data types
-
-- Class or module names that are carried around in hashes and configuration and what
-not should be designated by constants. So `DuplicateMethodCall`, not `:DuplicateMethodCall` or `"DuplicateMethodCall"`
-- Hash keys should be all symbols unless they designate classes / modules - see above.
-- Everything else like messages or parameters in smell warnings should be strings, nothing else.

data/docs/Subclassed-From-Core-Class.md

@@ -1,79 +0,0 @@
-# Subclassed From Core Class
-
-## Introduction
-
-Candidate classes for the _Subclassed From Core Class_ smell are classes which inherit from Core Classes like Hash, String and Array.
-
-Inheriting from Core Classes means that you are going to have a bad time debugging (the explanation below is taken from [here](http://words.steveklabnik.com/beware-subclassing-ruby-core-classes)):
-
-> What do you think this code should do?
-
-```Ruby
-List = Class.new(Array)
-
-l = List.new
-l << 1
-l << 2
-puts l.reverse.class # => Array
-```
-
-> If you said “it prints Array” you’d be right.
-> Let’s talk about a more pernicious issue: Strings.
-
-```Ruby
-class MyString < String
-  def to_s
-    "lol"
-  end
-end
-
-s = MyString.new
-s.concat "Hey"
-
-puts s      # => Hey
-puts s.to_s # => lol
-puts "#{s}" # => Hey
-```
-
-> That’s right! With Strings, Ruby doesn’t call #to_s: it puts the value in directly.
-> Generally speaking, subclassing isn’t the right idea here.
-
-## Example
-
-Given
-
-```Ruby
-class Ary < Array
-end
-
-class Str < String
-end
-```
-
-Reek would report the _Subclassed From Core Class_ smell for both classes. Instead of subclassing them you want a data structure that uses one of these core classes internally, but isn’t exactly like one. For instance:
-
-```Ruby
-require 'forwardable'
-
-class List
-  extend Forwardable
-  def_delegators :@list, :<<, :length # and anything else
-
-  def initialize(list = [])
-    @list = list
-  end
-
-  def reverse
-    List.new(@list.reverse)
-  end
-end
-
-l = List.new 
-l << 1
-l << 2
-puts l.reverse.class  # => List
-```
-
-## Configuration
-
-_Subclassed From Core Class_ offers the [Basic Smell Options](Basic-Smell-Options.md).

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.