reek 2.0.4 → 2.1.0

data/features/reports/yaml.feature

@@ -3,7 +3,8 @@ Feature: Report smells using simple YAML layout
   output a list of smells in Yaml.
 
   Scenario: output is empty when there are no smells
-    When I run reek --format yaml spec/samples/three_clean_files
+    Given a directory called 'clean_files' containing some clean files
+    When I run reek --format yaml clean_files
     Then it succeeds
     And it reports this yaml:
     """
@@ -11,33 +12,38 @@ Feature: Report smells using simple YAML layout
     """
 
   Scenario: Indicate smells and print them as yaml when using files
-    When I run reek --format yaml spec/samples/standard_smelly/minimal_dirty.rb
+    Given a smelly file called 'smelly.rb'
+    When I run reek --format yaml smelly.rb
     Then the exit status indicates smells
     And it reports this yaml:
       """
       ---
-      - smell_category: IrresponsibleModule
-        smell_type: IrresponsibleModule
-        source: spec/samples/standard_smelly/minimal_dirty.rb
-        context: C
+      - smell_category: Duplication
+        smell_type: DuplicateMethodCall
+        source: smelly.rb
+        context: Smelly#m
         lines:
-        - 1
-        message: has no descriptive comment
-        name: C
-      - smell_category: UncommunicativeName
-        smell_type: UncommunicativeModuleName
-        source: spec/samples/standard_smelly/minimal_dirty.rb
-        context: C
+        - 4
+        - 5
+        message: calls @foo.bar 2 times
+        name: "@foo.bar"
+        count: 2
+      - smell_category: Duplication
+        smell_type: DuplicateMethodCall
+        source: smelly.rb
+        context: Smelly#m
         lines:
-        - 1
-        message: has the name 'C'
-        name: C
+        - 4
+        - 5
+        message: calls puts(@foo.bar) 2 times
+        name: puts(@foo.bar)
+        count: 2
       - smell_category: UncommunicativeName
         smell_type: UncommunicativeMethodName
-        source: spec/samples/standard_smelly/minimal_dirty.rb
-        context: C#m
+        source: smelly.rb
+        context: Smelly#m
         lines:
-        - 2
+        - 3
         message: has the name 'm'
         name: m
       """
@@ -50,7 +56,7 @@ Feature: Report smells using simple YAML layout
       ---
       - smell_category: IrresponsibleModule
         smell_type: IrresponsibleModule
-        source: "$stdin"
+        source: "STDIN"
         context: Turn
         lines:
         - 1

data/features/ruby_api/api.feature

@@ -4,17 +4,18 @@ Feature: The Reek API maintains backwards compatibility
   I want to have a stable API
 
   Scenario: the demo example reports as expected
-    When I run reek spec/samples/demo
+    Given the smelly file 'demo.rb' from the example in the README
+    When I run reek demo.rb
     Then the exit status indicates smells
     And it reports:
       """
-      spec/samples/demo/demo.rb -- 8 warnings:
+      demo.rb -- 8 warnings:
         [1]:Dirty has no descriptive comment (IrresponsibleModule)
         [3]:Dirty#awful has 4 parameters (LongParameterList)
         [3]:Dirty#awful has boolean parameter 'log' (BooleanParameter)
+        [3]:Dirty#awful has the parameter name 'x' (UncommunicativeParameterName)
         [5]:Dirty#awful has the variable name 'w' (UncommunicativeVariableName)
         [3]:Dirty#awful has unused parameter 'log' (UnusedParameters)
         [3]:Dirty#awful has unused parameter 'offset' (UnusedParameters)
-        [3]:Dirty#awful has unused parameter 'x' (UnusedParameters)
         [3]:Dirty#awful has unused parameter 'y' (UnusedParameters)
       """

data/features/samples.feature

@@ -4,11 +4,12 @@ Feature: Basic smell detection
   I want to detect the smells in my Ruby code
 
   Scenario: Correct smells from inline.rb
-    When I run reek --no-line-numbers spec/samples/inline.rb
+    Given the "inline.rb" sample file exists
+    When I run reek --no-line-numbers inline.rb
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/inline.rb -- 44 warnings:
+    inline.rb -- 43 warnings:
       CompilationError has no descriptive comment (IrresponsibleModule)
       File has no descriptive comment (IrresponsibleModule)
       File#self.write_with_backup has approx 6 statements (TooManyStatements)
@@ -49,18 +50,18 @@ Feature: Basic smell detection
       Inline::C#parse_signature has the variable name 'x' (UncommunicativeVariableName)
       Inline::C#parse_signature is controlled by argument raw (ControlParameter)
       Inline::C#strip_comments doesn't depend on instance state (UtilityFunction)
