reek 1.4.0 → 1.5.0

data/lib/reek/source/sexp_formatter.rb

@@ -1,4 +1,6 @@
-require 'ruby2ruby'
+old_verbose, $VERBOSE = $VERBOSE, nil
+require 'unparser'
+$VERBOSE = old_verbose
 
 module Reek
   module Source
@@ -7,9 +9,13 @@ module Reek
     #
     class SexpFormatter
       def self.format(sexp)
-        return sexp.to_s unless sexp.is_a? Array
-        sexp = Sexp.from_array(YAML.load(YAML.dump(sexp)))
-        Ruby2Ruby.new.process(sexp)
+        return sexp.to_s unless sexp.is_a? AST::Node
+        lines = Unparser.unparse(sexp).split "\n"
+        if lines.length > 1
+          "#{lines.first} ... #{lines.last}"
+        else
+          lines.first
+        end
       end
     end
   end

data/lib/reek/source/sexp_node.rb

@@ -7,7 +7,7 @@ module Reek
     module SexpNode
       def self.format(expr)
         case expr
-        when Sexp then expr.format_ruby
+        when AST::Node then expr.format_ruby
         else expr.to_s
         end
       end
@@ -26,20 +26,14 @@ module Reek
         end
       end
 
-      def unnested_nodes(types)
+      def find_nodes(types, ignoring = [])
         result = []
-        if types.include? first
-          result << self
-        else
-          each_sexp do |elem|
-            result += elem.unnested_nodes(types)
-          end
-        end
+        look_for_alt(types, ignoring) { |exp| result << exp }
         result
       end
 
       def each_sexp
-        each { |elem| yield elem if elem.is_a? Sexp }
+        children.each { |elem| yield elem if elem.is_a? AST::Node }
       end
 
       #
@@ -49,9 +43,27 @@ module Reek
       #
       def look_for(target_type, ignoring = [], &blk)
         each_sexp do |elem|
-          elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.first)
+          elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.type)
+        end
+        blk.call(self) if type == target_type
+      end
+
+      #
+      # Carries out a depth-first traversal of this syntax tree, yielding
+      # every Sexp of type +target_type+. The traversal ignores any node
+      # whose type is listed in the Array +ignoring+, includeing the top node.
+      #
+      # Also, doesn't nest
+      #
+      def look_for_alt(target_types, ignoring = [], &blk)
+        return if ignoring.include?(type)
+        if target_types.include? type
+          blk.call(self)
+        else
+          each_sexp do |elem|
+            elem.look_for_alt(target_types, ignoring, &blk)
+          end
         end
-        blk.call(self) if first == target_type
       end
 
       def contains_nested_node?(target_type)
@@ -60,11 +72,7 @@ module Reek
       end
 
       def format_ruby
-        Ruby2Ruby.new.process(deep_copy)
-      end
-
-      def deep_copy
-        Sexp.new(*map { |elem| elem.is_a?(Sexp) ? elem.deep_copy : elem })
+        SexpFormatter.format(self)
       end
     end
   end

data/lib/reek/source/source_code.rb

@@ -1,6 +1,9 @@
-require 'ruby_parser'
+old_verbose, $VERBOSE = $VERBOSE, nil
+require 'parser/current'
+$VERBOSE = old_verbose
 require 'reek/source/config_file'
 require 'reek/source/tree_dresser'
+require 'reek/source/ast_node'
 
 module Reek
   module Source
@@ -10,7 +13,7 @@ module Reek
     class SourceCode
       attr_reader :desc
 
-      def initialize(code, desc, parser = RubyParser.new)
+      def initialize(code, desc, parser = Parser::Ruby21.new)
         @source = code
         @desc = desc
         @parser = parser
@@ -21,13 +24,22 @@ module Reek
       end
 
       def syntax_tree
