snoot 0.1.0

data/data/reek_docs/Instance-Variable-Assumption.md

@@ -0,0 +1,163 @@
+# Instance Variable Assumption
+
+## Introduction
+
+Classes should not assume that instance variables are set or present outside of the current class definition.
+
+Good:
+
+```ruby
+class Foo
+  def initialize
+    @bar = :foo
+  end
+
+  def foo?
+    @bar == :foo
+  end
+end
+```
+
+Good as well:
+
+```ruby
+class Foo
+  def foo?
+    bar == :foo
+  end
+
+  def bar
+    @bar ||= :foo
+  end
+end
+```
+
+Bad:
+
+```ruby
+class Foo
+  def go_foo!
+    @bar = :foo
+  end
+
+  def foo?
+    @bar == :foo
+  end
+end
+```
+
+## Example
+
+Running Reek on:
+
+```ruby
+class Dummy
+  def test
+    @ivar
+  end
+end
+```
+
+would report:
+
+```bash
+  [1]:InstanceVariableAssumption: Dummy assumes too much for instance variable @ivar
+```
+
+Note that this example would trigger this smell warning as well:
+
+```ruby
+class Parent
+  def initialize(omg)
+    @omg = omg
+  end
+end
+
+class Child < Parent
+  def foo
+    @omg
+  end
+end
+```
+
+The way to address the smell warning is that you should create an `attr_reader` to use `@omg` in the subclass and not access `@omg` directly like this:
+
+```ruby
+class Parent
+  attr_reader :omg
+
+  def initialize(omg)
+    @omg = omg
+  end
+end
+
+class Child < Parent
+  def foo
+    omg
+  end
+end
+```
+
+Directly accessing instance variables is considered a smell because it [breaks encapsulation](https://www.designisrefactoring.com/2015/03/30/organizing-data-self-encapsulation/) and makes it harder to reason about code.
+
+If you don't want to expose those methods as public API just make them private like this:
+
+```ruby
+class Parent
+  def initialize(omg)
+    @omg = omg
+  end
+
+  private
+  attr_reader :omg
+end
+
+class Child < Parent
+  def foo
+    omg
+  end
+end
+```
+
+
+## Current Support in Reek
+
+An instance variable must:
+
+* be set in the constructor
+* or be accessed through a method with lazy initialization / memoization.
+
+If not, _Instance Variable Assumption_ will be reported.
+
+## Using Instance Variable Assumption in a Rails context
+
+In ActiveRecord it seems common to use callbacks like `after_initialize` to initialize instance variables as
+outlined [here](https://stackoverflow.com/questions/41165520/overriding-applicationrecord-initialize-bad-idea)
+or [here](http://blog.dalethatcher.com/2008/03/rails-dont-override-initialize-on.html)
+instead of overriding the `initialize` method.
+If an instance variable is initialized in such a callback Reek will report it correspondingly.
+
+This would smell for instance:
+
+```ruby
+class Sample < ApplicationRecord
+  after_initialize do
+    @my_var = false
+  end
+end
+```
+
+Since Reek cannot reliably detect that is used in a Rails context we recommend to disable this detector
+for "app/models" like this:
+
+```yaml
+directories:
+  # Your other configuration....
+  "app/models":
+    InstanceVariableAssumption:
+      enabled: false
+```
+
+## Configuration
+
+_Instance Variable Assumption_ supports the [Basic Smell Options](Basic-Smell-Options.md).

data/data/reek_docs/Irresponsible-Module.md

@@ -0,0 +1,47 @@
+# 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/data/reek_docs/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008,2009 Kevin Rutherford
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/data/reek_docs/Large-Class.md

@@ -0,0 +1,16 @@
+# 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/data/reek_docs/Long-Parameter-List.md

@@ -0,0 +1,39 @@
+# 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/data/reek_docs/Long-Yield-List.md

@@ -0,0 +1,37 @@
+# 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/data/reek_docs/Manual-Dispatch.md

@@ -0,0 +1,30 @@
+## 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/data/reek_docs/Missing-Safe-Method.md

@@ -0,0 +1,92 @@
+# 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/data/reek_docs/Module-Initialize.md

@@ -0,0 +1,62 @@
+# 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/data/reek_docs/Nested-Iterators.md

@@ -0,0 +1,59 @@
+# 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/data/reek_docs/Nil-Check.md

@@ -0,0 +1,47 @@
+# 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).