reek 4.0.1 → 4.0.2

data/lib/reek/cli/command/base_command.rb

@@ -6,14 +6,15 @@ module Reek
       # Base class for all commands
       #
       class BaseCommand
-        def initialize(options, sources:)
+        def initialize(options:, sources:, configuration:)
           @options = options
           @sources = sources
+          @configuration = configuration
         end
 
         private
 
-        attr_reader :options, :sources
+        attr_reader :options, :sources, :configuration
 
         def smell_names
           @smell_names ||= options.smells_to_detect

data/lib/reek/cli/command/report_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require_relative 'base_command'
 require_relative '../../examiner'
+require_relative '../../report'
 
 module Reek
   module CLI
@@ -10,19 +11,19 @@ module Reek
       # text report format.
       #
       class ReportCommand < BaseCommand
-        def execute(app)
-          populate_reporter_with_smells app
+        def execute
+          populate_reporter_with_smells
           reporter.show
           result_code
         end
 
         private
 
-        def populate_reporter_with_smells(app)
+        def populate_reporter_with_smells
           sources.each do |source|
             reporter.add_examiner Examiner.new(source,
                                                filter_by_smells: smell_names,
-                                               configuration: app.configuration)
+                                               configuration: configuration)
           end
         end
 
@@ -31,7 +32,36 @@ module Reek
         end
 
         def reporter
-          @reporter ||= options.reporter
+          @reporter ||=
+            report_class.new(
+              warning_formatter: warning_formatter,
+              report_formatter: Report::Formatter,
+              sort_by_issue_count: sort_by_issue_count,
+              heading_formatter: heading_formatter)
+        end
+
+        def report_class
+          Report.report_class(options.report_format)
+        end
+
+        def warning_formatter
+          warning_formatter_class.new(location_formatter: location_formatter)
+        end
+
+        def warning_formatter_class
+          Report.warning_formatter_class(options.show_links ? :wiki_links : :simple)
+        end
+
+        def location_formatter
+          Report.location_formatter(options.location_format)
+        end
+
+        def heading_formatter
+          Report.heading_formatter(options.show_empty ? :verbose : :quiet)
+        end
+
+        def sort_by_issue_count
+          options.sorting == :smelliness
         end
       end
     end

data/lib/reek/cli/command/todo_list_command.rb

@@ -12,8 +12,8 @@ module Reek
       class TodoListCommand < BaseCommand
         FILE_NAME = '.todo.reek'.freeze
 
-        def execute(app)
-          smells = scan_for_smells(app)
+        def execute
+          smells = scan_for_smells
           if smells.empty?
             puts "\n'.todo.reek' not generated because "\
                     'there were no smells found!'
@@ -27,11 +27,11 @@ module Reek
 
         private
 
-        def scan_for_smells(app)
+        def scan_for_smells
           sources.map do |source|
             Examiner.new(source,
                          filter_by_smells: smell_names,
-                         configuration: app.configuration)
+                         configuration: configuration)
           end.map(&:smells).flatten
         end
 

data/lib/reek/configuration/app_configuration.rb

@@ -70,6 +70,19 @@ module Reek
         excluded_paths.include?(path)
       end
 
+      def load_values(configuration_hash)
+        configuration_hash.each do |key, value|
+          case
+          when key == EXCLUDE_PATHS_KEY
+            excluded_paths.add value
+          when smell_type?(key)
+            default_directive.add key, value
+          else
+            directory_directives.add key, value
+          end
+        end
+      end
+
       private
 
       attr_writer :directory_directives, :default_directive, :excluded_paths
@@ -87,22 +100,9 @@ module Reek
       end
 
       def find_and_load(path: nil)
-        configuration_file = ConfigurationFileFinder.find_and_load(path: path)
+        configuration_hash = ConfigurationFileFinder.find_and_load(path: path)
 
-        load_values(configuration_file)
-      end
-
-      def load_values(configuration_file)
-        configuration_file.each do |key, value|
-          case
-          when key == EXCLUDE_PATHS_KEY
-            excluded_paths.add value
-          when smell_type?(key)
-            default_directive.add key, value
-          else
-            directory_directives.add key, value
-          end
-        end
+        load_values(configuration_hash)
       end
     end
   end

data/lib/reek/configuration/default_directive.rb

@@ -8,7 +8,8 @@ module Reek
       include ConfigurationValidator
 
       def add(key, config)
-        self[key_to_smell_detector(key)] = config
+        detector = key_to_smell_detector(key)
+        self[detector] = (self[detector] || {}).merge config
       end
     end
   end

data/lib/reek/context/code_context.rb

@@ -24,7 +24,7 @@ module Reek
 
       # Initializes a new CodeContext.
       #