-      Inline::C#strip_comments refers to src more than self (FeatureEnvy)
       Module#inline calls Inline.const_get(lang) 2 times (DuplicateMethodCall)
       Module#inline calls options[:testing] 2 times (DuplicateMethodCall)
       Module#inline has approx 12 statements (TooManyStatements)
     """
 
   Scenario: Correct smells from optparse.rb
-    When I run reek --no-line-numbers spec/samples/optparse.rb
+    Given the "optparse.rb" sample file exists
+    When I run reek --no-line-numbers optparse.rb
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/optparse.rb -- 111 warnings:
+    optparse.rb -- 111 warnings:
       OptionParser has at least 42 methods (TooManyMethods)
       OptionParser has the variable name 'f' (UncommunicativeVariableName)
       OptionParser has the variable name 'k' (UncommunicativeVariableName)
@@ -175,11 +176,12 @@ Feature: Basic smell detection
     """
 
   Scenario: Correct smells from redcloth.rb
-    When I run reek --no-line-numbers spec/samples/redcloth.rb
+    Given the "redcloth.rb" sample file exists
+    When I run reek --no-line-numbers redcloth.rb
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/redcloth.rb -- 98 warnings:
+    redcloth.rb -- 95 warnings:
       RedCloth has at least 44 methods (TooManyMethods)
       RedCloth has the variable name 'a' (UncommunicativeVariableName)
       RedCloth has the variable name 'b' (UncommunicativeVariableName)
@@ -191,7 +193,7 @@ Feature: Basic smell detection
       RedCloth#block_markdown_atx refers to text more than self (FeatureEnvy)
       RedCloth#block_markdown_bq has approx 6 statements (TooManyStatements)
       RedCloth#block_markdown_lists has unused parameter 'text' (UnusedParameters)
-      RedCloth#block_markdown_rule refers to text more than self (FeatureEnvy)
+      RedCloth#block_markdown_rule doesn't depend on instance state (UtilityFunction)
       RedCloth#block_markdown_setext refers to text more than self (FeatureEnvy)
       RedCloth#block_textile_lists calls depth.last 5 times (DuplicateMethodCall)
       RedCloth#block_textile_lists calls depth.last.length 2 times (DuplicateMethodCall)
@@ -218,18 +220,15 @@ Feature: Basic smell detection
       RedCloth#clean_html has approx 15 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 text more than self (FeatureEnvy)
-      RedCloth#footnote_ref refers to text more than self (FeatureEnvy)
+      RedCloth#footnote_ref doesn't depend on instance state (UtilityFunction)
       RedCloth#glyphs_textile has approx 10 statements (TooManyStatements)
+      RedCloth#h_align doesn't depend on instance state (UtilityFunction)
       RedCloth#htmlesc doesn't depend on instance state (UtilityFunction)
       RedCloth#htmlesc is controlled by argument mode (ControlParameter)
-      RedCloth#htmlesc refers to str more than self (FeatureEnvy)
-      RedCloth#incoming_entities refers to text more than self (FeatureEnvy)
+      RedCloth#incoming_entities doesn't depend on instance state (UtilityFunction)
       RedCloth#initialize has the variable name 'r' (UncommunicativeVariableName)
       RedCloth#inline contains iterators nested 2 deep (NestedIterators)
       RedCloth#inline_markdown_link has approx 6 statements (TooManyStatements)
@@ -246,11 +245,10 @@ Feature: Basic smell detection
       RedCloth#inline_textile_span contains iterators nested 2 deep (NestedIterators)
       RedCloth#inline_textile_span has approx 9 statements (TooManyStatements)
       RedCloth#inline_textile_span has the variable name 'm' (UncommunicativeVariableName)
+      RedCloth#lT doesn't depend on instance state (UtilityFunction)
       RedCloth#lT has the name 'lT' (UncommunicativeMethodName)
       RedCloth#lT is controlled by argument text (ControlParameter)
-      RedCloth#lT refers to text more than self (FeatureEnvy)
       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 2 times (DuplicateMethodCall)
       RedCloth#pba has approx 21 statements (TooManyStatements)
       RedCloth#pba is controlled by argument element (ControlParameter)
@@ -278,22 +276,25 @@ Feature: Basic smell detection
       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 26 statements (TooManyStatements)
+      RedCloth#v_align doesn't depend on instance state (UtilityFunction)
     """
 
   Scenario: Correct smells from a source file with Ruby 2.0 specific syntax
-    When I run reek spec/samples/ruby20_syntax.rb
+    Given the "ruby20_syntax.rb" sample file exists
+    When I run reek ruby20_syntax.rb
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/ruby20_syntax.rb -- 1 warning:
+    ruby20_syntax.rb -- 1 warning:
       [1]:SomeClass has no descriptive comment (IrresponsibleModule)
     """
 
   Scenario: Correct smells from a source file with Ruby 2.1 specific syntax
