reek 1.4.0 → 1.5.0

data/lib/reek/core/code_parser.rb

@@ -1,4 +1,3 @@
-require 'sexp'
 require 'reek/core/method_context'
 require 'reek/core/module_context'
 require 'reek/core/stop_context'
@@ -12,6 +11,7 @@ module Reek
     #
     # SMELL: This class is responsible for counting statements and for feeding
     # each context to the smell repository.
+    # SMELL: This class has a name that doesn't match its responsibility.
     class CodeParser
       def initialize(smell_repository, ctx = StopContext.new)
         @smell_repository = smell_repository
@@ -19,14 +19,14 @@ module Reek
       end
 
       def process(exp)
-        meth = "process_#{exp[0]}"
+        meth = "process_#{exp.type}"
         meth = :process_default unless self.respond_to?(meth)
         send(meth, exp)
         @element
       end
 
       def process_default(exp)
-        exp.each { |sub| process(sub) if sub.is_a? Array }
+        exp.children.each { |sub| process(sub) if sub.is_a? AST::Node }
       end
 
       def process_module(exp)
@@ -37,16 +37,16 @@ module Reek
 
       alias_method :process_class, :process_module
 
-      def process_defn(exp)
+      def process_def(exp)
         inside_new_context(MethodContext, exp) do
-          count_statement_list(exp.body)
+          count_clause(exp.body)
           process_default(exp)
         end
       end
 
       def process_defs(exp)
         inside_new_context(SingletonMethodContext, exp) do
-          count_statement_list(exp.body)
+          count_clause(exp.body)
           process_default(exp)
         end
       end
@@ -57,20 +57,20 @@ module Reek
       # Recording of calls to methods and self
       #
 
-      def process_call(exp)
+      def process_send(exp)
         @element.record_call_to(exp)
         process_default(exp)
       end
 
-      alias_method :process_attrasgn, :process_call
-      alias_method :process_op_asgn1, :process_call
+      alias_method :process_attrasgn, :process_send
+      alias_method :process_op_asgn, :process_send
 
       def process_ivar(exp)
         @element.record_use_of_self
         process_default(exp)
       end
 
-      alias_method :process_iasgn, :process_ivar
+      alias_method :process_ivasgn, :process_ivar
 
       def process_self(_)
         @element.record_use_of_self
@@ -82,17 +82,19 @@ module Reek
       # Statement counting
       #
 
-      def process_iter(exp)
-        count_clause(exp[3])
+      def process_block(exp)
+        count_clause(exp.block)
         process_default(exp)
       end
 
-      def process_block(exp)
-        count_statement_list(exp[1..-1])
+      def process_begin(exp)
+        count_statement_list(exp.children)
         @element.count_statements(-1)
         process_default(exp)
       end
 
+      alias_method :process_kwbegin, :process_begin
+
       def process_if(exp)
         count_clause(exp[2])
         count_clause(exp[3])
@@ -126,14 +128,13 @@ module Reek
       end
 
       def process_case(exp)
-        count_statement_list(exp[2..-1].compact)
+        count_clause(exp.else_body)
         @element.count_statements(-1)
         process_default(exp)
       end
 
       def process_when(exp)
-        count_statement_list(exp[2..-1].compact)
-        @element.count_statements(-1)
+        count_clause(exp.body)
         process_default(exp)
       end
 
@@ -151,7 +152,7 @@ module Reek
         scope = klass.new(@element, exp)
         push(scope) do
           yield
-          check_smells(exp[0])
+          check_smells(exp.type)
         end
         scope
       end

data/lib/reek/core/method_context.rb

@@ -9,8 +9,8 @@ module Reek
     module MethodParameters
       def default_assignments
         result = []
-        self[1..-1].each do |exp|
-          result << exp[1..2] if exp.is_a?(Sexp) && exp[0] == :lasgn
+        each do |exp|
+          result << exp[1..2] if exp.optional_argument?
         end
         result
       end
@@ -26,9 +26,8 @@ module Reek
 
       def initialize(outer, exp)
         super(outer, exp)
-        @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
-        @parameters ||= []
-        @parameters.extend(MethodParameters)
+        @parameters = exp.parameters.dup
+        @parameters.extend MethodParameters
         @num_statements = 0
         @refs = ObjectRefs.new
       end
@@ -41,6 +40,8 @@ module Reek
         receiver, meth = exp[1..2]
         receiver ||= [:self]
         case receiver[0]
+        when :lvasgn
+          @refs.record_reference_to(receiver.updated(:lvar))
         when :lvar
           @refs.record_reference_to(receiver) unless meth == :new
         when :self
@@ -58,7 +59,7 @@ module Reek
       end
 
       def uses_param?(param)
-        local_nodes(:lvar).include?(Sexp.new(:lvar, param.to_sym))
+        local_nodes(:lvar).find { |node| node.var_name == param.to_sym }
       end
 
       def unused_params
@@ -70,7 +71,7 @@ module Reek
       end
 
       def uses_super_with_implicit_arguments?
