.nil? method
38 | * == and === operators when checking vs. nil
39 | * case statements that use syntax like when nil
40 |
41 | _Nil Check_ allows use of
42 |
43 | * the safe navigation operator like `foo&.bar`
44 |
45 | ## Configuration
46 |
47 | _Nil Check_ offers the [Basic Smell Options](Basic-Smell-Options.md).
48 |
--------------------------------------------------------------------------------
/docs/Rake-Task.md:
--------------------------------------------------------------------------------
1 | # Rake Task
2 |
3 | ## Introduction
4 |
5 | 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:
6 |
7 | ```ruby
8 | require 'reek/rake/task'
9 |
10 | Reek::Rake::Task.new do |t|
11 | t.fail_on_error = false
12 | end
13 | ```
14 |
15 | In its most simple form, that's it.
16 |
17 | When you now run:
18 |
19 | ```bash
20 | rake -T
21 | ```
22 |
23 | you should see
24 |
25 | ```bash
26 | rake reek # Check for code smells
27 | ```
28 |
29 | ## Configuration via task
30 |
31 | An more sophisticated rake task that would make use of all available configuration options could look like this:
32 |
33 | ```ruby
34 | Reek::Rake::Task.new do |t|
35 | t.name = 'custom_rake' # Whatever name you want. Defaults to "reek".
36 | t.config_file = 'config/.reek.yml' # Defaults to nothing.
37 | t.source_files = 'vendor/**/*.rb' # Glob pattern to match source files. Defaults to lib/**/*.rb
38 | t.reek_opts = '-U' # Defaults to ''. You can pass all the options here in that are shown by "reek -h"
39 | t.fail_on_error = false # Defaults to true
40 | t.verbose = true # Defaults to false
41 | end
42 | ```
43 |
44 | Alternatively, you can create your own [Rake::FileList](http://rake.rubyforge.org/classes/Rake/FileList.html) and use that for `source_files`:
45 |
46 | ```ruby
47 | Reek::Rake::Task.new do |t|
48 | t.source_files = FileList['lib/**/*.rb'].exclude('lib/templates/**/*.rb')
49 | end
50 | ```
51 |
52 | ## Configuration via environment variables
53 |
54 | You can overwrite the following attributes by environment variables:
55 |
56 | - "reek_opts" by using REEK_OPTS
57 | - "config_file" by using REEK_CFG
58 | - "source_files" by using REEK_SRC
59 |
60 | An example rake call using environment variables could look like this:
61 |
62 | ```bash
63 | REEK_CFG="config/custom.reek" REEK_OPTS="-s" rake reek
64 | ```
65 |
66 | See also: [Reek-Driven-Development](Reek-Driven-Development.md)
67 |
--------------------------------------------------------------------------------
/docs/Reek-Driven-Development.md:
--------------------------------------------------------------------------------
1 | # Reek-Driven Development
2 |
3 | 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.
4 |
5 | ## Rake: `Reek::Rake::Task`
6 |
7 | You can add a [Rake Task] to your Rakefile, which will run Reek on all your source files.
8 |
9 | ```ruby
10 | require 'reek/rake/task'
11 |
12 | Reek::Rake::Task.new do |t|
13 | t.fail_on_error = true
14 | t.verbose = false
15 | t.source_files = 'lib/**/*.rb'
16 | end
17 | ```
18 |
19 | Now, `rake reek` will run Reek on your source code. And, in this case, it fails if it finds any smells.
20 |
21 | For more detailed information about Reek's integration with Rake, see [Rake Task].
22 |
23 | [Rake Task]: Rake-Task.md
24 |
25 | ## RSpec: `reek/spec`
26 |
27 | You can add Reek expectations directly into your RSpec specs.
28 |
29 | This example is from Reek's own source code:
30 |
31 | ```ruby
32 | require 'reek/spec'
33 |
34 | it 'contains no code smells' do
35 | Pathname.glob('lib/**/*.rb').each do |file|
36 | expect(file).not_to reek
37 | end
38 | end
39 | ```
40 |
41 | By requiring [`reek/spec`] you gain access to the `reek` matcher.
42 |
43 | 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.
44 |
45 | [`reek/spec`]: ../lib/reek/spec.rb
46 |
47 |
--------------------------------------------------------------------------------
/docs/Repeated-Conditional.md:
--------------------------------------------------------------------------------
1 | # Repeated Conditional
2 |
3 | ## Introduction
4 |
5 | _Repeated Conditional_ is a case of
6 | [Simulated Polymorphism](Simulated-Polymorphism.md). Basically it means you are
7 | checking the same value throughout a single class and take decisions based on
8 | this.
9 |
10 | ## Example
11 |
12 | Given
13 |
14 | ```ruby
15 | class RepeatedConditionals
16 | attr_accessor :switch
17 |
18 | def repeat_1
19 | puts "Repeat 1!" if switch
20 | end
21 |
22 | def repeat_2
23 | puts "Repeat 2!" if switch
24 | end
25 |
26 | def repeat_3
27 | puts "Repeat 3!" if switch
28 | end
29 | end
30 | ```
31 |
32 | Reek would emit the following warning:
33 |
34 | ```
35 | test.rb -- 4 warnings:
36 | [5, 9, 13]:RepeatedConditionals tests switch at least 3 times (RepeatedConditional)
37 | ```
38 |
39 | If you get this warning then you are probably not using the right abstraction or even more probable, missing an additional abstraction.
40 |
41 | ## Configuration
42 |
43 | Reek's _Repeated Conditional_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
44 |
45 | | Option | Value | Effect |
46 | | ---------------|-------------|---------|
47 | | `max_ifs` | integer | The maximum number of identical conditional tests permitted before Reek raises a warning. Defaults to 2. |
48 |
--------------------------------------------------------------------------------
/docs/Simulated-Polymorphism.md:
--------------------------------------------------------------------------------
1 | # Simulated Polymorphism
2 |
3 | ## Introduction
4 |
5 | Simulated Polymorphism occurs when
6 |
7 | * code uses a case statement (especially on a type field);
8 | * or code has several if statements in a row (especially if they're comparing against the same value);
9 | * or code uses instance_of?, kind_of?, is_a?, or === to decide what type it's working with;
10 | * or multiple conditionals in different places test the same value.
11 |
12 | 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).
13 |
14 | ## Current Support in Reek
15 |
16 | Reek checks for [Manual Dispatch](Manual-Dispatch.md), [Repeated Conditional](Repeated-Conditional.md) and for [Nil Check](Nil-Check.md).
17 |
--------------------------------------------------------------------------------
/docs/Style-Guide.md:
--------------------------------------------------------------------------------
1 | # Style guide
2 |
3 | ## Instance variables and getters / setters
4 |
5 | We use instance vars only:
6 |
7 | - in the constructor
8 | - for [memoization](http://gavinmiller.io/2013/basics-of-ruby-memoization/)
9 |
10 | For everything else we use proper getters / setters.
11 |
12 | If possible those should be private.
13 |
14 | ## Data types
15 |
16 | - Class or module names that are carried around in hashes and configuration and what
17 | not should be designated by constants. So `DuplicateMethodCall`, not `:DuplicateMethodCall` or `"DuplicateMethodCall"`
18 | - Hash keys should be all symbols unless they designate classes / modules - see above.
19 | - Everything else like messages or parameters in smell warnings should be strings, nothing else.
20 |
--------------------------------------------------------------------------------
/docs/Subclassed-From-Core-Class.md:
--------------------------------------------------------------------------------
1 | # Subclassed From Core Class
2 |
3 | ## Introduction
4 |
5 | Candidate classes for the _Subclassed From Core Class_ smell are classes which inherit from Core Classes like Hash, String and Array.
6 |
7 | 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)):
8 |
9 | > What do you think this code should do?
10 |
11 | ```ruby
12 | List = Class.new(Array)
13 |
14 | l = List.new
15 | l << 1
16 | l << 2
17 | puts l.reverse.class # => Array
18 | ```
19 |
20 | > If you said “it prints Array” you’d be right.
21 | > Let’s talk about a more pernicious issue: Strings.
22 |
23 | ```ruby
24 | class MyString < String
25 | def to_s
26 | "lol"
27 | end
28 | end
29 |
30 | s = MyString.new
31 | s.concat "Hey"
32 |
33 | puts s # => Hey
34 | puts s.to_s # => lol
35 | puts "#{s}" # => Hey
36 | ```
37 |
38 | > That’s right! With Strings, Ruby doesn’t call #to_s: it puts the value in directly.
39 | > Generally speaking, subclassing isn’t the right idea here.
40 |
41 | ## Example
42 |
43 | Given
44 |
45 | ```ruby
46 | class Ary < Array
47 | end
48 |
49 | class Str < String
50 | end
51 | ```
52 |
53 | 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:
54 |
55 | ```ruby
56 | require 'forwardable'
57 |
58 | class List
59 | extend Forwardable
60 | def_delegators :@list, :<<, :length # and anything else
61 |
62 | def initialize(list = [])
63 | @list = list
64 | end
65 |
66 | def reverse
67 | List.new(@list.reverse)
68 | end
69 | end
70 |
71 | l = List.new
72 | l << 1
73 | l << 2
74 | puts l.reverse.class # => List
75 | ```
76 |
77 | ## Configuration
78 |
79 | _Subclassed From Core Class_ offers the [Basic Smell Options](Basic-Smell-Options.md).
80 |
--------------------------------------------------------------------------------
/docs/Too-Many-Constants.md:
--------------------------------------------------------------------------------
1 | ## Introduction
2 |
3 | _Too Many Constants_ is a case of [Large Class](Large-Class.md).
4 |
5 | ## Example
6 |
7 | Given this configuration
8 |
9 | ```yaml
10 | TooManyConstants:
11 | max_constants: 3
12 | ```
13 |
14 | and this code:
15 |
16 | ```ruby
17 | class Smelly
18 | CONST_1 = :dummy
19 | CONST_2 = :dummy
20 | CONST_3 = :dummy
21 | CONST_4 = :dummy
22 | end
23 | ```
24 |
25 | Reek would emit the following warning:
26 |
27 | ```
28 | test.rb -- 1 warning:
29 | [1]:TooManyConstants: Smelly has 4 constants
30 | ```
31 | ## Configuration
32 |
33 | Reek's _Too Many Constants_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
34 |
35 | | Option | Value | Effect |
36 | | -------------------------|---------|---------|
37 | | `max_constants` | integer | The maximum number of constants that are permitted. Defaults to 5 |
38 |
--------------------------------------------------------------------------------
/docs/Too-Many-Instance-Variables.md:
--------------------------------------------------------------------------------
1 | ## Introduction
2 |
3 | _Too Many Instance Variables_ is a case of [Large Class](Large-Class.md).
4 |
5 | ## Example
6 |
7 | Given this configuration
8 |
9 | ```yaml
10 | TooManyInstanceVariables:
11 | max_instance_variables: 3
12 | ```
13 |
14 | and this code:
15 |
16 | ```ruby
17 | class Smelly
18 | def initialize
19 | @arg_1 = :dummy
20 | @arg_2 = :dummy
21 | @arg_3 = :dummy
22 | @arg_4 = :dummy
23 | end
24 | end
25 | ```
26 |
27 | Reek would emit the following warning:
28 |
29 | ```
30 | test.rb -- 5 warnings:
31 | [1]:TooManyInstanceVariables: Smelly has at least 4 instance variables
32 | ```
33 | ## Current Support in Reek
34 |
35 | Reek only counts the instance variables you use explicitly like in the example above. Class macros like `attr_accessor` are disregarded.
36 |
37 | ## Configuration
38 |
39 | Reek's _Too Many Instance Variables_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
40 |
41 | | Option | Value | Effect |
42 | | -------------------------|---------|---------|
43 | | `max_instance_variables` | integer | The maximum number of instance variables that are permitted. Defaults to 4 |
44 |
--------------------------------------------------------------------------------
/docs/Too-Many-Methods.md:
--------------------------------------------------------------------------------
1 | ## Introduction
2 |
3 | _Too Many Methods_ is a case of [Large Class](Large-Class.md).
4 |
5 | ## Example
6 |
7 | Given this configuration
8 |
9 | ```yaml
10 | TooManyMethods:
11 | max_methods: 3
12 | ```
13 |
14 | and this code:
15 |
16 | ```ruby
17 | class Smelly
18 | def one; end
19 | def two; end
20 | def three; end
21 | def four; end
22 | end
23 | ```
24 |
25 | Reek would emit the following warning:
26 |
27 | ```
28 | test.rb -- 1 warning:
29 | [1]:TooManyMethods: Smelly has at least 4 methods
30 | ```
31 | ## Current Support in Reek
32 |
33 | Reek counts all the methods it can find in a class — instance *and* class
34 | methods. So given `max_methods` from above is 4, this:
35 |
36 | ```ruby
37 | class Smelly
38 | class << self
39 | def one; end
40 | def two; end
41 | end
42 |
43 | def three; end
44 | def four; end
45 | end
46 | ```
47 |
48 | would cause Reek to emit the same warning as in the example above.
49 |
50 | ## Configuration
51 |
52 | Reek's _Too Many Methods_ detector offers the [Basic Smell Options](Basic-Smell-Options.md), plus:
53 |
54 | | Option | Value | Effect |
55 | | --------------|---------|---------|
56 | | `max_methods` | integer | The maximum number of methods that are permitted. Defaults to 15 |
57 |
--------------------------------------------------------------------------------
/docs/Uncommunicative-Name.md:
--------------------------------------------------------------------------------
1 | # Uncommunicative Name
2 |
3 | ## Introduction
4 |
5 | An _Uncommunicative Name_ is a name that doesn't communicate its intent well enough.
6 |
7 | Poor names make it hard for the reader to build a mental picture of what's
8 | going on in the code. They can also be mis-interpreted; and they hurt the flow
9 | of reading, because the reader must slow down to interpret the names.
10 |
11 | ## Current Support in Reek
12 |
13 | Reek offers four checks in this category:
14 |
15 | * [Uncommunicative Method Name](Uncommunicative-Method-Name.md)
16 | * [Uncommunicative Module Name](Uncommunicative-Module-Name.md)
17 | * [Uncommunicative Parameter Name](Uncommunicative-Parameter-Name.md)
18 | * [Uncommunicative Variable Name](Uncommunicative-Variable-Name.md)
19 |
--------------------------------------------------------------------------------
/docs/Unused-Parameters.md:
--------------------------------------------------------------------------------
1 | ## Introduction
2 |
3 | _Unused Parameter_ refers to methods with parameters that are unused in scope of the method.
4 |
5 | Having unused parameters in a method is code smell because leaving dead code in
6 | a method can never improve the method and it makes the code confusing to read.
7 |
8 | ## Example
9 |
10 | Given:
11 |
12 | ```ruby
13 | class Klass
14 | def unused_parameters(x,y,z)
15 | puts x,y # but not z
16 | end
17 | end
18 | ```
19 |
20 | Reek would emit the following warning:
21 |
22 | ```
23 | [2]:UnusedParameters: Klass#unused_parameters has unused parameter 'z'
24 | ```
25 |
26 | ## Configuration
27 |
28 | _Unused Parameter_ offers the [Basic Smell Options](Basic-Smell-Options.md).
29 |
--------------------------------------------------------------------------------
/docs/Utility-Function.md:
--------------------------------------------------------------------------------
1 | # Utility Function
2 |
3 | ## Introduction
4 |
5 | A _Utility Function_ is any instance method that has no dependency on the state of the instance.
6 |
7 | _Utility Function_ is heavily related to _[Feature Envy](Feature-Envy.md)_, please check out the explanation there why _Utility Function_ is something you should care about.
8 |
9 | ## Example
10 |
11 | Given
12 |
13 | ```ruby
14 | class UtilityFunction
15 | def showcase(argument)
16 | argument.to_s + argument.to_i
17 | end
18 | end
19 | ```
20 |
21 | Reek would report:
22 |
23 | ```
24 | test.rb -- 2 warnings:
25 | [2]:UtilityFunction#showcase doesn't depend on instance state (UtilityFunction)
26 | ```
27 |
28 | ## Current Support in Reek
29 |
30 | _Utility Function_ will warn about any method that:
31 |
32 | * is non-empty
33 | * does not override an inherited method
34 | * calls at least one method on another object
35 | * doesn't use any of self's instance variables
36 | * doesn't use any of self's methods
37 |
38 | ## Differences to _Feature Envy_
39 |
40 | _[Feature Envy](Feature-Envy.md)_ is only triggered if there are some references to self and _Utility Function_ is triggered if there are no references to self.
41 |
42 | ## Configuration
43 |
44 | Reek's _Utility Function_ detector supports the [Basic Smell Options](Basic-Smell-Options.md), plus:
45 |
46 | | Option | Value | Effect |
47 | | ----------------------|-------------|---------|
48 | | `public_methods_only` | Boolean | Disable this smell detector for non-public methods (which means "private" and "protected") |
49 |
50 | A sample configuration file would look like this:
51 |
52 | ```yaml
53 | ---
54 | detectors:
55 | UtilityFunction:
56 | public_methods_only: true
57 | ```
58 |
--------------------------------------------------------------------------------
/docs/Versioning-Policy.md:
--------------------------------------------------------------------------------
1 | # Versioning Policy
2 |
3 | * CLI interface: Adding options is a non-breaking change, and would warrant an update of the minor version. Removing options is a breaking change and requires a major version update (we did this going to Reek 2). Adding a report format probably also warrants a minor version upgrade.
4 | * API: We haven't really defined a 'public' API for using Reek programmatically, and we've only just started testing it. So, this is basically a blank slate at the moment. We will work on this as a part of the Reek 3 release.
5 | * List of detected smells: Adding a smell warrants a minor release, removing a smell is a breaking change. This makes sense if you consider that the CLI allows running a single smell detector.
6 | * Consistency of detected smells: This is very hard to guarantee. If we fix a bug in one of the detectors, some fragrant code may become smelly, or vice versa. Right now we don't bother with this.
7 | * Smell configuration: The detectors are quite tolerant regarding configuration options that they don't recognize, so we regard any change here as only requiring a minor release.
8 |
--------------------------------------------------------------------------------
/docs/templates/default/docstring/html/public_api_marker.erb:
--------------------------------------------------------------------------------
1 | This <%= object.type %> is part of Reek's public API.