reek 6.0.1 → 6.0.5

data/spec/reek/report/xml_report_spec.rb

@@ -1,24 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/examiner'
-require_lib 'reek/report/xml_report'
-
-RSpec.describe Reek::Report::XMLReport do
-  let(:xml_report) { described_class.new }
-
-  context 'with an empty source' do
-    it 'prints empty checkstyle XML' do
-      xml_report.add_examiner Reek::Examiner.new('')
-      xml = "<?xml version='1.0'?>\n<checkstyle/>\n"
-      expect { xml_report.show }.to output(xml).to_stdout
-    end
-  end
-
-  context 'with a source with violations' do
-    it 'prints non-empty checkstyle XML' do
-      xml_report.add_examiner Reek::Examiner.new(SMELLY_FILE)
-      xml = SAMPLES_DIR.join('checkstyle.xml').read
-      xml = xml.gsub(SMELLY_FILE.to_s, SMELLY_FILE.expand_path.to_s)
-      expect { xml_report.show }.to output(xml).to_stdout
-    end
-  end
-end

data/spec/reek/report/yaml_report_spec.rb

@@ -1,55 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/examiner'
-require_lib 'reek/report/yaml_report'
-
-require 'yaml'
-require 'stringio'
-
-RSpec.describe Reek::Report::YAMLReport 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 empty yaml' do
-      expect { instance.show }.to output(/^--- \[\]\n.*$/).to_stdout
-    end
-  end
-
-  context 'with smelly source' do
-    let(:source) { 'def simple(a) a[3] end' }
-
-    it 'prints smells as yaml' do
-      out = StringIO.new
-      instance.show(out)
-      out.rewind
-      result = YAML.safe_load(out.read)
-      expected = YAML.safe_load <<~YAML
-        ---
-        - context:        "simple"
-          lines:
-          - 1
-          message:            "has the parameter name 'a'"
-          smell_type:         "UncommunicativeParameterName"
-          source:             "string"
-          name:               "a"
-          documentation_link: "https://github.com/troessner/reek/blob/v#{Reek::Version::STRING}/docs/Uncommunicative-Parameter-Name.md"
-        - context:        "simple"
-          lines:
-          - 1
-          message:            "doesn't depend on instance state (maybe move it to another class?)"
-          smell_type:         "UtilityFunction"
-          source:             "string"
-          documentation_link: "https://github.com/troessner/reek/blob/v#{Reek::Version::STRING}/docs/Utility-Function.md"
-      YAML
-
-      expect(result).to eq expected
-    end
-  end
-end

data/spec/reek/report_spec.rb

@@ -1,28 +0,0 @@
-require_relative '../spec_helper'
-require_lib 'reek/report'
-
-RSpec.describe Reek::Report do
-  describe '.report_class' do
-    it 'returns the correct class' do
-      expect(described_class.report_class(:text)).to eq Reek::Report::TextReport
-    end
-  end
-
-  describe '.location_formatter' do
-    it 'returns the correct class' do
-      expect(described_class.location_formatter(:plain)).to eq Reek::Report::BlankLocationFormatter
-    end
-  end
-
-  describe '.heading_formatter' do
-    it 'returns the correct class' do
-      expect(described_class.heading_formatter(:quiet)).to eq Reek::Report::QuietHeadingFormatter
-    end
-  end
-
-  describe '.warning_formatter_class' do
-    it 'returns the correct class' do
-      expect(described_class.warning_formatter_class(:simple)).to eq Reek::Report::SimpleWarningFormatter
-    end
-  end
-end

data/spec/reek/smell_configuration_spec.rb

