reek 3.0.4 → 3.1

data/lib/reek/spec.rb

@@ -85,8 +85,10 @@ module Reek
     #
     #   expect(src).to reek_of(Reek::Smells::DuplicateMethodCall, name: '@other.thing')
     #
-    def reek_of(smell_category, smell_details = {})
-      ShouldReekOf.new(smell_category, smell_details)
+    def reek_of(smell_category,
+                smell_details = {},
+                configuration = Configuration::AppConfiguration.new)
+      ShouldReekOf.new(smell_category, smell_details, configuration)
     end
 
     #
@@ -96,15 +98,15 @@ module Reek
     #   1.) "reek_of" doesn't mind if there are other smells of a different category.
     #       "reek_only_of" will fail in that case.
     #   2.) "reek_only_of" doesn't support the additional smell_details hash.
-    def reek_only_of(smell_category)
-      ShouldReekOnlyOf.new(smell_category)
+    def reek_only_of(smell_category, configuration = Configuration::AppConfiguration.new)
+      ShouldReekOnlyOf.new(smell_category, configuration)
     end
 
     #
     # Returns +true+ if and only if the target source code contains smells.
     #
-    def reek
-      ShouldReek.new
+    def reek(configuration = Configuration::AppConfiguration.new)
+      ShouldReek.new configuration
     end
   end
 end

data/lib/reek/spec/should_reek.rb

@@ -7,9 +7,13 @@ module Reek
     # An rspec matcher that matches when the +actual+ has code smells.
     #
     # @api private
-    class ShouldReek        # :nodoc:
+    class ShouldReek
+      def initialize(configuration = Configuration::AppConfiguration.new)
+        @configuration = configuration
+      end
+
       def matches?(actual)
-        @examiner = Examiner.new(actual)
+        @examiner = Examiner.new(actual, configuration: @configuration)
         @examiner.smelly?
       end
 

data/lib/reek/spec/should_reek_of.rb

@@ -8,13 +8,16 @@ module Reek
     #
     # @api private
     class ShouldReekOf
-      def initialize(smell_category, smell_details = {})
+      def initialize(smell_category,
+                     smell_details = {},
+                     configuration = Configuration::AppConfiguration.new)
         @smell_category = normalize smell_category
         @smell_details  = smell_details
+        @configuration  = configuration
       end
 
       def matches?(actual)
-        @examiner = Examiner.new(actual)
+        @examiner = Examiner.new(actual, configuration: @configuration)
         @all_smells = @examiner.smells
         @all_smells.any? { |warning| warning.matches?(@smell_category, @smell_details) }
       end

data/lib/reek/spec/should_reek_only_of.rb

@@ -10,7 +10,7 @@ module Reek
     # @api private
     class ShouldReekOnlyOf < ShouldReekOf
       def matches?(actual)
-        matches_examiner?(Examiner.new(actual))
+        matches_examiner?(Examiner.new(actual, configuration: @configuration))
       end
 
       def matches_examiner?(examiner)

data/lib/reek/tree_walker.rb

@@ -2,24 +2,36 @@ require_relative 'context/method_context'
 require_relative 'context/module_context'
 require_relative 'context/root_context'
 require_relative 'context/singleton_method_context'
-require_relative 'smells/smell_repository'
 require_relative 'ast/node'
 
 module Reek
   #
-  # Traverses a Sexp abstract syntax tree and fires events whenever
-  # it encounters specific node types.
+  # Traverses an abstract syntax tree and fires events whenever it encounters
+  # specific node types.
   #
   # SMELL: This class is responsible for counting statements and for feeding
   # each context to the smell repository.
   #
+  # TODO: Make TreeWalker responsible only for creating Context objects, and
+  # loop over the created set of contexts elsewhere.
+  #
   # @api private
   class TreeWalker
-    def initialize(smell_repository = Smells::SmellRepository.new)
+    def initialize(smell_repository, exp)
       @smell_repository = smell_repository
-      @element = Context::RootContext.new
+      @exp = exp
+      @element = Context::RootContext.new(exp)
     end
 
+    def walk
+      @result ||= process(@exp)
+      @result.each do |element|
+        @smell_repository.examine(element)
+      end
+    end
+
+    private
+
     def process(exp)
       context_processor = "process_#{exp.type}"
       if context_processor_exists?(context_processor)