-      # @param parent [CodeContext, nil] The parent context
+      # @param _parent [CodeContext, nil] The parent context
       # @param exp [Reek::AST::Node] The code described by this context
       #
       # For example, given the following code:

data/lib/reek/context/module_context.rb

@@ -45,16 +45,15 @@ module Reek
       end
 
       def defined_instance_methods(visibility: :public)
-        each.select do |context|
-          context.is_a?(Context::MethodContext) &&
-            context.visibility == visibility
+        instance_method_children.select do |context|
+          context.visibility == visibility
         end
       end
 
       def instance_method_calls
-        each.
-          grep(SendContext).
-          select { |context| context.parent.class == MethodContext }
+        instance_method_children.flat_map do |context|
+          context.children.grep(SendContext)
+        end
       end
 
       #

data/lib/reek/spec.rb

@@ -16,9 +16,9 @@ module Reek
   # Here's a spec that ensures there are no active code smells in the current project:
   #
   #  describe 'source code quality' do
-  #    Dir['lib/**/*.rb'].each do |path|
+  #    Pathname.glob('lib/**/*.rb').each do |path|
   #      it "reports no smells in #{path}" do
-  #        File.new(path).should_not reek
+  #        expect(path).not_to reek
   #      end
   #    end
   #  end
@@ -26,7 +26,9 @@ module Reek
   # And here's an even simpler way to do the same:
   #
   #  it 'has no code smells' do
-  #    Dir['lib/**/*.rb'].should_not reek
+  #    Pathname.glob('lib/**/*.rb').each do |path|
+  #      expect(path).not_to reek
+  #    end
   #  end
   #
   # Here's a simple check of a code fragment:
@@ -63,7 +65,7 @@ module Reek
     # much sense.
     #
     # @param smell_type [Symbol, String, Class] The "smell type" to check for.
-    # @param smells_details [Hash] A hash containing "smell warning" parameters
+    # @param smell_details [Hash] A hash containing "smell warning" parameters
     #
     # @example Without smell_details
     #

data/lib/reek/spec/should_reek_of.rb

@@ -15,14 +15,22 @@ module Reek
                      smell_details = {},
                      configuration = Configuration::AppConfiguration.default)
         @smell_type = normalize smell_type_or_class
-        @smell_details  = smell_details
-        @configuration  = configuration
+        @smell_details = smell_details
+        @configuration = configuration
+        @configuration.load_values(smell_type => { Smells::SmellConfiguration::ENABLED_KEY => true })
       end
 
       def matches?(source)
+        @matching_smell_types = nil
         self.examiner = Examiner.new(source, configuration: configuration)
         set_failure_messages
-        matching_smell_types? && matching_smell_details?
+        matching_smell_details?
+      end
+
+      def with_config(config_hash)
+        new_configuration = Configuration::AppConfiguration.default
+        new_configuration.load_values(smell_type => config_hash)
+        self.class.new(smell_type, smell_details, new_configuration)
       end
 
       private

data/lib/reek/version.rb

@@ -7,6 +7,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '4.0.1'.freeze
+    STRING = '4.0.2'.freeze
   end
 end

data/spec/factories/factories.rb

@@ -1,7 +1,6 @@
 require_relative '../../lib/reek/smells'
 require_relative '../../lib/reek/smells/smell_detector'
 require_relative '../../lib/reek/smells/smell_warning'
-require_relative '../../lib/reek/cli/option_interpreter'
 require_relative '../../lib/reek/cli/options'
 
 FactoryGirl.define do
@@ -53,14 +52,4 @@ FactoryGirl.define do
           parameters: parameters)
     end
   end
-
-  factory :options_interpreter_with_empty_sources, class: Reek::CLI::OptionInterpreter do
-    transient do
-      options { Reek::CLI::Options.new [] }
-    end
-
-    initialize_with do
-      Reek::CLI::OptionInterpreter.new(options)
-    end
-  end
 end

data/spec/reek/cli/application_spec.rb

@@ -15,18 +15,92 @@ RSpec.describe Reek::CLI::Application do
     end
   end
 
-  context 'report_command' do
-    describe '#execute' do
-      let(:command) { double 'reek_command' }
-      let(:app) { Reek::CLI::Application.new [] }
+  let(:path_excluded_in_configuration) do
+    SAMPLES_PATH.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb')
+  end
+
+  let(:configuration) { test_configuration_for(SAMPLES_PATH.join('configuration/with_excluded_paths.reek')) }
+
+  describe '#execute' do
+    let(:command) { double 'reek_command' }
+    let(:app) { Reek::CLI::Application.new [] }
+
+    before do
+      allow(Reek::CLI::Command::ReportCommand).to receive(:new).and_return command
+      allow(command).to receive(:execute).and_return 'foo'
+    end
+
+    it "returns the command's result code" do
+      expect(app.execute).to eq 'foo'
+    end
 
