reek 6.0.2 → 6.1.1

data/spec/reek/spec/should_reek_of_spec.rb

@@ -1,153 +0,0 @@
-require 'pathname'
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReekOf do
-  describe 'smell type selection' do
-    let(:ruby) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
-
-    it 'reports duplicate calls by smell type' do
-      expect(ruby).to reek_of(:DuplicateMethodCall)
-    end
-
-    it 'does not report any feature envy' do
-      expect(ruby).not_to reek_of(:FeatureEnvy)
-    end
-  end
-
-  describe 'different sources of input' do
-    context 'when checking code in a string' do
-      let(:clean_code) { 'def good() true; end' }
-      let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
-      let(:smelly_code) { 'def x() y = 4; end' }
-
-      it 'matches a smelly String' do
-        expect(matcher).to be_matches(smelly_code)
-      end
-
-      it 'doesnt match a fragrant String' do
-        expect(matcher).not_to be_matches(clean_code)
-      end
-
-      it 're-calculates matches every time' do
-        matcher.matches? smelly_code
-        expect(matcher).not_to be_matches(clean_code)
-      end
-    end
-
-    context 'when checking code in a File' do
-      let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
-
-      it 'matches a smelly file' do
-        expect(matcher).to be_matches(SMELLY_FILE)
-      end
-
-      it 'doesnt match a fragrant file' do
-        expect(matcher).not_to be_matches(CLEAN_FILE)
-      end
-    end
-  end
-
-  describe 'smell types and smell details' do
-    context 'when passing in smell_details with unknown parameter name' do
-      let(:matcher) { described_class.new(:UncommunicativeVariableName, foo: 'y') }
-      let(:smelly_code) { 'def x() y = 4; end' }
-
-      it 'raises ArgumentError' do
-        expect { matcher.matches?(smelly_code) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when both are matching' do
-      let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
-      let(:smelly_code) { 'def x() y = 4; end' }
-
-      it 'is truthy' do
-        expect(matcher).to be_matches(smelly_code)
-      end
-    end
-
-    context 'when no smell_type is matching' do
-      let(:smelly_code) { 'def dummy() y = 4; end' }
-
-      let(:falsey_matcher) { described_class.new(:FeatureEnvy, name: 'y') }
-      let(:truthy_matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
-
-      it 'is falsey' do
-        expect(falsey_matcher).not_to be_matches(smelly_code)
-      end
-
-      it 'sets the proper error message' do
-        falsey_matcher.matches?(smelly_code)
-
-        expect(falsey_matcher.failure_message).to\
-          match('Expected string to reek of FeatureEnvy, but it didn\'t')
-      end
-
-      it 'sets the proper error message when negated' do
-        truthy_matcher.matches?(smelly_code)
-
-        expect(truthy_matcher.failure_message_when_negated).to\
-          match('Expected string not to reek of UncommunicativeVariableName, but it did')
-      end
-    end
-
-    context 'when smell type is matching but smell details are not' do
-      let(:smelly_code) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
-      let(:matcher) { described_class.new(:DuplicateMethodCall, name: 'foo', count: 15) }
-
-      it 'is falsey' do
-        expect(matcher).not_to be_matches(smelly_code)
-      end
-
-      it 'sets the proper error message' do
-        matcher.matches?(smelly_code)
-        expected = <<~TEXT
-          Expected string to reek of DuplicateMethodCall (which it did) with smell details {:name=>"foo", :count=>15}, which it didn't.
-          The number of smell details I had to compare with the given one was 2 and here they are:
-          1.)
-          {"context"=>"double_thing", "lines"=>[1, 1], "message"=>"calls '@other.thing' 2 times", "source"=>"string", "name"=>"@other.thing", "count"=>2}
-          2.)
-          {"context"=>"double_thing", "lines"=>[1, 1], "message"=>"calls '@other.thing.foo' 2 times", "source"=>"string", "name"=>"@other.thing.foo", "count"=>2}
-        TEXT
-
-        expect(matcher.failure_message).to eq(expected)
-      end
-
-      it 'sets the proper error message when negated' do
-        matcher.matches?(smelly_code)
-
-        expect(matcher.failure_message_when_negated).to\
-          match('Expected string not to reek of DuplicateMethodCall with smell '\
-                  'details {:name=>"foo", :count=>15}, but it did')
-      end
-    end
-  end
-
-  context 'with a smell that is disabled by default' do
-    it 'enables the smell detector to match automatically' do
-      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
-      src = 'class C; private; def foo; end; end'
-
-      aggregate_failures do
-        expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
-        expect(src).to reek_of(:UnusedPrivateMethod)
-      end
-    end
-  end
-
-  describe '#with_config' do
-    let(:matcher) { described_class.new(:UncommunicativeVariableName) }
-    let(:configured_matcher) { matcher.with_config('accept' => 'x') }
-
-    it 'uses the passed-in configuration for matching' do
-      expect(configured_matcher).to be_matches('def foo; q = 2; end')
-      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
-    end
-
-    it 'leaves the original matcher intact' do
-      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
-      expect(matcher).to be_matches('def foo; x = 2; end')
-    end
-  end
-end

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -1,91 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReekOnlyOf do
-  let(:examiner) { instance_double('Reek::Examiner').as_null_object }
-  let(:expected_context_name) { 'SmellyClass#big_method' }
-  let(:expected_smell_type) { :NestedIterators }
-  let(:matcher) { described_class.new(expected_smell_type) }
-  let(:matcher_matches) { matcher.matches_examiner?(examiner) }
-
-  before do
-    allow(examiner).to receive(:smells) { smells }
-    matcher_matches
-  end
-
-  shared_examples_for 'no match' do
-    it 'does not match' do
-      expect(matcher_matches).to be_falsey
-    end
-
-    context 'when a match was expected' do
-      let(:source) { 'the_path/to_a/source_file.rb' }
-
-      before { allow(examiner).to receive(:origin).and_return(source) }
-
-      it 'reports the source' do
-        expect(matcher.failure_message).to match(source)
-      end
-
-      it 'reports the expected smell class' do
-        expect(matcher.failure_message).to match(expected_smell_type.to_s)
-      end
-    end
-  end
-
-  context 'with no smells' do
-    let(:smells) { [] }
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 non-matching smell' do
-    let(:smells) { [build_smell_warning(smell_type: 'ControlParameter')] }
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 2 non-matching smells' do
-    let(:smells) do
-      [
-        build_smell_warning(smell_type: 'ControlParameter'),
-        build_smell_warning(smell_type: 'FeatureEnvy')
-      ]
-    end
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 non-matching and 1 matching smell' do
-    let(:smells) do
-      [
-        build_smell_warning(smell_type: 'ControlParameter'),
-        build_smell_warning(smell_type: expected_smell_type.to_s,
-                              message: "message mentioning #{expected_context_name}")
-      ]
-    end
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 matching smell' do
-    let(:smells) do
-      [build_smell_warning(smell_type: expected_smell_type.to_s,
-                             message: "message mentioning #{expected_context_name}")]
-    end
-
-    it 'matches' do
-      expect(matcher_matches).to be_truthy
-    end
-
-    it 'reports the expected smell when no match was expected' do
-      expect(matcher.failure_message_when_negated).to match(expected_smell_type.to_s)
-    end
-
-    it 'reports the source when no match was expected' do
-      source = 'the_path/to_a/source_file.rb'
-      allow(examiner).to receive(:origin).and_return(source)
-      expect(matcher.failure_message_when_negated).to match(source)
-    end
-  end
-end

