reek 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8492565566dc33ddd04e6474399de644c050c31
-  data.tar.gz: 40d22b046c4c8a9be279dae6aacd3859d7534d46
+  metadata.gz: 846eb328f05e66b28b63cb9103b710d75a61a98b
+  data.tar.gz: f870a86b912aca22b1720902098afeb575de4a03
 SHA512:
-  metadata.gz: e929fb9f9a89fddb7383ed8fd606b22f31977ed43360160a3359cb325b7a56adbd4801ba7ded8993f90aae42f7369cda18be10b1ff2d44ed9181a2711affea84
-  data.tar.gz: ece84cae1ab3d23b457f7f31f6ce47ba48ea65683a82291645803020b418609137fbe5eae6185d1e706ae840a3cbc87a27de4d6abbbef624177cfc13373947e2
+  metadata.gz: b2ee82efb561b2270381528407b1488b695c24f954e78688999df29b3dc17246faa473b523454a7a1c0e65e8aea4201270786a3df2e251ef57f2760ea924228e
+  data.tar.gz: a80ad9e5f23f1e5db3d5e8df22d55e8cf17656a028582ce25af3d2c00c9bde74002a13f97724ef09c7ea12205e3b0ab0c3ee9a2612aad8fb346ef12f2d4c918f

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 3.4.1 (2015-09-24)
+
+* (chastell) Fix parsing `Foo = bar.new(new)`
+* (chastell) Sort line numbers in reports of multi-line smells
+* (chastell) Fix parsing bare `attr`
+* (troessner) Fix `reek_of` not checking `smell_details`
+* (chastell) Fix parsing `Foo = new`
+* (chastell) Fix parsing `Foo = Class.new do … end.new`
+
 ## 3.4.0 (2015-09-16)
 
 * (troessner) Make UtilityFunction configurable for non-public methods

data/features/step_definitions/reek_steps.rb

@@ -11,69 +11,72 @@ When /^I run rake (\w*) with:$/ do |name, task_def|
 end
 
 Then /^it reports nothing$/ do
-  assert_exact_output '', all_stdout
+  expect(last_command_started).to have_output_on_stdout('')
 end
 
 Then /^there is no output on stdout$/ do
-  assert_exact_output '', all_stdout
+  expect(last_command_started).to have_output_on_stdout('')
 end
 
 Then /^stdout includes "(.*)"$/ do |text|
