reek 6.0.3 → 6.1.0

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -1,498 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/ast/sexp_extensions'
-
-RSpec.describe Reek::AST::SexpExtensions::DefNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:def, :hello, sexp(:args)) }
-
-    it 'has no arg names' do
-      expect(node.arg_names).to eq []
-    end
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args, sexp(:arg, :parameter)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with a block parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args,
-                sexp(:arg, :parameter),
-                sexp(:blockarg, :blk)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:parameter, :blk]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    let(:node) do
-      sexp(:def, :hello,
-           sexp(:args,
-                sexp(:optarg, :parameter, sexp(:array))))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    let(:node) do
-      sexp(:def, :hello, sexp(:args),
-           sexp(:begin,
-                sexp(:first),
-                sexp(:second)))
-    end
-
-    it 'has 2 body statements' do
-      expect(node.body).to eq sexp(:begin, sexp(:first), sexp(:second))
-    end
-
-    it 'finds nodes in the body with #body_nodes' do
-      expect(node.body_nodes([:first]).to_a).to eq [sexp(:first)]
-    end
-  end
-
-  context 'with no body' do
-    let(:node) { sexp(:def, :hello, sexp(:args), nil) }
-
-    it 'has a body that is nil' do
-      expect(node.body).to be_nil
-    end
-
-    it 'finds no nodes in the body' do
-      expect(node.body_nodes([:foo])).to eq []
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::CSendNode do
-  let(:node) { Reek::Source::SourceCode.from('1&.foo(true)').syntax_tree }
-
-  it 'has a class including SendNode' do
-    expect(node.class.included_modules).to include(Reek::AST::SexpExtensions::SendNode)
-  end
-
-  it 'has a receiver' do
-    expect(node.receiver).to eq(sexp(:int, 1))
-  end
-
-  it 'has a name' do
-    expect(node.name).to eq(:foo)
-  end
-
-  it 'has arguments' do
-    expect(node.args).to eq([sexp(:true)])
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::DefsNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:defs, sexp(:lvar, :obj), :hello, sexp(:args)) }
-
-    it 'has no arg names' do
-      expect(node.arg_names).to eq []
-    end
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args, sexp(:arg, :parameter)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with a block' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args,
-                sexp(:arg, :parameter),
-                sexp(:blockarg, :blk)))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:parameter, :blk]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with 1 defaulted parameter' do
-    let(:node) do
-      sexp(:defs, sexp(:lvar, :obj), :hello,
-           sexp(:args,
-                sexp(:optarg, :parameter, sexp(:array))))
-    end
-
-    it 'has 1 arg name' do
-      expect(node.arg_names).to eq [:parameter]
-    end
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-
-    it 'includes outer scope in its full name' do
-      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
-    end
-
-    it 'includes no marker in its full name with empty outer scope' do
-      expect(node.full_name('')).to eq 'obj.hello'
-    end
-  end
-
-  context 'with a body with 2 statements' do
-    let(:node) do
-      sexp(:defs, sexp(:self), :hello, sexp(:args),
-           sexp(:begin,
-                sexp(:first),
-                sexp(:second)))
-    end
-
-    it 'has 2 body statements' do
-      expect(node.body).to eq sexp(:begin, sexp(:first), sexp(:second))
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::LvarNode do
-  let(:node) { sexp(:lvar, :foo) }
-
-  describe '#var_name' do
-    it 'returns the lvar’s name' do
-      expect(node.var_name).to eq(:foo)
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::ConstNode do
-  describe '#name' do
-    it 'returns the fully qualified name' do
-      node = sexp(:const, sexp(:const, sexp(:cbase), :Parser), :AST)
-
-      expect(node.name).to eq "#{sexp(:const, sexp(:cbase), :Parser)}::AST"
-    end
-
-    it 'returns only the name in case of no namespace' do
-      node = sexp(:const, nil, :AST)
-
-      expect(node.name).to eq 'AST'
-    end
-  end
-
-  describe '#simple_name' do
-    it 'returns the name' do
-      node = sexp(:const, sexp(:const, nil, :Rake), :TaskLib)
-
-      expect(node.simple_name).to eq :TaskLib
-    end
-  end
-
-  describe '#namespace' do
-    it 'returns the namespace' do
-      node = sexp(:const, :Parser, :AST)
-
-      expect(node.namespace).to eq :Parser
-    end
-
-    it 'returns nil in case of no namespace' do
-      node = sexp(:const, nil, :AST)
-
-      expect(node.namespace).to be_nil
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::SendNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:send, nil, :hello) }
-
-    it 'is not considered to be a writable attr' do
-      expect(sexp(:send, nil, :attr)).not_to be_attr_with_writable_flag
-    end
-  end
-
-  context 'when it’s ‘new’ with no parameters and no receiver' do
-    let(:bare_new) { sexp(:send, nil, :new) }
-
-    it 'is not considered to be a module creation call' do
-      expect(bare_new).not_to be_module_creation_call
-    end
-
-    it 'is not considered to have a module creation receiver' do
-      expect(bare_new).not_to be_module_creation_receiver
-    end
-
-    it 'is considered to be an object creation call' do
-      expect(bare_new).to be_object_creation_call
-    end
-  end
-
-  context 'when it’s ‘new’ with a complex receiver' do
-    let(:node) { Reek::Source::SourceCode.from('(foo ? bar : baz).new').syntax_tree }
-
-    it 'is not considered to be a module creation call' do
-      expect(node).not_to be_module_creation_call
-    end
-
-    it 'is not considered to have a module creation receiver' do
-      expect(node).not_to be_module_creation_receiver
-    end
-
-    it 'is considered to be an object creation call' do
-      expect(node).to be_object_creation_call
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::BlockNode do
-  context 'with no parameters' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args), nil) }
-
-    it 'has no parameter names' do
-      expect(node.parameter_names).to eq []
-    end
-
-    it 'has a name' do
-      expect(node.simple_name).to eq(:block)
-    end
-  end
-
-  context 'with 1 parameter' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args, :parameter), nil) }
-
-    it 'has 1 parameter name' do
-      expect(node.parameter_names).to eq [:parameter]
-    end
-  end
-
-  context 'with 2 parameters' do
-    let(:node) { sexp(:block, sexp(:send, nil, :map), sexp(:args, :x, :y), nil) }
-
-    it 'has 2 parameter names' do
-      expect(node.parameter_names).to eq [:x, :y]
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::LambdaNode do
-  let(:node) { sexp(:lambda) }
-
-  describe '#name' do
-    it 'returns :lambda' do
-      expect(node.name).to eq 'lambda'
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
-  context 'with a simple name' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module Fred; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'Fred'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Fred'
-    end
-
-    it 'has a simple full_name' do
-      expect(exp.full_name('')).to eq 'Fred'
-    end
-
-    it 'has a fq full_name' do
-      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Fred'
-    end
-  end
-
-  context 'with a scoped name' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module Foo::Bar; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'Foo::Bar'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Bar'
-    end
-
-    it 'has a simple full_name' do
-      expect(exp.full_name('')).to eq 'Foo::Bar'
-    end
-
-    it 'has a fully qualified full_name' do
-      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Foo::Bar'
-    end
-  end
-
-  context 'with a name scoped in a namespace that is not a constant' do
-    let(:exp) do
-      Reek::Source::SourceCode.from('module foo::Bar; end').syntax_tree
-    end
-
-    it 'has the correct #name' do
-      expect(exp.name).to eq 'foo::Bar'
-    end
-
-    it 'has the correct #simple_name' do
-      expect(exp.simple_name).to eq 'Bar'
-    end
-  end
-end
-
-RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
-  describe '#defines_module?' do
-    it 'is false for single assignment' do
-      exp = sexp(:casgn, nil, :Foo)
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is false for implicit receiver to new' do
-      exp = sexp(:casgn, nil, :Foo, sexp(:send, nil, :new))
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is true for explicit receiver to new' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-      expect(exp).to be_defines_module
-    end
-
-    it 'is false for assigning a lambda to a constant' do
-      exp = Reek::Source::SourceCode.from('C = ->{}').syntax_tree
-      expect(exp).not_to be_defines_module
-    end
-
-    it 'is false for assigning a string to a constant' do
-      exp = Reek::Source::SourceCode.from('C = "hello"').syntax_tree
-      expect(exp).not_to be_defines_module
-    end
-  end
-
-  describe '#superclass' do
-    it 'returns the superclass from the class definition' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
-      expect(exp.superclass).to eq sexp(:const, nil, :Bar)
-    end
-
-    it 'returns nil in case of no class definition' do
-      exp = Reek::Source::SourceCode.from('Foo = 23').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nil in case of no superclass' do
-      exp = Reek::Source::SourceCode.from('Foo = Class.new').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nothing for a class definition using Struct.new' do
-      exp = Reek::Source::SourceCode.from('Foo = Struct.new("Bar")').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-
-    it 'returns nothing for a constant assigned with a bare method call' do
-      exp = Reek::Source::SourceCode.from('Foo = foo("Bar")').syntax_tree
-      expect(exp.superclass).to be_nil
-    end
-  end
-end

