reek 5.6.0 → 6.0.0

data/spec/reek/context_builder_spec.rb

@@ -3,42 +3,126 @@ require_lib 'reek/context_builder'
 
 RSpec.describe Reek::ContextBuilder do
   describe '#context_tree' do
-    let(:walker) do
-      code = 'class Car; def drive; end; end'
-      described_class.new(syntax_tree(code))
+    context 'with some simple example code' do
+      let(:walker) do
+        code = 'class Car; def drive; end; end'
+        described_class.new(syntax_tree(code))
+      end
+      let(:context_tree) { walker.context_tree }
+      let(:module_context) { context_tree.children.first }
+      let(:method_context) { module_context.children.first }
+
+      describe 'the starting node' do
+        it 'is a root node' do
+          expect(context_tree.type).to eq(:root)
+          expect(context_tree).to be_a(Reek::Context::RootContext)
+        end
+
+        it 'has one module_context child' do
+          aggregate_failures do
+            expect(context_tree.children.count).to eq 1
+            expect(module_context).to be_a(Reek::Context::ModuleContext)
+          end
+        end
+      end
+
+      describe 'the module node' do
+        it 'has one method_context child' do
+          aggregate_failures do
+            expect(method_context).to be_a(Reek::Context::MethodContext)
+            expect(module_context.children.size).to eq(1)
+          end
+        end
+
+        it 'holds a reference to the parent context' do
+          expect(method_context.parent).to eq(module_context)
+        end
+      end
     end
-    let(:context_tree) { walker.context_tree }
-    let(:module_context) { context_tree.children.first }
-    let(:method_context) { module_context.children.first }
 
-    it 'starts with a root node' do
-      expect(context_tree.type).to eq(:root)
-      expect(context_tree).to be_a(Reek::Context::RootContext)
+    it 'creates the proper context for all kinds of singleton methods' do
+      src = <<-RUBY
+        class Car
+          def self.start; end
+
+          class << self
+            def drive; end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_node = context_tree.children.first
+      start_method = class_node.children.first
+      drive_method = class_node.children.last
+
+      expect(start_method).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(drive_method).to be_instance_of Reek::Context::SingletonMethodContext
     end
 
-    it 'has one child' do
-      expect(context_tree.children.size).to eq(1)
+    it 'returns something sensible for nested metaclasses' do
+      src = <<-RUBY
+        class Foo
+          class << self
+            class << self
+              def bar; end
+            end
+          end
+        end
+      RUBY
+
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      method_context = class_context.children.first
+
+      expect(method_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(method_context.parent).to eq class_context
     end
 
-    describe 'the root node' do
-      it 'has one module_context' do
-        expect(module_context).to be_a(Reek::Context::ModuleContext)
-      end
+    it 'returns something sensible for nested method definitions' do
+      src = <<-RUBY
+        class Foo
+          def foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(module_context.parent).to eq(context_tree)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::MethodContext
+      expect(bar_context.parent).to eq foo_context
     end
 
-    describe 'the module node' do
-      it 'has one method_context' do
-        expect(method_context).to be_a(Reek::Context::MethodContext)
-        expect(module_context.children.size).to eq(1)
-      end
+    it 'returns something sensible for method definitions nested in singleton methods' do
+      src = <<-RUBY
+        class Foo
+          def self.foo
+            def bar
+            end
+          end
+        end
+      RUBY
 
-      it 'holds a reference to the parent context' do
-        expect(method_context.parent).to eq(module_context)
-      end
+      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
+      context_tree = described_class.new(syntax_tree).context_tree
+
+      class_context = context_tree.children.first
+      foo_context = class_context.children.first
+
+      bar_context = foo_context.children.first
+      expect(bar_context).to be_instance_of Reek::Context::SingletonMethodContext
+      expect(bar_context.parent).to eq foo_context
     end
   end
 
@@ -370,91 +454,4 @@ RSpec.describe Reek::ContextBuilder do
       expect(nested_baz_context.visibility).to eq :public
     end
   end
-
-  describe '#context_tree' do
-    it 'creates the proper context for all kinds of singleton methods' do
-      src = <<-RUBY
-        class Car
-          def self.start; end
-
-          class << self
-            def drive; end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_node = context_tree.children.first
-      start_method = class_node.children.first
-      drive_method = class_node.children.last
-
-      expect(start_method).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(drive_method).to be_instance_of Reek::Context::SingletonMethodContext
-    end
-
-    it 'returns something sensible for nested metaclasses' do
-      src = <<-RUBY
-        class Foo
-          class << self
-            class << self
-              def bar; end
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      method_context = class_context.children.first
-
-      expect(method_context).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(method_context.parent).to eq class_context
-    end
-
-    it 'returns something sensible for nested method definitions' do
-      src = <<-RUBY
-        class Foo
-          def foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      foo_context = class_context.children.first
-
-      bar_context = foo_context.children.first
-      expect(bar_context).to be_instance_of Reek::Context::MethodContext
-      expect(bar_context.parent).to eq foo_context
-    end
-
-    it 'returns something sensible for method definitions nested in singleton methods' do
-      src = <<-RUBY
-        class Foo
-          def self.foo
-            def bar
-            end
-          end
-        end
-      RUBY
-
-      syntax_tree = Reek::Source::SourceCode.from(src).syntax_tree
-      context_tree = described_class.new(syntax_tree).context_tree
-
-      class_context = context_tree.children.first
-      foo_context = class_context.children.first
-
-      bar_context = foo_context.children.first
-      expect(bar_context).to be_instance_of Reek::Context::SingletonMethodContext
-      expect(bar_context.parent).to eq foo_context
-    end
-  end
 end

data/spec/reek/smell_detectors/base_detector_spec.rb

@@ -31,16 +31,6 @@ RSpec.describe Reek::SmellDetectors::BaseDetector do
     end
   end
 
-  describe '.valid_detector?' do
-    it 'returns true for a valid detector' do
-      expect(described_class.valid_detector?('DuplicateMethodCall')).to be true
-    end
-
-    it 'returns false for an invalid detector' do
-      expect(described_class.valid_detector?('Unknown')).to be false
-    end
-  end
-
   describe '.to_detector' do
     it 'returns the right detector' do
       expect(described_class.to_detector('DuplicateMethodCall')).to eq(Reek::SmellDetectors::DuplicateMethodCall)

data/spec/reek/smell_detectors/data_clump_spec.rb

@@ -76,6 +76,20 @@ RSpec.describe Reek::SmellDetectors::DataClump do
                              parameters: ['echo', 'foxtrot'])
     end
 