data/spec/reek/spec/should_reek_spec.rb

@@ -1,52 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReek do
-  describe 'checking code in a string' do
-    let(:matcher) { described_class.new }
-    let(:clean_code) { 'def good() true; end' }
-    let(:smelly_code) { 'def x() y = 4; end' }
-
-    it 'matches a smelly String' do
-      expect(matcher).to be_matches(smelly_code)
-    end
-
-    it 'doesnt match a fragrant String' do
-      expect(matcher).not_to be_matches(clean_code)
-    end
-
-    it 'reports the smells when should_not fails' do
-      matcher.matches?(smelly_code)
-      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
-    end
-  end
-
-  describe 'checking code in a File' do
-    context 'without masking' do
-      let(:matcher) { described_class.new }
-
-      it 'matches a smelly File' do
-        expect(matcher).to be_matches(SMELLY_FILE)
-      end
-
-      it 'doesnt match a fragrant File' do
-        expect(matcher).not_to be_matches(CLEAN_FILE)
-      end
-
-      it 'reports the smells when should_not fails' do
-        matcher.matches?(SMELLY_FILE)
-        expect(matcher.failure_message_when_negated).to match('UncommunicativeMethodName')
-      end
-    end
-
-    context 'with masking' do
-      let(:path) { CONFIGURATION_DIR.join('full_mask.reek') }
-      let(:configuration) { test_configuration_for(path) }
-      let(:matcher) { described_class.new(configuration: configuration) }
-
-      it 'masks smells using the relevant configuration' do
-        expect(matcher).not_to be_matches(SMELLY_FILE)
-      end
-    end
-  end
-end