data/spec/reek/cli/application_spec.rb

@@ -1,168 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/cli/application'
-
-RSpec.describe Reek::CLI::Application do
-  describe '#initialize' do
-    it 'exits with default error code on invalid options' do
-      call = lambda do
-        Reek::CLI::Silencer.silently do
-          described_class.new ['--foo']
-        end
-      end
-      expect(&call).to raise_error(SystemExit) do |error|
-        expect(error.status).to eq Reek::CLI::Status::DEFAULT_ERROR_EXIT_CODE
-      end
-    end
-  end
-
-  describe '#execute' do
-    let(:path_excluded_in_configuration) do
-      SAMPLES_DIR.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb')
-    end
-    let(:configuration) { test_configuration_for(CONFIGURATION_DIR.join('with_excluded_paths.reek')) }
-    let(:command) { instance_double 'Reek::CLI::Command::ReportCommand' }
-    let(:app) { described_class.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
-
-    context 'when no source files given and input was piped' do
-      before do
-        allow_any_instance_of(IO).to receive(:tty?).and_return(false)
-      end
-
-      it 'uses source from pipe' do
-        expected_sources = a_collection_containing_exactly(have_attributes(origin: 'STDIN'))
-        app.execute
-        expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
-          with(sources: expected_sources,
-               configuration: Reek::Configuration::AppConfiguration,
-               options: Reek::CLI::Options)
-      end
-
-      context 'when a stdin filename is provided' do
-        let(:app) { described_class.new ['--stdin-filename', 'foo.rb'] }
-
-        it 'assumes that filename' do
-          expected_sources = a_collection_containing_exactly(have_attributes(origin: 'foo.rb'))
-          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
-
-    context 'when no source files given and no input was piped' do
-      before do
-        allow_any_instance_of(IO).to receive(:tty?).and_return(true)
-      end
-
-      it 'uses 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
-
-      context 'when source files are excluded through configuration' do
-        let(:app) { described_class.new ['--config', 'some_file.reek'] }
-
-        before do
-          allow(Reek::Configuration::AppConfiguration).
-            to receive(:from_path).
-            with(Pathname.new('some_file.reek')).
-            and_return configuration
-        end
-
-        it 'uses 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) { described_class.new ['.'] }
-
-      it 'uses 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
-
-      context 'when source files are excluded through configuration' do
-        let(:app) { described_class.new ['--config', 'some_file.reek', '.'] }
-
-        before do
-          allow(Reek::Configuration::AppConfiguration).
-            to receive(:from_path).
-            with(Pathname.new('some_file.reek')).
-            and_return configuration
-        end
-
-        it 'uses 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
-  end
-
-  describe 'show configuration path' do
-    let(:app) { described_class.new ['--show-configuration-path', '.'] }
-
-    around do |example|
-      Dir.mktmpdir do |tmp|
-        Dir.chdir(tmp) do
-          example.run
-        end
-      end
-    end
-
-    context 'when not using any configuration file' do
-      it 'prints that we are not using any configuration file' do
-        expect do
-          app.execute
-        end.to output("Not using any configuration file.\n").to_stdout
-      end
-    end
-
-    context 'with a default configuration file' do
-      it 'prints that we are using the default configuration file' do
-        FileUtils.touch '.reek.yml'
-        expect do
-          app.execute
-        end.to output("Using '.reek.yml' as configuration file.\n").to_stdout
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require_relative '../../../spec_helper'
-require_lib 'reek/cli/command/report_command'
-require_lib 'reek/cli/options'
-
-RSpec.describe Reek::CLI::Command::ReportCommand do
-  describe '#execute' do
-    let(:options) { Reek::CLI::Options.new [] }
-
-    let(:configuration) { instance_double 'Reek::Configuration::AppConfiguration' }
-    let(:sources) { [source_file] }
-
-    let(:command) do
-      described_class.new(options: options,
-                          sources: sources,
-                          configuration: configuration)
-    end
-
-    before do
-      allow(configuration).to receive(:directive_for).and_return({})
-    end
-
-    context 'when no smells are found' do
-      let(:source_file) { CLEAN_FILE }
-
-      it 'returns a success code' do
-        result = Reek::CLI::Silencer.silently do
-          command.execute
-        end
-        expect(result).to eq Reek::CLI::Status::DEFAULT_SUCCESS_EXIT_CODE
-      end
-    end
-
-    context 'when smells are found' do
-      let(:source_file) { SMELLY_FILE }
-
-      it 'returns a failure code' do
-        result = Reek::CLI::Silencer.silently do
-          command.execute
-        end
-        expect(result).to eq Reek::CLI::Status::DEFAULT_FAILURE_EXIT_CODE
-      end
-    end
-  end
-end