-        exp.body.contains_nested_node? :zsuper
+        (body = exp.body) && body.contains_nested_node?(:zsuper)
       end
     end
   end

data/lib/reek/core/module_context.rb

@@ -9,7 +9,7 @@ module Reek
     class ModuleContext < CodeContext
       def initialize(outer, exp)
         super(outer, exp)
-        @name = Source::SexpFormatter.format(exp[1])
+        @name = Source::SexpFormatter.format(exp.children.first)
       end
     end
   end

data/lib/reek/core/smell_repository.rb

@@ -19,6 +19,7 @@ module Reek
           Smells::IrresponsibleModule,
           Smells::LongParameterList,
           Smells::LongYieldList,
+          Smells::ModuleInitialize,
           Smells::NestedIterators,
           Smells::NilCheck,
           Smells::PrimaDonnaMethod,

data/lib/reek/core/sniffer.rb

@@ -8,7 +8,9 @@ module Reek
     # Configures all available smell detectors and applies them to a source.
     #
     class Sniffer
-      def initialize(src, extra_config_files = [], smell_repository = Core::SmellRepository.new(src.desc))
+      def initialize(src,
+                     extra_config_files = [],
+                     smell_repository = Core::SmellRepository.new(src.desc))
         @smell_repository = smell_repository
         @source = src
 

data/lib/reek/rake/task.rb

@@ -97,10 +97,6 @@ module Reek
         raise('Smells found!') if !system(cmd) && fail_on_error
       end
 
-      def self.reek_script
-        File.expand_path(File.dirname(__FILE__) + '/../../../bin/reek')
-      end
-
       def self.ruby_exe
         File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
       end
@@ -108,7 +104,7 @@ module Reek
       def cmd_words
         [Task.ruby_exe] +
             ruby_options +
-            [%("#{Task.reek_script}")] +
+            [%(reek)] +
             [sort_option] +
             config_file_list.map { |fn| ['-c', %("#{fn}")] }.flatten +
             source_file_list.map { |fn| %("#{fn}") }

data/lib/reek/smell_description.rb

@@ -0,0 +1,26 @@
+module Reek
+  class SmellDescription
+    attr_reader :smell_class, :smell_subclass, :message, :details
+
+    def initialize(smell_class, smell_subclass, message, details)
+      @smell_class = smell_class
+      @smell_subclass = smell_subclass
+      @message = message
+      @details = details
+    end
+
+    def [](key)
+      @details[key]
+    end
+
+    def encode_with coder
+      coder.tag = nil
+      coder['class'] = @smell_class
+      coder['subclass'] = @smell_subclass
+      coder['message'] = @message
+      @details.each do |k, v|
+        coder[k] = v
+      end
+    end
+  end
+end

data/lib/reek/smell_warning.rb

@@ -1,71 +1,45 @@
+require 'reek/smell_description'
+
 module Reek
   #
   # Reports a warning that a smell has been found.
-  # This object is essentially a DTO, and therefore contains a :reek:attribute or two.
   #
   class SmellWarning
     include Comparable
 
-    MESSAGE_KEY = 'message'
-    SUBCLASS_KEY = 'subclass'
-    CLASS_KEY = 'class'
-
-    CONTEXT_KEY = 'context'
-    LINES_KEY = 'lines'
-    SOURCE_KEY = 'source'
-
-    ACTIVE_KEY = 'is_active'
-
     def initialize(class_name, context, lines, message,
         source = '', subclass_name = '', parameters = {})
-      @smell = {
-        CLASS_KEY => class_name,
-        SUBCLASS_KEY => subclass_name,
-        MESSAGE_KEY => message
-      }
-      @smell.merge!(parameters)
-      @status = {
-        ACTIVE_KEY => true
-      }
+      @smell = SmellDescription.new(class_name, subclass_name, message, parameters)
       @location = {
-        CONTEXT_KEY => context.to_s,
-        LINES_KEY => lines,
-        SOURCE_KEY => source
+        'context' => context.to_s,
+        'lines'   => lines,
+        'source'  => source
       }
     end
 
     #
-    # Details of the smell found, including its class ({CLASS_KEY}),
-    # subclass ({SUBCLASS_KEY}) and summary message ({MESSAGE_KEY})
+    # Details of the smell found, including its class, subclass and summary message.
     #
     # @return [Hash{String => String}]
     #
     attr_reader :smell
 
-    def smell_class() @smell[CLASS_KEY] end
-    def subclass() @smell[SUBCLASS_KEY] end
-    def message() @smell[MESSAGE_KEY] end
+    def smell_classes() [smell_class, subclass] end
+    def smell_class() @smell.smell_class end
+    def subclass() @smell.smell_subclass end
+    def message() @smell.message end
 
     #
-    # Details of the smell's location, including its context ({CONTEXT_KEY}),
-    # the line numbers on which it occurs ({LINES_KEY}) and the source
-    # file ({SOURCE_KEY})
+    # Details of the smell's location, including its context,
+    # the line numbers on which it occurs and the source file
     #
     # @return [Hash{String => String, Array<Number>}]
     #
     attr_reader :location
 
