reek 4.7.2 → 4.7.3

data/lib/reek/source/source_code.rb

@@ -7,9 +7,10 @@ end
 require_relative '../tree_dresser'
 require_relative '../ast/node'
 require_relative '../ast/builder'
+require_relative '../errors/encoding_error'
 
 # Opt in to new way of representing lambdas
-Parser::Builders::Default.emit_lambda = true
+Reek::AST::Builder.emit_lambda = true
 
 module Reek
   module Source
@@ -20,7 +21,7 @@ module Reek
       IO_IDENTIFIER     = 'STDIN'.freeze
       STRING_IDENTIFIER = 'string'.freeze
 
-      attr_reader :origin, :diagnostics, :syntax_tree
+      attr_reader :origin
 
       # Initializer.
       #
@@ -30,7 +31,8 @@ module Reek
       def initialize(code:, origin:, parser: default_parser)
         @origin = origin
         @diagnostics = []
-        @syntax_tree = parse(parser, code)
+        @parser = parser
+        @code = code
       end
 
       # Initializes an instance of SourceCode given a source.
@@ -54,11 +56,24 @@ module Reek
 
       # @return [true|false] Returns true if parsed file does not have any syntax errors.
       def valid_syntax?
-        @diagnostics.none? { |diagnostic| [:error, :fatal].include?(diagnostic.level) }
+        diagnostics.none? { |diagnostic| [:error, :fatal].include?(diagnostic.level) }
+      end
+
+      def diagnostics
+        parse_if_needed
+        @diagnostics
+      end
+
+      def syntax_tree
+        parse_if_needed
       end
 
       private
 
+      def parse_if_needed
+        @syntax_tree ||= parse(@parser, @code)
+      end
+
       attr_reader :source
 
       # Parses the given source into an AST and associates the source code comments with it.
@@ -94,9 +109,15 @@ module Reek
       # @param source [String] - Ruby code
       # @return [Anonymous subclass of Reek::AST::Node] the AST presentation
       #         for the given source
+      # :reek:TooManyStatements { max_statements: 8 }
       def parse(parser, source)
-        buffer = Parser::Source::Buffer.new(origin, 1)
-        buffer.source = source
+        begin
+          buffer = Parser::Source::Buffer.new(origin, 1)
+          source.force_encoding(Encoding::UTF_8)
+          buffer.source = source
+        rescue EncodingError => exception
+          raise Errors::EncodingError, origin: origin, original_exception: exception
+        end
         begin
           ast, comments = parser.parse_with_comments(buffer)
         rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions

data/lib/reek/source/source_locator.rb

@@ -69,7 +69,7 @@ module Reek
 
       # :reek:UtilityFunction
       def print_no_such_file_error(path)
-        $stderr.puts "Error: No such file - #{path}"
+        warn "Error: No such file - #{path}"
       end
 
       # :reek:UtilityFunction

data/lib/reek/spec.rb

@@ -114,7 +114,7 @@ module Reek
     # @public
     #
     # :reek:UtilityFunction
-    def reek(configuration = Configuration::AppConfiguration.default)
+    def reek(configuration = Configuration::AppConfiguration.from_path)
       ShouldReek.new(configuration: configuration)
     end
   end

data/lib/reek/version.rb

@@ -8,6 +8,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '4.7.2'.freeze
+    STRING = '4.7.3'.freeze
   end
 end

data/reek.gemspec

@@ -1,5 +1,3 @@
-# -*- encoding: utf-8 -*-
-
 require File.join(File.dirname(__FILE__), 'lib/reek/version')
 
 Gem::Specification.new do |s|

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -303,12 +303,8 @@ RSpec.describe Reek::AST::SexpExtensions::SendNode do
   context 'with no parameters' do
     let(:node) { sexp(:send, nil, :hello) }
 
-    it 'has no argument names' do
-      expect(node.arg_names).to eq []
-    end
-
     it 'is not considered to be a writable attr' do
-      expect(sexp(:send, nil, :attr).attr_with_writable_flag?).to be_falsey
+      expect(sexp(:send, nil, :attr)).not_to be_attr_with_writable_flag
     end
   end
 
@@ -316,15 +312,15 @@ RSpec.describe Reek::AST::SexpExtensions::SendNode do
     let(:bare_new) { sexp(:send, nil, :new) }
 
     it 'is not considered to be a module creation call' do
-      expect(bare_new.module_creation_call?).to be_falsey
+      expect(bare_new).not_to be_module_creation_call
     end
 
     it 'is not considered to have a module creation receiver' do
-      expect(bare_new.module_creation_receiver?).to be_falsey
+      expect(bare_new).not_to be_module_creation_receiver
     end
 
     it 'is considered to be an object creation call' do