data/spec/reek/spec/smell_matcher_spec.rb

@@ -1,87 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/spec/smell_matcher'
-
-RSpec.describe Reek::Spec::SmellMatcher do
-  let(:smell_warning) do
-    build_smell_warning(smell_type: 'UncommunicativeVariableName',
-                          message: "has the variable name '@s'",
-                          parameters: { test: 'something' })
-  end
-  let(:matcher) { described_class.new(smell_warning) }
-
-  describe '#matches?' do
-    it 'matches on class symbol' do
-      expect(matcher).to be_matches(:UncommunicativeVariableName)
-    end
-
-    it 'matches on class symbol and params' do
-      expect(matcher).to be_matches(:UncommunicativeVariableName,
-                                    test: 'something')
-    end
-
-    it 'matches on class symbol, params and attributes' do
-      expect(matcher).to be_matches(:UncommunicativeVariableName,
-                                    test: 'something',
-                                    message: "has the variable name '@s'")
-    end
-
-    it 'does not match on different class symbol' do
-      expect(matcher).not_to be_matches(:FeatureEnvy)
-    end
-
-    it 'does not match on different params' do
-      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
-                                        test: 'something else')
-    end
-
-    it 'does not match on different attributes' do
-      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
-                                        test: 'something',
-                                        message: 'nothing')
-    end
-
-    it 'raises error on uncomparable attribute' do
-      expect do
-        matcher.matches?(:UncommunicativeVariableName,
-                         test: 'something',
-                         random: 'nothing')
-      end.to raise_error("The attribute 'random' is not available for comparison")
-    end
-  end
-
-  describe '#matches_smell_type?' do
-    it 'matches on class symbol' do
-      expect(matcher).to be_matches_smell_type(:UncommunicativeVariableName)
-    end
-
-    it 'does not match on different class symbol' do
-      expect(matcher).not_to be_matches_smell_type(:FeatureEnvy)
-    end
-  end
-
-  describe '#matches_attributes?' do
-    it 'matches on params' do
-      expect(matcher).to be_matches_attributes(test: 'something')
-    end
-
-    it 'matches on class symbol, params and attributes' do
-      expect(matcher).to be_matches_attributes(test: 'something',
-                                               message: "has the variable name '@s'")
-    end
-
-    it 'does not match on different params' do
-      expect(matcher).not_to be_matches_attributes(test: 'something else')
-    end
-
-    it 'does not match on different attributes' do
-      expect(matcher).not_to be_matches_attributes(test: 'something',
-                                                   message: 'nothing')
-    end
-
-    it 'raises error on uncomparable attribute' do
-      expect do
-        matcher.matches_attributes? test: 'something', random: 'nothing'
-      end.to raise_error("The attribute 'random' is not available for comparison")
-    end
-  end
-end

