reek 6.0.3 → 6.0.4

data/spec/reek/smell_detectors/utility_function_spec.rb

@@ -1,309 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/smell_detectors/utility_function'
-
-RSpec.describe Reek::SmellDetectors::UtilityFunction do
-  it 'reports the right values' do
-    src = <<-RUBY
-      def alfa(bravo)
-        bravo.charlie.delta
-      end
-    RUBY
-
-    expect(src).to reek_of(:UtilityFunction,
-                           lines:   [1],
-                           context: 'alfa',
-                           message: "doesn't depend on instance state (maybe move it to another class?)",
-                           source:  'string')
-  end
-
-  it 'counts a local call in a param initializer' do
-    src = 'def alfa(bravo = charlie) bravo.to_s end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'counts usages of self' do
-    src = 'def alfa(bravo); alfa.bravo(self); end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'counts self reference within a dstr' do
-    src = 'def alfa(bravo); "#{self} #{bravo}"; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'counts calls to self within a dstr' do
-    src = 'def alfa(bravo); "#{self.gsub(/charlie/, /delta/)}"; end'
-    expect(src).
-      not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report a method that calls super' do
-    src = 'def alfa(bravo) super; bravo.to_s; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report a method that calls super with arguments' do
-    src = 'def alfa(bravo) super(bravo); bravo.to_s; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'recognises a deep call' do
-    src = <<-RUBY
-        class Alfa
-          def bravo(charlie)
-            charlie.each { |delta| foxtrot(delta) }
-          end
-
-          def foxtrot(golf)
-            @india << golf
-          end
-        end
-    RUBY
-
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report empty method' do
-    src = 'def alfa(bravo); end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report literal' do
-    src = 'def alfa; 3; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report instance variable reference' do
-    src = 'def alfa; @bravo; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report vcall' do
-    src = 'def alfa; bravo; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'does not report references to self' do
-    src = 'def alfa; self; end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'recognises an ivar reference within a block' do
-    src = 'def alfa(bravo) bravo.each { @charlie = 3} end'
-    expect(src).not_to reek_of(:UtilityFunction)
-  end
-
-  it 'reports a call to a constant' do
-    src = 'def simple(arga) FIELDS[arga] end'
-    expect(src).to reek_of(:UtilityFunction, context: 'simple')
-  end
-
-  context 'when examining singleton methods' do
-    ['class', 'module'].each do |scope|
-      it "does not report for #{scope} with `class << self` notation" do
-        src = "#{scope} Alfa; class << self; def bravo(charlie) charlie.to_s; end; end; end"
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-
-      it "does not report for #{scope} with `self.` notation" do
-        src = "#{scope} Alfa; def self.bravo(charlie) charlie.to_s; end; end"
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-    end
-
-    context 'when defined by using `module_function`' do
-      it 'does not report UtilityFunction also when using multiple arguments' do
-        src = <<-RUBY
-          class Alfa
-            def bravo(charlie) charlie.to_s; end
-            def delta(echo) echo.to_s; end
-            module_function :bravo, :delta
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-
-      it 'does not report module functions defined by earlier modifier' do
-        src = <<-RUBY
-          module Alfa
-            module_function
-            def bravo(charlie) charlie.to_s; end
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-
-      it 'reports functions preceded by canceled modifier' do
-        src = <<-RUBY
-          module Alfa
-            module_function
-            public
-            def bravo(charlie) charlie.to_s; end
-          end
-        RUBY
-
-        expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
-      end
-
-      it 'does not report when module_function is called in separate scope' do
-        src = <<-RUBY
-          class Alfa
-            def bravo(charlie) charlie.to_s; end
-            begin
-              module_function :bravo
-            end
-          end
-        RUBY
-        expect(src).not_to reek_of(:UtilityFunction)
-      end
-    end
-  end
-
-  context 'when examining refinements' do
-    it 'reports on the refined class' do
-      src = <<-RUBY
-        module Alfa
-          refine Bravo do
-            def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:UtilityFunction, context: 'Bravo#bravo')
-    end
-  end
-
-  describe 'method visibility' do
-    it 'reports private methods' do
-      src = <<-RUBY
-        class Alfa
-          private
-          def bravo(charlie)
-            charlie.delta.echo
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
-    end
-
-    it 'reports protected methods' do
-      src = <<-RUBY
-        class Alfa
-          protected
-          def bravo(charlie)
-            charlie.delta.echo
-          end
-        end
-      RUBY
-
-      expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo')
-    end
-  end
-
-  describe 'disabling UtilityFunction via configuration for non-public methods' do
-    let(:config) do
-      { Reek::SmellDetectors::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true }
-    end
-
-    context 'when examining public methods' do
-      it 'still reports UtilityFunction' do
-        src = <<-RUBY
-          class Alfa
-            def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        RUBY
-
-        expect(src).to reek_of(:UtilityFunction, context: 'Alfa#bravo').with_config(config)
-      end
-    end
-
-    context 'when examining private methods' do
-      it 'does not report UtilityFunction' do
-        src = <<-RUBY
-          class Alfa
-            private
-            def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
-      end
-
-      it 'does not report UtilityFunction when private is used as a def modifier' do
-        src = <<-RUBY
-          class Alfa
-            private def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
-      end
-    end
-
-    context 'when examining protected methods' do
-      it 'does not report UtilityFunction' do
-        src = <<-RUBY
-          class Alfa
-            protected
-            def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
-      end
-
-      it 'does not report UtilityFunction when protected is used as a def modifier' do
-        src = <<-RUBY
-          class Alfa
-            protected def bravo(charlie)
-              charlie.delta.echo
-            end
-          end
-        RUBY
-
-        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
-      end
-    end
-  end
-
-  describe 'disabling with a comment' do
-    it 'disables the method following the comment' do
-      src = <<-RUBY
-        class Alfa
-          # :reek:UtilityFunction
-          def bravo(charlie)
-            charlie.delta.echo
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
-
-    it 'disables a method when it has a visibility modifier' do
-      src = <<-RUBY
-        class Alfa
-          # :reek:UtilityFunction
-          private def bravo(charlie)
-            charlie.delta.echo
-          end
-        end
-      RUBY
-
-      expect(src).not_to reek_of(:UtilityFunction)
-    end
-  end
-end