-    When I run reek spec/samples/ruby21_syntax.rb
+    Given the "ruby21_syntax.rb" sample file exists
+    When I run reek ruby21_syntax.rb
     Then the exit status indicates smells
     And it reports:
     """
-    spec/samples/ruby21_syntax.rb -- 1 warning:
+    ruby21_syntax.rb -- 1 warning:
       [1]:SomeClass has no descriptive comment (IrresponsibleModule)
     """

data/features/step_definitions/.rubocop.yml

@@ -0,0 +1,5 @@
+inherit_from: ../../.rubocop.yml
+
+# Allow common When <regexp> syntax
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false

data/features/step_definitions/reek_steps.rb

@@ -11,81 +11,69 @@ When /^I run rake (\w*) with:$/ do |name, task_def|
 end
 
 Then /^it reports nothing$/ do
-  expect(@last_stdout).to eq ''
+  assert_exact_output '', all_stdout
 end
 
 Then /^there is no output on stdout$/ do
-  expect(@last_stdout).to eq ''
+  assert_exact_output '', all_stdout
 end
 
 Then /^stdout includes "(.*)"$/ do |text|
-  expect(@last_stdout).to include text
+  assert_partial_output(text, all_stdout)
 end
 
 Then /^it succeeds$/ do
-  expect(@last_exit_status).to eq Reek::Cli::Application::STATUS_SUCCESS
+  assert_exit_status Reek::CLI::Application::STATUS_SUCCESS
 end
 
 Then /^the exit status indicates an error$/ do
-  expect(@last_exit_status).to eq Reek::Cli::Application::STATUS_ERROR
+  assert_exit_status Reek::CLI::Application::STATUS_ERROR
 end
 
 Then /^the exit status indicates smells$/ do
-  expect(@last_exit_status).to eq Reek::Cli::Application::STATUS_SMELLS
+  assert_exit_status Reek::CLI::Application::STATUS_SMELLS
 end
 
 Then /^it reports:$/ do |report|
-  expect(@last_stdout).to eq "#{report}\n"
+  assert_exact_output "#{report}\n", all_stdout
 end
 
 Then /^it reports this yaml:$/ do |expected_yaml|
   expected_warnings = YAML.load(expected_yaml.chomp)
-  actual_warnings = YAML.load(@last_stdout)
+  actual_warnings = YAML.load(all_stdout)
   expect(actual_warnings).to eq expected_warnings
 end
 
 Then /^it reports this JSON:$/ do |expected_json|
   expected_warnings = JSON.parse(expected_json.chomp)
-  actual_warnings = JSON.parse(@last_stdout)
+  actual_warnings = JSON.parse(all_stdout)
   expect(actual_warnings).to eq expected_warnings
 end
 
 Then /^stderr reports:$/ do |report|
-  expect(@last_stderr).to eq report
+  assert_exact_output report, all_stderr
 end
 
 Then /^it reports no errors$/ do
-  expect(@last_stderr.chomp).to eq ''
+  assert_exact_output '', all_stderr
 end
 
 Then /^it reports an error$/ do