data/spec/reek/tree_dresser_spec.rb

@@ -1,46 +0,0 @@
-require_relative '../spec_helper'
-Reek::CLI::Silencer.without_warnings { require 'parser/ruby25' }
-require_lib 'reek/tree_dresser'
-
-RSpec.describe Reek::TreeDresser do
-  describe '#dress' do
-    let(:dresser) { described_class.new }
-    let(:sexp) do
-      Parser::Ruby25.parse('class Klazz; def meth(argument); argument.call_me; end; end')
-    end
-    let(:dressed_ast) { dresser.dress(sexp, {}) }
-
-    # The dressed AST looks like this:
-    #   (class
-    #     (const nil :Klazz) nil
-    #     (def :meth
-    #       (args
-    #         (arg :argument))
-    #       (send
-    #         (lvar :argument) :call_me)))
-    let(:const_node) { dressed_ast.children.first }
-    let(:def_node) { dressed_ast.children.last }
-    let(:args_node) { def_node.children[1] }
-    let(:send_node) { def_node.children[2] }
-
-    it 'dresses `const` nodes properly' do
-      expect(const_node).to be_a Reek::AST::SexpExtensions::ConstNode
-    end
-
-    it 'dresses `def` nodes properly' do
-      expect(def_node).
-        to be_a(Reek::AST::SexpExtensions::DefNode).
-        and be_a(Reek::AST::SexpExtensions::MethodNodeBase)
-    end
-
-    it 'dresses `args` nodes properly' do
-      expect(args_node).
-        to be_a(Reek::AST::SexpExtensions::ArgsNode).
-        and be_a(Reek::AST::SexpExtensions::NestedAssignables)
-    end
-
-    it 'dresses `send` nodes properly' do
-      expect(send_node).to be_a Reek::AST::SexpExtensions::SendNode
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,110 +0,0 @@
-require 'pathname'
-require 'timeout'
-require 'rspec-benchmark'
-require_relative '../lib/reek'
-require_relative '../lib/reek/spec'
-require_relative '../lib/reek/ast/ast_node_class_map'
-require_relative '../lib/reek/configuration/app_configuration'
-
-require_relative '../samples/paths'
-
-begin
-  Reek::CLI::Silencer.without_warnings { require 'pry-byebug' }
-rescue LoadError # rubocop:disable Lint/SuppressedException
-end
-
-# Simple helpers for our specs.
-module Helpers
-  def test_configuration_for(config)
-    case config
-    when Pathname
-      configuration = Reek::Configuration::AppConfiguration.from_path(config)
-    when Hash
-      configuration = Reek::Configuration::AppConfiguration.from_hash config
-    else
-      raise "Unknown config given in `test_configuration_for`: #{config.inspect}"
-    end
-    configuration
-  end
-
-  # @param code [String] The given code.
-  #
-  # @return syntax_tree [Reek::AST::Node]
-  def syntax_tree(code)
-    Reek::Source::SourceCode.from(code).syntax_tree
-  end
-
-  # @param code [String] The given code.
-  #
-  # @return syntax_tree [Reek::Context::CodeContext]
-  def code_context(code)
-    Reek::Context::CodeContext.new(nil, syntax_tree(code))
-  end
-
-  # @param code [String] The given code.
-  #
-  # @return syntax_tree [Reek::Context::MethodContext]
-  def method_context(code)
-    Reek::Context::MethodContext.new(nil, syntax_tree(code))
-  end
-
-  # Helper methods to generate a configuration for smell types that support
-  # `accept` and `reject` settings.
-  %w(accept reject).each do |switch|
-    define_method("#{switch}_configuration_for") do |smell_type, pattern:|
-      hash = {
-        smell_type => {
-          switch => pattern
-        }
-      }
-      Reek::Configuration::AppConfiguration.from_hash(hash)
-    end
-  end
-
-  # :reek:UncommunicativeMethodName
-  def sexp(type, *children)
-    @klass_map ||= Reek::AST::ASTNodeClassMap.new
-    @klass_map.klass_for(type).new(type, children)
-  end
-
-  def build_smell_warning(smell_type: 'FeatureEnvy',
-                          context: 'self',
-                          lines: [42],
-                          message: 'smell warning message',
-                          source: 'dummy_file',
-                          parameters: {})
-    Reek::SmellWarning.new(smell_type,
-                           context: context,
-                           lines: lines,
-                           message: message,
-                           source: source,
-                           parameters: parameters)
-  end
-
-  def build_code_comment(comment: '', line: 1, source: 'string')
-    Reek::CodeComment.new(comment: comment, line: line, source: source)
-  end
-end
-
-RSpec.configure do |config|
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-  config.include Helpers
-  config.include RSpec::Benchmark::Matchers
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-
-  config.disable_monkey_patching!
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-    mocks.verify_doubled_constant_names = true
-  end
-end
-
-RSpec::Matchers.define_negated_matcher :not_reek_of, :reek_of
-
-private
-
-def require_lib(path)
-  require_relative "../lib/#{path}"
-end