-    def context() @location[CONTEXT_KEY] end
-    def lines() @location[LINES_KEY] end
-    def source() @location[SOURCE_KEY] end
-
-    #
-    # Details of the smell's status, including whether it is active ({ACTIVE_KEY})
-    # (as opposed to being masked by a config file)
-    #
-    # @return [Hash{String => Boolean}]
-    #
-    attr_reader :status
+    def context() @location.fetch('context') end
+    def lines() @location.fetch('lines') end
+    def source() @location.fetch('source') end
 
     def hash
       sort_key.hash
@@ -79,23 +53,35 @@ module Reek
       (self <=> other) == 0
     end
 
-    def contains_all?(patterns)
-      rpt = sort_key.to_s
-      patterns.all? { |pattern| pattern =~ rpt }
-    end
-
     def matches?(klass, patterns)
-      @smell.values.include?(klass.to_s) && contains_all?(patterns)
+      smell_classes.include?(klass.to_s) && contains_all?(patterns)
     end
 
     def report_on(listener)
       listener.found_smell(self)
     end
 
+    def init_with(coder)
+      @location = coder['location']
+      smell_attributes = coder['smell']
+      smell_class = smell_attributes.delete('class')
+      smell_subclass = smell_attributes.delete('subclass')
+      smell_message = smell_attributes.delete('message')
+      @smell = SmellDescription.new(smell_class,
+                                    smell_subclass,
+                                    smell_message,
+                                    smell_attributes)
+    end
+
     protected
 
+    def contains_all?(patterns)
+      rpt = sort_key.to_s
+      patterns.all? { |pattern| pattern =~ rpt }
+    end
+
     def sort_key
-      [@location[CONTEXT_KEY], @smell[MESSAGE_KEY], @smell[CLASS_KEY]]
+      [context, message, smell_class]
     end
   end
 end

data/lib/reek/smells.rb

@@ -8,6 +8,7 @@ require 'reek/smells/feature_envy'
 require 'reek/smells/irresponsible_module'
 require 'reek/smells/long_parameter_list'
 require 'reek/smells/long_yield_list'
+require 'reek/smells/module_initialize'
 require 'reek/smells/nested_iterators'
 require 'reek/smells/nil_check'
 require 'reek/smells/prima_donna_method'

data/lib/reek/smells/attribute.rb

@@ -50,7 +50,7 @@ module Reek
       def attributes_in(module_ctx)
         result = Set.new
         attr_defn_methods = [:attr, :attr_reader, :attr_writer, :attr_accessor]
-        module_ctx.local_nodes(:call) do |call_node|
+        module_ctx.local_nodes(:send) do |call_node|
           if attr_defn_methods.include?(call_node.method_name)
             call_node.arg_names.each { |arg| result << [arg, call_node.line] }
           end

data/lib/reek/smells/control_parameter.rb

@@ -88,6 +88,8 @@ module Reek
 
       # Finds cases of ControlParameter in a particular node for a particular parameter
       class ControlParameterFinder
+        CONDITIONAL_NODE_TYPES = [:if, :case, :and, :or]
+
         def initialize(node, param)
           @node = node
           @param = param
@@ -108,7 +110,7 @@ module Reek
         private
 
         def conditional_nodes
-          @node.body.unnested_nodes([:if, :case, :and, :or])
+          @node.body_nodes(CONDITIONAL_NODE_TYPES)
         end
 
         def nested_finders
@@ -118,8 +120,8 @@ module Reek
         end
 
         def uses_param_in_call_in_condition?
-          return false unless (condition = @node.condition)
-          condition.each_node(:call) do |inner|
+          return unless condition
+          condition.each_node(:send) do |inner|
             next unless regular_call_involving_param? inner
             return true
           end
@@ -127,10 +129,15 @@ module Reek
         end
 
         def uses_of_param_in_condition
-          return [] unless (condition = @node.condition)
+          return [] unless condition
           condition.each_node(:lvar).select { |inner| inner.var_name == @param }
         end
 
+        def condition
+          return nil unless CONDITIONAL_NODE_TYPES.include? @node.type
+          @node.condition
+        end
+
         def regular_call_involving_param?(call_node)
           call_involving_param?(call_node) && !comparison_call?(call_node)
         end
@@ -140,15 +147,15 @@ module Reek
         end
 
         def comparison_method_names
-          [:==, :!=]
+          [:==, :!=, :=~]
         end
 
         def call_involving_param?(call_node)
-          call_node.participants.any? { |it| it.var_name == @param }
+          call_node.each_node(:lvar).any? { |it| it.var_name == @param }
         end
 
         def uses_param_in_body?
-          nodes = @node.body.each_node(:lvar, [:if, :case, :and, :or])
+          nodes = @node.body_nodes([:lvar], [:if, :case, :and, :or])
           nodes.any? { |lvar_node| lvar_node.var_name == @param }
         end
       end