reek 6.0.3 → 6.1.0

data/spec/reek/examiner_spec.rb

@@ -1,309 +0,0 @@
-require_relative '../spec_helper'
-require_lib 'reek/examiner'
-require_lib 'reek/logging_error_handler'
-
-RSpec.shared_examples_for 'no smells found' do
-  it 'is not smelly' do
-    expect(examiner).not_to be_smelly
-  end
-
-  it 'finds no smells' do
-    expect(examiner.smells.length).to eq(0)
-  end
-end
-
-RSpec.shared_examples_for 'one smell found' do
-  it 'is smelly' do
-    expect(examiner).to be_smelly
-  end
-
-  it 'reports the smell' do
-    expect(examiner.smells.length).to eq(1)
-  end
-
-  it 'reports the correct smell' do
-    expect(examiner.smells[0].smell_type).to eq(expected_first_smell)
-  end
-end
-
-RSpec.describe Reek::Examiner do
-  context 'with a fragrant String' do
-    let(:examiner) { described_class.new('def good() true; end') }
-
-    it_behaves_like 'no smells found'
-  end
-
-  context 'with a smelly String' do
-    let(:examiner) { described_class.new('def fine() y = 4; end') }
-    let(:expected_first_smell) { 'UncommunicativeVariableName' }
-
-    it_behaves_like 'one smell found'
-  end
-
-  context 'with a partially masked smelly File' do
-    let(:configuration) { test_configuration_for(path) }
-    let(:examiner) do
-      described_class.new(SMELLY_FILE,
-                          filter_by_smells: [],
-                          configuration: configuration)
-    end
-    let(:path) { CONFIGURATION_DIR.join('partial_mask.reek') }
-    let(:expected_first_smell) { 'UncommunicativeVariableName' }
-
-    it_behaves_like 'one smell found'
-  end
-
-  context 'with a fragrant File' do
-    let(:examiner) { described_class.new(CLEAN_FILE) }
-
-    it_behaves_like 'no smells found'
-  end
-
-  describe '#origin' do
-    let(:source) { 'class C; def f; end; end' }
-    let(:examiner) { described_class.new(source) }
-
-    it 'returns "string" for a string source' do
-      expect(examiner.origin).to eq('string')
-    end
-  end
-
-  describe '#smells' do
-    it 'returns the detected smell warnings' do
-      code     = 'def foo; bar.call_me(); bar.call_me(); end'
-      examiner = described_class.new code, filter_by_smells: ['DuplicateMethodCall']
-
-      smell = examiner.smells.first
-      expect(smell).to be_a(Reek::SmellWarning)
-      expect(smell.message).to eq("calls 'bar.call_me()' 2 times")
-    end
-
-    context 'with a source with three smells' do
-      let(:source) { 'class C; def f; end; end' }
-      let(:examiner) { described_class.new(source) }
-
-      it 'has the right smells' do
-        smells = examiner.smells
-        expect(smells.map(&:message)).
-          to eq ['has no descriptive comment',
-                 "has the name 'f'",
-                 "has the name 'C'"]
-      end
-    end
-
-    context 'when source only contains comments' do
-      let(:source) do
-        <<-RUBY
-            # Just a comment
-            # And another
-        RUBY
-      end
-      let(:examiner) do
-        described_class.new(source)
-      end
-
-      it 'has no warnings' do
-        expect(examiner.smells).to eq([])
-      end
-    end
-
-    context 'with an incomprehensible source that causes the detectors to crash' do
-      let(:source) { 'class C; def does_crash_reek; end; end' }
-
-      let(:examiner) do
-        detector_repository = instance_double 'Reek::DetectorRepository'
-        allow(detector_repository).to receive(:examine) do
-          raise ArgumentError, 'Looks like bad source'
-        end
-        class_double('Reek::DetectorRepository').as_stubbed_const
-        allow(Reek::DetectorRepository).to receive(:eligible_smell_types)
-        allow(Reek::DetectorRepository).to receive(:new).and_return detector_repository
-
-        described_class.new source
-      end
-
-      it 'raises an incomprehensible source error' do
-        expect { examiner.smells }.to raise_error Reek::Errors::IncomprehensibleSourceError
-      end
-
-      it 'explains the origin of the error' do
-        origin = 'string'
-        expect { examiner.smells }.
-          to raise_error.with_message("Source #{origin} cannot be processed by Reek.")
-      end
-
-      it 'explains what to do' do
-        explanation = 'It would be great if you could report this back to the Reek team'
-        expect { examiner.smells }.
-          to raise_error { |it| expect(it.long_message).to match(/#{explanation}/) }
-      end
-
-      it 'contains the original error message' do
-        original = 'Looks like bad source'
-        expect { examiner.smells }.
-          to raise_error { |it| expect(it.long_message).to match(/#{original}/) }
-      end
-
-      it 'shows the original exception class' do
-        expect { examiner.smells }.
-          to raise_error { |it| expect(it.long_message).to match(/ArgumentError/) }
-      end
-    end
-  end
-
-  describe '#smells_count' do
-    let(:source) { 'class C; def f; end; end' }
-    let(:examiner) { described_class.new(source) }
-
-    it 'has the right smell count' do
-      expect(examiner.smells_count).to eq(3)
-    end
-  end
-
-  context 'when the source causes the source buffer to crash' do
-    let(:source) { 'I make the buffer crash' }
-
-    before do
-      buffer = double
-      allow(buffer).to receive(:source=) { raise RuntimeError }
-      allow(Parser::Source::Buffer).to receive(:new).and_return(buffer)
-    end
-
-    context 'when the error handler does not handle the error' do
-      let(:examiner) { described_class.new(source) }
-
-      it 'does not raise an error during initialization' do
-        expect { examiner }.not_to raise_error
-      end
-
-      it 'raises an incomprehensible source error when asked for smells' do
-        expect { examiner.smells }.to raise_error Reek::Errors::IncomprehensibleSourceError
-      end
-    end
-
-    context 'when the error handler handles the error' do
-      let(:handler) { instance_double(Reek::LoggingErrorHandler, handle: true) }
-      let(:examiner) { described_class.new(source, error_handler: handler) }
-
-      it 'does not raise an error when asked for smells' do
-        expect { examiner.smells }.not_to raise_error
-      end
-
-      it 'passes the wrapped error to the handler' do
-        examiner.smells
-        expect(handler).to have_received(:handle).with(Reek::Errors::IncomprehensibleSourceError)
-      end
-    end
-  end
-
-  context 'with a source that triggers a syntax error' do
-    let(:examiner) { described_class.new(source) }
-    let(:source) do
-      <<~RUBY
-        1 2 3
-      RUBY
-    end
-
-    it 'does not raise an error during initialization' do
-      expect { examiner }.not_to raise_error
-    end
-
-    it 'raises an encoding error when asked for smells' do
-      expect { examiner.smells }.to raise_error Reek::Errors::SyntaxError
-    end
-
-    it 'explains the origin of the error' do
-      message = "Source 'string' cannot be processed by Reek due to a syntax error in the source file."
-      expect { examiner.smells }.to raise_error.with_message(/#{message}/)
-    end
-
-    it 'shows the original exception class' do
-      expect { examiner.smells }.
-        to raise_error { |it| expect(it.long_message).to match(/Parser::SyntaxError/) }
-    end
-  end
-
-  context 'with a source that triggers an encoding error' do
-    let(:examiner) { described_class.new(source) }
-    let(:source) do
-      <<~RUBY
-        # encoding: US-ASCII
-        puts 'こんにちは世界'
-      RUBY
-    end
-
-    it 'does not raise an error during initialization' do
-      expect { examiner }.not_to raise_error
-    end
-
-    it 'raises an encoding error when asked for smells' do
-      expect { examiner.smells }.to raise_error Reek::Errors::EncodingError
-    end
-
-    it 'explains the origin of the error' do
-      message = "Source 'string' cannot be processed by Reek due to an encoding error in the source file."
-      expect { examiner.smells }.to raise_error.with_message(/#{message}/)
-    end
-
-    it 'shows the original exception class' do
-      expect { examiner.smells }.
-        to raise_error { |it| expect(it.long_message).to match(/InvalidByteSequenceError/) }
-    end
-  end
-
-  describe 'bad comment config' do
-    let(:examiner) { described_class.new(source) }
-
-    context 'with an unknown smell detector' do
-      let(:source) do
-        <<-RUBY
-          # :reek:DoesNotExist
-          def alfa; end
-        RUBY
-      end
-
-      it 'raises a bad detector name error' do
-        expect { examiner.smells }.to raise_error Reek::Errors::BadDetectorInCommentError
-      end
-
-      it 'explains the reason for the error' do
-        message = "You are trying to configure an unknown smell detector 'DoesNotExist'"
-
-        expect { examiner.smells }.to raise_error.with_message(/#{message}/)
-      end
-
-      it 'explains the origin of the error' do
-        details = "The source is 'string' and the comment belongs "\
-                  'to the expression starting in line 2.'
-
-        expect { examiner.smells }.to raise_error.with_message(/#{details}/)
-      end
-    end
-
-    context 'with garbage in detector config' do
-      let(:source) do
-        <<-RUBY
-          # :reek:UncommunicativeMethodName { thats: a: bad: config }
-          def alfa; end
-        RUBY
-      end
-
-      it 'raises a garbarge configuration error' do
-        expect { examiner.smells }.to raise_error Reek::Errors::GarbageDetectorConfigurationInCommentError
-      end
-
-      it 'explains the reason for the error' do
-        message = "Error: You are trying to configure the smell detector 'UncommunicativeMethodName'"
-
-        expect { examiner.smells }.to raise_error.with_message(/#{message}/)
-      end
-
-      it 'explains the origin of the error' do
-        details = "The source is 'string' and the comment belongs "\
-                  'to the expression starting in line 2.'
-
-        expect { examiner.smells }.to raise_error.with_message(/#{details}/)
-      end
-    end
-  end
-end

data/spec/reek/logging_error_handler_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../spec_helper'
-require_lib 'reek/logging_error_handler'
-
-RSpec.describe Reek::LoggingErrorHandler do
-  describe '#handle' do
-    let(:exception) { RuntimeError.new('some message') }
-    let(:handler) { described_class.new }
-
-    it "outputs the exception's message to stderr" do
-      expect { handler.handle(exception) }.
-        to output(/some message/).to_stderr
-    end
-
-    it 'indicates the exception has been appropriately handled' do
-      result = false
-
-      Reek::CLI::Silencer.silently do
-        result = handler.handle(exception)
-      end
-
-      expect(result).to be_truthy
-    end
-  end
-end

data/spec/reek/rake/task_spec.rb

@@ -1,56 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/rake/task'
-
-RSpec.describe Reek::Rake::Task do
-  describe '#source_files' do
-    it 'is set to "lib/**/*.rb" by default' do
-      task = described_class.new
-      expect(task.source_files).to eq FileList['lib/**/*.rb']
-    end
-
-    it 'is set to ENV["REEK_SRC"]' do
-      begin
-        ENV['REEK_SRC'] = '*.rb'
-        task = described_class.new
-        expect(task.source_files).to eq FileList['*.rb']
-      ensure
-        ENV['REEK_SRC'] = nil
-      end
-    end
-  end
-
-  describe '#source_files=' do
-    it 'sets source_files to a FileList when passed a string' do
-      task = described_class.new do |it|
-        it.source_files = '*.rb'
-      end
-      expect(task.source_files).to eq FileList['*.rb']
-    end
-
-    it 'has no effect when ENV["REEK_SRC"] is set' do
-      begin
-        ENV['REEK_SRC'] = '*.rb'
-        task = described_class.new do |it|
-          it.source_files = 'lib/*.rb'
-        end
-        expect(task.source_files).to eq FileList['*.rb']
-      ensure
-        ENV['REEK_SRC'] = nil
-      end
-    end
-  end
-
-  # SMELL: Testing a private method
-  describe '#command' do
-    let(:task) { described_class.new }
-
-    it 'does not include a config file by default' do
-      expect(task.send(:command)).not_to include '-c'
-    end
-
-    it 'includes a config file when set' do
-      task.config_file = 'foo.reek'
-      expect(task.send(:command)[1..2]).to eq ['-c', 'foo.reek']
-    end
-  end
-end

data/spec/reek/report/code_climate/code_climate_configuration_spec.rb

@@ -1,22 +0,0 @@
-require_relative '../../../spec_helper'
-require_lib 'reek/report/code_climate/code_climate_configuration'
-
-RSpec.describe Reek::Report::CodeClimateConfiguration do
-  yml = described_class.load
-  smell_types = Reek::SmellDetectors::BaseDetector.descendants.map(&:smell_type)
-
-  smell_types.each do |name|
-    config = yml.fetch(name)
-    it "provides remediation_points for #{name}" do
-      expect(config['remediation_points']).to be_a Integer
-    end
-
-    it "provides content for #{name}" do
-      expect(config['content']).to be_a String
-    end
-  end
-
-  it 'does not include extraneous configuration' do
-    expect(smell_types).to match_array(yml.keys)
-  end
-end

data/spec/reek/report/code_climate/code_climate_fingerprint_spec.rb

@@ -1,126 +0,0 @@
-require_relative '../../../spec_helper'
-require_lib 'reek/report/code_climate/code_climate_fingerprint'
-
-RSpec.describe Reek::Report::CodeClimateFingerprint do
-  describe '#compute' do
-    let(:computed) { described_class.new(warning).compute }
-
-    context 'when fingerprinting a warning with no parameters' do
-      let(:expected_fingerprint) { 'e68badd29db51c92363a7c6a2438d722' }
-      let(:warning) do
-        Reek::SmellWarning.new(
-          'UtilityFunction',
-          context:    'alfa',
-          message:    "doesn't depend on instance state (maybe move it to another class?)",
-          lines:      lines,
-          source:     'a/ruby/source/file.rb')
-      end
-
-      context 'with code at a specific location' do
-        let(:lines) { [1] }
-
-        it 'computes the fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-
-      context 'with code at a different location' do
-        let(:lines) { [5] }
-
-        it 'computes the same fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-    end
-
-    context 'when the fingerprint should not be computed' do
-      let(:warning) do
-        Reek::SmellWarning.new(
-          'ManualDispatch',
-          context:    'Alfa#bravo',
-          message:    'manually dispatches method call',
-          lines:      [4],
-          source:     'a/ruby/source/file.rb')
-      end
-
-      it 'returns nil' do
-        expect(computed).to be_nil
-      end
-    end
-
-    context 'when the smell warning has only identifying parameters' do
-      let(:warning) do
-        Reek::SmellWarning.new(
-          'ClassVariable',
-          context:    'Alfa',
-          message:    "declares the class variable '@@#{name}'",
-          lines:      [4],
-          parameters: { name: "@@#{name}" },
-          source:     'a/ruby/source/file.rb')
-      end
-
-      context 'when the name is one thing' do
-        let(:name) { 'bravo' }
-        let(:expected_fingerprint) { '9c3fd378178118a67e9509f87cae24f9' }
-
-        it 'computes the fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-
-      context 'when the name is another thing' do
-        let(:name) { 'echo' }
-        let(:expected_fingerprint) { 'd2a6d2703ce04cca65e7300b7de4b89f' }
-
-        it 'computes another fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-    end
-
-    context 'when the smell warning has identifying and non-identifying parameters' do
-      let(:warning) do
-        Reek::SmellWarning.new(
-          'DuplicateMethodCall',
-          context:    "Alfa##{name}",
-          message:    "calls '#{name}' #{count} times",
-          lines:      lines,
-          parameters: { name: "@@#{name}", count: count },
-          source:     'a/ruby/source/file.rb')
-      end
-
-      context 'when the parameters are provided' do
-        let(:name) { 'bravo' }
-        let(:count) { 5 }
-        let(:lines) { [1, 7, 10, 13, 15] }
-        let(:expected_fingerprint) { '238733f4f51ba5473dcbe94a43ec5400' }
-
-        it 'computes the fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-
-      context 'when the non-identifying parameters change' do
-        let(:name) { 'bravo' }
-        let(:count) { 9 }
-        let(:lines) { [1, 7, 10, 13, 15, 17, 19, 20, 25] }
-        let(:expected_fingerprint) { '238733f4f51ba5473dcbe94a43ec5400' }
-
-        it 'computes the same fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-
-      context 'when the identifying parameters change' do
-        let(:name) { 'echo' }
-        let(:count) { 5 }
-        let(:lines) { [1, 7, 10, 13, 15] }
-        let(:expected_fingerprint) { 'e0c35e9223cc19bdb9a04fb3e60573e1' }
-
-        it 'computes a different fingerprint' do
-          expect(computed).to eq expected_fingerprint
-        end
-      end
-    end
-  end
-end

data/spec/reek/report/code_climate/code_climate_formatter_spec.rb

@@ -1,51 +0,0 @@
-require_relative '../../../spec_helper'
-require_lib 'reek/report/code_climate/code_climate_formatter'
-
-RSpec.describe Reek::Report::CodeClimateFormatter do
-  describe '#render' do
-    let(:warning) do
-      Reek::SmellWarning.new(
-        'UtilityFunction',
-        context:    'context foo',
-          message:    'message bar',
-          lines:      [1, 2],
-          source:     'a/ruby/source/file.rb')
-    end
-    let(:rendered) { described_class.new(warning).render }
-    let(:json) { JSON.parse rendered.chop }
-
-    it "sets the type as 'issue'" do
-      expect(json['type']).to eq 'issue'
-    end
-
-    it 'sets the category' do
-      expect(json['categories']).to eq ['Complexity']
-    end
-
-    it 'constructs a description based on the context and message' do
-      expect(json['description']).to eq 'context foo message bar'
-    end
-
-    it 'sets a check name based on the smell detector' do
-      expect(json['check_name']).to eq 'UtilityFunction'
-    end
-
-    it 'sets the location' do
-      expect(json['location']).to eq('path' => 'a/ruby/source/file.rb',
-                                     'lines' => { 'begin' => 1, 'end' => 2 })
-    end
-
-    it 'sets a content based on the smell detector' do
-      expect(json['content']['body']).
-        to eq "A _Utility Function_ is any instance method that has no dependency on the state of the instance.\n"
-    end
-
-    it 'sets remediation points based on the smell detector' do
-      expect(json['remediation_points']).to eq 250_000
-    end
-
-    it 'sets fingerprint based on warning context' do
-      expect(json['fingerprint']).to eq '70c530e45999af129d520f1f579f967f'
-    end
-  end
-end

data/spec/reek/report/code_climate/code_climate_report_spec.rb

@@ -1,56 +0,0 @@
-require_relative '../../../spec_helper'
-require_lib 'reek/examiner'
-require_lib 'reek/report/code_climate'
-
-require 'json'
-require 'stringio'
-
-RSpec.describe Reek::Report::CodeClimateReport do
-  let(:options) { {} }
-  let(:instance) { described_class.new(**options) }
-  let(:examiner) { Reek::Examiner.new(source) }
-
-  before do
-    instance.add_examiner examiner
-  end
-
-  context 'with empty source' do
-    let(:source) { '' }
-
-    it 'prints an empty string' do
-      expect { instance.show }.to output('').to_stdout
-    end
-  end
-
-  context 'with smelly source' do
-    let(:source) { 'def simple(a) a[3] end' }
-
-    it 'prints smells as json' do
-      expected = <<~HERE.delete("\n")
-        {"type":"issue",
-        "check_name":"UncommunicativeParameterName",
-        "description":"simple has the parameter name 'a'",
-        "categories":["Complexity"],
-        "location":{"path":"string","lines":{"begin":1,"end":1}},
-        "remediation_points":150000,
-        "content":{"body":"An `Uncommunicative Parameter Name` is a parameter name that
-         doesn't communicate its intent well enough.\\n\\nPoor names make it hard for the reader
-         to build a mental picture of what's going on in the code. They can also be
-         mis-interpreted; and they hurt the flow of reading, because the reader must slow down
-         to interpret the names.\\n"},
-        "fingerprint":"09970037d92b5a628bf682a3e2bb126d"}\u0000
-        {"type":"issue",
-        "check_name":"UtilityFunction",
-        "description":"simple doesn't depend on instance state (maybe move it to another class?)",
-        "categories":["Complexity"],
-        "location":{"path":"string","lines":{"begin":1,"end":1}},
-        "remediation_points":250000,
-        "content":{"body":"A _Utility Function_ is any instance method that has no
-         dependency on the state of the instance.\\n"},
-        "fingerprint":"db456db7cb344bb5a98b8fc54a2f382e"}\u0000
-      HERE
-
-      expect { instance.show }.to output(expected).to_stdout
-    end
-  end
-end

data/spec/reek/report/html_report_spec.rb

@@ -1,19 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/examiner'
-require_lib 'reek/report/html_report'
-
-RSpec.describe Reek::Report::HTMLReport do
-  let(:instance) { described_class.new }
-
-  context 'with an empty source' do
-    let(:examiner) { Reek::Examiner.new('') }
-
-    before do
-      instance.add_examiner examiner
-    end
-
-    it 'has the text 0 total warnings' do
-      expect { instance.show }.to output(/0 total warnings/).to_stdout
-    end
-  end
-end