reek 3.2.1 → 3.3.0

data/lib/reek/tree_dresser.rb

@@ -25,8 +25,12 @@ module Reek
       type = sexp.type
       children = sexp.children.map { |child| dress(child, comment_map, sexp) }
       comments = comment_map[sexp]
-      @klass_map.klass_for(type).new(type, children,
-                                     location: sexp.loc, comments: comments, parent: parent)
+      klass_map.klass_for(type).new(type, children,
+                                    location: sexp.loc, comments: comments, parent: parent)
     end
+
+    private
+
+    private_attr_reader :klass_map
   end
 end

data/lib/reek/tree_walker.rb

@@ -24,14 +24,20 @@ module Reek
     end
 
     def walk
-      @result ||= process(@exp)
-      @result.each do |element|
-        @smell_repository.examine(element)
+      result.each do |element|
+        smell_repository.examine(element)
       end
     end
 
     private
 
+    private_attr_accessor :element
+    private_attr_reader :exp, :smell_repository
+
+    def result
+      @result ||= process(exp)
+    end
+
     def process(exp)
       context_processor = "process_#{exp.type}"
       if context_processor_exists?(context_processor)
@@ -39,7 +45,7 @@ module Reek
       else
         process_default exp
       end
-      @element
+      element
     end
 
     def process_module(exp)
@@ -85,29 +91,35 @@ module Reek
     #
 
     def process_send(exp)
-      if visibility_modifier? exp
-        @element.track_visibility(exp.method_name, exp.arg_names)
+      if exp.visibility_modifier?
+        element.track_visibility(exp.method_name, exp.arg_names)
       end
-      @element.record_call_to(exp)
+      if exp.attribute_writer?
+        exp.args.each do |arg|
+          next unless arg.type == :sym
+          new_context(Context::MethodContext, arg)
+        end
+      end
+      element.record_call_to(exp)
       process_default(exp)
     end
 
     def process_attrasgn(exp)
-      @element.record_call_to(exp)
+      element.record_call_to(exp)
       process_default(exp)
     end
 
     alias_method :process_op_asgn, :process_attrasgn
 
     def process_ivar(exp)
-      @element.record_use_of_self
+      element.record_use_of_self
       process_default(exp)
     end
 
     alias_method :process_ivasgn, :process_ivar
 
     def process_self(_)
-      @element.record_use_of_self
+      element.record_use_of_self
     end
 
     alias_method :process_zsuper, :process_self
@@ -123,7 +135,7 @@ module Reek
 
     def process_begin(exp)
       count_statement_list(exp.children)
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
@@ -132,13 +144,13 @@ module Reek
     def process_if(exp)
       count_clause(exp[2])
       count_clause(exp[3])
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
     def process_while(exp)
       count_clause(exp[2])
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
@@ -146,13 +158,13 @@ module Reek
 
     def process_for(exp)
       count_clause(exp[3])
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
     def process_rescue(exp)
       count_clause(exp[1])
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
@@ -163,7 +175,7 @@ module Reek
 
     def process_case(exp)
       count_clause(exp.else_body)
-      @element.count_statements(-1)
+      element.count_statements(-1)
       process_default(exp)
     end
 
@@ -177,34 +189,30 @@ module Reek
     end
 
     def count_clause(sexp)
-      @element.count_statements(1) if sexp
+      element.count_statements(1) if sexp
     end
 
     def count_statement_list(statement_list)
-      @element.count_statements statement_list.length
+      element.count_statements statement_list.length
     end
 
     def inside_new_context(klass, exp)
-      scope = klass.new(@element, exp)
-      @element.append_child_context(scope)
-      push(scope) do
+      push(new_context(klass, exp)) do
         yield
       end
-      scope
     end
 
-    def push(scope)
-      orig = @element
-      @element = scope
-      yield
-      @element = orig
+    def new_context(klass, exp)
+      klass.new(element, exp).tap do |scope|
+        element.append_child_context(scope)
+      end
     end
 
-    # FIXME: Move to SendNode?
-    def visibility_modifier?(call_node)
-      VISIBILITY_MODIFIERS.include?(call_node.method_name)
+    def push(scope)
+      orig = element
+      self.element = scope
+      yield
+      self.element = orig
     end