-        begin
-          ast = @parser.parse(@source, @desc)
-        rescue Racc::ParseError, RubyParser::SyntaxError => error
-          $stderr.puts "#{desc}: #{error.class.name}: #{error}"
-        end
-        ast ||= s()
-        TreeDresser.new.dress(ast)
+        @syntax_tree ||=
+          begin
+            buffer = Parser::Source::Buffer.new(@desc)
+            buffer.source = @source
+
+            begin
+              ast, comments = @parser.parse_with_comments(buffer)
+            rescue Racc::ParseError, Parser::SyntaxError => error
+              $stderr.puts "#{desc}: #{error.class.name}: #{error}"
+            end
+            ast ||= AstNode.new(:empty)
+            comments ||= []
+
+            comment_map = Parser::Source::Comment.associate(ast, comments)
+            TreeDresser.new.dress(ast, comment_map)
+          end
       end
     end
   end

data/lib/reek/source/tree_dresser.rb

@@ -1,5 +1,4 @@
-require 'reek/source/sexp_node'
-require 'reek/source/sexp_extensions'
+require 'reek/source/ast_node_class_map'
 
 module Reek
   module Source
@@ -8,39 +7,17 @@ module Reek
     # the tree more understandable and less implementation-dependent.
     #
     class TreeDresser
-      def initialize(extensions_module = SexpExtensions, node_module = SexpNode)
-        @extensions_module = extensions_module
-        @node_module = node_module
+      def initialize(klass_map = AstNodeClassMap.new)
+        @klass_map = klass_map
       end
 
-      def dress(sexp)
-        extend_sexp(sexp)
-        sexp.each_sexp { |sub| dress(sub) }
-        sexp
-      end
-
-      private
-
-      def extend_sexp(sexp)
-        sexp.extend(@node_module)
-        extension_module = extension_for(sexp)
-        sexp.extend(extension_module) if extension_module
-      end
-
-      def extension_for(sexp)
-        extension_map[sexp.sexp_type]
-      end
-
-      def extension_map
-        @extension_map ||= begin
-                             assoc = @extensions_module.constants.map do |const|
-                               [
-                                 const.to_s.sub(/Node$/, '').downcase.to_sym,
-                                 @extensions_module.const_get(const)
-                               ]
-                             end
-                             Hash[assoc]
-                           end
+      def dress(sexp, comment_map)
+        return sexp unless sexp.is_a? AST::Node
+        type = sexp.type
+        children = sexp.children.map { |child| dress(child, comment_map) }
+        comments = comment_map[sexp]
+        @klass_map.klass_for(type).new(type, children,
+                                       location: sexp.loc, comments: comments)
       end
     end
   end

data/lib/reek/version.rb

@@ -1,3 +1,3 @@
 module Reek
-  VERSION = '1.4.0'
+  VERSION = '1.5.0'
 end

data/reek.gemspec

@@ -30,15 +30,13 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.2'
   s.summary = 'Code smell detector for Ruby'
 
-  s.add_runtime_dependency('ruby_parser', ['>= 3.5.0', '< 4.0'])
-  s.add_runtime_dependency('sexp_processor', ['~> 4.4'])
-  s.add_runtime_dependency('ruby2ruby', ['>= 2.0.8', '< 3.0'])
+  s.add_runtime_dependency('parser', ['~> 2.2.0.pre.7'])
+  s.add_runtime_dependency('unparser', ['~> 0.1.16'])
   s.add_runtime_dependency('rainbow', ['>= 1.99', '< 3.0'])
 
   s.add_development_dependency('bundler', ['~> 1.1'])
   s.add_development_dependency('rake', ['~> 10.0'])
   s.add_development_dependency('cucumber', ['~> 1.3'])
   s.add_development_dependency('rspec', ['~> 3.0'])
-  s.add_development_dependency('flay', ['~> 2.4'])
   s.add_development_dependency('yard', ['>= 0.8.7', '< 0.9'])
 end

data/spec/matchers/smell_of_matcher.rb

@@ -34,7 +34,15 @@ module SmellOfMatcher
     private
 
     def detect_smells
-      ctx = MethodContext.new(nil, @source.syntax_tree)
+      tree = @source.syntax_tree
+      ctx = case tree.type
+            when :def, :defs
+              MethodContext.new(nil, tree)
+            when :module, :class
+              ModuleContext.new(nil, tree)
+            else
+              CodeContext.new(nil, tree)
+            end
       detector = @klass.new(@source.desc, @klass.default_config.merge(@config))
       detector.examine(ctx)
       @actual_smells = detector.smells_found.to_a