@@ -30,12 +42,6 @@ module Reek
       @element
     end
 
-    def process_default(exp)
-      exp.children.each do |child|
-        process(child) if child.is_a? AST::Node
-      end
-    end
-
     def process_module(exp)
       inside_new_context(Context::ModuleContext, exp) do
         process_default(exp)
@@ -44,6 +50,14 @@ module Reek
 
     alias_method :process_class, :process_module
 
+    def process_casgn(exp)
+      if exp.defines_module?
+        process_module(exp)
+      else
+        process_default(exp)
+      end
+    end
+
     def process_def(exp)
       inside_new_context(Context::MethodContext, exp) do
         count_clause(exp.body)
@@ -58,6 +72,12 @@ module Reek
       end
     end
 
+    def process_default(exp)
+      exp.children.each do |child|
+        process(child) if child.is_a? AST::Node
+      end
+    end
+
     def process_args(_) end
 
     #
@@ -65,12 +85,19 @@ module Reek
     #
 
     def process_send(exp)
+      if visibility_modifier? exp
+        @element.track_visibility(exp.method_name, exp.arg_names)
+      end
       @element.record_call_to(exp)
       process_default(exp)
     end
 
-    alias_method :process_attrasgn, :process_send
-    alias_method :process_op_asgn, :process_send
+    def process_attrasgn(exp)
+      @element.record_call_to(exp)
+      process_default(exp)
+    end
+
+    alias_method :process_op_asgn, :process_attrasgn
 
     def process_ivar(exp)
       @element.record_use_of_self
@@ -145,10 +172,8 @@ module Reek
       process_default(exp)
     end
 
-    private
-
     def context_processor_exists?(name)
-      respond_to?(name)
+      self.class.private_method_defined?(name)
     end
 
     def count_clause(sexp)
@@ -161,22 +186,25 @@ module Reek
 
     def inside_new_context(klass, exp)
       scope = klass.new(@element, exp)
+      @element.append_child_context(scope)
       push(scope) do
         yield
-        check_smells(exp.type)
       end
       scope
     end
 
-    def check_smells(type)
-      @smell_repository.examine(@element, type)
-    end
-
     def push(scope)
       orig = @element
       @element = scope
       yield
       @element = orig
     end
+
+    # FIXME: Move to SendNode?
+    def visibility_modifier?(call_node)
+      VISIBILITY_MODIFIERS.include?(call_node.method_name)
+    end
+
+    VISIBILITY_MODIFIERS = [:private, :public, :protected, :module_function]
   end
 end

data/lib/reek/version.rb

@@ -3,6 +3,6 @@ module Reek
   # This module holds the Reek version informations
   #
   module Version
-    STRING = '3.0.4'
+    STRING = '3.1'
   end
 end

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -309,15 +309,11 @@ RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
     end
 
     it 'has the correct #name' do
-      expect(subject.name).to eq :Fred
+      expect(subject.name).to eq 'Fred'
     end
 
     it 'has the correct #simple_name' do
-      expect(subject.simple_name).to eq :Fred
-    end
-
-    it 'has the correct #text_name' do
-      expect(subject.text_name).to eq 'Fred'
+      expect(subject.simple_name).to eq 'Fred'
     end
 
     it 'has a simple full_name' do
@@ -335,15 +331,11 @@ RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
     end
 
     it 'has the correct #name' do
-      expect(subject.name).to eq s(:const, s(:const, nil, :Foo), :Bar)
+      expect(subject.name).to eq 'Foo::Bar'
     end
 
     it 'has the correct #simple_name' do
-      expect(subject.simple_name).to eq :Bar
-    end
-
-    it 'has the correct #text_name' do
-      expect(subject.text_name).to eq 'Foo::Bar'
+      expect(subject.simple_name).to eq 'Bar'
     end
 
     it 'has a simple full_name' do

data/spec/reek/configuration/app_configuration_spec.rb

@@ -1,78 +1,106 @@
+require 'pathname'
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/configuration/app_configuration'
 require_relative '../../../lib/reek/smells/smell_repository'
+require_relative '../../../lib/reek/source/source_code'
 
 RSpec.describe Reek::Configuration::AppConfiguration do