-      before do
-        allow(Reek::CLI::Command::ReportCommand).to receive(:new).and_return command
+    context 'when no source files given' do
+      context 'and input was piped' do
+        before do
+          allow_any_instance_of(IO).to receive(:tty?).and_return(false)
+        end
+
+        it 'should use source form pipe' do
+          app.execute
+          expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
+            with(sources: [$stdin],
+                 configuration: Reek::Configuration::AppConfiguration,
+                 options: Reek::CLI::Options)
+        end
       end
 
-      it "returns the command's result code" do
-        allow(command).to receive(:execute).and_return 'foo'
-        expect(app.execute).to eq 'foo'
+      context 'and input was not piped' do
+        before do
+          allow_any_instance_of(IO).to receive(:tty?).and_return(true)
+        end
+
+        it 'should use working directory as source' do
+          expected_sources = Reek::Source::SourceLocator.new(['.']).sources
+          app.execute
+          expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
+            with(sources: expected_sources,
+                 configuration: Reek::Configuration::AppConfiguration,
+                 options: Reek::CLI::Options)
+        end
+      end
+
+      context 'when source files are excluded through configuration' do
+        let(:app) { Reek::CLI::Application.new ['--config', 'some_file.reek'] }
+
+        before do
+          allow(File).to receive(:exist?).and_call_original
+          allow(File).to receive(:exist?).with('some_file.reek').and_return true
+          allow(Reek::Configuration::AppConfiguration).
+            to receive(:from_path).
+            with(Pathname.new('some_file.reek')).
+            and_return configuration
+        end
+
+        it 'should use configuration for excluded paths' do
+          expected_sources = Reek::Source::SourceLocator.
+            new(['.'], configuration: configuration).sources
+          expect(expected_sources).not_to include(path_excluded_in_configuration)
+
+          app.execute
+
+          expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
+            with(sources: expected_sources,
+                 configuration: configuration,
+                 options: Reek::CLI::Options)
+        end
+      end
+    end
+
+    context 'when source files given' do
+      let(:app) { Reek::CLI::Application.new ['.'] }
+
+      it 'should use sources from argv' do
+        expected_sources = Reek::Source::SourceLocator.new(['.']).sources
+        app.execute
+        expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
+          with(sources: expected_sources,
+               configuration: Reek::Configuration::AppConfiguration,
+               options: Reek::CLI::Options)
       end
     end
   end

data/spec/reek/cli/command/report_command_spec.rb

@@ -1,41 +1,44 @@
 require_relative '../../../spec_helper'
 require_lib 'reek/cli/command/report_command'
 require_lib 'reek/cli/options'
-require_lib 'reek/cli/option_interpreter'
 
 RSpec.describe Reek::CLI::Command::ReportCommand do
   describe '#execute' do
     let(:options) { Reek::CLI::Options.new [] }
-    let(:option_interpreter) { Reek::CLI::OptionInterpreter.new(options) }
 
     let(:reporter) { double 'reporter' }
-    let(:app) { double 'app' }
+    let(:configuration) { double 'configuration' }
+    let(:sources) { [source_file] }
 
-    let(:command) { described_class.new(option_interpreter, sources: []) }
+    let(:clean_file) { Pathname.glob("#{SAMPLES_PATH}/three_clean_files/*.rb").first }
+    let(:smelly_file) { Pathname.glob("#{SAMPLES_PATH}/two_smelly_files/*.rb").first }
+
+    let(:command) do
+      described_class.new(options: options,
+                          sources: sources,
+                          configuration: configuration)
+    end
 
     before do
-      allow(option_interpreter).to receive(:reporter).and_return reporter
-      allow(reporter).to receive(:show)
+      allow(configuration).to receive(:directive_for).and_return({})
     end
 
     context 'when no smells are found' do
-      before do
-        allow(reporter).to receive(:smells?).and_return false
-      end
+      let(:source_file) { clean_file }
 
       it 'returns a success code' do
-        result = command.execute app
+        result = command.execute
         expect(result).to eq Reek::CLI::Options::DEFAULT_SUCCESS_EXIT_CODE
       end
     end
 
     context 'when smells are found' do
-      before do
-        allow(reporter).to receive(:smells?).and_return true
-      end
+      let(:source_file) { smelly_file }
 
       it 'returns a failure code' do
-        result = command.execute app
+        result = Reek::CLI::Silencer.silently do
+          command.execute
+        end
         expect(result).to eq Reek::CLI::Options::DEFAULT_FAILURE_EXIT_CODE
       end
     end