-  assert_partial_output(text, all_stdout)
+  expect(last_command_started).to have_output_on_stdout(/#{Regexp.escape(text)}/)
 end
 
 Then /^it succeeds$/ do
-  assert_exit_status Reek::CLI::Application::STATUS_SUCCESS
+  success = Reek::CLI::Application::STATUS_SUCCESS
+  expect(last_command_started).to have_exit_status(success)
 end
 
 Then /^the exit status indicates an error$/ do
-  assert_exit_status Reek::CLI::Application::STATUS_ERROR
+  error = Reek::CLI::Application::STATUS_ERROR
+  expect(last_command_started).to have_exit_status(error)
 end
 
 Then /^the exit status indicates smells$/ do
-  assert_exit_status Reek::CLI::Application::STATUS_SMELLS
+  smells = Reek::CLI::Application::STATUS_SMELLS
+  expect(last_command_started).to have_exit_status(smells)
 end
 
 Then /^it reports:$/ do |report|
-  assert_exact_output "#{report}\n", all_stdout
+  expect(last_command_started).to have_output_on_stdout(report.gsub('\n', "\n"))
 end
 
 Then /^it reports this yaml:$/ do |expected_yaml|
   expected_warnings = YAML.load(expected_yaml.chomp)
-  actual_warnings = YAML.load(all_stdout)
+  actual_warnings = YAML.load(last_command_started.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(all_stdout)
+  actual_warnings = JSON.parse(last_command_started.stdout)
   expect(actual_warnings).to eq expected_warnings
 end
 
 Then /^stderr reports:$/ do |report|
-  assert_exact_output report, all_stderr
+  expect(last_command_started).to have_output_on_stderr(report.chomp)
 end
 
 Then /^it reports no errors$/ do
-  assert_exact_output '', all_stderr
+  expect(last_command_started).to have_output_on_stderr('')
 end
 
 Then /^it reports an error$/ do
-  expect(all_stderr).to_not be_empty
+  expect(last_command_started.stderr).to_not be_empty
 end
 
 Then /^it reports the error ['"](.*)['"]$/ do |string|
-  assert_partial_output string, all_stderr
+  expect(last_command_started).to have_output_on_stderr(/#{Regexp.escape(string)}/)
 end
 
 Then /^it reports a parsing error$/ do
-  assert_partial_output 'Parser::SyntaxError', all_stderr
+  expect(last_command_started).to have_output_on_stderr(/Parser::SyntaxError/)
 end
 
 Then /^it should indicate the line numbers of those smells$/ do
-  assert_matching_output /\[.*\]:/, all_stdout
+  expect(last_command_started).to have_output(/\[.*\]:/)
 end
 
 Then /^it reports the current version$/ do
-  assert_exact_output "reek #{Reek::Version::STRING}\n", all_stdout
+  expect(last_command_started).to have_output("reek #{Reek::Version::STRING}")
 end

data/lib/reek/ast/sexp_extensions.rb

@@ -180,6 +180,14 @@ module Reek
           args.map { |arg| arg[1] }
         end
 
+        def module_creation_call?
+          object_creation_call? && module_creation_receiver?
+        end
+
+        def module_creation_receiver?
+          receiver && [:Class, :Struct].include?(receiver.simple_name)
+        end
+
         def object_creation_call?
           method_name == :new
         end
@@ -196,7 +204,7 @@ module Reek
         # Handles the case where we create an attribute writer via:
         # attr :foo, true
         def attr_with_writable_flag?
-          method_name == :attr && args.last.type == :true
+          method_name == :attr && args.any? && args.last.type == :true
         end
 
         VISIBILITY_MODIFIERS = [:private, :public, :protected, :module_function]
@@ -231,8 +239,9 @@ module Reek
       # Utility methods for :lvar nodes.
       module LvarNode
         include VariableBase
-        # TODO: Replace with name().
-        def var_name() self[1] end
+
+        alias_method :simple_name, :name
+        alias_method :var_name,    :name
       end
 
       LvasgnNode = LvarNode
@@ -353,6 +362,10 @@ module Reek
         def parameter_names
           parameters[1..-1].to_a
         end
+
+        def simple_name
+          :block
+        end
       end
 
       # Utility methods for :lit nodes.
@@ -419,8 +432,6 @@ module Reek
       module CasgnNode
         include ModuleNodeBase
 
-        MODULE_DEFINERS = [:Class, :Struct]
-
         def defines_module?
           return false unless value
           call = case value.type
@@ -429,9 +440,7 @@ module Reek
                  when :send
                    value
                  end
-          call &&
-            call.object_creation_call? &&
-            MODULE_DEFINERS.include?(call.receiver.simple_name)
+          call && call.module_creation_call?
         end
 
         def name

data/lib/reek/cli/application.rb

@@ -1,5 +1,6 @@
 require_relative 'options'
 require_relative 'reek_command'
+require_relative 'option_interpreter'
 require_relative '../configuration/app_configuration'
 
 module Reek
@@ -15,17 +16,14 @@ module Reek
       STATUS_SMELLS  = 2
       attr_reader :configuration
 
+      private_attr_accessor :status
+      private_attr_reader :command, :options
+
       def initialize(argv)
         @status = STATUS_SUCCESS
-        options_parser = Options.new(argv)
-        begin
-          options = options_parser.parse
-          @command = ReekCommand.new(OptionInterpreter.new(options))
-          @configuration = Configuration::AppConfiguration.from_path(options.config_file)
-        rescue OptionParser::InvalidOption, Reek::Configuration::ConfigFileException => error
-          $stderr.puts "Error: #{error}"
-          @status = STATUS_ERROR
-        end
+        @options = configure_options(argv)
+        @configuration = configure_app_configuration(options.config_file)
+        @command = ReekCommand.new(OptionInterpreter.new(options))
       end
 
       def execute
@@ -48,12 +46,23 @@ module Reek
 
       private
 
-      private_attr_accessor :status
-      private_attr_reader :command
-
       def error_occured?
         status == STATUS_ERROR
       end
+
+      def configure_options(argv)
+        Options.new(argv).parse
+      rescue OptionParser::InvalidOption => error
+        $stderr.puts "Error: #{error}"
+        exit STATUS_ERROR
+      end
+
+      def configure_app_configuration(config_file)
+        Configuration::AppConfiguration.from_path(config_file)
+      rescue Reek::Configuration::ConfigFileException => error
+        $stderr.puts "Error: #{error}"
+        exit STATUS_ERROR
+      end
     end
   end
 end

data/lib/reek/cli/option_interpreter.rb

@@ -9,10 +9,9 @@ module Reek
     #
     class OptionInterpreter
       include Input
-
       extend Forwardable
-
       def_delegators :options, :smells_to_detect
+      private_attr_reader :argv, :options
 
       def initialize(options)
         @options = options
@@ -51,10 +50,6 @@ module Reek
       def sort_by_issue_count
         options.sorting == :smelliness
       end
-
-      private
-
-      private_attr_reader :argv, :options
     end
   end
 end

data/lib/reek/cli/options.rb

@@ -1,7 +1,5 @@
 require 'optparse'
-require 'ostruct'
 require 'rainbow'
-require_relative 'option_interpreter'
 require_relative '../version'
 
 module Reek
@@ -10,28 +8,40 @@ module Reek
     # Parses the command line
     #
     # See {file:docs/Command-Line-Options.md} for details.
+    #
+    # :reek:TooManyInstanceVariables: { max_instance_variables: 6 }
+    # :reek:Attribute: { enabled: false }
     class Options
+      attr_accessor :argv,
+                    :colored,
+                    :config_file,
+                    :location_format,
+                    :parser,
+                    :report_format,
+                    :show_empty,
+                    :show_links,
+                    :smells_to_detect,
+                    :sorting
+
       def initialize(argv = [])
-        @argv    = argv
-        @parser  = OptionParser.new
-        @options = OpenStruct.new(report_format: :text,
-                                  location_format: :numbers,
-                                  colored: color_support?,
-                                  smells_to_detect: [])
+        @argv             = argv
+        @parser           = OptionParser.new
+        @report_format    = :text
+        @location_format  = :numbers
+        @smells_to_detect = []
+        @colored          = color_support?
+
         set_up_parser
       end
 
       def parse
         parser.parse!(argv)
-        options.argv = argv
-        Rainbow.enabled = options.colored
-        options
+        Rainbow.enabled = colored
+        self
       end
 
       private
 
-      private_attr_reader :argv, :options, :parser
-
       # :reek:UtilityFunction
       def color_support?
         $stdout.tty?
@@ -68,7 +78,7 @@ module Reek
           'Report smells in the given format:',
           '  html', '  text (default)', '  yaml', '  json', '  xml'
         ) do |opt|
-          options.report_format = opt
+          self.report_format = opt
         end
       end
 
@@ -77,10 +87,10 @@ module Reek
         parser.separator 'Configuration:'
         parser.on('-c', '--config FILE', 'Read configuration options from FILE') do |file|
           raise ArgumentError, "Config file #{file} doesn't exist" unless File.exist?(file)
-          options.config_file = Pathname.new(file)
+          self.config_file = Pathname.new(file)
         end
         parser.on('--smell SMELL', 'Detect smell SMELL (default: all enabled smells)') do |smell|
-          options.smells_to_detect << smell
+          smells_to_detect << smell
         end
       end
 
@@ -94,29 +104,29 @@ module Reek
 
       def set_up_color_option
         parser.on('--[no-]color', 'Use colors for the output (default: true)') do |opt|
-          options.colored = opt
+          self.colored = opt
         end
       end
 
       def set_up_verbosity_options
         parser.on('-V', '--[no-]empty-headings',
                   'Show headings for smell-free source files (default: false)') do |show_empty|
-          options.show_empty = show_empty
+          self.show_empty = show_empty
         end
         parser.on('-U', '--[no-]wiki-links',
                   'Show link to related wiki page for each smell (default: false)') do |show_links|
-          options.show_links = show_links
+          self.show_links = show_links
         end
       end
 
       def set_up_location_formatting_options
         parser.on('-n', '--[no-]line-numbers',
                   'Show line numbers in the output (default: true)') do |show_numbers|
-          options.location_format = show_numbers ? :numbers : :plain
+          self.location_format = show_numbers ? :numbers : :plain
         end
         parser.on('-s', '--single-line',
                   'Show location in editor-compatible single-line-per-smell format') do
-          options.location_format = :single_line
+          self.location_format = :single_line
         end
       end
 
@@ -125,7 +135,7 @@ module Reek
                   'Sort reported files by the given criterium:',
                   '  smelliness ("smelliest" files first)',
                   '  none (default - output in processing order)') do |sorting|
-          options.sorting = sorting
+          self.sorting = sorting
         end
       end
 

data/lib/reek/report/location_formatter.rb

@@ -4,7 +4,9 @@ module Reek
     # Formats the location of a warning as an empty string.
     #
     module BlankLocationFormatter
-      def self.format(_warning)
+      module_function
+
+      def format(_warning)
         ''
       end
     end
@@ -13,8 +15,10 @@ module Reek
     # Formats the location of a warning as an array of line numbers.
     #
     module DefaultLocationFormatter
-      def self.format(warning)
-        "#{warning.lines.inspect}:"
+      module_function
+
+      def format(warning)
+        "#{warning.lines.sort.inspect}:"
       end
     end
 
@@ -24,8 +28,10 @@ module Reek
     # one line number, so the first number is displayed.
     #
     module SingleLineLocationFormatter
-      def self.format(warning)
-        "#{warning.source}:#{warning.lines.first}: "
+      module_function
+
+      def format(warning)
+        "#{warning.source}:#{warning.lines.sort.first}: "
       end
     end
   end

data/lib/reek/smells/smell_warning.rb

@@ -49,8 +49,16 @@ module Reek
         (self <=> other) == 0
       end
 
-      def matches?(klass, other_parameters = {})
-        smell_classes.include?(klass.to_s) && common_parameters_equal?(other_parameters)
+      def matches_smell_type?(klass)
+        smell_classes.include?(klass.to_s)
+      end
+
+      def matches_smell_details?(other_smell_details = {})
+        common_parameters_equal?(other_smell_details)
+      end
+
+      def matches?(klass, other_smell_details = {})
+        matches_smell_type?(klass) && matches_smell_details?(other_smell_details)
       end
 
       def report_on(listener)

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -18,16 +18,10 @@ module Reek
     #
     # See {file:docs/Uncommunicative-Method-Name.md} for details.
     class UncommunicativeMethodName < SmellDetector
-      # The name of the config field that lists the regexps of
-      # smelly names to be reported.
       REJECT_KEY = 'reject'
-      DEFAULT_REJECT_SET = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]
-
-      # The name of the config field that lists the specific names that are
-      # to be treated as exceptions; these names will not be reported as
-      # uncommunicative.
       ACCEPT_KEY = 'accept'
-      DEFAULT_ACCEPT_SET = []
+      DEFAULT_REJECT_PATTERNS = [/^[a-z]$/, /[0-9]$/, /[A-Z]/]
+      DEFAULT_ACCEPT_NAMES = []
 
       def self.smell_category
         'UncommunicativeName'
@@ -35,8 +29,8 @@ module Reek
 
       def self.default_config
         super.merge(
-          REJECT_KEY => DEFAULT_REJECT_SET,
-          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+          REJECT_KEY => DEFAULT_REJECT_PATTERNS,
+          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
         )
       end
 
@@ -45,21 +39,31 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:TooManyStatements: { max_statements: 9 }
-      def examine_context(ctx)
-        reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
-        accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
-        name = ctx.name.to_s
-        return [] if accept_names.include?(ctx.full_name)
-        var = name.gsub(/^[@\*\&]*/, '')
-        return [] if accept_names.include?(var)
-        return [] unless reject_names.find { |patt| patt =~ var }
+      def examine_context(context)
+        name = context.name.to_s
+        return [] if acceptable_name?(name: name, context: context)
+
         [smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
+          context: context,
+          lines: [context.exp.line],
           message: "has the name '#{name}'",
           parameters: { name: name })]
       end
+
+      private
+
+      def acceptable_name?(name: raise, context: raise)
+        accept_names(context).any? { |accept_name| name == accept_name } ||
+          reject_patterns(context).none? { |pattern| name.match pattern }
+      end
+
+      def reject_patterns(context)
+        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+      end
+
+      def accept_names(context)
+        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
+      end
     end
   end
 end