reek 6.0.2 → 6.0.6

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)