reek 1.2.13 → 1.3

data/lib/reek/core/method_context.rb

@@ -9,21 +9,12 @@ module Reek
     #
     module MethodParameters
       def default_assignments
-        assignments = self[-1]
         result = []
-        return result unless is_assignment_block?(assignments)
-        assignments[1..-1].each do |exp|
-          result << exp[1..2] if exp[0] == :lasgn
+        self[1..-1].each do |exp|
+          result << exp[1..2] if Sexp === exp && exp[0] == :lasgn
         end
         result
       end
-      def is_arg?(param)
-        return false if is_assignment_block?(param)
-        return !(param.to_s =~ /^\&/)
-      end
-      def is_assignment_block?(param)
-        Array === param and param[0] == :block
-      end
     end
 
     #

data/lib/reek/core/smell_repository.rb

@@ -25,6 +25,7 @@ module Reek
           Smells::UncommunicativeModuleName,
           Smells::UncommunicativeParameterName,
           Smells::UncommunicativeVariableName,
+          Smells::UnusedParameters,
           Smells::UtilityFunction
         ]
       end

data/lib/reek/smells.rb

@@ -16,6 +16,7 @@ require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommu
 require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_module_name')
 require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_parameter_name')
 require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'uncommunicative_variable_name')
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'unused_parameters')
 require File.join( File.dirname( File.expand_path(__FILE__)), 'smells', 'utility_function')
 # SMELL: Duplication -- all these should be found automagically
 

data/lib/reek/smells/duplication.rb

@@ -79,7 +79,7 @@ module Reek
           result[call_node].push(call_node)
         end
         method_ctx.local_nodes(:attrasgn) do |asgn_node|
-          result[asgn_node].push(asgn_node) unless asgn_node.args.length < 2
+          result[asgn_node].push(asgn_node) unless asgn_node.args.nil?
         end
         result
       end

data/lib/reek/smells/irresponsible_module.rb

@@ -19,6 +19,10 @@ module Reek
         [:class]
       end
 
+      def self.descriptive   # :nodoc:
+        @descriptive ||= {}
+      end
+
       #
       # Checks the given class or module for a descriptive comment.
       #
@@ -26,7 +30,7 @@ module Reek
       #
       def examine_context(ctx)
         comment = Source::CodeComment.new(ctx.exp.comments)
-        return [] if comment.is_descriptive?
+        return [] if self.class.descriptive[ctx.full_name] ||= comment.is_descriptive?
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
           'has no descriptive comment',
           @source, SMELL_SUBCLASS, {MODULE_NAME_KEY => ctx.exp.text_name})

data/lib/reek/smells/simulated_polymorphism.rb

@@ -72,7 +72,7 @@ module Reek
         result = Hash.new {|hash, key| hash[key] = []}
         collector = proc { |node|
           condition = node.condition
-          next if condition.nil? or condition == s(:call, nil, :block_given?, s(:arglist))
+          next if condition.nil? or condition == s(:call, nil, :block_given?)
           result[condition].push(condition.line)
         }
         [:if, :case].each {|stmt| sexp.local_nodes(stmt, &collector) }

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -75,14 +75,54 @@ module Reek
       end
 
       def variable_names(exp)
+        result = Hash.new {|hash, key| hash[key] = []}
+        find_assignment_variable_names(exp, result)
+        find_block_argument_variable_names(exp, result)
+        result
+      end
+
+      def find_assignment_variable_names(exp, accumulator)
         assignment_nodes = exp.each_node(:lasgn, [:class, :module, :defs, :defn])
+
         case exp.first
           when :class, :module
             assignment_nodes += exp.each_node(:iasgn, [:class, :module])
         end