-  expect(@last_stderr.chomp).to_not be_empty
+  expect(all_stderr).to_not be_empty
 end
 
 Then /^it reports the error ['"](.*)['"]$/ do |string|
-  expect(@last_stderr.chomp).to eq string
+  assert_partial_output string, all_stderr
 end
 
 Then /^it reports a parsing error$/ do
-  expect(@last_stderr.chomp).to match(/Parser::SyntaxError/)
+  assert_partial_output 'Parser::SyntaxError', all_stderr
 end
 
 Then /^it should indicate the line numbers of those smells$/ do
-  expect(@last_stdout.chomp).to match(/\[.*\]:/)
+  assert_matching_output /\[.*\]:/, all_stdout
 end
 
 Then /^it reports the current version$/ do
-  expect(@last_stdout).to eq "reek #{Reek::Version::STRING}\n"
-end
-
-Given(/^"(.*?)" exists in the working directory$/) do |path|
-  FileUtils.cp path, Pathname.pwd
-end
-
-Given(/^"(.*?)" exists in the parent directory of the working directory$/) do |path|
-  FileUtils.cp path, Pathname.pwd.parent
-end
-
-Given(/^"(.*?)" exists in the HOME directory$/) do |path|
-  FileUtils.cp path, Pathname.new(Dir.home)
+  assert_exact_output "reek #{Reek::Version::STRING}\n", all_stdout
 end

data/features/step_definitions/sample_file_steps.rb

@@ -0,0 +1,158 @@
+Given(/^the smelly file 'demo.rb' from the example in the README$/) do
+  contents = <<-EOS.strip_heredoc
+    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 * x}}
+        puts @screen.contents
+      end
+    end
+  EOS
+  write_file('demo.rb', contents)
+end
+
+Given(/^a smelly file with inline masking called 'inline.rb'$/) do
+  write_file 'inline.rb', <<-EOS.strip_heredoc
+    # smells of :reek:NestedIterators but ignores them
+    class Dirty
+      def a
+        puts @s.title
+        @s = foo.map {|x| x.each {|key| key += 3}}
+        puts @s.title
+      end
+    end
+  EOS
+end
+
+Given(/^the "(.*?)" sample file exists$/) do |file_name|
+  full_path = File.expand_path file_name, 'spec/samples'
+  in_current_dir { FileUtils.cp full_path, file_name }
+end
+
+Given(/^a directory called 'clean_files' containing some clean files$/) do
+  contents = <<-EOS.strip_heredoc
+    # clean class for testing purposes
+    class Clean
+      def assign
+        puts @sub.title
+        @sub.map {|para| para.name }
+      end
+    end
+  EOS
+  write_file 'clean_files/clean_one.rb', contents
+  write_file 'clean_files/clean_two.rb', contents
+  write_file 'clean_files/clean_three.rb', contents
+end
+
+Given(/^a directory called 'smelly' containing two smelly files$/) do
+  write_file('smelly/dirty_one.rb', <<-EOS.strip_heredoc)
+    class Dirty
+      def a; end
+    end
+  EOS
+  write_file('smelly/dirty_two.rb', <<-EOS.strip_heredoc)
+    class Dirty
+      def a; end
+      def b; end
+    end
+  EOS
+end
+
+Given(/^a smelly file called 'smelly.rb'( in a subdirectory)?$/) do |in_subdir|
+  file_name = in_subdir ? 'subdir/smelly.rb' : 'smelly.rb'
+  write_file file_name, <<-EOS.strip_heredoc
+    # smelly class for testing purposes
+    class Smelly
+      def m
+        puts @foo.bar
+        puts @foo.bar
+      end
+    end
+  EOS
+end
+
+Given(/^a file with smelly variable names called 'camel_case.rb'$/) do
+  write_file('camel_case.rb', <<-EOS.strip_heredoc)
+    # Class containing camelCase variable which would normally smell
+    class CamelCase
+      def initialize
+        # These next two would normally smell if it weren't for overridden config values
+        camelCaseVariable = []
+        anotherOne = 1
+
+        # this next one should still smell
+        x1 = 0
+
+        # this next one should not smell
+        should_not_smell = true
+      end
+    end
+  EOS
+end
+
+Given(/^an empty configuration file called 'empty.reek'$/) do
+  write_file('empty.reek', '')
+end
+
+Given(/^a corrupt configuration file called 'corrupt.reek'$/) do
+  write_file('corrupt.reek', 'This is not a configuration file')
+end
+
+Given(/^a masking configuration file called 'config.reek'$/) do
+  write_file('config.reek', <<-EOS.strip_heredoc)
+    ---
+    DuplicateMethodCall:
+      enabled: false
+    UncommunicativeMethodName:
+      enabled: false
+  EOS
+end
+
+Given(/^a configuration file masking some duplication smells called 'config.reek'$/) do
+  write_file('config.reek', <<-EOS.strip_heredoc)
+    ---
+    DuplicateMethodCall:
+      allow_calls:
+        - puts\\(@foo.bar\\)
+  EOS
+end
+
+Given(/^a configuration file allowing camel case variables$/) do
+  write_file('config.reek', <<-EOS.strip_heredoc)
+    ---
+    UncommunicativeVariableName:
+      enabled: true
+      reject:
+      - !ruby/regexp /^.$/
+      - !ruby/regexp /[0-9]$/
+  EOS
+end
+
+When(/^I run "reek (.*?)" in the subdirectory$/) do |args|
+  cd 'subdir'
+  reek(args)
+end
+
+Given(/^a masking configuration file in the HOME directory$/) do
+  set_env('HOME', File.expand_path(File.join(current_dir, 'home')))
+  write_file('home/config.reek', <<-EOS.strip_heredoc)
+    ---
+    DuplicateMethodCall:
+      enabled: false
+    UncommunicativeMethodName:
+      enabled: false
+  EOS
+end
+
+Given(/^an enabling configuration file in the subdirectory$/) do
+  write_file('subdir/config.reek', <<-EOS.strip_heredoc)
+    ---
+    IrresponsibleModule:
+      enabled: true
+    UncommunicativeModuleName:
+      enabled: true
+    UncommunicativeMethodName:
+      enabled: true
+  EOS
+end