data/spec/quality/reek_source_spec.rb

@@ -1,42 +1,7 @@
 require 'spec_helper'
-require 'flay'
-
-RSpec::Matchers.define :flay do |threshold|
-  match do |dirs_and_files|
-    @threshold = threshold
-    @flay = Flay.new(fuzzy: false, verbose: false, mass: @threshold)
-    @flay.process(*Flay.expand_dirs_to_files(dirs_and_files))
-    @flay.total > 0
-  end
-
-  failure_message_for_should do
-    "Expected source to contain duplication, but it didn't"
-  end
-
-  failure_message_for_should_not do
-    "Expected source not to contain duplication, but got:\n#{report}"
-  end
-
-  def report
-    lines = ["Total mass = #{@flay.total} (threshold = #{@threshold})"]
-    @flay.masses.each do |hash, mass|
-      nodes = @flay.hashes[hash]
-      match = @flay.identical[hash] ? 'IDENTICAL' : 'Similar'
-      lines << format('%s code found in %p (%d)', match, nodes.first.first, mass)
-      nodes.each { |x| lines << "  #{x.file}:#{x.line}" }
-    end
-    lines.join("\n")
-  end
-end
 
 describe 'Reek source code' do
   it 'has no smells' do
     Dir['lib/**/*.rb'].should_not reek
   end
-  it 'has no structural duplication' do
-    ['lib'].should_not flay(16)
-  end
-  it 'has no structural duplication in the tests' do
-    ['spec/reek'].should_not flay(25)
-  end
 end

data/spec/reek/core/code_context_spec.rb

@@ -56,8 +56,8 @@ describe CodeContext do
     it 'should pass unknown method calls down the stack' do
       stop = StopContext.new
       def stop.bananas(arg1, arg2) arg1 + arg2 + 43 end
-      element = ModuleContext.new(stop, ast(:module, :mod, nil))
-      element = MethodContext.new(element, ast(:defn, :bad))
+      element = ModuleContext.new(stop, s(:module, :mod, nil))
+      element = MethodContext.new(element, s(:def, :bad, s(:args), nil))
       expect(element.bananas(17, -5)).to eq(55)
     end
   end
@@ -70,16 +70,21 @@ describe CodeContext do
         ast = src.to_reek_source.syntax_tree
         @ctx = CodeContext.new(nil, ast)
       end
+
       it 'yields no calls' do
-        @ctx.each_node(:call, []) { |exp| raise "#{exp} yielded by empty module!" }
+        @ctx.each_node(:send, []) { |exp| raise "#{exp} yielded by empty module!" }
       end
+
       it 'yields one module' do
         mods = 0
         @ctx.each_node(:module, []) { |_exp| mods += 1 }
         expect(mods).to eq(1)
       end
+
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) { |exp| expect(exp[1]).to eq(@module_name.to_sym) }
+        @ctx.each_node(:module, []) do |exp|
+          expect(exp).to eq(s(:module, s(:const, nil, @module_name.to_sym), nil))
+        end
       end
 
       context 'with no block' do
@@ -103,19 +108,28 @@ describe CodeContext do
       it 'yields one module' do
         expect(@ctx.each_node(:module, []).length).to eq(1)
       end
+
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) { |exp| expect(exp[1]).to eq(@module_name.to_sym) }
+        @ctx.each_node(:module, []) do |exp|
+          expect(exp).to eq s(:module,
+                              s(:const, nil, @module_name.to_sym),
+                              s(:def, :calloo,
+                                s(:args),
+                                s(:send, nil, :puts, s(:str, 'hello'))))
+        end
       end
+
       it 'yields one method' do
-        expect(@ctx.each_node(:defn, []).length).to eq(1)
+        expect(@ctx.each_node(:def, []).length).to eq(1)
       end
+
       it "yields the method's full AST" do
-        @ctx.each_node(:defn, []) { |exp| expect(exp[1]).to eq(@method_name.to_sym) }
+        @ctx.each_node(:def, []) { |exp| expect(exp[1]).to eq(@method_name.to_sym) }
       end
 
       context 'pruning the traversal' do
         it 'ignores the call inside the method' do