data/tasks/configuration.rake

@@ -1,18 +0,0 @@
-require_relative '../lib/reek'
-require_relative '../lib/reek/detector_repository'
-require_relative '../lib/reek/configuration/rake_task_converter'
-require_relative '../lib/reek/configuration/app_configuration'
-
-require 'yaml'
-
-namespace :configuration do
-  desc 'Updates the default configuration file when smell defaults change'
-  task :update_default_configuration do
-    content = Reek::DetectorRepository.smell_types.each_with_object({}) do |klass, hash|
-      hash[klass.smell_type] = Reek::Configuration::RakeTaskConverter.convert klass.default_config
-    end
-    File.open(Reek::DEFAULT_SMELL_CONFIGURATION, 'w') do |file|
-      YAML.dump({ Reek::DETECTORS_KEY => content }, file)
-    end
-  end
-end

data/tasks/console.rake

@@ -1,5 +0,0 @@
-desc 'Starts the interactive console'
-task :console do
-  require 'pry'
-  Pry.start
-end

data/tasks/reek.rake

@@ -1,6 +0,0 @@
-require_relative '../lib/reek/rake/task'
-
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = true
-  t.verbose = false
-end

data/tasks/rubocop.rake

@@ -1,11 +0,0 @@
-begin
-  require 'rubocop/rake_task'
-
-  RuboCop::RakeTask.new do |task|
-    task.options << '--display-cop-names'
-  end
-rescue LoadError
-  task :rubocop do
-    puts 'Install rubocop to run its rake tasks'
-  end
-end

data/tasks/test.rake

@@ -1,32 +0,0 @@
-require 'cucumber/rake/task'
-require 'rspec/core/rake_task'
-
-namespace 'test' do
-  RSpec::Core::RakeTask.new('spec') do |t|
-    t.pattern = 'spec/reek/**/*_spec.rb'
-    t.ruby_opts = ['-rbundler/setup -rsimplecov -Ilib -w']
-  end
-
-  RSpec::Core::RakeTask.new('performance') do |t|
-    t.pattern = 'spec/performance/**/*_spec.rb'
-  end
-
-  desc 'Tests code quality'
-  RSpec::Core::RakeTask.new('quality') do |t|
-    t.pattern = 'spec/quality/**/*_spec.rb'
-    t.ruby_opts = ['-rbundler/setup -Ilib']
-  end
-
-  Cucumber::Rake::Task.new(:features) do |t|
-    t.cucumber_opts = 'features --format progress --color'
-  end
-
-  desc 'Runs all unit tests and acceptance tests'
-  task 'all' => ['test:spec', 'test:features']
-end
-
-desc 'Synonym for test:spec'
-task 'spec' => 'test:spec'
-
-desc 'Synonym for test:all'
-task 'test' => 'test:all'