reek 1.2.8 → 1.2.9

data/History.txt

@@ -1,3 +1,7 @@
+== Unpublished
+
+* (marktabler) Allow single underscore as a variable assignment without triggering UncommunicativeVariableName.
+
 == 1.2.8 (2010-04-26)
 
 === Major Changes

data/README.md

@@ -1,50 +1,62 @@
 # Reek -- code smell detection for Ruby
 
+[![Build Status](https://secure.travis-ci.org/troessner/reek.png?branch=master)](http://travis-ci.org/troessner/reek?branch=master)
+
 Reek is a tool that examines Ruby classes, modules and methods and
 reports any code smells it finds. Install it like this:
 
-    $ gem install reek
+```bash
+$ gem install reek
+```
 
 and run it like this:
 
-    $ reek [options] [dir_or_source_file]*
+```bash
+$ reek [options] [dir_or_source_file]*
+```
 
 For a full list of command-line options see the Reek
-wiki[http://wiki.github.com/kevinrutherford/reek/command-line-options]
+wiki[http://wiki.github.com/troessner/reek/command-line-options]
 or run
 
-    $ reek --help
+```bash
+$ reek --help
+```
 
 ## Example
 
 Imagine a source file <tt>demo.rb</tt> containing:
 
-    class Dirty
-      # This method smells of :reek:NestedIterators but ignores them
-      def awful(x, y, offset = 0, log = false)
-        puts @screen.title
-        @screen = widgets.map {|w| w.each {|key| key += 3}}
-        puts @screen.contents
-      end
-    end
+```ruby
+class Dirty
+  # This method smells of :reek:NestedIterators but ignores them
+  def awful(x, y, offset = 0, log = false)
+    puts @screen.title
+    @screen = widgets.map {|w| w.each {|key| key += 3}}
+    puts @screen.contents
+  end
+end
+```
 
 Reek will report the following code smells in this file:
 
-    $ reek demo.rb
-    spec/samples/demo/demo.rb -- 6 warnings:
-      Dirty has no descriptive comment (IrresponsibleModule)
-      Dirty#awful has 4 parameters (LongParameterList)
-      Dirty#awful has boolean parameter 'log' (ControlCouple)
-      Dirty#awful has the parameter name 'x' (UncommunicativeName)
-      Dirty#awful has the parameter name 'y' (UncommunicativeName)
-      Dirty#awful has the variable name 'w' (UncommunicativeName)
+```bash
+$ reek demo.rb
+spec/samples/demo/demo.rb -- 6 warnings:
+  Dirty has no descriptive comment (IrresponsibleModule)
+  Dirty#awful has 4 parameters (LongParameterList)
+  Dirty#awful has boolean parameter 'log' (ControlCouple)
+  Dirty#awful has the parameter name 'x' (UncommunicativeName)
+  Dirty#awful has the parameter name 'y' (UncommunicativeName)
+  Dirty#awful has the variable name 'w' (UncommunicativeName)
+```
 
 ## Features
 
 Reek currently includes checks for some aspects of Control Couple,
 Data Clump, Feature Envy, Large Class, Long Method, Long Parameter List,
 Simulated Polymorphism, Uncommunicative Name and more.
-See the [Reek wiki](http://wiki.github.com/kevinrutherford/reek/code-smells)
+See the [Reek wiki](http://wiki.github.com/troessner/reek/code-smells)
 for up to date details of exactly what Reek will check in your code.
 
 ### Tool Integration
@@ -53,7 +65,9 @@ Reek integrates with many of your favourite tools:
 
 * `require 'reek/rake/task'` to easily add Reek to your Rakefile
 * `require 'reek/spec'` to add the `should_not reek` custom matcher to your Rspec examples
-* Reek is fully compliant with Ruby 1.8.6, 1.8.7 and 1.9.1
+* Reek is compatible with Ruby 1.8.6, 1.8.7, 1.9.2 and 1.9.3
+
+At present Reek is unable to parse the new Ruby 1.9 hash syntax of {a: 1}.
 
 ### Dependencies
 
@@ -68,7 +82,8 @@ Learn More
 
 Find out more about Reek from any of the following sources:
 
-* Browse the Reek documentation at [http://wiki.github.com/kevinrutherford/reek](http://wiki.github.com/kevinrutherford/reek)
-* Browse the code or install the latest development version from [http://github.com/kevinrutherford/reek/tree](http://github.com/kevinrutherford/reek/tree)
-* Read the code API at [http://rdoc.info/projects/kevinrutherford/reek](http://rdoc.info/projects/kevinrutherford/reek)
+* Browse the Reek documentation at [http://wiki.github.com/troessner/reek](http://wiki.github.com/troessner/reek)
+* Browse the code or install the latest development version from [http://github.com/troessner/reek/tree](http://github.com/troessner/reek/tree)
+* Read the code API at [http://rdoc.info/projects/troessner/reek](http://rdoc.info/projects/troessner/reek)
 * Follow [@rubyreek](http://twitter.com/rubyreek) on twitter!
+

data/Rakefile

@@ -1,15 +1,2 @@
-require 'rake/clean'
-
-$:.unshift File.dirname(__FILE__) + '/lib'
-
-PROJECT_NAME = 'reek'
-
-BUILD_DIR = 'build'; directory BUILD_DIR
-PKG_DIR = "#{BUILD_DIR}/pkg"; directory PKG_DIR
-
-GEM_MANIFEST = "Manifest.txt"
-VERSION_FILE = 'lib/reek.rb'
-
-CLOBBER.include("#{BUILD_DIR}/*")
-
-Dir['tasks/**/*.rake'].each { |t| load t }
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/reek

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 #
 # Reek examines Ruby source code for smells.
-# Visit http://wiki.github.com/kevinrutherford/reek for docs etc.
+# Visit http://wiki.github.com/troessner/reek for docs etc.
 #
 # Author: Kevin Rutherford
 #

data/features/{options.feature → command_line_interface/options.feature}

@@ -28,17 +28,15 @@ Feature: Reek can be controlled using command-line options
       reek -q lib
       cat my_class.rb | reek
 
-      See http://wiki.github.com/kevinrutherford/reek for detailed help.
+      See http://wiki.github.com/troessner/reek for detailed help.
 
       Common options:
           -h, --help                       Show this message
           -v, --version                    Show version
 
-
       Configuration:
           -c, --config FILE                Read configuration options from FILE
 
-
       Report formatting:
           -q, --[no-]quiet                 Suppress headings for smell-free source files
           -y, --yaml                       Report smells in YAML format

data/features/{stdin.feature → command_line_interface/stdin.feature}

@@ -34,8 +34,8 @@ Feature: Reek reads from $stdin when no files are given
       """
       $stdin -- 3 warnings:
         Turn has no descriptive comment (IrresponsibleModule)
-        Turn has the variable name '@x' (UncommunicativeName)
-        Turn#y has the name 'y' (UncommunicativeName)
+        Turn has the variable name '@x' (UncommunicativeVariableName)
+        Turn#y has the name 'y' (UncommunicativeMethodName)
 
       """
 

data/features/{masking_smells.feature → configuration_files/masking_smells.feature}

@@ -10,12 +10,12 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/empty_config_file/dirty.rb -- 6 warnings:
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
-        Dirty#a has the variable name 'x' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
+        Dirty#a has the variable name 'x' (UncommunicativeVariableName)
 
       """
 
@@ -26,15 +26,15 @@ Feature: Masking smells using config files
       """
       spec/samples/corrupt_config_file/dirty.rb -- 7 warnings:
         Dirty has no descriptive comment (IrresponsibleModule)
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
-        Dirty#a has the variable name 'x' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
+        Dirty#a has the variable name 'x' (UncommunicativeVariableName)
 
       """
-    And it reports the error 'Error: Invalid configuration file "corrupt.reek" -- "This is not a config file" is not a code smell'
+    And it reports an error
 
   Scenario: missing source file is an error
     When I run reek no_such_file.rb spec/samples/masked/dirty.rb
@@ -42,8 +42,8 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/masked/dirty.rb -- 3 warnings:
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
 
       """
@@ -55,8 +55,8 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/masked/dirty.rb -- 3 warnings:
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
 
       """
@@ -67,11 +67,11 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/not_quite_masked/dirty.rb -- 5 warnings:
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
 
       """
 
@@ -82,8 +82,8 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/overrides/masked/dirty.rb -- 2 warnings:
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
 
       """
 
@@ -93,7 +93,7 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/mask_some/dirty.rb -- 2 warnings:
-        Dirty#a calls @s.title twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
 
       """
@@ -105,7 +105,7 @@ Feature: Masking smells using config files
     And it reports:
       """
       spec/samples/inline_config/dirty.rb -- 1 warning:
-        Dirty#a calls @s.title twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
 
       """
 

data/features/{rake_task.feature → rake_task/rake_task.feature}

@@ -14,8 +14,8 @@ Feature: Reek can be driven through its Task
     And it reports:
       """
       spec/samples/masked/dirty.rb -- 3 warnings:
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
       """
 
@@ -30,8 +30,8 @@ Feature: Reek can be driven through its Task
     And it reports:
       """
       spec/samples/masked/dirty.rb -- 3 warnings:
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
       """
 
@@ -58,12 +58,12 @@ Feature: Reek can be driven through its Task
     And it reports:
       """
       spec/samples/empty_config_file/dirty.rb -- 6 warnings:
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
-        Dirty#a has the variable name 'x' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
+        Dirty#a has the variable name 'x' (UncommunicativeVariableName)
       """
 
   Scenario: can be configured with config_files

data/features/{reports.feature → reports/reports.feature}

@@ -10,19 +10,19 @@ Feature: Correctly formatted reports
     And it reports:
       """
       spec/samples/two_smelly_files/dirty_one.rb -- 6 warnings:
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
-        Dirty#a has the variable name 'x' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
+        Dirty#a has the variable name 'x' (UncommunicativeVariableName)
       spec/samples/two_smelly_files/dirty_two.rb -- 6 warnings:
-        Dirty has the variable name '@s' (UncommunicativeName)
-        Dirty#a calls @s.title twice (Duplication)
-        Dirty#a calls puts(@s.title) twice (Duplication)
+        Dirty has the variable name '@s' (UncommunicativeVariableName)
+        Dirty#a calls @s.title twice (DuplicateMethodCall)
+        Dirty#a calls puts(@s.title) twice (DuplicateMethodCall)
         Dirty#a contains iterators nested 2 deep (NestedIterators)
-        Dirty#a has the name 'a' (UncommunicativeName)
-        Dirty#a has the variable name 'x' (UncommunicativeName)
+        Dirty#a has the name 'a' (UncommunicativeMethodName)
+        Dirty#a has the variable name 'x' (UncommunicativeVariableName)
 
       """
 

data/features/{yaml.feature → reports/yaml.feature}

@@ -12,7 +12,7 @@ Feature: Report smells using simple YAML layout
   Scenario: masked smells always appear
     When I run reek --yaml spec/samples/masked/dirty.rb
     Then the exit status indicates smells
-    And it reports:
+    And it reports this yaml:
       """
       --- 
       - !ruby/object:Reek::SmellWarning 
@@ -65,7 +65,7 @@ Feature: Report smells using simple YAML layout
   Scenario: return non-zero status when there are smells
     When I pass "class Turn; end" to reek --yaml
     Then the exit status indicates smells
-    And it reports:
+    And it reports this yaml:
       """
       --- 
       - !ruby/object:Reek::SmellWarning 

data/features/{api.feature → ruby_api/api.feature}

@@ -1,8 +1,8 @@
 @masking
 Feature: The Reek API maintains backwards compatibility
-  In order to use Reek witthout fuss
+  In order to use Reek without fuss
   As a developer
-  I want to mave a stable API
+  I want to have a stable API
 
   Scenario: the demo example reports as expected
     When I run reek spec/samples/demo
@@ -12,9 +12,9 @@ Feature: The Reek API maintains backwards compatibility
       spec/samples/demo/demo.rb -- 6 warnings:
         Dirty has no descriptive comment (IrresponsibleModule)
         Dirty#awful has 4 parameters (LongParameterList)
-        Dirty#awful has boolean parameter 'log' (ControlCouple)
-        Dirty#awful has the parameter name 'x' (UncommunicativeName)
-        Dirty#awful has the parameter name 'y' (UncommunicativeName)
-        Dirty#awful has the variable name 'w' (UncommunicativeName)
+        Dirty#awful has boolean parameter 'log' (BooleanParameter)
+        Dirty#awful has the parameter name 'x' (UncommunicativeParameterName)
+        Dirty#awful has the parameter name 'y' (UncommunicativeParameterName)
+        Dirty#awful has the variable name 'w' (UncommunicativeVariableName)
 
       """

data/features/samples.feature

@@ -2,176 +2,168 @@
 Feature: Basic smell detection
   In order to write better software
   As a developer
-  I want to detect the smels in my Ruby code
+  I want to detect the smells in my Ruby code
 
   @inline
   Scenario: Correct smells from inline.rb
     When I run reek spec/samples/inline.rb
     Then the exit status indicates smells
-    And it reports:
-    """
-    spec/samples/inline.rb -- 41 warnings:
-      File has no descriptive comment (IrresponsibleModule)
-      Inline declares the class variable @@directory (ClassVariable)
-      Inline declares the class variable @@rootdir (ClassVariable)
-      Inline#self.rootdir calls env.nil? twice (Duplication)
-      Inline#self.rootdir has approx 8 statements (LongMethod)
-      Inline::C declares the class variable @@type_map (ClassVariable)
-      Inline::C has at least 13 instance variables (LargeClass)
-      Inline::C takes parameters [options, src] to 5 methods (DataClump)
-      Inline::C tests $DEBUG at least 7 times (SimulatedPolymorphism)
-      Inline::C tests $TESTING at least 4 times (SimulatedPolymorphism)
-      Inline::C tests @@type_map.has_key?(type) at least 3 times (SimulatedPolymorphism)
-      Inline::C#build calls ($? == 0) twice (Duplication)
-      Inline::C#build calls Inline.directory 5 times (Duplication)
-      Inline::C#build calls io.puts 6 times (Duplication)
-      Inline::C#build calls io.puts("#endif") twice (Duplication)
-      Inline::C#build calls io.puts("#ifdef __cplusplus") twice (Duplication)
-      Inline::C#build calls module_name twice (Duplication)
-      Inline::C#build calls warn("Output:\n#{result}") twice (Duplication)
-      Inline::C#build contains iterators nested 2 deep (NestedIterators)
-      Inline::C#build has approx 60 statements (LongMethod)
-      Inline::C#build has the variable name 'n' (UncommunicativeName)
-      Inline::C#build has the variable name 't' (UncommunicativeName)
-      Inline::C#c has the name 'c' (UncommunicativeName)
-      Inline::C#crap_for_windoze calls Config::CONFIG["libdir"] twice (Duplication)
-      Inline::C#generate calls result.sub!(/\A\n/, "") twice (Duplication)
-      Inline::C#generate calls signature["args"] twice (Duplication)
-      Inline::C#generate calls signature["args"].map twice (Duplication)
-      Inline::C#generate has approx 32 statements (LongMethod)
-      Inline::C#initialize calls stack.empty? twice (Duplication)
-      Inline::C#load calls so_name twice (Duplication)
-      Inline::C#module_name has the variable name 'm' (UncommunicativeName)
-      Inline::C#module_name has the variable name 'x' (UncommunicativeName)
-      Inline::C#parse_signature has approx 15 statements (LongMethod)
-      Inline::C#parse_signature has boolean parameter 'raw' (ControlCouple)
-      Inline::C#parse_signature has the variable name 'x' (UncommunicativeName)
-      Inline::C#parse_signature is controlled by argument raw (ControlCouple)
-      Inline::C#strip_comments doesn't depend on instance state (LowCohesion)
-      Inline::C#strip_comments refers to src more than self (LowCohesion)
-      Module#inline calls Inline.const_get(lang) twice (Duplication)
-      Module#inline has approx 11 statements (LongMethod)
-      Module#inline is controlled by argument options (ControlCouple)
-
-    """
+    And it reports something like: spec/samples/inline.rb -- 41 warnings:
+    And it reports something like: File has no descriptive comment (IrresponsibleModule)
+    And it reports something like: Inline declares the class variable @@directory (ClassVariable)
+    And it reports something like: Inline declares the class variable @@rootdir (ClassVariable)
+    And it reports something like: Inline#self.rootdir calls env.nil? twice (DuplicateMethodCall)
+    And it reports something like: Inline#self.rootdir has approx 8 statements (TooManyStatements)
+    And it reports something like: Inline::C declares the class variable @@type_map (ClassVariable)
+    And it reports something like: Inline::C has at least 13 instance variables (TooManyInstanceVariables)
+    And it reports something like: Inline::C takes parameters [options, src] to 5 methods (DataClump)
+    And it reports something like: Inline::C tests $DEBUG at least 7 times (RepeatedConditional)
+    And it reports something like: Inline::C tests $TESTING at least 4 times (RepeatedConditional)
+    And it reports something like: Inline::C tests @@type_map.has_key?(type) at least 3 times (RepeatedConditional)
+    And it reports something like: Inline::C#build calls ($? == 0) twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#build calls Inline.directory 5 times (DuplicateMethodCall)
+    And it reports something like: Inline::C#build calls io.puts 6 times (DuplicateMethodCall)
+    And it reports something like: Inline::C#build calls io.puts("#endif") twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#build calls io.puts("#ifdef __cplusplus") twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#build calls module_name twice (DuplicateMethodCall)
+    And it reports something like (pending): Inline::C#build calls warn("Output:\n#{result}") twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#build contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: Inline::C#build has approx 60 statements (TooManyStatements)
+    And it reports something like: Inline::C#build has the variable name 'n' (UncommunicativeVariableName)
+    And it reports something like: Inline::C#build has the variable name 't' (UncommunicativeVariableName)
+    And it reports something like: Inline::C#c has the name 'c' (UncommunicativeMethodName)
+    And it reports something like: Inline::C#crap_for_windoze calls Config::CONFIG["libdir"] twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#generate calls result.sub!(/\A\n/, "") twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#generate calls signature["args"] twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#generate calls signature["args"].map twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#generate has approx 32 statements (TooManyStatements)
+    And it reports something like: Inline::C#initialize calls stack.empty? twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#load calls so_name twice (DuplicateMethodCall)
+    And it reports something like: Inline::C#module_name has the variable name 'm' (UncommunicativeVariableName)
+    And it reports something like: Inline::C#module_name has the variable name 'x' (UncommunicativeVariableName)
+    And it reports something like: Inline::C#parse_signature has approx 15 statements (TooManyStatements)
+    And it reports something like: Inline::C#parse_signature has boolean parameter 'raw' (BooleanParameter)
+    And it reports something like: Inline::C#parse_signature has the variable name 'x' (UncommunicativeVariableName)
+    And it reports something like: Inline::C#parse_signature is controlled by argument raw (ControlParameter)
+    And it reports something like: Inline::C#strip_comments doesn't depend on instance state (UtilityFunction)
+    And it reports something like: Inline::C#strip_comments refers to src more than self (FeatureEnvy)
+    And it reports something like: Module#inline calls Inline.const_get(lang) twice (DuplicateMethodCall)
+    And it reports something like: Module#inline has approx 11 statements (TooManyStatements)
+    And it reports something like: Module#inline is controlled by argument options (ControlParameter)
 
   Scenario: Correct smells from optparse.rb
     When I run reek spec/samples/optparse.rb
     Then the exit status indicates smells
-    And it reports:
-    """
-    spec/samples/optparse.rb -- 109 warnings:
-      OptionParser has at least 42 methods (LargeClass)
-      OptionParser has the variable name 'f' (UncommunicativeName)
-      OptionParser has the variable name 'k' (UncommunicativeName)
-      OptionParser has the variable name 'o' (UncommunicativeName)
-      OptionParser has the variable name 's' (UncommunicativeName)
-      OptionParser has the variable name 'v' (UncommunicativeName)
-      OptionParser tests ((argv.size == 1) and Array.===(argv[0])) at least 3 times (SimulatedPolymorphism)
-      OptionParser tests a at least 7 times (SimulatedPolymorphism)
-      OptionParser tests default_pattern at least 7 times (SimulatedPolymorphism)
-      OptionParser tests not_style at least 3 times (SimulatedPolymorphism)
-      OptionParser tests s at least 7 times (SimulatedPolymorphism)
-      OptionParser#complete contains iterators nested 2 deep (NestedIterators)
-      OptionParser#complete has 4 parameters (LongParameterList)
-      OptionParser#complete has boolean parameter 'icase' (ControlCouple)
-      OptionParser#getopts calls result[opt] = false twice (Duplication)
-      OptionParser#getopts has approx 17 statements (LongMethod)
-      OptionParser#load has the variable name 's' (UncommunicativeName)
-      OptionParser#make_switch calls (long << o = q.downcase) twice (Duplication)
-      OptionParser#make_switch calls (sdesc << "-#{q}") twice (Duplication)
-      OptionParser#make_switch calls default_style.guess(arg = a) 4 times (Duplication)
-      OptionParser#make_switch calls notwice(NilClass, klass, "type") twice (Duplication)
-      OptionParser#make_switch calls notwice(a ? (Object) : (TrueClass), klass, "type") twice (Duplication)
-      OptionParser#make_switch calls pattern.method(:convert) twice (Duplication)
-      OptionParser#make_switch calls pattern.method(:convert).to_proc twice (Duplication)
-      OptionParser#make_switch calls pattern.respond_to?(:convert) twice (Duplication)
-      OptionParser#make_switch calls q.downcase 3 times (Duplication)
-      OptionParser#make_switch calls search(:atype, FalseClass) twice (Duplication)
-      OptionParser#make_switch calls search(:atype, o) 6 times (Duplication)
-      OptionParser#make_switch contains iterators nested 2 deep (NestedIterators)
-      OptionParser#make_switch contains iterators nested 3 deep (NestedIterators)
-      OptionParser#make_switch has approx 68 statements (LongMethod)
-      OptionParser#make_switch has the variable name 'a' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 'c' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 'n' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 'o' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 'q' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 's' (UncommunicativeName)
-      OptionParser#make_switch has the variable name 'v' (UncommunicativeName)
-      OptionParser#order calls argv[0] twice (Duplication)
-      OptionParser#order refers to argv more than self (LowCohesion)
-      OptionParser#parse calls argv[0] twice (Duplication)
-      OptionParser#parse refers to argv more than self (LowCohesion)
-      OptionParser#parse_in_order calls $!.set_option(arg, true) twice (Duplication)
-      OptionParser#parse_in_order calls cb.call(val) twice (Duplication)
-      OptionParser#parse_in_order calls raise($!.set_option(arg, true)) twice (Duplication)
-      OptionParser#parse_in_order calls raise(*exc) twice (Duplication)
-      OptionParser#parse_in_order calls setter.call(sw.switch_name, val) twice (Duplication)
-      OptionParser#parse_in_order calls sw.block twice (Duplication)
-      OptionParser#parse_in_order calls sw.switch_name twice (Duplication)
-      OptionParser#parse_in_order contains iterators nested 2 deep (NestedIterators)
-      OptionParser#parse_in_order contains iterators nested 3 deep (NestedIterators)
-      OptionParser#parse_in_order has approx 28 statements (LongMethod)
-      OptionParser#parse_in_order is controlled by argument setter (ControlCouple)
-      OptionParser#permute calls argv[0] twice (Duplication)
-      OptionParser#permute refers to argv more than self (LowCohesion)
-      OptionParser#search has the variable name 'k' (UncommunicativeName)
-      OptionParser#summarize has 4 parameters (LongParameterList)
-      OptionParser#summarize has the variable name 'l' (UncommunicativeName)
-      OptionParser#ver has the variable name 'v' (UncommunicativeName)
-      OptionParser::CompletingHash#match contains iterators nested 2 deep (NestedIterators)
-      OptionParser::Completion#complete calls candidates.size twice (Duplication)
-      OptionParser::Completion#complete calls k.id2name twice (Duplication)
-      OptionParser::Completion#complete has approx 22 statements (LongMethod)
-      OptionParser::Completion#complete has boolean parameter 'icase' (ControlCouple)
-      OptionParser::Completion#complete has the variable name 'k' (UncommunicativeName)
-      OptionParser::Completion#complete has the variable name 'v' (UncommunicativeName)
-      OptionParser::Completion#complete refers to candidates more than self (LowCohesion)
-      OptionParser::List#accept has the parameter name 't' (UncommunicativeName)
-      OptionParser::List#accept is controlled by argument pat (ControlCouple)
-      OptionParser::List#accept refers to pat more than self (LowCohesion)
-      OptionParser::List#add_banner refers to opt more than self (LowCohesion)
-      OptionParser::List#complete has 4 parameters (LongParameterList)
-      OptionParser::List#complete has boolean parameter 'icase' (ControlCouple)
-      OptionParser::List#reject has the parameter name 't' (UncommunicativeName)
-      OptionParser::List#summarize refers to opt more than self (LowCohesion)
-      OptionParser::List#update has 5 parameters (LongParameterList)
-      OptionParser::List#update has approx 6 statements (LongMethod)
-      OptionParser::List#update has the variable name 'o' (UncommunicativeName)
-      OptionParser::List#update is controlled by argument lopts (ControlCouple)
-      OptionParser::List#update is controlled by argument sopts (ControlCouple)
-      OptionParser::ParseError#set_option is controlled by argument eq (ControlCouple)
-      OptionParser::Switch#add_banner has the variable name 's' (UncommunicativeName)
-      OptionParser::Switch#conv_arg calls conv twice (Duplication)
-      OptionParser::Switch#initialize has 7 parameters (LongParameterList)
-      OptionParser::Switch#parse_arg calls pattern twice (Duplication)
-      OptionParser::Switch#parse_arg calls s.length twice (Duplication)
-      OptionParser::Switch#parse_arg has approx 11 statements (LongMethod)
-      OptionParser::Switch#parse_arg has the variable name 'm' (UncommunicativeName)
-      OptionParser::Switch#parse_arg has the variable name 's' (UncommunicativeName)
-      OptionParser::Switch#self.guess has the variable name 't' (UncommunicativeName)
-      OptionParser::Switch#self.incompatible_argument_styles has the parameter name 't' (UncommunicativeName)
-      OptionParser::Switch#summarize calls (indent + l) twice (Duplication)
-      OptionParser::Switch#summarize calls arg 4 times (Duplication)
-      OptionParser::Switch#summarize calls left.collect twice (Duplication)
-      OptionParser::Switch#summarize calls left.collect { |s| s.length }.max twice (Duplication)
-      OptionParser::Switch#summarize calls left.collect { |s| s.length }.max.to_i twice (Duplication)
-      OptionParser::Switch#summarize calls left.shift twice (Duplication)
-      OptionParser::Switch#summarize calls left[-1] 3 times (Duplication)
-      OptionParser::Switch#summarize calls s.length 3 times (Duplication)
-      OptionParser::Switch#summarize contains iterators nested 2 deep (NestedIterators)
-      OptionParser::Switch#summarize has 5 parameters (LongParameterList)
-      OptionParser::Switch#summarize has approx 25 statements (LongMethod)
-      OptionParser::Switch#summarize has the variable name 'l' (UncommunicativeName)
-      OptionParser::Switch#summarize has the variable name 'r' (UncommunicativeName)
-      OptionParser::Switch#summarize has the variable name 's' (UncommunicativeName)
-      OptionParser::Switch::NoArgument#parse is controlled by argument arg (ControlCouple)
-      OptionParser::Switch::OptionalArgument#parse is controlled by argument arg (ControlCouple)
-      OptionParser::Switch::PlacedArgument#parse has approx 6 statements (LongMethod)
-      OptionParser::Switch::RequiredArgument#parse is controlled by argument arg (ControlCouple)
-
-    """
+    And it reports something like: spec/samples/optparse.rb -- 109 warnings:
+    And it reports something like: OptionParser has at least 42 methods (TooManyMethods)
+    And it reports something like: OptionParser has the variable name 'f' (UncommunicativeVariableName)
+    And it reports something like: OptionParser has the variable name 'k' (UncommunicativeVariableName)
+    And it reports something like: OptionParser has the variable name 'o' (UncommunicativeVariableName)
+    And it reports something like: OptionParser has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser has the variable name 'v' (UncommunicativeVariableName)
+    And it reports something like: OptionParser tests ((argv.size == 1) and Array.===(argv[0])) at least 3 times (RepeatedConditional)
+    And it reports something like: OptionParser tests a at least 7 times (RepeatedConditional)
+    And it reports something like: OptionParser tests default_pattern at least 7 times (RepeatedConditional)
+    And it reports something like: OptionParser tests not_style at least 3 times (RepeatedConditional)
+    And it reports something like: OptionParser tests s at least 7 times (RepeatedConditional)
+    And it reports something like: OptionParser#complete contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: OptionParser#complete has 4 parameters (LongParameterList)
+    And it reports something like: OptionParser#complete has boolean parameter 'icase' (BooleanParameter)
+    And it reports something like: OptionParser#getopts calls result[opt] = false twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#getopts has approx 17 statements (TooManyStatements)
+    And it reports something like: OptionParser#load has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch calls (long << o = q.downcase) twice (DuplicateMethodCall)
+    And it reports something like (pending): OptionParser#make_switch calls (sdesc << "-#{q}") twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls default_style.guess(arg = a) 4 times (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls notwice(NilClass, klass, "type") twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls notwice(a ? (Object) : (TrueClass), klass, "type") twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls pattern.method(:convert) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls pattern.method(:convert).to_proc twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls pattern.respond_to?(:convert) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls q.downcase 3 times (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls search(:atype, FalseClass) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch calls search(:atype, o) 6 times (DuplicateMethodCall)
+    And it reports something like: OptionParser#make_switch contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: OptionParser#make_switch contains iterators nested 3 deep (NestedIterators)
+    And it reports something like: OptionParser#make_switch has approx 68 statements (TooManyStatements)
+    And it reports something like: OptionParser#make_switch has the variable name 'a' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 'c' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 'n' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 'o' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 'q' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#make_switch has the variable name 'v' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#order calls argv[0] twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#order refers to argv more than self (FeatureEnvy)
+    And it reports something like: OptionParser#parse calls argv[0] twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse refers to argv more than self (FeatureEnvy)
+    And it reports something like: OptionParser#parse_in_order calls $!.set_option(arg, true) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls cb.call(val) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls raise($!.set_option(arg, true)) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls raise(*exc) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls setter.call(sw.switch_name, val) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls sw.block twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order calls sw.switch_name twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#parse_in_order contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: OptionParser#parse_in_order contains iterators nested 3 deep (NestedIterators)
+    And it reports something like: OptionParser#parse_in_order has approx 28 statements (TooManyStatements)
+    And it reports something like: OptionParser#parse_in_order is controlled by argument setter (ControlParameter)
+    And it reports something like: OptionParser#permute calls argv[0] twice (DuplicateMethodCall)
+    And it reports something like: OptionParser#permute refers to argv more than self (FeatureEnvy)
+    And it reports something like: OptionParser#search has the variable name 'k' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#summarize has 4 parameters (LongParameterList)
+    And it reports something like: OptionParser#summarize has the variable name 'l' (UncommunicativeVariableName)
+    And it reports something like: OptionParser#ver has the variable name 'v' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::CompletingHash#match contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: OptionParser::Completion#complete calls candidates.size twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Completion#complete calls k.id2name twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Completion#complete has approx 22 statements (TooManyStatements)
+    And it reports something like: OptionParser::Completion#complete has boolean parameter 'icase' (BooleanParameter)
+    And it reports something like: OptionParser::Completion#complete has the variable name 'k' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Completion#complete has the variable name 'v' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Completion#complete refers to candidates more than self (FeatureEnvy)
+    And it reports something like: OptionParser::List#accept has the parameter name 't' (UncommunicativeParameterName)
+    And it reports something like: OptionParser::List#accept is controlled by argument pat (ControlParameter)
+    And it reports something like: OptionParser::List#accept refers to pat more than self (FeatureEnvy)
+    And it reports something like: OptionParser::List#add_banner refers to opt more than self (FeatureEnvy)
+    And it reports something like: OptionParser::List#complete has 4 parameters (LongParameterList)
+    And it reports something like: OptionParser::List#complete has boolean parameter 'icase' (BooleanParameter)
+    And it reports something like: OptionParser::List#reject has the parameter name 't' (UncommunicativeParameterName)
+    And it reports something like: OptionParser::List#summarize refers to opt more than self (FeatureEnvy)
+    And it reports something like: OptionParser::List#update has 5 parameters (LongParameterList)
+    And it reports something like: OptionParser::List#update has approx 6 statements (TooManyStatements)
+    And it reports something like: OptionParser::List#update has the variable name 'o' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::List#update is controlled by argument lopts (ControlParameter)
+    And it reports something like: OptionParser::List#update is controlled by argument sopts (ControlParameter)
+    And it reports something like: OptionParser::ParseError#set_option is controlled by argument eq (ControlParameter)
+    And it reports something like: OptionParser::Switch#add_banner has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#conv_arg calls conv twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#initialize has 7 parameters (LongParameterList)
+    And it reports something like: OptionParser::Switch#parse_arg calls pattern twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#parse_arg calls s.length twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#parse_arg has approx 11 statements (TooManyStatements)
+    And it reports something like: OptionParser::Switch#parse_arg has the variable name 'm' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#parse_arg has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#self.guess has the variable name 't' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#self.incompatible_argument_styles has the parameter name 't' (UncommunicativeParameterName)
+    And it reports something like: OptionParser::Switch#summarize calls (indent + l) twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls arg 4 times (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls left.collect twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls left.collect { |s| s.length }.max twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls left.collect { |s| s.length }.max.to_i twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls left.shift twice (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls left[-1] 3 times (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize calls s.length 3 times (DuplicateMethodCall)
+    And it reports something like: OptionParser::Switch#summarize contains iterators nested 2 deep (NestedIterators)
+    And it reports something like: OptionParser::Switch#summarize has 5 parameters (LongParameterList)
+    And it reports something like: OptionParser::Switch#summarize has approx 25 statements (TooManyStatements)
+    And it reports something like: OptionParser::Switch#summarize has the variable name 'l' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#summarize has the variable name 'r' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch#summarize has the variable name 's' (UncommunicativeVariableName)
+    And it reports something like: OptionParser::Switch::NoArgument#parse is controlled by argument arg (ControlParameter)
+    And it reports something like: OptionParser::Switch::OptionalArgument#parse is controlled by argument arg (ControlParameter)
+    And it reports something like: OptionParser::Switch::PlacedArgument#parse has approx 6 statements (TooManyStatements)
+    And it reports something like: OptionParser::Switch::RequiredArgument#parse is controlled by argument arg (ControlParameter)
 
   Scenario: Correct smells from redcloth.rb
     When I run reek spec/samples/redcloth.rb
@@ -179,102 +171,102 @@ Feature: Basic smell detection
     And it reports:
     """
     spec/samples/redcloth.rb -- 97 warnings:
-      RedCloth has at least 44 methods (LargeClass)
-      RedCloth has the variable name 'a' (UncommunicativeName)
-      RedCloth has the variable name 'b' (UncommunicativeName)
+      RedCloth has at least 44 methods (TooManyMethods)
+      RedCloth has the variable name 'a' (UncommunicativeVariableName)
+      RedCloth has the variable name 'b' (UncommunicativeVariableName)
       RedCloth takes parameters [atts, cite, content, tag] to 3 methods (DataClump)
-      RedCloth tests atts at least 6 times (SimulatedPolymorphism)
-      RedCloth tests codepre.zero? at least 3 times (SimulatedPolymorphism)
-      RedCloth tests href at least 3 times (SimulatedPolymorphism)
-      RedCloth tests title at least 4 times (SimulatedPolymorphism)
-      RedCloth#block_markdown_atx refers to text more than self (LowCohesion)
-      RedCloth#block_markdown_bq has approx 6 statements (LongMethod)
-      RedCloth#block_markdown_rule refers to text more than self (LowCohesion)
-      RedCloth#block_markdown_setext refers to text more than self (LowCohesion)
-      RedCloth#block_textile_lists calls (line_id - 1) twice (Duplication)
-      RedCloth#block_textile_lists calls depth.last 5 times (Duplication)
-      RedCloth#block_textile_lists calls depth.last.length twice (Duplication)
-      RedCloth#block_textile_lists calls depth[i] twice (Duplication)
-      RedCloth#block_textile_lists calls lines[(line_id - 1)] twice (Duplication)
-      RedCloth#block_textile_lists calls tl.length 3 times (Duplication)
+      RedCloth tests atts at least 6 times (RepeatedConditional)
+      RedCloth tests codepre.zero? at least 3 times (RepeatedConditional)
+      RedCloth tests href at least 3 times (RepeatedConditional)
+      RedCloth tests title at least 4 times (RepeatedConditional)
+      RedCloth#block_markdown_atx refers to text more than self (FeatureEnvy)
+      RedCloth#block_markdown_bq has approx 6 statements (TooManyStatements)
+      RedCloth#block_markdown_rule refers to text more than self (FeatureEnvy)
+      RedCloth#block_markdown_setext refers to text more than self (FeatureEnvy)
+      RedCloth#block_textile_lists calls (line_id - 1) twice (DuplicateMethodCall)
+      RedCloth#block_textile_lists calls depth.last 5 times (DuplicateMethodCall)
+      RedCloth#block_textile_lists calls depth.last.length twice (DuplicateMethodCall)
+      RedCloth#block_textile_lists calls depth[i] twice (DuplicateMethodCall)
+      RedCloth#block_textile_lists calls lines[(line_id - 1)] twice (DuplicateMethodCall)
+      RedCloth#block_textile_lists calls tl.length 3 times (DuplicateMethodCall)
       RedCloth#block_textile_lists contains iterators nested 3 deep (NestedIterators)
-      RedCloth#block_textile_lists has approx 20 statements (LongMethod)
-      RedCloth#block_textile_lists has the variable name 'i' (UncommunicativeName)
-      RedCloth#block_textile_lists has the variable name 'v' (UncommunicativeName)
-      RedCloth#block_textile_lists refers to depth more than self (LowCohesion)
+      RedCloth#block_textile_lists has approx 20 statements (TooManyStatements)
+      RedCloth#block_textile_lists has the variable name 'i' (UncommunicativeVariableName)
+      RedCloth#block_textile_lists has the variable name 'v' (UncommunicativeVariableName)
+      RedCloth#block_textile_lists refers to depth more than self (FeatureEnvy)
       RedCloth#block_textile_table contains iterators nested 2 deep (NestedIterators)
       RedCloth#block_textile_table contains iterators nested 3 deep (NestedIterators)
-      RedCloth#block_textile_table has approx 18 statements (LongMethod)
-      RedCloth#block_textile_table has the variable name 'x' (UncommunicativeName)
+      RedCloth#block_textile_table has approx 18 statements (TooManyStatements)
+      RedCloth#block_textile_table has the variable name 'x' (UncommunicativeVariableName)
       RedCloth#blocks contains iterators nested 2 deep (NestedIterators)
-      RedCloth#blocks has approx 18 statements (LongMethod)
-      RedCloth#blocks has boolean parameter 'deep_code' (ControlCouple)
-      RedCloth#blocks is controlled by argument deep_code (ControlCouple)
-      RedCloth#check_refs is controlled by argument text (ControlCouple)
-      RedCloth#clean_html calls tags[tag] twice (Duplication)
+      RedCloth#blocks has approx 18 statements (TooManyStatements)
+      RedCloth#blocks has boolean parameter 'deep_code' (BooleanParameter)
+      RedCloth#blocks is controlled by argument deep_code (ControlParameter)
+      RedCloth#check_refs is controlled by argument text (ControlParameter)
+      RedCloth#clean_html calls tags[tag] twice (DuplicateMethodCall)
       RedCloth#clean_html contains iterators nested 3 deep (NestedIterators)
-      RedCloth#clean_html doesn't depend on instance state (LowCohesion)
-      RedCloth#clean_html has approx 14 statements (LongMethod)
-      RedCloth#clean_html has the variable name 'q' (UncommunicativeName)
-      RedCloth#clean_html has the variable name 'q2' (UncommunicativeName)
-      RedCloth#clean_html refers to raw more than self (LowCohesion)
-      RedCloth#clean_html refers to tags more than self (LowCohesion)
-      RedCloth#clean_white_space has approx 7 statements (LongMethod)
-      RedCloth#clean_white_space refers to text more than self (LowCohesion)
-      RedCloth#flush_left doesn't depend on instance state (LowCohesion)
-      RedCloth#flush_left refers to indt more than self (LowCohesion)
-      RedCloth#flush_left refers to text more than self (LowCohesion)
-      RedCloth#footnote_ref refers to text more than self (LowCohesion)
-      RedCloth#glyphs_textile has approx 10 statements (LongMethod)
-      RedCloth#htmlesc doesn't depend on instance state (LowCohesion)
-      RedCloth#htmlesc refers to str more than self (LowCohesion)
-      RedCloth#incoming_entities refers to text more than self (LowCohesion)
-      RedCloth#initialize has the variable name 'r' (UncommunicativeName)
+      RedCloth#clean_html doesn't depend on instance state (UtilityFunction)
+      RedCloth#clean_html has approx 14 statements (TooManyStatements)
+      RedCloth#clean_html has the variable name 'q' (UncommunicativeVariableName)
+      RedCloth#clean_html has the variable name 'q2' (UncommunicativeVariableName)
+      RedCloth#clean_html refers to raw more than self (FeatureEnvy)
+      RedCloth#clean_html refers to tags more than self (FeatureEnvy)
+      RedCloth#clean_white_space has approx 7 statements (TooManyStatements)
+      RedCloth#clean_white_space refers to text more than self (FeatureEnvy)
+      RedCloth#flush_left doesn't depend on instance state (UtilityFunction)
+      RedCloth#flush_left refers to indt more than self (FeatureEnvy)
+      RedCloth#flush_left refers to text more than self (FeatureEnvy)
+      RedCloth#footnote_ref refers to text more than self (FeatureEnvy)
+      RedCloth#glyphs_textile has approx 10 statements (TooManyStatements)
+      RedCloth#htmlesc doesn't depend on instance state (UtilityFunction)
+      RedCloth#htmlesc refers to str more than self (FeatureEnvy)
+      RedCloth#incoming_entities refers to text more than self (FeatureEnvy)
+      RedCloth#initialize has the variable name 'r' (UncommunicativeVariableName)
       RedCloth#inline contains iterators nested 2 deep (NestedIterators)
-      RedCloth#inline_markdown_link has approx 6 statements (LongMethod)
-      RedCloth#inline_markdown_link has the variable name 'm' (UncommunicativeName)
-      RedCloth#inline_markdown_reflink has approx 8 statements (LongMethod)
-      RedCloth#inline_markdown_reflink has the variable name 'm' (UncommunicativeName)
-      RedCloth#inline_textile_code has the variable name 'm' (UncommunicativeName)
-      RedCloth#inline_textile_image has approx 17 statements (LongMethod)
-      RedCloth#inline_textile_image has the variable name 'href_a1' (UncommunicativeName)
-      RedCloth#inline_textile_image has the variable name 'href_a2' (UncommunicativeName)
-      RedCloth#inline_textile_image has the variable name 'm' (UncommunicativeName)
-      RedCloth#inline_textile_link has approx 9 statements (LongMethod)
-      RedCloth#inline_textile_link has the variable name 'm' (UncommunicativeName)
+      RedCloth#inline_markdown_link has approx 6 statements (TooManyStatements)
+      RedCloth#inline_markdown_link has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#inline_markdown_reflink has approx 8 statements (TooManyStatements)
+      RedCloth#inline_markdown_reflink has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#inline_textile_code has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#inline_textile_image has approx 17 statements (TooManyStatements)
+      RedCloth#inline_textile_image has the variable name 'href_a1' (UncommunicativeVariableName)
+      RedCloth#inline_textile_image has the variable name 'href_a2' (UncommunicativeVariableName)
+      RedCloth#inline_textile_image has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#inline_textile_link has approx 9 statements (TooManyStatements)
+      RedCloth#inline_textile_link has the variable name 'm' (UncommunicativeVariableName)
       RedCloth#inline_textile_span contains iterators nested 2 deep (NestedIterators)
-      RedCloth#inline_textile_span has approx 8 statements (LongMethod)
-      RedCloth#inline_textile_span has the variable name 'm' (UncommunicativeName)
-      RedCloth#lT has the name 'lT' (UncommunicativeName)
-      RedCloth#no_textile doesn't depend on instance state (LowCohesion)
-      RedCloth#no_textile refers to text more than self (LowCohesion)
-      RedCloth#pba calls $1.length twice (Duplication)
-      RedCloth#pba has approx 21 statements (LongMethod)
-      RedCloth#pba is controlled by argument text_in (ControlCouple)
-      RedCloth#pba refers to style more than self (LowCohesion)
-      RedCloth#pba refers to text more than self (LowCohesion)
-      RedCloth#refs_markdown has the variable name 'm' (UncommunicativeName)
-      RedCloth#refs_textile has the variable name 'm' (UncommunicativeName)
-      RedCloth#retrieve has the variable name 'i' (UncommunicativeName)
-      RedCloth#retrieve has the variable name 'r' (UncommunicativeName)
-      RedCloth#rip_offtags calls ((codepre - used_offtags.length) > 0) twice (Duplication)
-      RedCloth#rip_offtags calls (@pre_list.last << line) twice (Duplication)
-      RedCloth#rip_offtags calls (codepre - used_offtags.length) twice (Duplication)
-      RedCloth#rip_offtags calls @pre_list.last twice (Duplication)
-      RedCloth#rip_offtags calls codepre.zero? twice (Duplication)
-      RedCloth#rip_offtags calls htmlesc(line, :NoQuotes) twice (Duplication)
-      RedCloth#rip_offtags calls used_offtags.length twice (Duplication)
-      RedCloth#rip_offtags calls used_offtags["notextile"] 3 times (Duplication)
-      RedCloth#rip_offtags has approx 18 statements (LongMethod)
+      RedCloth#inline_textile_span has approx 8 statements (TooManyStatements)
+      RedCloth#inline_textile_span has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#lT has the name 'lT' (UncommunicativeMethodName)
+      RedCloth#no_textile doesn't depend on instance state (UtilityFunction)
+      RedCloth#no_textile refers to text more than self (FeatureEnvy)
+      RedCloth#pba calls $1.length twice (DuplicateMethodCall)
+      RedCloth#pba has approx 21 statements (TooManyStatements)
+      RedCloth#pba is controlled by argument text_in (ControlParameter)
+      RedCloth#pba refers to style more than self (FeatureEnvy)
+      RedCloth#pba refers to text more than self (FeatureEnvy)
+      RedCloth#refs_markdown has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#refs_textile has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#retrieve has the variable name 'i' (UncommunicativeVariableName)
+      RedCloth#retrieve has the variable name 'r' (UncommunicativeVariableName)
+      RedCloth#rip_offtags calls ((codepre - used_offtags.length) > 0) twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls (@pre_list.last << line) twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls (codepre - used_offtags.length) twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls @pre_list.last twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls codepre.zero? twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls htmlesc(line, :NoQuotes) twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls used_offtags.length twice (DuplicateMethodCall)
+      RedCloth#rip_offtags calls used_offtags["notextile"] 3 times (DuplicateMethodCall)
+      RedCloth#rip_offtags has approx 18 statements (TooManyStatements)
       RedCloth#textile_bq has 4 parameters (LongParameterList)
-      RedCloth#textile_bq is controlled by argument atts (ControlCouple)
-      RedCloth#textile_bq is controlled by argument cite (ControlCouple)
+      RedCloth#textile_bq is controlled by argument atts (ControlParameter)
+      RedCloth#textile_bq is controlled by argument cite (ControlParameter)
       RedCloth#textile_fn_ has 5 parameters (LongParameterList)
-      RedCloth#textile_fn_ is controlled by argument atts (ControlCouple)
+      RedCloth#textile_fn_ is controlled by argument atts (ControlParameter)
       RedCloth#textile_p has 4 parameters (LongParameterList)
-      RedCloth#textile_p is controlled by argument atts (ControlCouple)
-      RedCloth#textile_popup_help has the parameter name 'windowH' (UncommunicativeName)
-      RedCloth#textile_popup_help has the parameter name 'windowW' (UncommunicativeName)
-      RedCloth#to_html has approx 24 statements (LongMethod)
+      RedCloth#textile_p is controlled by argument atts (ControlParameter)
+      RedCloth#textile_popup_help has the parameter name 'windowH' (UncommunicativeParameterName)
+      RedCloth#textile_popup_help has the parameter name 'windowW' (UncommunicativeParameterName)
+      RedCloth#to_html has approx 24 statements (TooManyStatements)
 
     """