data/spec/reek/smell_warning_spec.rb

@@ -1,137 +0,0 @@
-require_relative '../spec_helper'
-require_lib 'reek/smell_warning'
-
-RSpec.describe Reek::SmellWarning do
-  let(:uncommunicative_name_detector) { build(:smell_detector, smell_type: 'UncommunicativeVariableName') }
-
-  describe 'sort order' do
-    shared_examples_for 'first sorts ahead of second' do
-      it 'hash differently' do
-        expect(first.hash).not_to eq(second.hash)
-      end
-
-      it 'are not equal' do
-        expect(first).not_to eq(second)
-      end
-
-      it 'sort correctly' do
-        expect(first <=> second).to be < 0
-      end
-
-      it 'does not match using eql?' do
-        expect(first).not_to eql(second)
-      end
-    end
-
-    context 'when smells differ only by detector' do
-      let(:first) { build_smell_warning(smell_type: 'DuplicateMethodCall') }
-      let(:second) { build_smell_warning(smell_type: 'FeatureEnvy') }
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-
-    context 'when smells differ only by lines' do
-      let(:first) { build_smell_warning(smell_type: 'FeatureEnvy', lines: [2]) }
-      let(:second) { build_smell_warning(smell_type: 'FeatureEnvy', lines: [3]) }
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-
-    context 'when smells differ only by context' do
-      let(:first) { build_smell_warning(smell_type: 'DuplicateMethodCall', context: 'first') }
-      let(:second) do
-        build_smell_warning(smell_type: 'DuplicateMethodCall', context: 'second')
-      end
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-
-    context 'when smells differ only by message' do
-      let(:first) do
-        build_smell_warning(smell_type: 'DuplicateMethodCall',
-                              context: 'ctx', message: 'first message')
-      end
-      let(:second) do
-        build_smell_warning(smell_type: 'DuplicateMethodCall',
-                              context: 'ctx', message: 'second message')
-      end
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-
-    context 'when smells differ by name and message' do
-      let(:first) do
-        build_smell_warning(smell_type: 'FeatureEnvy', message: 'second message')
-      end
-      let(:second) do
-        build_smell_warning(smell_type: 'UtilityFunction', message: 'first message')
-      end
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-
-    context 'when smells differ everywhere' do
-      let(:first) do
-        build_smell_warning(smell_type: 'DuplicateMethodCall',
-                              context: 'Dirty#a',
-                              message: 'calls @s.title twice')
-      end
-
-      let(:second) do
-        build_smell_warning(smell_type: 'UncommunicativeVariableName',
-                              context: 'Dirty',
-                              message: "has the variable name '@s'")
-      end
-
-      it_behaves_like 'first sorts ahead of second'
-    end
-  end
-
-  describe '#yaml_hash' do
-    let(:context_name) { 'Module::Class#method/block' }
-    let(:lines) { [24, 513] }
-    let(:message) { 'test message' }
-    let(:parameters) { { 'one' => 34, 'two' => 'second' } }
-    let(:smell_type) { 'FeatureEnvy' }
-    let(:source) { 'a/ruby/source/file.rb' }
-
-    let(:yaml) do
-      warning = described_class.new(smell_type, source: source,
-                                    context: context_name,
-                                    lines: lines,
-                                    message: message,
-                                    parameters: parameters)
-      warning.yaml_hash
-    end
-
-    it 'includes the smell type' do
-      expect(yaml['smell_type']).to eq 'FeatureEnvy'
-    end
-
-    it 'includes the context' do
-      expect(yaml['context']).to eq context_name
-    end
-
-    it 'includes the message' do
-      expect(yaml['message']).to eq message
-    end
-
-    it 'includes the line numbers' do
-      expect(yaml['lines']).to match_array lines
-    end
-
-    it 'includes the source' do
-      expect(yaml['source']).to eq source
-    end
-
-    it 'includes the documentation link' do
-      expect(yaml['documentation_link']).to eq Reek::DocumentationLink.build('FeatureEnvy')
-    end
-
-    it 'includes the parameters' do
-      parameters.each do |key, value|
-        expect(yaml[key]).to eq value
-      end
-    end
-  end
-end