@@ -1,56 +0,0 @@
-require_relative '../spec_helper'
-require_lib 'reek/smell_configuration'
-
-RSpec.describe Reek::SmellConfiguration do
-  context 'when overriding default configs' do
-    let(:base_config) do
-      {
-        'accept'  => ['_'],
-        'enabled' => true,
-        'exclude' => [],
-        'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/]
-      }
-    end
-
-    let(:smell_config) { described_class.new(base_config) }
-
-    it { expect(smell_config.merge({})).to eq(base_config) }
-    it { expect(smell_config.merge('enabled' => true)).to eq(base_config) }
-    it { expect(smell_config.merge('exclude' => [])).to eq(base_config) }
-    it { expect(smell_config.merge('accept' => ['_'])).to eq(base_config) }
-
-    it do
-      updated = smell_config.merge('reject' => [/^.$/, /[0-9]$/, /[A-Z]/])
-      expect(updated).to eq(base_config)
-    end
-
-    it do
-      updated = smell_config.merge('accept' => ['_'], 'enabled' => true)
-      expect(updated).to eq(base_config)
-    end
-
-    it 'overrides single values' do
-      updated = smell_config.merge('enabled' => false)
-      expect(updated).to eq('accept'  => ['_'],
-                            'enabled' => false,
-                            'exclude' => [],
-                            'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/])
-    end
-
-    it 'overrides arrays of values' do
-      updated = smell_config.merge('reject' => [/^.$/, /[3-9]$/])
-      expect(updated).to eq('accept'  => ['_'],
-                            'enabled' => true,
-                            'exclude' => [],
-                            'reject'  => [/^.$/, /[3-9]$/])
-    end
-
-    it 'overrides multiple values' do
-      updated = smell_config.merge('accept' => [/[A-Z]$/], 'enabled' => false)
-      expect(updated).to eq('accept'  => [/[A-Z]$/],
-                            'enabled' => false,
-                            'exclude' => [],
-                            'reject'  => [/^.$/, /[0-9]$/, /[A-Z]/])
-    end
-  end
-end

data/spec/reek/smell_detectors/attribute_spec.rb

@@ -1,197 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/attribute'
-
-RSpec.describe Reek::SmellDetectors::Attribute do
-  it 'reports the right values' do
-    src = <<-RUBY
-      class Alfa
-        attr_writer :bravo
-      end
-    RUBY
-
-    expect(src).to reek_of(:Attribute,
-                           lines: [2],
-                           context: 'Alfa#bravo',
-                           message: 'is a writable attribute')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      class Alfa
-        attr_writer :bravo
-        attr_writer :charlie
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:Attribute, lines: [2], context: 'Alfa#bravo').
-      and reek_of(:Attribute, lines: [3], context: 'Alfa#charlie')
-  end
-
-  it 'records nothing with no attributes' do
-    src = <<-RUBY
-      class Alfa
-      end
-    RUBY
-
-    expect(src).not_to reek_of(:Attribute)
-  end
-
-  context 'with attributes' do
-    it 'records nothing for attribute readers' do
-      src = <<-RUBY
-        class Alfa
-          attr :bravo
-          attr_reader :charlie
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:Attribute)
-    end
-
-    it 'records writer attribute' do
-      src = <<-RUBY
-        class Alfa
-          attr_writer :bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute, context: 'Alfa#bravo')
-    end
-
-    it 'does not record writer attribute if suppressed with a preceding code comment' do
-      src = <<-RUBY
-        class Alfa
-          # :reek:Attribute
-          attr_writer :bravo
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:Attribute)
-    end
-
-    it 'records attr_writer attribute in a module' do
-      src = <<-RUBY
-        module Mod
-          attr_writer :bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it 'records accessor attribute' do
-      src = <<-RUBY
-        class Alfa
-          attr_accessor :bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it 'records attr defining a writer' do
-      src = <<-RUBY
-        class Alfa
-          attr :bravo, true
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it "doesn't record protected attributes" do
-      src = <<-RUBY
-        class Alfa
-          protected
-          attr_writer :alfa
-          attr_accessor :bravo
-          attr :charlie
-          attr :delta, true
-          attr_reader :echo
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:Attribute)
-    end
-
-    it "doesn't record private attributes" do
-      src = <<-RUBY
-        class Alfa
-          private
-          attr_writer :alfa
-          attr_accessor :bravo
-          attr :charlie
-          attr :delta, true
-          attr_reader :echo
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:Attribute)
-    end
-
-    it 'records attr_writer defined in public section' do
-      src = <<-RUBY
-        class Alfa
-          private
-          public
-          attr_writer :bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it 'records attr_writer after switching visbility to public' do
-      src = <<-RUBY
-        class Alfa
-          private
-          attr_writer :bravo
-          public :bravo
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it 'resets visibility in new contexts' do
-      src = <<-RUBY
-        class Alfa
-          private
-          attr_writer :bravo
-        end
-
-        class Charlie
-          attr_writer :delta
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute, context: 'Charlie#delta')
-    end
-
-    it 'records attr_writer defining a class attribute' do
-      src = <<-RUBY
-        class Alfa
-          class << self
-            attr_writer :bravo
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:Attribute)
-    end
-
-    it 'does not record private class attributes' do
-      src = <<-RUBY
-        class Alfa
-          class << self
-            private
-            attr_writer :bravo
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:Attribute)
-    end
-  end
-end

data/spec/reek/smell_detectors/base_detector_spec.rb