-      expect(bare_new.object_creation_call?).to be_truthy
+      expect(bare_new).to be_object_creation_call
     end
   end
 
@@ -332,31 +328,15 @@ RSpec.describe Reek::AST::SexpExtensions::SendNode 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.module_creation_call?).to be_falsey
+      expect(node).not_to be_module_creation_call
     end
 
     it 'is not considered to have a module creation receiver' do
-      expect(node.module_creation_receiver?).to be_falsey
+      expect(node).not_to be_module_creation_receiver
     end
 
     it 'is considered to be an object creation call' do
-      expect(node.object_creation_call?).to be_truthy
-    end
-  end
-
-  context 'with 1 literal parameter' do
-    let(:node) { sexp(:send, nil, :hello, sexp(:lit, :param)) }
-
-    it 'has 1 argument name' do
-      expect(node.arg_names).to eq [:param]
-    end
-  end
-
-  context 'with 2 literal parameters' do
-    let(:node) { sexp(:send, nil, :hello, sexp(:lit, :x), sexp(:lit, :y)) }
-
-    it 'has 2 argument names' do
-      expect(node.arg_names).to eq [:x, :y]
+      expect(node).to be_object_creation_call
     end
   end
 end
@@ -466,14 +446,14 @@ RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
     context 'with single assignment' do
       it 'does not define a module' do
         exp = sexp(:casgn, nil, :Foo)
-        expect(exp.defines_module?).to be_falsey
+        expect(exp).not_to be_defines_module
       end
     end
 
     context 'with implicit receiver to new' do
       it 'does not define a module' do
         exp = sexp(:casgn, nil, :Foo, sexp(:send, nil, :new))
-        expect(exp.defines_module?).to be_falsey
+        expect(exp).not_to be_defines_module
       end
     end
 
@@ -481,7 +461,7 @@ RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
       it 'does not define a module' do
         exp = Reek::Source::SourceCode.from('Foo = Class.new(Bar)').syntax_tree
 
-        expect(exp.defines_module?).to be_truthy
+        expect(exp).to be_defines_module
       end
     end
 
@@ -489,7 +469,7 @@ RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
       it 'does not define a module' do
         exp = Reek::Source::SourceCode.from('C = ->{}').syntax_tree
 
-        expect(exp.defines_module?).to be_falsey
+        expect(exp).not_to be_defines_module
       end
     end
 
@@ -497,7 +477,7 @@ RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
       it 'does not define a module' do
         exp = Reek::Source::SourceCode.from('C = "hello"').syntax_tree
 
-        expect(exp.defines_module?).to be_falsey
+        expect(exp).not_to be_defines_module
       end
     end
   end

data/spec/reek/cli/application_spec.rb

@@ -15,13 +15,11 @@ RSpec.describe Reek::CLI::Application do
     end
   end
 
-  let(:path_excluded_in_configuration) do
-    SAMPLES_PATH.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb')
-  end
-
-  let(:configuration) { test_configuration_for(CONFIG_PATH.join('with_excluded_paths.reek')) }
-
   describe '#execute' do
+    let(:path_excluded_in_configuration) do
+      SAMPLES_PATH.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb')
+    end
+    let(:configuration) { test_configuration_for(CONFIG_PATH.join('with_excluded_paths.reek')) }
     let(:command) { instance_double 'Reek::CLI::Command::ReportCommand' }
     let(:app) { described_class.new [] }
 

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 require 'fileutils'
 require 'pathname'
 require 'tmpdir'

data/spec/reek/examiner_spec.rb

@@ -1,5 +1,6 @@
 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
@@ -107,7 +108,7 @@ RSpec.describe Reek::Examiner do
       end
     end
 
-    context 'with an incomprehensible source that causes Reek to crash' do
+    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
@@ -143,6 +144,42 @@ RSpec.describe Reek::Examiner do
     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 'if 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 'if 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
+
   describe 'bad comment config' do
     let(:examiner) { described_class.new(source) }
 

data/spec/reek/rake/task_spec.rb

@@ -7,14 +7,37 @@ RSpec.describe Reek::Rake::Task 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
-      task.source_files = '*.rb'
+      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

data/spec/reek/smell_detectors/base_detector_spec.rb

@@ -21,16 +21,15 @@ RSpec.describe Reek::SmellDetectors::BaseDetector do
     context 'with default exclusions present' do
       let(:subclass) { Reek::SmellDetectors::TooManyStatements }
 
-      before do
-        expect(subclass.default_config['exclude']).to eq ['initialize']
-      end
-
       it 'includes default exclusions' do
         detector = subclass.new
         smell = create(:smell_warning, smell_detector: detector, context: 'Foo#bar')
         result = subclass.todo_configuration_for([smell])
 