-
-    VISIBILITY_MODIFIERS = [:private, :public, :protected, :module_function]
   end
 end

data/lib/reek/version.rb

@@ -3,6 +3,6 @@ module Reek
   # This module holds the Reek version informations
   #
   module Version
-    STRING = '3.2.1'
+    STRING = '3.3.0'
   end
 end

data/reek.gemspec

@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.name = 'reek'
   s.version = Reek::Version::STRING
 
-  s.authors = ['Kevin Rutherford', 'Timo Roessner', 'Matijs van Zuijlen']
+  s.authors = ['Kevin Rutherford', 'Timo Roessner', 'Matijs van Zuijlen', 'Piotr Szotkowski']
   s.default_executable = 'reek'
   s.description = <<-DESC
     Reek is a tool that examines Ruby classes, modules and methods and reports

data/spec/reek/ast/node_spec.rb

@@ -4,8 +4,7 @@ require_relative '../../../lib/reek/ast/node'
 RSpec.describe Reek::AST::Node do
   context 'format' do
     it 'formats self' do
-      @node = s(:self)
-      expect(@node.format_to_ruby).to eq('self')
+      expect(s(:self).format_to_ruby).to eq('self')
     end
   end
 

data/spec/reek/ast/object_refs_spec.rb

@@ -2,52 +2,50 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/reek/ast/object_refs'
 
 RSpec.describe Reek::AST::ObjectRefs do
-  before(:each) do
-    @refs = Reek::AST::ObjectRefs.new
-  end
+  let(:refs) { Reek::AST::ObjectRefs.new }
 
   context 'when empty' do
     it 'should report no refs to self' do
-      expect(@refs.references_to(:self)).to be_empty
+      expect(refs.references_to(:self)).to be_empty
     end
   end
 
   context 'with references to a, b, and a' do
     context 'with no refs to self' do
       before(:each) do
-        @refs.record_reference_to(:a)
-        @refs.record_reference_to(:b)
-        @refs.record_reference_to(:a)
+        refs.record_reference_to(:a)
+        refs.record_reference_to(:b)
+        refs.record_reference_to(:a)
       end
 
       it 'should report no refs to self' do
-        expect(@refs.references_to(:self)).to be_empty
+        expect(refs.references_to(:self)).to be_empty
       end
 
       it 'should report :a as the max' do
-        expect(@refs.most_popular).to include(:a)
+        expect(refs.most_popular).to include(:a)
       end
 
       it 'should not report self as the max' do
-        expect(@refs.self_is_max?).to eq(false)
+        expect(refs.self_is_max?).to eq(false)
       end
 
       context 'with one reference to self' do
         before(:each) do
-          @refs.record_reference_to(:self)
+          refs.record_reference_to(:self)
         end
 
         it 'should report 1 ref to self' do
-          expect(@refs.references_to(:self).size).to eq(1)
+          expect(refs.references_to(:self).size).to eq(1)
         end
 
         it 'should not report self among the max' do
-          expect(@refs.most_popular).to include(:a)
-          expect(@refs.most_popular).not_to include(:self)
+          expect(refs.most_popular).to include(:a)
+          expect(refs.most_popular).not_to include(:self)
         end
 
         it 'should not report self as the max' do
-          expect(@refs.self_is_max?).to eq(false)
+          expect(refs.self_is_max?).to eq(false)
         end
       end
     end
@@ -55,70 +53,70 @@ RSpec.describe Reek::AST::ObjectRefs do
 
   context 'with many refs to self' do
     before(:each) do
-      @refs.record_reference_to(:self)
-      @refs.record_reference_to(:self)
-      @refs.record_reference_to(:a)
-      @refs.record_reference_to(:self)
-      @refs.record_reference_to(:b)
-      @refs.record_reference_to(:a)
-      @refs.record_reference_to(:self)
+      refs.record_reference_to(:self)
+      refs.record_reference_to(:self)
+      refs.record_reference_to(:a)
+      refs.record_reference_to(:self)
+      refs.record_reference_to(:b)
+      refs.record_reference_to(:a)
+      refs.record_reference_to(:self)
     end
 
     it 'should report all refs to self' do