-        result = Hash.new {|hash, key| hash[key] = []}
-        assignment_nodes.each {|asgn| result[asgn[1]].push(asgn.line) }
-        result
+
+        assignment_nodes.each {|asgn| accumulator[asgn[1]].push(asgn.line) }
+      end
+
+      def find_block_argument_variable_names(exp, accumulator)
+        arg_search_exp = case exp.first
+                         when :class, :module
+                           exp
+                         when :defs, :defn
+                           exp.body
+                         end
+
+        args_nodes = arg_search_exp.each_node(:args, [:class, :module, :defs, :defn])
+
+        args_nodes.each do |args_node|
+          recursively_record_variable_names(accumulator, args_node)
+        end
+      end
+
+      def recursively_record_variable_names(accumulator, exp)
+        exp[1..-1].each do |subexp|
+          if subexp.is_a? Symbol
+            record_variable_name(exp, subexp, accumulator)
+          elsif subexp.first == :masgn
+            recursively_record_variable_names(accumulator, subexp)
+          end
+        end
+      end
+
+      def record_variable_name(exp, symbol, accumulator)
+        varname = symbol.to_s.sub(/^\*/, '')
+        if varname != ""
+          var = varname.to_sym
+          accumulator[var].push(exp.line)
+        end
       end
     end
   end

data/lib/reek/smells/unused_parameters.rb

@@ -0,0 +1,37 @@
+require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+
+module Reek
+  module Smells
+
+    #
+    # Methods should use their parameters.
+    # 
+    class UnusedParameters < SmellDetector
+
+      SMELL_CLASS = 'ControlCouple'
+      SMELL_SUBCLASS = name.split(/::/)[-1]
+
+      PARAMETER_KEY = 'parameter'
+
+      #
+      # Checks whether the given method has any unused parameters.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(method_ctx)
+        params = method_ctx.exp.arg_names || []
+        params.select do |param|
+          param = param.to_s.sub(/^\*/, '')
+          !["", "_"].include?(param) &&
+            !method_ctx.local_nodes(:lvar).include?(Sexp.new(:lvar, param.to_sym))
+        end.map do |param|
+          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
+                           "has unused parameter '#{param.to_s}'",
+                           @source, SMELL_SUBCLASS, {PARAMETER_KEY => param.to_s})
+        end
+      end
+
+    end
+  end
+end

data/lib/reek/source/source_code.rb

@@ -1,3 +1,4 @@
+require 'ruby_parser'
 require File.join(File.dirname(File.expand_path(__FILE__)), 'config_file')
 require File.join(File.dirname(File.expand_path(__FILE__)), 'tree_dresser')
 
@@ -21,19 +22,7 @@ module Reek
 
       attr_reader :desc
 
-      # At runtime, reek tries to load ripper_ruby_parser. If that succeeds,
-      # reek uses that parser and will be able to handle Ruby 1.9 syntax. On
-      # Ruby versions below 1.9.3, it will fail and reek will use ruby_parser
-      # and handle Ruby 1.8 syntax only.
-      PARSER_CLASS = begin
-                       require 'ripper_ruby_parser'
-                       RipperRubyParser::Parser
-                     rescue LoadError
-                       require 'ruby_parser'
-                       RubyParser
-                     end
-
-      def initialize(code, desc, parser = PARSER_CLASS.new)
+      def initialize(code, desc, parser = RubyParser.new)
         @source = code
         @desc = desc
         @parser = parser

data/lib/reek/source/tree_dresser.rb

@@ -69,9 +69,9 @@ module Reek
       module CallNode
         def receiver() self[1] end
         def method_name() self[2] end
-        def args() self[3] end
+        def args() self[3..-1] end
         def arg_names
-          args[1..-1].map {|arg| arg[1]}
+          args.map {|arg| arg[1]}
         end
       end
 
@@ -84,26 +84,19 @@ module Reek
 
       module MethodNode
         def arg_names
