reek 6.0.2 → 6.2.0

data/docs/Missing-Safe-Method.md

@@ -1,92 +0,0 @@
-# Missing Safe Method
-
-## Introduction
-
-Candidate methods for the _Missing Safe Method_ smell are methods whose names
-end with an exclamation mark.
-
-An exclamation mark in method names means (the explanation below is taken from
-[here](http://dablog.rubypal.com/2007/8/15/bang-methods-or-danger-will-rubyist)):
-
-> The ! in method names that end with ! means, “This method is dangerous”—or,
-> more precisely, this method is the “dangerous” version of an otherwise
-> equivalent method, with the same name minus the !. “Danger” is relative; the
-> ! doesn’t mean anything at all unless the method name it’s in corresponds to
-> a similar but bang-less method name.
->
-> So, for example, gsub! is the dangerous version of gsub. exit! is the
-> dangerous version of exit. flatten! is the dangerous version of flatten. And
-> so forth.
-
-Such a method is called _Missing Safe Method_ if and only if the non-bang
-version does not exist and this method is reported as a smell.
-
-Missing Safe Method was formerly known as Prima Donna Method. 
-
-## Example
-
-Given
-
-```Ruby
-class C
-  def foo; end
-  def foo!; end
-  def bar!; end
-end
-```
-
-Reek would report the _Missing Safe Method_ smell for `bar!`, but not for `foo!`.
-
-Reek reports this smell only in a class context, not in a module context in order to allow perfectly legit code like this:
-
-
-```Ruby
-class Parent
-  def foo; end
-end
-
-module Dangerous
-  def foo!; end
-end
-
-class Son < Parent
-  include Dangerous
-end
-
-class Daughter < Parent
-end
-```
-
-In this example, Reek would not report the _Missing Safe Method_ smell for the
-method `foo` of the `Dangerous` module.
-
-## Configuration
-
-_Missing Safe Method_ offers the [Basic Smell Options](Basic-Smell-Options.md).
-
-## Example configuration via source comment
-
-Imagine code like this:
-
-```Ruby
-class Alfa
-  def bravo!
-  end
-end
-```
-
-This would report:
-
->>
-ruby.rb -- 1 warning:
-  [1]:MissingSafeMethod: Alfa has missing safe method 'bravo!'
-
-If you want to suppress this warning you can do this via source comment like this:
-
-```Ruby
-# :reek:MissingSafeMethod { exclude: [ bravo! ] }
-class Alfa
-  def bravo!
-  end
-end
-```

data/docs/Module-Initialize.md

@@ -1,62 +0,0 @@
-# Module Initialize
-
-## Introduction
-
-A module is usually a mixin, so when an `#initialize` method is present it is
-hard to tell initialization order and parameters so having `#initialize`
-in a module is usually a bad idea.
-
-## Example
-
-The `Foo` module below contains a method `initialize`. Although class `B` inherits from `A`, the inclusion of `Foo` stops `A#initialize` from being called.
-
-```Ruby
-class A
-  def initialize(a)
-    @a = a
-  end
-end
-
-module Foo
-  def initialize(foo)
-    @foo = foo
-  end
-end
-
-class B < A
-  include Foo
-
-  def initialize(b)
-    super('bar')
-    @b = b
-  end
-end
-```
-
-A simple solution is to rename `Foo#initialize` and call that method by name:
-
-```Ruby
-module Foo
-  def setup_foo_module(foo)
-    @foo = foo
-  end
-end
-
-class B < A
-  include Foo
-
-  def initialize(b)
-    super 'bar'
-    setup_foo_module('foo')
-    @b = b
-  end
-end
-```
-
-## Current Support in Reek
-
-Reek warns about module initialize when an instance method named `initialize` is present in a module.
-
-## Configuration
-
-Module Initialize supports the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Nested-Iterators.md

@@ -1,59 +0,0 @@
-# Nested Iterators
-
-## Introduction
-
-A _Nested Iterator_ occurs when a block contains another block.
-
-## Example
-
-Given
-
-```Ruby
-class Duck
-  class << self
-    def duck_names
-      %i!tick trick track!.each do |surname|
-        %i!duck!.each do |last_name|
-          puts "full name is #{surname} #{last_name}"
-        end
-      end
-    end
-  end
-end
-```
-
-Reek would report the following warning:
-
-```
-test.rb -- 1 warning:
-  [5]:Duck#duck_names contains iterators nested 2 deep (NestedIterators)
-```
-
-## Current Support in Reek
-
-_Nested Iterators_ reports failing methods only once.
-`Object#tap` is ignored by default and thus does not count as iterator.
-Furthermore iterators without block arguments are not counted, e.g.:
-
-
-```Ruby
-def foo
-  before do
-    item.each do |part|
-      puts part
-    end
-  end
-end
-```
-
-would not smell of NestedIterators (given a maximum allowed nesting of 1) since the
-`before` would not be counted (because it doesn't pass any arguments to the block).
-
-## Configuration
-
-_Nested Iterators_ offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option                | Value   | Effect  |
-| ----------------------|---------|---------|
-| `max_allowed_nesting` | integer | The maximum depth of nested iterators. Defaults to 1 |
-| `ignore_iterators`    | Array   | List of iterators to be excluded from the smell check. Includes only `tap` at the moment|

data/docs/Nil-Check.md

@@ -1,47 +0,0 @@
-# Nil Check
-
-## Introduction
-
-A _Nil Check_ is a type check. Failures of _Nil Check_ violate the
-["tell, don't ask"](http://robots.thoughtbot.com/tell-dont-ask) principle.
-Additionally to that, type checks often mask bigger problems in your source
-code like not using OOP and / or polymorphism when you should.
-
-The _Nil Check_ code smell is a case of [Simulated Polymorphism](Simulated-Polymorphism.md).
-
-## Example
-
-Given
-
-```Ruby
-class Klass
-  def nil_checker(argument)
-    if argument.nil?
-      puts "argument is nil!"
-    end
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 1 warning:
-  [3]:Klass#nil_checker performs a nil-check. (NilCheck)
-```
-
-##  Current Support in Reek
-
-_Nil Check_ reports use of 
-
-* <code>.nil?</code> method
-* <code>==</code> and <code>===</code> operators when checking vs. <code>nil</code>
-* case statements that use syntax like <code>when nil</code>
-
-_Nil Check_ allows use of
-
-* the safe navigation operator like `foo&.bar`
-
-## Configuration
-
-_Nil Check_ offers the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/RSpec-matchers.md

@@ -1,129 +0,0 @@
-# RSpec matchers
-
-## Introduction
-
-Reek offers matchers for RSpec you can easily include into your project.
-
-There are 3 matchers available:
-
-- `reek`
-- `reek_of`
-- `reek_only_of`
-
-## Quickstart
-
-Let's install the dependencies:
-
-```
-gem install reek
-gem install rspec
-```
-
-And then use it like that in your spec file:
-
-```Ruby
-require 'reek'
-require 'reek/spec'
-require 'rspec'
-
-RSpec.describe 'Reek Integration' do
-  it 'works with Reek' do
-    smelly_class = 'class C; def m; end; end'
-    expect(smelly_class).not_to reek
-  end
-end
-```
-
-Running this via
-
-```
-rspec reek-integration-spec.rb
-```
-
-would give you:
-
-```
-Failures:
-
-  1) Reek Integration works with Reek
-     Failure/Error: expect(smelly_class).not_to reek
-       Expected no smells, but got:
-         C has no descriptive comment (IrresponsibleModule)
-         C has the name 'C' (UncommunicativeModuleName)
-         C#m has the name 'm' (UncommunicativeMethodName)
-     # ./reek-integration-spec.rb:8:in `block (2 levels) in <top (required)>'
-
-Finished in 0.00284 seconds (files took 0.28815 seconds to load)
-1 example, 1 failure
-
-Failed examples:
-
-rspec ./reek-integration-spec.rb:6 # Reek Integration works with Reek
-```
-
-## The matchers explained
-
-### `reek`
-
-A very generic matcher that basically just tells you if something reeks, but
-not after what exactly.
-See the "Quickstart" example from above.
-
-### `reek_of`
-
-Checks the target source code for instances of "smell type"
-and returns true only if it can find one of them that matches.
-
-You can pass the smell type you want to check for as String or as Symbol:
-
-- `:UtilityFunction`
-- `"UtilityFunction"`
-
-It is recommended to pass this as a symbol like `:UtilityFunction`. However we
-don't enforce this.
-
-Additionally you can be more specific and pass in "smell_details" you want to
-check for as well e.g. "name" or "count" (see the examples below). The
-parameters you can check for are depending on the smell you are checking for.
-For instance "count" doesn't make sense everywhere whereas "name" does in most
-cases. If you pass in a parameter that doesn't exist (e.g. you make a typo like
-"namme") Reek will raise an ArgumentError to give you a hint that you passed
-something that doesn't make much sense.
-
-So in a nutshell `reek_of` takes the following two arguments:
-
-- `smell_type` - The "smell type" we check for.
-- `smells_details` - A hash containing "smell warning" parameters
-
-**Examples**
-
- Without smell_details:
-
-```Ruby
-  reek_of(:FeatureEnvy)
-  reek_of(:UtilityFunction)
-```
-
-With smell_details:
-
-```Ruby
-  reek_of(:UncommunicativeParameterName, name: 'x2')
-  reek_of(:DataClump, count: 3)
-```
-
-**Examples from a real spec**
-
-```Ruby
-  expect(src).to reek_of(:DuplicateMethodCall, name: '@other.thing')
-```
-
-### reek_only_of
-
-See the documentaton for `reek_of`.
-
-**Notable differences to `reek_of`:**
-
-1. `reek_of` doesn't mind if there are other smells of a different type.
-   "reek_only_of" will fail in that case.
-
-2. `reek_only_of` doesn't support the additional smell_details hash.

data/docs/Rake-Task.md

@@ -1,66 +0,0 @@
-# Rake Task
-
-## Introduction
-
-Reek provides a Rake task that runs Reek on a set of source files. In its most simple form you just include something like that in your Rakefile:
-
-```Ruby
-require 'reek/rake/task'
-
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = false
-end
-```
-
-In its most simple form, that's it.
-
-When you now run:
-
-```Bash
-rake -T
-```
-
-you should see
-
-```Bash
-rake reek  # Check for code smells
-```
-
-## Configuration via task
-
-An more sophisticated rake task that would make use of all available configuration options could look like this:
-
-```Ruby
-Reek::Rake::Task.new do |t|
-  t.name          = 'custom_rake' # Whatever name you want. Defaults to "reek".
-  t.config_file   = 'config/.reek.yml' # Defaults to nothing.
-  t.source_files  = 'vendor/**/*.rb' # Glob pattern to match source files. Defaults to lib/**/*.rb
-  t.reek_opts     = '-U'  # Defaults to ''. You can pass all the options here in that are shown by "reek -h"
-  t.fail_on_error = false # Defaults to true
-  t.verbose       = true  # Defaults to false
-end
-```
-
-Alternatively, you can create your own [Rake::FileList](http://rake.rubyforge.org/classes/Rake/FileList.html) and use that for `source_files`:
-
-```Ruby
-Reek::Rake::Task.new do |t|
-  t.source_files = FileList['lib/**/*.rb'].exclude('lib/templates/**/*.rb')
-end
-```
-
-## Configuration via environment variables
-
-You can overwrite the following attributes by environment variables:
-
-- "reek_opts" by using REEK_OPTS
-- "config_file" by using REEK_CFG
-- "source_files" by using REEK_SRC
-
-An example rake call using environment variables could look like this:
-
-```Bash
-REEK_CFG="config/custom.reek" REEK_OPTS="-s" rake reek
-```
-
-See also: [Reek-Driven-Development](Reek-Driven-Development.md)

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
-