reek 6.0.1 → 6.0.5

data/.travis.yml

@@ -1,36 +0,0 @@
-language: ruby
-
-dist: xenial
-
-cache:
-  bundler: true
-
-bundler_args: --without debugging
-
-script: bundle exec rake ci
-
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - jruby-9.2
-  - jruby-head
-  - ruby-head
-
-matrix:
-  allow_failures:
-    - rvm: jruby-head
-    - rvm: ruby-head
-  fast_finish: true
-
-notifications:
-  email:
-    - timo.roessner@googlemail.com
-    - matijs@matijs.net
-    - chastell@chastell.net
-  irc: irc.freenode.org#reek
-
-branches:
-  only:
-    - master

data/docs/API.md

@@ -1,174 +0,0 @@
-# Using Reek inside your Ruby application
-
-## Installation
-
-Either standalone via
-
-```bash
-gem install reek
-```
-
-or by adding
-
-```
-gem 'reek'
-```
-
-to your Gemfile.
-
-## Quick start
-
-Code says more than a thousand words:
-
-```ruby
-require 'reek'
-
-source = <<-RUBY
-  class Dirty
-    def m(a,b,c)
-      puts a,b
-    end
-  end
-RUBY
-
-reporter = Reek::Report::TextReport.new
-examiner = Reek::Examiner.new source
-reporter.add_examiner examiner
-reporter.show
-```
-
-This would output the following on STDOUT:
-
-```
-string -- 5 warnings:
-  Dirty has no descriptive comment (IrresponsibleModule)
-  Dirty#m has the name 'm' (UncommunicativeMethodName)
-  Dirty#m has the parameter name 'a' (UncommunicativeParameterName)
-  Dirty#m has the parameter name 'b' (UncommunicativeParameterName)
-  Dirty#m has unused parameter 'c' (UnusedParameters)
-```
-
-Note that `Reek::Examiner.new` can take `source` as `String`, `Pathname`, `File` or `IO`.
-
-## API stability
-
-Everything that is mentioned in this document can be considered stable in the
-sense that it will only change across major versions.
-
-There is one thing in this API documentation you can't and shouldn't rely on:
-The `SmellWarning` messages itself.
-
-Something like this
-
-```
-Dirty#m has the parameter name 'a' (UncommunicativeParameterName)
-```
-
-might change even across minor versions.
-
-You should not need to be specific about those messages anyways.
-In case you'd like to be specific about `SmellWarnings` please have a look at
-[accessing the smell warnings directly](#accessing-the-smell-warnings-directly).
-
-Additionally you can use one of our structured [outputs formats](#choosing-your-output-format)
-like JSON or YAML if you need a more fine-grained access to our
-`SmellWarnings`.
-
-## Choosing your output format
-
-Besides normal text output, Reek can generate output in YAML,
-JSON, HTML and XML by using the following Report types:
-
-```
-TextReport
-YAMLReport
-JSONReport
-HTMLReport
-XMLReport
-```
-
-## Configuration
-
-Given you have the following configuration file called `.reek.yml` in your root directory:
-
-```Yaml
----
-IrresponsibleModule:
-  enabled: false
-```
-
-Reek will load this file automatically by default. If you want to load the
-configuration explicitely, you can use one of the methods below.
-
-You can now use either
-
-```Ruby
-Reek::Configuration::AppConfiguration.from_path Pathname.new('config.reek')
-```
-
-but you can also pass a hash with the contents of the `.reek.yml` YAML file
-to `Reek::Configuration::AppConfiguration.from_hash`.
-
-Given the example above you would load that as follows:
-
-```Ruby
-require 'reek'
-
-config_hash = { 'IrresponsibleModule' => { 'enabled' => false } }
-configuration = Reek::Configuration::AppConfiguration.from_hash config_hash
-
-source = <<-RUBY
-  class Dirty
-    def call_me(a,b)
-      puts a,b
-    end
-  end
-RUBY
-
-reporter = Reek::Report::TextReport.new
-examiner = Reek::Examiner.new(source, configuration: configuration); nil
-reporter.add_examiner examiner; nil
-reporter.show
-```
-
-This would now only report `UncommunicativeParameterName` but not
-`IrresponsibleModule` for the `Dirty` class:
-
-```
-string -- 2 warnings:
-  Dirty#call_me has the parameter name 'a' (UncommunicativeParameterName)
-  Dirty#call_me has the parameter name 'b' (UncommunicativeParameterName)
-```
-
-Of course, directory specific configuration and excluded paths are supported as
-well:
-
-```
-config_hash = {
-  'IrresponsibleModule' => { 'enabled' => false }
-  'spec/samples/three_clean_files/' =>
-    { 'UtilityFunction' => { "enabled" => false } }
-  'exclude_paths' =>
-    [ 'spec/samples/two_smelly_files' ]
-}
-```
-
-## Accessing the smell warnings directly
-
-You can also access the smells detected by an examiner directly:
-
-```ruby
-require 'reek'
-
-source = <<-END
-  class C
-  end
-END
-
-examiner = Reek::Examiner.new source
-examiner.smells.each do |smell|
-  puts smell.message
-end
-```
-
-`Examiner#smells` returns a list of `SmellWarning` objects.

data/docs/Attribute.md

@@ -1,39 +0,0 @@
-# Attribute
-
-## Introduction
-
-A class that publishes a setter for an instance variable invites
-client classes to become too intimate with its inner workings, and in
-particular with its representation of state.
-
-The same holds to a lesser extent for getters, but Reek doesn't flag those.
-
-## Example
-
-Given:
-
-```Ruby
-class Klass
-  attr_accessor :dummy
-end
-```
-
-Reek would emit the following warning:
-
-```
-reek test.rb
-
-test.rb -- 1 warning:
-  [2]:Attribute: Klass#dummy is a writable attribute
-```
-
-## Support in Reek
-
-This detector raises a warning for every public `attr_writer`,
-`attr_accessor`, and `attr` with the writable flag set to `true`.
-
-Reek does not raise warnings for read-only attributes.
-
-## Configuration
-
-_Attribute_ supports only the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Basic-Smell-Options.md

@@ -1,85 +0,0 @@
-# Basic Smell Options
-
-## Introduction
-
-Every smell detector in Reek offers at least the following configuration options:
-
-| Option         | Value       | Effect  |
-| ---------------|-------------|---------|
-| `enabled` |  Boolean | Determines whether the smell detector is active. Defaults to `true` |
-| `exclude` | an array of strings that will be converted into regular expressions | Ignores any context whose full description matches any element of this array. |
-
-The file `docs/defaults.reek.yml` (shipped with the Reek gem) lists any default
-exclusions for each smell.
-
-## Examples
-
-**An easy one:**
-
-To stop Reek reporting smells in any method called `write` you might create a configuration file containing this:
-
-```yaml
-DuplicateMethodCall:
-  exclude:
-  - write
-```
-
-Internally Reek will convert this to the Regexp /write/.
-
-**A more sophisticated one:**
-
-```yaml
-FeatureEnvy:
-  exclude:
-    - "MyModel#do_things"
-    - "MyHelper"
-    - "ApplicationController#respond"
-```
-
-This would not report FeatureEnvy for the instance method `MyModel#do_things`, the whole module `MyHelper` and the `respond` instance method of `ApplicationController`
-
-## Advanced configuration
-
-Sometimes just strings are not enough for configuration. E.g. consider this code sample:
-
-```Ruby
-class Klass
-  def foo1; end
-  def foo1bar; end
-end
-```
-Both "Klass#foo1" and "Klass#foo1bar" will smell of UncommunicativeMethodName. Now let's assume
-you are ok with "Klass#foo1" but not "Klass#foo1bar".
-Just having this configuration 
-
-```yaml
-UncommunicativeMethodName:
-  exclude:
-    - "Klass#foo1"
-```
-
-wouldn't work because now "Klass#foo1bar" wouldn't smell as well.
-
-For this reason Reek has a special syntax that allows you to use regexes by using a forward slash at the beginning and the end of the string.
-Everything within the forward slashes will be loaded as a regex.
-
-A possible configuration that hat excludes "Klass#foo1" from this scan but not "Klass#foo1bar" could look like this:
-
-```yaml
-UncommunicativeMethodName:
-  exclude:
-    - "/Klass#foo1$/"
-```
-
-## Reek 4
-
-In Reek 4 you could also pass regexes to `exclude`, meaning this was perfectly valid as well:
-
-```yaml
-DuplicateMethodCall:
-  exclude:
-    - !ruby/regexp /write/
-```
-
-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. Please see "Advanced configuration" above.

data/docs/Boolean-Parameter.md

@@ -1,54 +0,0 @@
-# Boolean Parameter
-
-## Introduction
-
-_Boolean Parameter_ is a case of [Control Couple](Control-Couple.md), where a
-method parameter is defaulted to true or false. A _Boolean Parameter_
-effectively permits a method's caller to decide which execution path to take.
-This is a case of bad cohesion. You're creating a dependency between methods
-that is not really necessary, thus increasing coupling.
-
-## Example
-
-Given
-
-```Ruby
-class Dummy
-  def hit_the_switch(switch = true)
-    if switch
-      puts 'Hitting the switch'
-      # do other things...
-    else
-      puts 'Not hitting the switch'
-      # do other things...
-    end
-  end
-end
-```
-
-Reek would emit the following warning:
-
-```
-test.rb -- 3 warnings:
-  [1]:Dummy#hit_the_switch has boolean parameter 'switch' (BooleanParameter)
-  [2]:Dummy#hit_the_switch is controlled by argument switch (ControlParameter)
-```
-
-Note that both smells are reported, _Boolean Parameter_ and _Control Parameter_.
-
-## Getting rid of the smell
-
-This is highly dependant on your exact architecture, but looking at the example above what you could do is:
-
-* Move everything in the `if` branch into a separate method
-* Move everything in the `else` branch into a separate method
-* Get rid of the `hit_the_switch` method alltogether
-* Make the decision what method to call in the initial caller of `hit_the_switch`
-
-## Current support in Reek
-
-Reek can only detect a _Boolean Parameter_ when it has a default initializer like in the example above.
-
-## Configuration
-
-_Boolean Parameter_ supports the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Class-Variable.md

@@ -1,40 +0,0 @@
-# Class Variable
-
-## Introduction
-
-Class variables form part of the global runtime state, and as such make it easy for one part of the system to accidentally or inadvertently depend on another part of the system. So the system becomes more prone to problems where changing something over here breaks something over there. In particular, class variables can make it hard to set up tests (because the context of the test includes all global state).
-
-For a detailed explanation, check out [this article](http://4thmouse.com/index.php/2011/03/20/why-class-variables-in-ruby-are-a-bad-idea/).
-
-## Example
-
-Given
-
-```Ruby
-class Dummy
-  @@class_variable = :whatever
-end
-```
-
-Reek would emit the following warning:
-
-```
-reek test.rb
-
-test.rb -- 1 warning:
-  [2]:Dummy declares the class variable @@class_variable (ClassVariable)
-```
-
-## Getting rid of the smell
-
-You can use class-instance variable to mitigate the problem (as also suggested in the linked article above):
-
-```Ruby
-class Dummy
-  @class_variable = :whatever
-end
-```
-
-##  Configuration
-
-_Class Variable_ supports the [Basic Smell Options](Basic-Smell-Options.md).

data/docs/Code-Smells.md

@@ -1,39 +0,0 @@
-# Code Smells
-
-Smells are indicators of where your code might be hard to read, maintain or evolve, rather than things that are specifically _wrong_. Naturally this means that Reek is looking towards your code's future (and that can make its reports seem somewhat subjective, of course).
-
-Reek currently includes checks for the following smells:
-
-* [Attribute](Attribute.md)
-* [Class Variable](Class-Variable.md)
-* [Control Couple](Control-Couple.md), including
-  * [Boolean Parameter](Boolean-Parameter.md)
-  * [Control Parameter](Control-Parameter.md)
-* [Data Clump](Data-Clump.md)
-* [Duplicate Method Call](Duplicate-Method-Call.md)
-* [Instance Variable Assumption](Instance-Variable-Assumption.md)
-* [Irresponsible Module](Irresponsible-Module.md)
-* [Large Class](Large-Class.md), including
-  * [Too Many Constants](Too-Many-Constants.md)
-  * [Too Many Instance Variables](Too-Many-Instance-Variables.md)
-  * [Too Many Methods](Too-Many-Methods.md)
-* [Long Parameter List](Long-Parameter-List.md), and its special case [Long Yield List](Long-Yield-List.md)
-* Low Cohesion, including
-  * [Feature Envy](Feature-Envy.md)
-  * [Utility Function](Utility-Function.md)
-* [Module Initialize](Module-Initialize.md)
-* [Nested Iterators](Nested-Iterators.md)
-* [Missing Safe Method](Missing-Safe-Method.md), formerly known as Prima Donna Method
-* [Simulated Polymorphism](Simulated-Polymorphism.md), including
-  * [Manual Dispatch](Manual-Dispatch.md)
-  * [Nil Check](Nil-Check.md)
-  * [Repeated Conditional](Repeated-Conditional.md)
-* [Subclassed From Core Class](Subclassed-From-Core-Class.md)
-* [Too Many Statements](Too-Many-Statements.md)
-* [Uncommunicative Name](Uncommunicative-Name.md), including
-  * [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)
-* [Unused Parameters](Unused-Parameters.md)
-* [Unused Private Method](Unused-Private-Method.md)