-  let(:sample_configuration_path) { 'spec/samples/configuration/simple_configuration.reek' }
-  let(:sample_configuration_loaded) do
-    {
-      'UncommunicativeVariableName' => { 'enabled' => false },
-      'UncommunicativeMethodName'   => { 'enabled' => false }
-    }
-  end
-  let(:default_configuration) { Hash.new }
-
-  after(:each) { described_class.reset }
+  describe '#initialize' do
+    let(:full_configuration_path) { SAMPLES_PATH.join('configuration/full_configuration.reek') }
+    let(:expected_exclude_paths) do
+      [SAMPLES_PATH.join('two_smelly_files'),
+       SAMPLES_PATH.join('source_with_non_ruby_files')]
+    end
+    let(:expected_default_directive) do
+      { Reek::Smells::IrresponsibleModule => { 'enabled' => false } }
+    end
+    let(:expected_directory_directives) do
+      { Pathname.new('spec/samples/three_clean_files') =>
+        { Reek::Smells::UtilityFunction => { 'enabled' => false } } }
+    end
 
-  describe '.initialize_with' do
-    it 'loads a configuration file if it can find one' do
+    it 'properly loads configuration and processes it' do
       finder = Reek::Configuration::ConfigurationFileFinder
-      allow(finder).to receive(:find).and_return sample_configuration_path
-      expect(described_class.configuration).to eq(default_configuration)
+      allow(finder).to receive(:find_by_cli).and_return full_configuration_path
 
-      described_class.initialize_with(nil)
-      expect(described_class.configuration).to eq(sample_configuration_loaded)
+      expect(subject.exclude_paths).to eq(expected_exclude_paths)
+      expect(subject.default_directive).to eq(expected_default_directive)
+      expect(subject.directory_directives).to eq(expected_directory_directives)
     end
+  end
+
+  describe '#directive_for' do
+    context 'our source is in a directory for which we have a directive' do
+      let(:baz_config)  { { Reek::Smells::IrresponsibleModule => { enabled: false } } }
+      let(:bang_config) { { Reek::Smells::Attribute => { enabled: true } } }
 
-    it 'leaves the default configuration untouched if it can\'t find one' do
-      allow(Reek::Configuration::ConfigurationFileFinder).to receive(:find).and_return nil
-      expect(described_class.configuration).to eq(default_configuration)
+      let(:directory_directives) do
+        {
+          Pathname.new('foo/bar/baz')  => baz_config,
+          Pathname.new('foo/bar/bang') => bang_config
+        }
+      end
+      let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
-      described_class.initialize_with(nil)
-      expect(described_class.configuration).to eq(default_configuration)
+      it 'returns the corresponding directive' do
+        allow(subject).to receive(:directory_directives).and_return directory_directives
+        expect(subject.directive_for(source_via)).to eq(bang_config)
+      end
     end
-  end
 
-  describe '.configure_smell_repository' do
-    it 'should configure a given smell_repository' do
-      described_class.load_from_file(sample_configuration_path)
-      smell_repository = Reek::Smells::SmellRepository.new('def m; end')
-      described_class.configure_smell_repository smell_repository
+    context 'our source is not in a directory for which we have a directive' do
+      let(:baz_config)  { { Reek::Smells::IrresponsibleModule => { enabled: false } } }
+      let(:default_directive) do
+        { Reek::Smells::Attribute => { enabled: true } }
+      end
+      let(:directory_directives) do
+        { Pathname.new('foo/bar/baz')  => baz_config }
+      end
+      let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
-      expect(smell_repository.detectors[Reek::Smells::DataClump]).to be_enabled
-      expect(smell_repository.detectors[Reek::Smells::UncommunicativeVariableName]).
-        not_to be_enabled
-      expect(smell_repository.detectors[Reek::Smells::UncommunicativeMethodName]).not_to be_enabled
+      it 'returns the default directive' do
+        allow(subject).to receive(:directory_directives).and_return directory_directives
+        allow(subject).to receive(:default_directive).and_return default_directive
+        expect(subject.directive_for(source_via)).to eq(default_directive)
+      end
     end
   end
 
-  describe '.exclude_paths' do
-    let(:config_path) { 'spec/samples/configuration/with_excluded_paths.reek' }
+  describe '#best_directory_match_for' do
+    let(:directory_directives) do
+      {
+        Pathname.new('foo/bar/baz')  => {},
+        Pathname.new('foo/bar')      => {},
+        Pathname.new('bar/boo')      => {}
+      }
+    end
 