@@ -1,50 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/base_detector'
-require_lib 'reek/smell_detectors/duplicate_method_call'
-
-RSpec.describe Reek::SmellDetectors::BaseDetector do
-  describe '.todo_configuration_for' do
-    it 'returns exclusion configuration for the given smells' do
-      smell = build_smell_warning(smell_type: 'Foo', context: 'Foo#bar')
-      result = described_class.todo_configuration_for([smell])
-      expect(result).to eq('BaseDetector' => { 'exclude' => ['Foo#bar'] })
-    end
-
-    it 'merges identical contexts' do
-      smell = build_smell_warning(smell_type: 'Foo', context: 'Foo#bar')
-      result = described_class.todo_configuration_for([smell, smell])
-      expect(result).to eq('BaseDetector' => { 'exclude' => ['Foo#bar'] })
-    end
-
-    context 'with default exclusions present' do
-      let(:subclass) { Reek::SmellDetectors::TooManyStatements }
-
-      it 'includes default exclusions' do
-        smell = build_smell_warning(smell_type: 'TooManyStatements', context: 'Foo#bar')
-        result = subclass.todo_configuration_for([smell])
-
-        aggregate_failures do
-          expect(subclass.default_config['exclude']).to eq ['initialize']
-          expect(result).to eq('TooManyStatements' => { 'exclude' => ['initialize', 'Foo#bar'] })
-        end
-      end
-    end
-  end
-
-  describe '.to_detector' do
-    it 'returns the right detector' do
-      expect(described_class.to_detector('DuplicateMethodCall')).to eq(Reek::SmellDetectors::DuplicateMethodCall)
-    end
-
-    it 'raise NameError for an invalid detector name' do
-      expect { described_class.to_detector('Unknown') }.to raise_error(NameError)
-    end
-  end
-
-  describe '.configuration_keys' do
-    it 'returns the right keys' do
-      expected_keys = Reek::SmellDetectors::DuplicateMethodCall.configuration_keys.to_a
-      expect(expected_keys).to eq([:enabled, :exclude, :max_calls, :allow_calls])
-    end
-  end
-end

data/spec/reek/smell_detectors/boolean_parameter_spec.rb

@@ -1,93 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/boolean_parameter'
-
-RSpec.describe Reek::SmellDetectors::BooleanParameter do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo = true)
-      end
-    RUBY
-
-    expect(src).to reek_of(:BooleanParameter,
-                           lines: [1],
-                           context: 'alfa',
-                           message: "has boolean parameter 'bravo'",
-                           source: 'string',
-                           parameter: 'bravo')
-  end
-
-  it 'does count all occurences' do
-    src = <<-RUBY
-      def alfa(bravo = true, charlie = true)
-      end
-    RUBY
-
-    expect(src).
-      to reek_of(:BooleanParameter, lines: [1], context: 'alfa', parameter: 'bravo').
-      and reek_of(:BooleanParameter, lines: [1], context: 'alfa', parameter: 'charlie')
-  end
-
-  context 'when examining an instance method' do
-    it 'reports a parameter defaulted to false' do
-      src = 'def alfa(bravo = false) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports two parameters defaulted to booleans in a mixed parameter list' do
-      src = 'def alfa(bravo, charlie = true, delta = false, &echo) end'
-
-      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie').
-        and reek_of(:BooleanParameter, parameter: 'delta').
-        and not_reek_of(:BooleanParameter, parameter: 'bravo').
-        and not_reek_of(:BooleanParameter, parameter: 'echo')
-    end
-
-    it 'reports keyword parameters defaulted to booleans' do
-      src = 'def alfa(bravo: true, charlie: false) end'
-      expect(src).
-        to reek_of(:BooleanParameter, parameter: 'bravo').
-        and reek_of(:BooleanParameter, parameter: 'charlie')
-    end
-
-    it 'does not report regular parameters' do
-      src = 'def alfa(bravo, charlie) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report array decomposition parameters' do
-      src = 'def alfa((bravo, charlie)) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report keyword parameters with no default' do
-      src = 'def alfa(bravo:, charlie:) end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-
-    it 'does not report keyword parameters with non-boolean default' do
-      src = 'def alfa(bravo: 42, charlie: "32") end'
-      expect(src).not_to reek_of(:BooleanParameter)
-    end
-  end
-
-  context 'when examining a singleton method' do
-    it 'reports a parameter defaulted to true' do
-      src = 'def self.alfa(bravo = true) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports a parameter defaulted to false' do
-      src = 'def self.alfa(bravo = false) end'
-      expect(src).to reek_of(:BooleanParameter)
-    end
-
-    it 'reports two parameters defaulted to booleans' do
-      src = 'def self.alfa(bravo, charlie = true, delta = false, &echo) end'
-
-      expect(src).to reek_of(:BooleanParameter, parameter: 'charlie').
-        and reek_of(:BooleanParameter, parameter: 'delta').
-        and not_reek_of(:BooleanParameter, parameter: 'bravo').
-        and not_reek_of(:BooleanParameter, parameter: 'echo')
-    end
-  end
-end