-      expect(@refs.references_to(:self).size).to eq(4)
+      expect(refs.references_to(:self).size).to eq(4)
     end
 
     it 'should report self among the max' do
-      expect(@refs.most_popular).to include(:self)
+      expect(refs.most_popular).to include(:self)
     end
 
     it 'should report self as the max' do
-      expect(@refs.self_is_max?).to eq(true)
+      expect(refs.self_is_max?).to eq(true)
     end
   end
 
   context 'when self is not the only max' do
     before(:each) do
-      @refs.record_reference_to(:a)
-      @refs.record_reference_to(:self)
-      @refs.record_reference_to(:self)
-      @refs.record_reference_to(:b)
-      @refs.record_reference_to(:a)
+      refs.record_reference_to(:a)
+      refs.record_reference_to(:self)
+      refs.record_reference_to(:self)
+      refs.record_reference_to(:b)
+      refs.record_reference_to(:a)
     end
 
     it 'should report all refs to self' do
-      expect(@refs.references_to(:self).size).to eq(2)
+      expect(refs.references_to(:self).size).to eq(2)
     end
 
     it 'should report self among the max' do
-      expect(@refs.most_popular).to include(:a)
-      expect(@refs.most_popular).to include(:self)
+      expect(refs.most_popular).to include(:a)
+      expect(refs.most_popular).to include(:self)
     end
 
     it 'should report self as the max' do
-      expect(@refs.self_is_max?).to eq(true)
+      expect(refs.self_is_max?).to eq(true)
     end
   end
 
   context 'when self is not among the max' do
     before(:each) do
-      @refs.record_reference_to(:a)
-      @refs.record_reference_to(:b)
-      @refs.record_reference_to(:a)
-      @refs.record_reference_to(:b)
+      refs.record_reference_to(:a)
+      refs.record_reference_to(:b)
+      refs.record_reference_to(:a)
+      refs.record_reference_to(:b)
     end
 
     it 'should report all refs to self' do
-      expect(@refs.references_to(:self).size).to eq(0)
+      expect(refs.references_to(:self).size).to eq(0)
     end
 
     it 'should not report self among the max' do
-      expect(@refs.most_popular).to include(:a)
-      expect(@refs.most_popular).to include(:b)
+      expect(refs.most_popular).to include(:a)
+      expect(refs.most_popular).to include(:b)
     end
 
     it 'should not report self as the max' do
-      expect(@refs.self_is_max?).to eq(false)
+      expect(refs.self_is_max?).to eq(false)
     end
   end
 end

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -3,300 +3,282 @@ require_relative '../../../lib/reek/ast/sexp_extensions'
 
 RSpec.describe Reek::AST::SexpExtensions::DefNode do
   context 'with no parameters' do
-    before :each do
-      @node = s(:def, :hello, s(:args))
-    end
+    let(:node) { s(:def, :hello, s(:args)) }
 
     it 'has no arg names' do
-      expect(@node.arg_names).to eq []
+      expect(node.arg_names).to eq []
     end
 
     it 'has no parameter names' do
-      expect(@node.parameter_names).to eq []
+      expect(node.parameter_names).to eq []
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#hello'
+      expect(node.full_name('Fred')).to eq 'Fred#hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'hello'
+      expect(node.full_name('')).to eq 'hello'
     end
   end
 
   context 'with 1 parameter' do
-    before :each do
-      @node = s(:def, :hello,
-                s(:args, s(:arg, :param)))
+    let(:node) do
+      s(:def, :hello,
+        s(:args, s(:arg, :param)))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 1 parameter name' do
-      expect(@node.parameter_names).to eq [:param]
+      expect(node.parameter_names).to eq [:param]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#hello'
+      expect(node.full_name('Fred')).to eq 'Fred#hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'hello'
+      expect(node.full_name('')).to eq 'hello'
     end
   end
 
   context 'with a block parameter' do
-    before :each do
-      @node = s(:def, :hello,
-                s(:args,
-                  s(:arg, :param),
-                  s(:blockarg, :blk)))
+    let(:node) do
+      s(:def, :hello,
+        s(:args,
+          s(:arg, :param),
+          s(:blockarg, :blk)))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 2 parameter names' do
-      expect(@node.parameter_names).to eq [:param, :blk]
+      expect(node.parameter_names).to eq [:param, :blk]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#hello'
+      expect(node.full_name('Fred')).to eq 'Fred#hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'hello'
+      expect(node.full_name('')).to eq 'hello'
     end
   end
 
   context 'with 1 defaulted parameter' do