-          expect(@ctx.each_node(:call, [:defn])).to be_empty
+          expect(@ctx.each_node(:send, [:def])).to be_empty
         end
       end
     end

data/spec/reek/core/method_context_spec.rb

@@ -24,23 +24,23 @@ end
 
 describe MethodContext do
   it 'should record ivars as refs to self' do
-    mctx = MethodContext.new(StopContext.new, ast(:defn, :feed))
+    mctx = MethodContext.new(StopContext.new, s(:def, :feed, s(:args), nil))
     expect(mctx.envious_receivers).to eq([])
-    mctx.record_call_to(ast(:call, s(:ivar, :@cow), :feed_to))
+    mctx.record_call_to(s(:send, s(:ivar, :@cow), :feed_to))
     expect(mctx.envious_receivers).to eq([])
   end
 
   it 'should count calls to self' do
-    mctx = MethodContext.new(StopContext.new, ast(:defn, :equals))
+    mctx = MethodContext.new(StopContext.new, s(:def, :equals, s(:args), nil))
     mctx.refs.record_reference_to([:lvar, :other])
-    mctx.record_call_to(ast(:call, s(:self), :thing))
+    mctx.record_call_to(s(:send, s(:self), :thing))
     expect(mctx.envious_receivers).to be_empty
   end
 
   it 'should recognise a call on self' do
-    mc = MethodContext.new(StopContext.new, s(:defn, :deep))
-    mc.record_call_to(ast(:call, s(:lvar, :text), :each, s(:arglist)))
-    mc.record_call_to(ast(:call, nil, :shelve, s(:arglist)))
+    mc = MethodContext.new(StopContext.new, s(:def, :deep, s(:args), nil))
+    mc.record_call_to(s(:send, s(:lvar, :text), :each, s(:arglist)))
+    mc.record_call_to(s(:send, nil, :shelve, s(:arglist)))
     expect(mc.envious_receivers).to be_empty
   end
 end
@@ -65,7 +65,7 @@ describe MethodParameters, 'default assignments' do
       @defaults = assignments_from(src)
     end
     it 'returns the param-value pair' do
-      expect(@defaults[0]).to eq(s(:argb, s(:lit, 456)))
+      expect(@defaults[0]).to eq [:argb, s(:int, 456)]
     end
     it 'returns the nothing else' do
       expect(@defaults.length).to eq(1)
@@ -78,8 +78,8 @@ describe MethodParameters, 'default assignments' do
       @defaults = assignments_from(src)
     end
     it 'returns both param-value pairs' do
-      expect(@defaults[0]).to eq(s(:arga, s(:lit, 123)))
-      expect(@defaults[1]).to eq(s(:argb, s(:lit, 456)))
+      expect(@defaults[0]).to eq [:arga, s(:int, 123)]
+      expect(@defaults[1]).to eq [:argb, s(:int, 456)]
     end
     it 'returns nothing else' do
       expect(@defaults.length).to eq(2)

data/spec/reek/smell_description_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'reek/smell_description'
+
+describe Reek::SmellDescription do
+  let(:smell_class) { 'SmellClass' }
+  let(:smell_subclass) { 'SmellySubclass' }
+  let(:message) { 'smell message' }
+  let(:details) { { 'key1' => 'value1', 'key2' => 'value2' } }
+
+  let(:description) { described_class.new(smell_class, smell_subclass, message, details) }
+
+  it "knows its smell class" do
+    expect(description.smell_class).to eq smell_class
+  end
+
+  it "knows its smell subclass" do
+    expect(description.smell_subclass).to eq smell_subclass
+  end
+
+  it "knows its smell message" do
+    expect(description.message).to eq message
+  end
+
+  it "knows its details" do
+    expect(description.details).to eq details
+  end
+
+  it "accesses its details through #[]" do
+    expect(description['key1']).to eq 'value1'
+    expect(description['key2']).to eq 'value2'
+  end
+
+  it "outputs the correct YAML" do
+    expect(description.to_yaml).to eq <<-END
+---
+class: SmellClass
+subclass: SmellySubclass
+message: smell message
+key1: value1
+key2: value2
+    END
+  end
+end