-          unless @args
-            @args = argslist[1..-1].reject {|param| Sexp === param or param.to_s =~ /^&/}
-          end
-          @args
-        end
-        def parameters()
-          unless @params
-            @params = argslist.reject {|param| Sexp === param}
-          end
-          @params
+          @args ||= parameter_names.reject {|param| param.to_s =~ /^&/}
         end
         def parameter_names
-          parameters[1..-1]
+          @param_names ||= argslist[1..-1].map { |param| Sexp === param ?  param[1] : param }
         end
       end
 
       module DefnNode
         def name() self[1] end
         def argslist() self[2] end
-        def body() self[3] end
+        def body()
+          self[3..-1].tap {|b| b.extend SexpNode }
+        end
         include MethodNode
         def full_name(outer)
           prefix = outer == '' ? '' : "#{outer}#"
@@ -115,7 +108,9 @@ module Reek
         def receiver() self[1] end
         def name() self[2] end
         def argslist() self[3] end
-        def body() self[4] end
+        def body()
+          self[4..-1].tap {|b| b.extend SexpNode }
+        end
         include MethodNode
         def full_name(outer)
           prefix = outer == '' ? '' : "#{outer}#"
@@ -133,15 +128,7 @@ module Reek
         def block() self[3] end
         def parameters() self[2] || [] end
         def parameter_names
-          result = parameters
-          return case result[0]
-          when :lasgn
-            [result[1]]
-          when :masgn
-            result[1][1..-1].map {|lasgn| lasgn[1]}
-          else
-            []
-          end
+          parameters[1..-1].to_a
         end
       end
 

data/lib/reek/version.rb

@@ -1,3 +1,3 @@
 module Reek
-  VERSION = '1.2.13'
+  VERSION = '1.3'
 end

data/reek.gemspec

@@ -6,7 +6,6 @@ Gem::Specification.new do |s|
   s.version = Reek::VERSION
 
   s.authors = ['Kevin Rutherford', 'Timo Roessner', 'Matijs van Zuijlen']
-  s.date = %q{2010-04-26}
   s.default_executable = %q{reek}
   s.description = %q{Reek is a tool that examines Ruby classes, modules and methods
 and reports any code smells it finds.
@@ -26,13 +25,13 @@ and reports any code smells it finds.
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{Code smell detector for Ruby}
 
-  s.add_runtime_dependency(%q<ruby_parser>, ["~> 2.0"])
-  s.add_runtime_dependency(%q<ripper_ruby_parser>, ["~> 0.0.7"])
-  s.add_runtime_dependency(%q<ruby2ruby>, ["~> 1.2.5"])
-  s.add_runtime_dependency(%q<sexp_processor>, ["~> 3.0"])
+  s.add_runtime_dependency(%q<ruby_parser>, ["~> 3.0.4"])
+  s.add_runtime_dependency(%q<sexp_processor>)
+  s.add_runtime_dependency(%q<ruby2ruby>, ["~> 2.0.0"])
 
   s.add_development_dependency(%q<bundler>, ["~> 1.1"])
   s.add_development_dependency(%q<rake>)
   s.add_development_dependency(%q<cucumber>)
   s.add_development_dependency(%q<rspec>, ["~> 2.12"])
+  s.add_development_dependency(%q<yard>)
 end

data/spec/reek/smells/control_couple_spec.rb

@@ -51,11 +51,7 @@ EOS
 
     it 'has the correct fields' do
       @warning.smell[ControlCouple::PARAMETER_KEY].should == 'arg'
-      if RUBY_VERSION < "1.9.3"
-        @warning.lines.should == [3,6]
-      else
-        @warning.lines.should == [3,5]
-      end
+      @warning.lines.should == [3, 5]
     end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -13,9 +13,6 @@ describe FeatureEnvy do
     it 'should not report vcall with no argument' do
       'def simple() func; end'.should_not reek
     end
-    it 'should not report vcall with argument' do
-      'def simple(arga) func(17); end'.should_not reek
-    end
     it 'should not report single use' do
       'def no_envy(arga) arga.barg(@item) end'.should_not reek
     end

data/spec/reek/smells/irresponsible_module_spec.rb

@@ -1,7 +1,6 @@
 require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'spec_helper')
 require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'smells', 'irresponsible_module')
 require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shared')
