reek 6.0.1 → 6.0.5

data/docs/Irresponsible-Module.md

@@ -1,47 +0,0 @@
-# Irresponsible Module
-
-## Introduction
-
-Classes and modules are the units of reuse and release. It is therefore
-considered good practice to annotate every class and module with a brief
-comment outlining its responsibilities.
-
-For further guideline on how to write good documentation in Ruby, see these
-links:
-- [Rails API documentation guidelines](http://edgeguides.rubyonrails.org/api_documentation_guidelines.html)
-- [Comments tell you why](https://blog.codinghorror.com/code-tells-you-how-comments-tell-you-why/)
-
-## Example
-
-Given
-
-```Ruby
-class Dummy
-  # Do things...
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 1 warning:
-  [1]:IrresponsibleModule: Dummy has no descriptive comment
-```
-
-Fixing this is simple - just an explaining comment:
-
-```Ruby
-# The Dummy class is responsible for ...
-class Dummy
-  # Do things...
-end
-```
-
-## Current Support in Reek
-
-_Irresponsible Module_ checks classes and modules, including those
-created through `Struct.new` and `Class.new` and directly assigned to a constant.
-
-## Configuration
-
-_Irresponsible Module_ supports only the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Large-Class.md

@@ -1,16 +0,0 @@
-# Large Class
-
-## Introduction
-
-A _Large Class_ is a class or module that has a large number of instance
-variables, methods or lines of code in any one piece of its specification.
-(That is, this smell relates to pieces of the class's specification, not to the
-size of the corresponding instance of `Class`.)
-
-## Current Support in Reek
-
-Reek offers three checks in this category.
-
-* [Too Many Constants](Too-Many-Constants.md)
-* [Too Many Instance Variables](Too-Many-Instance-Variables.md)
-* [Too Many Methods](Too-Many-Methods.md)

data/docs/Long-Parameter-List.md

@@ -1,39 +0,0 @@
-# Long Parameter List
-
-## Introduction
-
-A _Long Parameter List_ occurs when a method has a lot of parameters.
-
-## Example
-
-Given
-
-```Ruby
-class Dummy
-  def long_list(foo,bar,baz,fling,flung)
-    puts foo,bar,baz,fling,flung
-  end
-end
-```
-
-Reek would report the following warning:
-
-```
-test.rb -- 1 warning:
-  [2]:Dummy#long_list has 5 parameters (LongParameterList)
-```
-
-A common solution to this problem would be the introduction of parameter objects.
-
-## Current Support in Reek
-
-_Long Parameter List_ reports any method or block with more than 3 parameters.
-
-## Configuration
-
-Reek's _Long Parameter List_ detector supports the
-[Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option       | Value   | Effect  |
-| -------------|---------|---------|
-| `max_params` | integer | The maximum number of parameters allowed in a method or block before a warning is issued. Defaults to 3. |

data/docs/Long-Yield-List.md

@@ -1,37 +0,0 @@
-# Long Yield List
-
-## Introduction
-
-A _Long Yield List_ occurs when a method yields a lot of arguments to the block
-it gets passed. It is a special case of [Long Parameter List](Long-Parameter-List.md).
-
-## Example
-
-```Ruby
-class Dummy
-  def yields_a_lot(foo,bar,baz,fling,flung)
-    yield foo,bar,baz,fling,flung
-  end
-end
-```
-
-Reek would report the following warning:
-
-```
-test.rb -- 1 warning:
-  [4]:Dummy#yields_a_lot yields 5 parameters (LongYieldList)
-```
-
-A common solution to this problem would be the introduction of parameter objects.
-
-## Current Support in Reek
-
-Currently _Long Yield List_ reports any method or block with more than 3 parameters.
-
-## Configuration
-
-Reek's _Long Yield List_ detector supports the [Basic Smell Options](Basic-Smell-Options.md), plus:
-
-| Option       | Value   | Effect  |
-| -------------|---------|---------|
-| `max_params` | integer | The maximum number of parameters allowed in a method or block before a warning is issued. Defaults to 3. |

data/docs/Manual-Dispatch.md

@@ -1,30 +0,0 @@
-## Introduction
-
-Reek reports a _Manual Dispatch_ smell if it finds source code that manually checks whether an object responds to a method before that method is called. Manual dispatch is a type of [Simulated Polymorphism](Simulated-Polymorphism.md) which leads to code that is harder to reason about, debug, and refactor.
-
-## Example
-
-```Ruby
-class MyManualDispatcher
-  attr_reader :foo
-
-  def initialize(foo)
-    @foo = foo
-  end
-
-  def call
-    foo.bar if foo.respond_to?(:bar)
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 1 warning:
-  [9]: MyManualDispatcher manually dispatches method call (ManualDispatch)
-```
-
-## Configuration
-
-_Manual Dispatch_ offers the [Basic Smell Options](Basic-Smell-Options.md).

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.