reek 6.0.3 → 6.0.4

data/docs/Reek-4-to-Reek-5-migration.md

@@ -1,188 +0,0 @@
-## Reek 4 to Reek 5 migration
-
-### Schema validation
-
-Reek now uses a schema to validate your configuration against on start up and will faily loudly in
-case you misspelled an option or used the wrong data type for a value like this:
-
-```
-Error: We found some problems with your configuration file: [/detectors/DetectorWithTypo] key 'DetectorWithTypo:' is undefined.
-```
-
-Obviously this might affect existing configuration files that until now contained an error nobody noticed.
-
-### Scoping detectors under `detectors`
-
-In Reek 4 you could just configure your detectors on top level like this:
-
-```yaml
-UncommunicativeMethodName:
-  accept:
-    - foobar
-UnusedPrivateMethod:
-  exclude:
-    - app/controllers  
-```
-
-In Reek 5 you have to scope your detector configurations under the `detectors` key:
-
-```yaml
-detectors:
-  UncommunicativeMethodName:
-    accept:
-      - foobar
-  UnusedPrivateMethod:
-    exclude:
-    - app/controllers  
-```
-
-### Move directory directives under a special key
-
-In Reek 4 you could apply directory specific directives like this:
-
-```Yaml
----
-"web_app/app/controllers":
-  NestedIterators:
-    enabled: false
-"web_app/app/helpers":
-  UtilityFunction:
-    enabled: false
-```
-
-which was nice and easy but also quite messy. With Reek 5 you'll have to scope this under a `directories`
-key like this:
-
-```Yaml
----
-directories:
-  "web_app/app/controllers":
-    NestedIterators:
-      enabled: false
-  "web_app/app/helpers":
-    UtilityFunction:
-      enabled: false
-```
-
-### No more regular expressions in Reeks configuration
-
-In Reek 4 you could pass regular expressions to the `accept` or `reject` settings of
- 
-* [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)
-
-and to the `exclude` settings which are part of our [Basic Smell Options](docs/Basic-Smell-Options.md).
- 
-This means that this configuration was perfectly valid:
-
-```yaml
-detectors:
-  UncommunicativeMethodName:
-    accept:
-      - !ruby/regexp /foobar/
-  UnusedPrivateMethod:
-    exclude:
-      - !ruby/regexp /i am(.*)unused/  
-```
-
-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 using a forward slash at the
-beginning and at the end of the string like this:
-
-```Yaml
----
-UncommunicativeMethodName:
-  accept:
-    - "/^foobar$/"
-UnusedPrivateMethod:
-  exclude:
-    - "/i am(.*)unused/"  
-```
-
-Everything within the forward slashes will be loaded as a regex.
-
-### No more single item shortcuts for list items 
-
-You cant use a configuration option that is supposed to be a list with a single element like this anymore:
-
-```Yaml
----
-UncommunicativeMethodName:
-  accept: foobar
-UnusedPrivateMethod:
-  exclude: omg  
-```
-
-You'll have to use a proper list here like this:
-
-```Yaml
----
-UncommunicativeMethodName:
-  accept: 
-    - foobar
-UnusedPrivateMethod:
-  exclude:
-    - omg  
-```
-
-## Failing on syntax errors in source files
-
-Previously Reek would just continue on syntax errors in source files which might have been convenient but
-not necessarily fitting for a tool that's all about code quality. With Reek 5, Reek will fail hard on
-invalid source files.
-
-### API changes
-
-This is something that will only affect very advanced users. In case you have no idea what this might be about
-you can just skip it or check out our [Developer API](docs/API.md).
-
-#### Allow only detector names in configuration hash
-
-In Reek 4 you could build your configuration like this:
-
-```ruby
-config_hash = { Reek::SmellDetectors::IrresponsibleModule => { 'enabled' => false } }
-```
-
-or like this:
-
-```ruby
-config_hash = { 'IrresponsibleModule' => { 'enabled' => false } }
-```
-
-Starting with Reek 5, the first way is not working anymore and the latter one is what you'll have to use.
-
-#### Do not accept a class as parameter for reek_of
-
-In the same vein as the change above you also can't use fully qualified detector names like this:
-
-```Ruby
- reek_of(Reek::SmellDetectors::DuplicateMethodCall)
- ```
- 
-The only supported way now is either as symbol or string:
- 
-```Ruby
-reek_of(:DuplicateMethodCall)
-reek_of('DuplicateMethodCall')
-```
-
-## Smaller changes
-
-* `PrimaDonnaMethod` has been given the better name `MissingSafeMethod`
-* `wiki-links` flag has been renamed to `documentation` flag
-* Reek assumes the default configuration file to be named ".reek.yml" and will ignore all other files. You can
-still use any name you want though by passing in a name via the `-c` flag
-* We have dropped the legacy code comment separator `:` at the end of a detector name. Before this release,
-to configure a smell detector via comment, you had to end with a colon after the detector name.
-This syntax is disallowed with Reek 5 - now you have to drop the `:` at the end, like this:
-
-```diff
--# :reek:UnusedPrivateMethod: { exclude: [ bravo ] }
-+# :reek:UnusedPrivateMethod { exclude: [ bravo ] }
-```
-
-* We have dropped support for Ruby 2.1 and 2.2 since they are officially not supported by the Ruby core team anymore
-

data/docs/Reek-Driven-Development.md

@@ -1,46 +0,0 @@
-# Reek-Driven Development
-
-One way to drive quality into your code from the very beginning of a project is to run Reek as a part of your testing process.
-
-## Rake: `Reek::Rake::Task`
-
-You can add a [Rake Task] to your Rakefile, which will run Reek on all your source files.
-
-```Ruby
-require 'reek/rake/task'
-
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = true
-  t.verbose = false
-  t.source_files = 'lib/**/*.rb'
-end
-```
-
-Now, `rake 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]: Rake-Task.md
-
-## RSpec: `reek/spec`
-
-You can add Reek expectations directly into your RSpec specs.
-
-This example is from Reek's own source code:
-
-```Ruby
-require 'reek/spec'
-
-it 'contains no code smells' do
-  Pathname.glob('lib/**/*.rb').each do |file|
-    expect(file).not_to reek
-  end
-end
-```
-
-By requiring [`reek/spec`] you gain access to the `reek` matcher.
-
-The `reek` matcher returns true if and only if Reek finds smells in your code. If the test fails, the matcher produces an error message that includes details of all the smells it found.
-
-[`reek/spec`]: ../lib/reek/spec.rb
-

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