-    before :each do
-      @node = s(:def, :hello,
-                s(:args,
-                  s(:optarg, :param, s(:array))))
+    let(:node) do
+      s(:def, :hello,
+        s(:args,
+          s(:optarg, :param, s(:array))))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 1 parameter name' do
-      expect(@node.parameter_names).to eq [:param]
+      expect(node.parameter_names).to eq [:param]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#hello'
+      expect(node.full_name('Fred')).to eq 'Fred#hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'hello'
+      expect(node.full_name('')).to eq 'hello'
     end
   end
 
   context 'with a body with 2 statements' do
-    before :each do
-      @node = s(:def, :hello, s(:args),
-                s(:begin,
-                  s(:first),
-                  s(:second)))
+    let(:node) do
+      s(:def, :hello, s(:args),
+        s(:begin,
+          s(:first),
+          s(:second)))
     end
 
     it 'has 2 body statements' do
-      expect(@node.body).to eq s(:begin, s(:first), s(:second))
+      expect(node.body).to eq s(:begin, s(:first), s(:second))
     end
 
     it 'finds nodes in the body with #body_nodes' do
-      expect(@node.body_nodes([:first])).to eq [s(:first)]
+      expect(node.body_nodes([:first])).to eq [s(:first)]
     end
   end
 
   context 'with no body' do
-    before :each do
-      @node = s(:def, :hello, s(:args), nil)
-    end
+    let(:node) { s(:def, :hello, s(:args), nil) }
 
     it 'has a body that is nil' do
-      expect(@node.body).to be_nil
+      expect(node.body).to be_nil
     end
 
     it 'finds no nodes in the body' do
-      expect(@node.body_nodes([:foo])).to eq []
+      expect(node.body_nodes([:foo])).to eq []
     end
   end
 end
 
 RSpec.describe Reek::AST::SexpExtensions::DefsNode do
   context 'with no parameters' do
-    before :each do
-      @node = s(:defs, s(:lvar, :obj), :hello, s(:args))
-    end
+    let(:node) { s(:defs, s(:lvar, :obj), :hello, s(:args)) }
 
     it 'has no arg names' do
-      expect(@node.arg_names).to eq []
+      expect(node.arg_names).to eq []
     end
 
     it 'has no parameter names' do
-      expect(@node.parameter_names).to eq []
+      expect(node.parameter_names).to eq []
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#obj.hello'
+      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'obj.hello'
+      expect(node.full_name('')).to eq 'obj.hello'
     end
   end
 
   context 'with 1 parameter' do
-    before :each do
-      @node = s(:defs, s(:lvar, :obj), :hello,
-                s(:args, s(:arg, :param)))
+    let(:node) do
+      s(:defs, s(:lvar, :obj), :hello,
+        s(:args, s(:arg, :param)))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 1 parameter name' do
-      expect(@node.parameter_names).to eq [:param]
+      expect(node.parameter_names).to eq [:param]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#obj.hello'
+      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'obj.hello'
+      expect(node.full_name('')).to eq 'obj.hello'
     end
   end
 
   context 'with a block' do
-    before :each do
-      @node = s(:defs, s(:lvar, :obj), :hello,
-                s(:args,
-                  s(:arg, :param),
-                  s(:blockarg, :blk)))
+    let(:node) do
+      s(:defs, s(:lvar, :obj), :hello,
+        s(:args,
+          s(:arg, :param),
+          s(:blockarg, :blk)))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 2 parameter names' do
-      expect(@node.parameter_names).to eq [:param, :blk]
+      expect(node.parameter_names).to eq [:param, :blk]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#obj.hello'
+      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'obj.hello'
+      expect(node.full_name('')).to eq 'obj.hello'
     end
   end
 
   context 'with 1 defaulted parameter' do