-    it 'should return all paths to exclude' do
-      with_test_config(config_path) do
-        expect(described_class.exclude_paths).to eq [
-          'spec/samples/source_with_exclude_paths/ignore_me',
-          'spec/samples/source_with_exclude_paths/nested/ignore_me_as_well'
-        ]
-      end
+    before do
+      allow(subject).to receive(:directory_directives).and_return directory_directives
     end
-  end
 
-  describe '.load_from_file' do
-    it 'loads the configuration from given file' do
-      described_class.load_from_file(sample_configuration_path)
-      expect(described_class.configuration).to eq(sample_configuration_loaded)
+    it 'returns the corresponding directory when source_base_dir is a leaf' do
+      source_base_dir = 'foo/bar/baz/bang'
+      hit = subject.send :best_directory_match_for, source_base_dir
+      expect(hit.to_s).to eq('foo/bar/baz')
     end
-  end
 
-  describe '.reset' do
-    it 'resets the configuration' do
-      described_class.load_from_file(sample_configuration_path)
+    it 'returns the corresponding directory when source_base_dir is in the middle of the tree' do
+      source_base_dir = 'foo/bar'
+      hit = subject.send :best_directory_match_for, source_base_dir
+      expect(hit.to_s).to eq('foo/bar')
+    end
+
+    it 'returns nil we are on top at the top of the and all other directories are below' do
+      source_base_dir = 'foo'
+      hit = subject.send :best_directory_match_for, source_base_dir
+      expect(hit).to be_nil
+    end
 
-      expect(described_class.configuration).to eq(sample_configuration_loaded)
-      described_class.reset
-      expect(described_class.configuration).to eq(default_configuration)
+    it 'returns nil when there source_base_dir is not part of any directory directive at all' do
+      source_base_dir = 'non/existent'
+      hit = subject.send :best_directory_match_for, source_base_dir
+      expect(hit).to be_nil
     end
   end
 end

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -16,36 +16,31 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
 
     it 'returns the file in current dir if config_file is nil' do
       options = double(config_file: nil)
-      current = Pathname.new('spec/samples')
-      found = described_class.find(options: options, current: current)
-      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+      found = described_class.find(options: options, current: SAMPLES_PATH)
+      expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
     end
 
     it 'returns the file in current dir if options is nil' do
-      current = Pathname.new('spec/samples')
-      found = described_class.find(current: current)
-      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+      found = described_class.find(current: SAMPLES_PATH)
+      expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
     end
 
     it 'returns the file in a parent dir if none in current dir' do
-      current = Pathname.new('spec/samples/no_config_file')
-      found = described_class.find(current: current)
-      expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+      found = described_class.find(current: SAMPLES_PATH.join('no_config_file'))
+      expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
     end
 
     it 'returns the file even if it’s just ‘.reek’' do
-      current = Pathname.new('spec/samples/masked_by_dotfile')
-      found = described_class.find(current: current)
-      expect(found).to eq(Pathname.new('spec/samples/masked_by_dotfile/.reek'))
+      found = described_class.find(current: SAMPLES_PATH.join('masked_by_dotfile'))
+      expect(found).to eq(SAMPLES_PATH.join('masked_by_dotfile/.reek'))
     end
 
     it 'returns the file in home if traversing from the current dir fails' do
       skip_if_a_config_in_tempdir
       Dir.mktmpdir do |tempdir|
         current = Pathname.new(tempdir)
-        home    = Pathname.new('spec/samples')
-        found = described_class.find(current: current, home: home)
-        expect(found).to eq(Pathname.new('spec/samples/exceptions.reek'))
+        found = described_class.find(current: current, home: SAMPLES_PATH)
+        expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
       end
     end
 
@@ -70,6 +65,23 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
       end
     end
 
+    describe '.load_from_file' do
+      let(:sample_configuration_path) do
+        SAMPLES_PATH.join('configuration/simple_configuration.reek')
+      end
+      let(:sample_configuration_loaded) do
+        {
+          'UncommunicativeVariableName' => { 'enabled' => false },
+          'UncommunicativeMethodName'   => { 'enabled' => false }
+        }
+      end
+
+      it 'loads the configuration from given file' do
+        configuration = described_class.load_from_file(sample_configuration_path)
+        expect(configuration).to eq(sample_configuration_loaded)
+      end
+    end
+
     private
 
     def skip_if_a_config_in_tempdir