-
 include Reek::Smells
 
 describe IrresponsibleModule do
@@ -12,6 +11,16 @@ describe IrresponsibleModule do
 
   it_should_behave_like 'SmellDetector'
 
+  it 'does not report re-opened modules' do
+    src = <<-EOS
+      # Abstract base class
+      class C; end
+
+      class C; def foo; end; end
+    EOS
+    src.should_not reek_of(:IrresponsibleModule)
+  end
+
   it "does not report a class having a comment" do
     src = <<EOS
 # test class

data/spec/reek/smells/long_method_spec.rb

@@ -13,6 +13,12 @@ def process_method(src)
   Core::CodeParser.new(sniffer).process_defn(source.syntax_tree)
 end
 
+def process_singleton_method(src)
+  source = src.to_reek_source
+  sniffer = Core::Sniffer.new(source)
+  Core::CodeParser.new(sniffer).process_defs(source.syntax_tree)
+end
+
 describe LongMethod do
   it 'should not report short methods' do
     src = 'def short(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;end'
@@ -20,7 +26,7 @@ describe LongMethod do
   end
 
   it 'should report long methods' do
-    src = 'def long(arga) alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
+    src = 'def long() alf = f(1);@bet = 2;@cut = 3;@dit = 4; @emp = 5;@fry = 6;end'
     src.should reek_only_of(:LongMethod, /6 statements/)
   end
 
@@ -53,7 +59,7 @@ EOS
 
   it 'should report long inner block' do
     src = <<EOS
-def long(arga)
+def long()
   f(3)
   self.each do |xyzero|
     xyzero = 1
@@ -177,6 +183,22 @@ describe LongMethod, 'does not count control statements' do
     method.num_statements.should == 0
   end
 
+  it 'counts 1 statement in a block' do
+    method = process_method('def one() fred.each do; callee(); end; end')
+    method.num_statements.should == 1
+  end
+
+  # FIXME: I think this is wrong, but it specs current behavior.
+  it 'counts 4 statements in a block' do
+    method = process_method('def one() fred.each do; callee(); callee(); callee(); end; end')
+    method.num_statements.should == 4
+  end
+
+  it 'counts 1 statement in a singleton method' do
+    method = process_singleton_method('def self.foo; callee(); end')
+    method.num_statements.should == 1
+  end
+
   it 'counts else statement' do
     src = <<EOS
 def parse(arg, argv, &error)

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -80,6 +80,72 @@ EOS
       src.should smell_of(UncommunicativeVariableName,
         {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'})
     end
+
+    it "reports all relevant block parameters" do
+      src = <<-EOS
+        def bad
+          @foo.map { |x, y| x + y }
+        end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+    end
+
+    it "reports block parameters used outside of methods" do
+      src = <<-EOS
+      class Foo
+        @foo.map { |x| x * 2 }
+      end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'})
+    end
+
+    it "reports splatted block parameters correctly" do
+      src = <<-EOS
+        def bad
+          @foo.map { |*y| y << 1 }
+        end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+    end
+
+    it "reports nested block parameters" do
+      src = <<-EOS
+        def bad
+          @foo.map { |(x, y)| x + y }
+        end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+    end
+
+    it "reports splatted nested block parameters" do
+      src = <<-EOS
+        def bad
+          @foo.map { |(x, *y)| x + y }
+        end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+    end
+
+    it "reports deeply nested block parameters" do
+      src = <<-EOS
+        def bad
+          @foo.map { |(x, (y, z))| x + y + z }
+        end
+      EOS
+      src.should smell_of(UncommunicativeVariableName,
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'},
+                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'z'})
+    end
+
   end
 
   context 'when a smell is reported' do