-    before :each do
-      @node = s(:defs, s(:lvar, :obj), :hello,
-                s(:args,
-                  s(:optarg, :param, s(:array))))
+    let(:node) do
+      s(:defs, s(:lvar, :obj), :hello,
+        s(:args,
+          s(:optarg, :param, s(:array))))
     end
 
     it 'has 1 arg name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
 
     it 'has 1 parameter name' do
-      expect(@node.parameter_names).to eq [:param]
+      expect(node.parameter_names).to eq [:param]
     end
 
     it 'includes outer scope in its full name' do
-      expect(@node.full_name('Fred')).to eq 'Fred#obj.hello'
+      expect(node.full_name('Fred')).to eq 'Fred#obj.hello'
     end
 
     it 'includes no marker in its full name with empty outer scope' do
-      expect(@node.full_name('')).to eq 'obj.hello'
+      expect(node.full_name('')).to eq 'obj.hello'
     end
   end
 
   context 'with a body with 2 statements' do
-    before :each do
-      @node = s(:defs, s(:self), :hello, s(:args),
-                s(:begin,
-                  s(:first),
-                  s(:second)))
+    let(:node) do
+      s(:defs, s(:self), :hello, s(:args),
+        s(:begin,
+          s(:first),
+          s(:second)))
     end
 
     it 'has 2 body statements' do
-      expect(@node.body).to eq s(:begin, s(:first), s(:second))
+      expect(node.body).to eq s(:begin, s(:first), s(:second))
     end
   end
 end
 
 RSpec.describe Reek::AST::SexpExtensions::SendNode do
   context 'with no parameters' do
-    before :each do
-      @node = s(:send, nil, :hello)
-    end
+    let(:node) { s(:send, nil, :hello) }
 
     it 'has no argument names' do
-      expect(@node.arg_names).to eq []
+      expect(node.arg_names).to eq []
     end
   end
 
   context 'with 1 literal parameter' do
-    before :each do
-      @node = s(:send, nil, :hello, s(:lit, :param))
-    end
+    let(:node) { s(:send, nil, :hello, s(:lit, :param)) }
 
     it 'has 1 argument name' do
-      expect(@node.arg_names).to eq [:param]
+      expect(node.arg_names).to eq [:param]
     end
   end
 
   context 'with 2 literal parameters' do
-    before :each do
-      @node = s(:send, nil, :hello, s(:lit, :x), s(:lit, :y))
-    end
+    let(:node) { s(:send, nil, :hello, s(:lit, :x), s(:lit, :y)) }
 
     it 'has 2 argument names' do
-      expect(@node.arg_names).to eq [:x, :y]
+      expect(node.arg_names).to eq [:x, :y]
     end
   end
 end
 
 RSpec.describe Reek::AST::SexpExtensions::BlockNode do
   context 'with no parameters' do
-    before :each do
-      @node = s(:block, s(:send, nil, :map), s(:args), nil)
-    end
+    let(:node) { s(:block, s(:send, nil, :map), s(:args), nil) }
 
     it 'has no parameter names' do
-      expect(@node.parameter_names).to eq []
+      expect(node.parameter_names).to eq []
     end
   end
 
   context 'with 1 parameter' do
-    before :each do
-      @node = s(:block, s(:send, nil, :map), s(:args, :param), nil)
-    end
+    let(:node) { s(:block, s(:send, nil, :map), s(:args, :param), nil) }
 
     it 'has 1 parameter name' do
-      expect(@node.parameter_names).to eq [:param]
+      expect(node.parameter_names).to eq [:param]
     end
   end
 
   context 'with 2 parameters' do
-    before :each do
-      @node = s(:block, s(:send, nil, :map), s(:args, :x, :y), nil)
-    end
+    let(:node) { s(:block, s(:send, nil, :map), s(:args, :x, :y), nil) }
 
     it 'has 2 parameter names' do
-      expect(@node.parameter_names).to eq [:x, :y]
+      expect(node.parameter_names).to eq [:x, :y]
     end
   end
 end
@@ -347,3 +329,15 @@ RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
     end
   end
 end
+
+RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
+  context 'with single assignment' do
+    subject do
+      s(:casgn, nil, :Foo)
+    end
+
+    it 'does not define a module' do
+      expect(subject.defines_module?).to eq(false)
+    end
+  end
+end