+    it 'reports arguments in alphabetical order even if they are never used that way' do
+      src = <<-RUBY
+        #{scope} Alfa
+          def bravo  (foxtrot, echo); end
+          def charlie(foxtrot, echo); end
+          def delta  (foxtrot, echo); end
+        end
+      RUBY
+
+      expect(src).to reek_of(:DataClump,
+                             count: 3,
+                             parameters: ['echo', 'foxtrot'])
+    end
+
     it 'reports parameter sets that are > 2' do
       src = <<-RUBY
         #{scope} Alfa

data/spec/reek/smell_detectors/missing_safe_method_spec.rb

@@ -50,13 +50,19 @@ RSpec.describe Reek::SmellDetectors::MissingSafeMethod do
 
   it 'does not report methods we excluded via comment' do
     source = <<-RUBY
-      # :reek:MissingSafeMethod: { exclude: [ bravo! ] }
+      # :reek:MissingSafeMethod { exclude: [ bravo! ] }
       class Alfa
         def bravo!
         end
+
+        def charlie!
+        end
       end
     RUBY
 
-    expect(source).not_to reek_of(:MissingSafeMethod)
+    aggregate_failures do
+      expect(source).not_to reek_of(:MissingSafeMethod, name: 'bravo!')
+      expect(source).to reek_of(:MissingSafeMethod, name: 'charlie!')
+    end
   end
 end

data/spec/reek/smell_detectors/nil_check_spec.rb

@@ -76,14 +76,14 @@ RSpec.describe Reek::SmellDetectors::NilCheck do
     expect(src).to reek_of(:NilCheck)
   end
 
-  it 'reports when scope uses &.' do
+  it 'does not report when scope uses &.' do
     src = <<-RUBY
       def alfa(bravo)
         bravo&.charlie
       end
     RUBY
 
-    expect(src).to reek_of(:NilCheck)
+    expect(src).not_to reek_of(:NilCheck)
   end
 
   it 'reports all lines when scope uses multiple nilchecks' do
@@ -95,6 +95,6 @@ RSpec.describe Reek::SmellDetectors::NilCheck do
       end
     RUBY
 
-    expect(src).to reek_of(:NilCheck, lines: [2, 3, 4])
+    expect(src).to reek_of(:NilCheck, lines: [2, 3])
   end
 end

data/spec/reek/source/source_code_spec.rb

@@ -62,5 +62,18 @@ RSpec.describe Reek::Source::SourceCode 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

data/spec/spec_helper.rb

@@ -78,6 +78,7 @@ RSpec.configure do |config|
   config.include FactoryBot::Syntax::Methods
   config.include Helpers
   config.include RSpec::Benchmark::Matchers
+  config.example_status_persistence_file_path = 'spec/examples.txt'
 
   config.disable_monkey_patching!
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reek
 version: !ruby/object:Gem::Version
-  version: 5.6.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Kevin Rutherford
@@ -11,22 +11,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2020-03-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: codeclimate-engine-rb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: kwalify
   requirement: !ruby/object:Gem::Requirement
@@ -281,6 +267,7 @@ files:
 - lib/reek/errors/encoding_error.rb
 - lib/reek/errors/garbage_detector_configuration_in_comment_error.rb
 - lib/reek/errors/incomprehensible_source_error.rb
+- lib/reek/errors/legacy_comment_separator_error.rb
 - lib/reek/errors/syntax_error.rb
 - lib/reek/examiner.rb
 - lib/reek/logging_error_handler.rb
@@ -492,14 +479,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubyforge_project: 
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Code smell detector for Ruby