data/spec/reek/source/source_code_spec.rb

@@ -1,79 +0,0 @@
-require_relative '../../spec_helper'
-require 'stringio'
-require_lib 'reek/source/source_code'
-
-RSpec.describe Reek::Source::SourceCode do
-  describe '#syntax_tree' do
-    it 'associates comments with the AST' do
-      source = "# this is\n# a comment\ndef foo; end"
-      source_code = described_class.new(source: source, origin: '(string)')
-      result = source_code.syntax_tree
-      expect(result.leading_comment).to eq "# this is\n# a comment"
-    end
-
-    it 'cleanly processes empty source' do
-      source_code = described_class.new(source: '', origin: '(string)')
-      result = source_code.syntax_tree
-      expect(result.type).to eq :empty
-    end
-
-    it 'cleanly processes empty source with comments' do
-      source = "# this is\n# a comment\n"
-      source_code = described_class.new(source: source, origin: '(string)')
-      result = source_code.syntax_tree
-      expect(result.type).to eq :empty
-    end
-
-    it 'does not crash with sequences incompatible with UTF-8' do
-      source = '"\xFF"'
-      source_code = described_class.new(source: source, origin: '(string)')
-      result = source_code.syntax_tree
-      expect(result.children.first).to eq "\xFF"
-    end
-
-    it 'returns a :lambda node for lambda expressions' do
-      source = '->() { }'
-      source_code = described_class.new(source: source, origin: '(string)')
-      result = source_code.syntax_tree
-      expect(result.children.first.type).to eq :lambda
-    end
-
-    context 'when the parser fails with a Parser::SyntaxError' do
-      let(:src) { described_class.new(source: code) }
-      let(:code) { '== Invalid Syntax ==' }
-
-      it 'raises the error' do
-        expect { src.syntax_tree }.to raise_error Parser::SyntaxError
-      end
-    end
-
-    context 'when the parser fails with a generic error' do
-      let(:code) { '' }
-      let(:parser) { instance_double('Parser::Ruby25') }
-      let(:src) { described_class.new(source: code, parser: parser) }
-      let(:error_class) { RuntimeError }
-      let(:error_message) { 'An error' }
-
-      before do
-        allow(parser).to receive(:parse_with_comments).and_raise(error_class, error_message)
-      end
-
-      it 'raises the error' do
-        expect { src.syntax_tree }.to raise_error error_class, error_message
-      end
-    end
-
-    if RUBY_VERSION >= '2.7'
-      context 'with ruby 2.7 syntax' do
-        context 'with forward_args (`...`)' do
-          let(:source_code) { described_class.new(source: 'def alpha(...) bravo(...); end') }
-
-          it 'returns a :forward_args node' do
-            result = source_code.syntax_tree
-            expect(result.children[1].type).to eq(:forward_args)
-          end
-        end
-      end
-    end
-  end
-end