-        expect(result).to eq('TooManyStatements' => { 'exclude' => ['initialize', 'Foo#bar'] })
+        aggregate_failures do
+          expect(subclass.default_config['exclude']).to eq ['initialize']
+          expect(result).to eq('TooManyStatements' => { 'exclude' => ['initialize', 'Foo#bar'] })
+        end
       end
     end
   end

data/spec/reek/smell_detectors/prima_donna_method_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
     EOS
 
     expect(src).to reek_of(:PrimaDonnaMethod,
-                           lines:   [1],
+                           lines:   [2],
                            context: 'Alfa',
                            message: "has prima donna method 'bravo!'",
                            source:  'string',
@@ -30,8 +30,8 @@ RSpec.describe Reek::SmellDetectors::PrimaDonnaMethod do
     EOS
 
     expect(src).
-      to reek_of(:PrimaDonnaMethod, lines: [1], name: 'bravo!').
-      and reek_of(:PrimaDonnaMethod, lines: [1], name: 'charlie!')
+      to reek_of(:PrimaDonnaMethod, lines: [2], name: 'bravo!').
+      and reek_of(:PrimaDonnaMethod, lines: [5], name: 'charlie!')
   end
 
   it 'reports nothing when method and bang counterpart exist' do

data/spec/reek/source/source_code_spec.rb

@@ -30,6 +30,33 @@ RSpec.describe Reek::Source::SourceCode do
       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(code: source, origin: '(string)')
+      result = source_code.syntax_tree
+      expect(result.children.first.type).to eq :lambda
+    end
+  end
+
+  context 'with a source that triggers an encoding error' do
+    let(:source_name) { 'Bad source' }
+    let(:code) do
+      <<-SRC.strip_heredoc
+      # encoding: US-ASCII
+      puts 'こんにちは世界'
+      SRC
+    end
+    let(:src) { described_class.new(code: code, origin: source_name) }
+
+    it 'raises an encoding error' do
+      expect { src.syntax_tree }.to raise_error Reek::Errors::EncodingError
+    end
+
+    it 'explains the origin of the error' do
+      message = "Source '#{source_name}' cannot be processed by Reek due to an encoding error in the source file."
+      expect { src.syntax_tree }.to raise_error.with_message(/#{message}/)
+    end
   end
 
   context 'when the parser fails' do
@@ -58,7 +85,7 @@ RSpec.describe Reek::Source::SourceCode do
       end
 
       it 'raises the error' do
-        expect { src }.to raise_error error_class, error_message
+        expect { src.valid_syntax? }.to raise_error error_class, error_message
       end
     end
   end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -27,16 +27,16 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'matches a smelly String' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
 
       it 'doesnt match a fragrant String' do
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
 
       it 're-calculates matches every time' do
         matcher.matches? smelly_code
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
     end
 
@@ -44,11 +44,11 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
 
       it 'matches a smelly file' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_truthy
+        expect(matcher).to be_matches(SMELLY_FILE)
       end
 
       it 'doesnt match a fragrant file' do
-        expect(matcher.matches?(CLEAN_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(CLEAN_FILE)
       end
     end
   end
@@ -68,7 +68,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'is truthy' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
     end
 
@@ -79,7 +79,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       let(:truthy_matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
 
       it 'is falsey' do
-        expect(falsey_matcher.matches?(smelly_code)).to be_falsey
+        expect(falsey_matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -102,7 +102,7 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       let(:matcher) { described_class.new(:DuplicateMethodCall, name: 'foo', count: 15) }
 
       it 'is falsey' do
-        expect(matcher.matches?(smelly_code)).to be_falsey
+        expect(matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -130,14 +130,14 @@ RSpec.describe Reek::Spec::ShouldReekOf do
   end
 
   context 'for a smell that is disabled by default' do
-    before do
-      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
-      expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
-    end
-
     it 'enables the smell detector to match automatically' do
+      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
       src = 'class C; private; def foo; end; end'
-      expect(src).to reek_of(:UnusedPrivateMethod)
+
+      aggregate_failures do
+        expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
+        expect(src).to reek_of(:UnusedPrivateMethod)
+      end
     end
   end
 
@@ -146,13 +146,13 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     let(:configured_matcher) { matcher.with_config('accept' => 'x') }
 
     it 'uses the passed-in configuration for matching' do
-      expect(configured_matcher.matches?('def foo; q = 2; end')).to be_truthy
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
+      expect(configured_matcher).to be_matches('def foo; q = 2; end')
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
     end
 
     it 'leaves the original matcher intact' do
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
-      expect(matcher.matches?('def foo; x = 2; end')).to be_truthy
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
+      expect(matcher).to be_matches('def foo; x = 2; end')
     end
   end
 end