reek 6.0.2 → 6.2.0

data/docs/Repeated-Conditional.md

@@ -1,47 +0,0 @@
-# Repeated Conditional
-
-## Introduction
-
-_Repeated Conditional_ is a case of
-[Simulated Polymorphism](Simulated-Polymorphism.md). Basically it means you are
-checking the same value throughout a single class and take decisions based on
-this.
-
-## Example
-
-Given
-
-```Ruby
-class RepeatedConditionals
-  attr_accessor :switch
-
-  def repeat_1
-    puts "Repeat 1!" if switch
-  end
-
-  def repeat_2
-    puts "Repeat 2!" if switch
-  end
-
-  def repeat_3
-    puts "Repeat 3!" if switch
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 4 warnings:
-  [5, 9, 13]:RepeatedConditionals tests switch at least 3 times (RepeatedConditional)
-```
-
-If you get this warning then you are probably not using the right abstraction or even more probable, missing an additional abstraction.
-
-## Configuration
-
-Reek's _Repeated Conditional_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option         | Value       | Effect  |
-| ---------------|-------------|---------|
-| `max_ifs` |  integer | The maximum number of identical conditional tests permitted before Reek raises a warning. Defaults to 2. |

data/docs/Simulated-Polymorphism.md

@@ -1,16 +0,0 @@
-# Simulated Polymorphism
-
-## Introduction
-
-Simulated Polymorphism occurs when
-
-* code uses a case statement (especially on a type field);
-* or code has several if statements in a row (especially if they're comparing against the same value);
-* or code uses instance_of?, kind_of?, is_a?, or === to decide what type it's working with;
-* or multiple conditionals in different places test the same value.
-
-Conditional code is hard to read and understand, because the reader must hold more state in their head. When the same value is tested in multiple places throughout an application, any change to the set of possible values will require many methods and classes to change. Tests for the type of an object may indicate that the abstraction represented by that type is not completely defined (or understood).
-
-## Current Support in Reek
-
-Reek checks for [Manual Dispatch](Manual-Dispatch.md), [Repeated Conditional](Repeated-Conditional.md)  and for [Nil Check](Nil-Check.md).

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)