rubocop 0.12.0 → 0.13.0

data/lib/rubocop/config.rb

@@ -31,7 +31,7 @@ module Rubocop
         puts "configuration from #{path}" if debug?
         contains_auto_generated_config = false
 
-        base_configs(path, hash['inherit_from']).reverse.each do |base_config|
+        base_configs(path, hash['inherit_from']).reverse_each do |base_config|
           if File.basename(base_config.loaded_path) == DOTFILE
             make_excludes_absolute(base_config)
           end
@@ -179,11 +179,12 @@ module Rubocop
     end
 
     def for_cop(cop)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
       self[cop]
     end
 
     def cop_enabled?(cop)
-      self[cop].nil? || self[cop]['Enabled']
+      for_cop(cop).nil? || for_cop(cop)['Enabled']
     end
 
     def warn_unless_valid

data/lib/rubocop/cop/commissioner.rb

@@ -38,8 +38,9 @@ module Rubocop
         class_eval <<-EOS
           def #{callback}(node)
             @cops.each do |cop|
-              if cop.respond_to?(:#{callback})
-                delegate_to(cop, :#{callback}, node)
+              next unless cop.respond_to?(:#{callback})
+              with_cop_error_handling(cop) do
+                cop.send(:#{callback}, node)
               end
             end
 
@@ -50,6 +51,7 @@ module Rubocop
 
       def investigate(processed_source)
         reset_errors
+        prepare(processed_source)
         invoke_cops_callback(processed_source)
         process(processed_source.ast) if processed_source.ast
         @cops.reduce([]) do |offences, cop|
@@ -64,18 +66,26 @@ module Rubocop
         @errors = Hash.new { |hash, k| hash[k] = [] }
       end
 
+      # TODO: Bad design.
+      def prepare(processed_source)
+        @cops.each { |cop| cop.processed_source = processed_source }
+      end
+
       # There are cops that require their own custom processing.
       # If they define the #investigate method all input parameters passed
       # to the commissioner will be passed to the cop too in order to do
       # its own processing.
       def invoke_cops_callback(processed_source)
         @cops.each do |cop|
-          cop.investigate(processed_source) if cop.respond_to?(:investigate)
+          next unless cop.respond_to?(:investigate)
+          with_cop_error_handling(cop) do
+            cop.investigate(processed_source)
+          end
         end
       end
 
-      def delegate_to(cop, callback, node)
-        cop.send callback, node
+      def with_cop_error_handling(cop)
+        yield
       rescue => e
         if @options[:raise_error]
           raise e

data/lib/rubocop/cop/cop.rb

@@ -46,18 +46,10 @@ module Rubocop
           + - * / % ** ~ +@ -@ [] []= ! != !~
         ).map(&:to_sym) + [:'`']
 
-      attr_accessor :offences
-      attr_accessor :debug
-      attr_accessor :autocorrect
-      attr_writer :disabled_lines
-      attr_reader :corrections
+      attr_reader :config, :offences, :corrections
+      attr_accessor :processed_source # TODO: Bad design.
 
       @all = CopStore.new
-      @config = {}
-
-      class << self
-        attr_accessor :config
-      end
 
       def self.all
         @all.clone
@@ -83,53 +75,76 @@ module Rubocop
         cop_type == :lint
       end
 
-      # Extracts the first line out of the description
-      def self.short_description
-        desc = full_description
-        desc ? desc.lines.first.strip : ''
-      end
-
-      # Gets the full description of the cop or nil if no description is set.
-      def self.full_description
-        config['Description']
-      end
-
       def self.rails?
         cop_type == :rails
       end
 
-      def initialize
+      def initialize(config = nil, options = nil)
+        @config = config || Config.new
+        @options = options || { autocorrect: false, debug: false }
+
         @offences = []
-        @debug = false
-        @autocorrect = false
-        @ignored_nodes = []
         @corrections = []
+        @ignored_nodes = []
       end
 
-      def do_autocorrect(node, *args)
-        autocorrect_action(node, *args) if autocorrect
+      def cop_config
+        @config.for_cop(self)
       end
 
-      def autocorrect_action(node, *args)
+      def autocorrect?
+        @options[:autocorrect]
       end
 
-      def add_offence(severity, location, message)
-        unless @disabled_lines && @disabled_lines.include?(location.line)
-          message = debug ? "#{name}: #{message}" : message
+      def debug?
+        @options[:debug]
+      end
+
+      def autocorrect_action(node)
+      end
+
+      def message(node = nil)
+        self.class::MSG
+      end
+
+      def add_offence(severity, node, loc, message = nil)
+        location = loc.is_a?(Symbol) ? node.loc.send(loc) : loc
+
+        unless disabled_line?(location.line)
+          message = message ? message : message(node)
+          message = debug? ? "#{name}: #{message}" : message
           @offences << Offence.new(severity, location, message, name)
+          autocorrect_action(node) if autocorrect?
         end
       end
 
-      def name
+      def convention(node, location, message = nil)
+        add_offence(:convention, node, location, message)
+      end
+
+      def warning(node, location, message = nil)
+        add_offence(:warning, node, location, message)
+      end
+
+      def cop_name
         self.class.cop_name
       end
 
+      alias_method :name, :cop_name
+
       def ignore_node(node)
         @ignored_nodes << node
       end
 
       private
 
+      def disabled_line?(line_number)
+        return false unless @processed_source
+        disabled_lines = @processed_source.disabled_lines_for_cops[name]
+        return false unless disabled_lines
+        disabled_lines.include?(line_number)
+      end
+
       def part_of_ignored_node?(node)
         expression = node.loc.expression
         @ignored_nodes.each do |ignored_node|

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -35,7 +35,7 @@ module Rubocop
 
             # assignment nodes from shorthand ops like ||= don't have operator
             if asgn_node.type != :begin && asgn_node.loc.operator
-              add_offence(:warning, asgn_node.loc.operator, MSG)
+              warning(asgn_node, :operator)
             end
           end
         end
@@ -46,7 +46,7 @@ module Rubocop
         end
 
         def safe_assignment_allowed?
-          AssignmentInCondition.config['AllowSafeAssignment']
+          cop_config['AllowSafeAssignment']
         end
       end
     end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -12,9 +12,9 @@ module Rubocop
       #     i
       #   end
       class BlockAlignment < Cop
-        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
+        MSG = 'end at %d, %d is not aligned with %s at %d, %d%s'
 
-        def initialize
+        def initialize(config = nil, options = nil)
           super
           @inspected_blocks = []
         end
@@ -118,16 +118,37 @@ module Rubocop
         def check_block_alignment(start_node, block_node)
           start_loc = start_node.loc.expression
           end_loc = block_node.loc.end
-          if block_node.loc.begin.line != end_loc.line &&
-              start_loc.column != end_loc.column
-            add_offence(:warning,
-                        end_loc,
-                        sprintf(MSG, end_loc.line, end_loc.column,
-                                start_loc.source.lines.to_a.first.chomp,
-                                start_loc.line, start_loc.column))
+          do_loc = block_node.loc.begin # Actually it's either do or {.
+          return if do_loc.line == end_loc.line # One-liner, not interesting.
+          if start_loc.column != end_loc.column
+            # We've found that "end" is not aligned with the start node (which
+            # can be a block, a variable assignment, etc). But we also allow
+            # the "end" to be aligned with the start of the line where the "do"
+            # is, which is a style some people use in multi-line chains of
+            # blocks.
+            match = /\S.*/.match(do_loc.source_line)
+            indentation_of_do_line = match.begin(0)
+            if end_loc.column != indentation_of_do_line
+              alt_start_msg = if start_loc.line == do_loc.line &&
+                                  start_loc.column == indentation_of_do_line
+                                ''
+                              else
+                                " or #{match[0]} at #{do_loc.line}, " +
+                                  "#{indentation_of_do_line}"
+                              end
+              warning(nil,
+                      end_loc,
+                      sprintf(MSG, end_loc.line, end_loc.column,
+                              start_loc.source.lines.to_a.first.chomp,
+                              start_loc.line, start_loc.column,
+                              alt_start_msg))
+            end
           end
         end
 
+        def message
+        end
+
         def already_processed_node?(node)
           @inspected_blocks.include?(node)
         end

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_ensure(node)
           _body, ensure_body = *node
 
-          add_offence(:warning, node.loc.keyword, MSG) unless ensure_body
+          warning(node, :keyword) unless ensure_body
         end
       end
     end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -53,10 +53,10 @@ module Rubocop
           end_loc = node.loc.end
 
           if kw_loc.line != end_loc.line && kw_loc.column != end_loc.column
-            add_offence(:warning,
-                        end_loc,
-                        sprintf(MSG, end_loc.line, end_loc.column,
-                                kw_loc.source, kw_loc.line, kw_loc.column))
+            warning(nil,
+                    end_loc,
+                    sprintf(MSG, end_loc.line, end_loc.column,
+                            kw_loc.source, kw_loc.line, kw_loc.column))
           end
         end
       end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -19,7 +19,7 @@ module Rubocop
 
         def check(node)
           on_node(:postexe, node) do |end_node|
-            add_offence(:warning, end_node.loc.keyword, MSG)
+            warning(end_node, :keyword)
           end
         end
       end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -13,7 +13,7 @@ module Rubocop
           return unless ensure_body
 
           on_node(:return, ensure_body) do |e|
-            add_offence(:warning, e.loc.expression, MSG)
+            warning(e, :expression)
           end
         end
       end

data/lib/rubocop/cop/lint/eval.rb

@@ -10,9 +10,7 @@ module Rubocop
         def on_send(node)
           receiver, method_name, = *node
 
-          if receiver.nil? && method_name == :eval
-            add_offence(:warning, node.loc.selector, MSG)
-          end
+          warning(node, :selector) if receiver.nil? && method_name == :eval
         end
       end
     end

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_resbody(node)
           _exc_list_node, _exc_var_node, body_node = *node
 
-          add_offence(:warning, node.loc.expression, MSG) unless body_node
+          warning(node, :expression) unless body_node
         end
       end
     end

data/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -43,6 +43,10 @@ module Rubocop
           check_for_literal(node)
         end
 
+        def message(node)
+          MSG.format(node.loc.expression.source)
+        end
+
         private
 
         def check_for_literal(node)
@@ -50,8 +54,7 @@ module Rubocop
 
           # if the cond node is literal we obviously have a problem
           if literal?(cond)
-            add_offence(:warning, cond.loc.expression,
-                        format(MSG, cond.loc.expression.source))
+            warning(cond, :expression)
           else
             # alternatively we have to consider a logical node with a
             # literal argument
@@ -91,8 +94,7 @@ module Rubocop
 
         def handle_node(node)
           if literal?(node)
-            add_offence(:warning, node.loc.expression,
-                        format(MSG, node.loc.expression.source))
+            warning(node, :expression)
           elsif [:send, :and, :or, :begin].include?(node.type)
             check_node(node)
           end

data/lib/rubocop/cop/lint/loop.rb

@@ -19,7 +19,7 @@ module Rubocop
         private
 
         def register_offence(node)
-          add_offence(:warning, node.loc.keyword, MSG)
+          warning(node, :keyword)
         end
       end
     end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -37,7 +37,7 @@ module Rubocop
                 Parser::Source::Range.new(expr.source_buffer,
                                           expr.begin_pos - space_length,
                                           expr.begin_pos)
-              add_offence(:warning, space_range, MSG)
+              warning(nil, space_range)
             end
           end
         end

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -11,7 +11,7 @@ module Rubocop
           return unless node.children.first
           rescue_args = node.children.first.children
           if rescue_args.any? { |a| targets_exception?(a) }
-            add_offence(:warning, node.location.expression, MSG)
+            warning(node, :expression)
           end
         end
 

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -16,17 +16,14 @@ module Rubocop
           inspect_variables(processed_source.ast)
         end
 
-        def before_declaring_variable(entry)
-          # Only block scope can reference outer local variables.
-          return unless variable_table.current_scope.node.type == :block
-          return unless ARGUMENT_DECLARATION_TYPES.include?(entry.node.type)
-          return if entry.name.to_s.start_with?('_')
+        def before_declaring_variable(variable)
+          return if variable.name.to_s.start_with?('_')
 
-          outer_local_variable = variable_table.find_variable_entry(entry.name)
+          outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
 
-          message = sprintf(MSG, entry.name)
-          add_offence(:warning, entry.node.loc.expression, message)
+          message = sprintf(MSG, variable.name)
+          warning(variable.declaration_node, :expression, message)
         end
       end
     end

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -17,7 +17,7 @@ module Rubocop
 
           expressions.each_cons(2) do |e1, e2|
             if NODE_TYPES.include?(e1.type) || flow_command?(e1)
-              add_offence(:warning, e2.loc.expression, MSG)
+              warning(e2, :expression)
             end
           end
         end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -3,87 +3,84 @@
 module Rubocop
   module Cop
     module Lint
-      # This cop checks for useless assignment as the final expression
-      # of a function definition.
+      # This cop checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
       #
-      # @example
+      #   assigned but unused variable - foo
       #
-      #  def something
-      #    x = 5
-      #  end
-      #
-      #  def something
-      #    x = Something.new
-      #    x.attr = 5
-      #  end
+      # Currently this cop has advanced logic that detects unreferenced
+      # reassignments and properly handles varied cases such as branch, loop,
+      # rescue, ensure, etc.
       class UselessAssignment < Cop
-        MSG = 'Useless assignment to local variable %s.'
+        include VariableInspector
 
-        def on_def(node)
-          _name, args, body = *node
+        MSG = 'Useless assignment to variable - %s'
 
-          check_for_useless_assignment(body, args)
+        def investigate(processed_source)
+          inspect_variables(processed_source.ast)
         end
 
-        def on_defs(node)
-          _target, _name, args, body = *node
-
-          check_for_useless_assignment(body, args)
+        def after_leaving_scope(scope)
+          scope.variables.each_value do |variable|
+            check_for_unused_assignments(variable)
+            check_for_unused_block_local_variable(variable)
+          end
         end
 
-        private
+        def check_for_unused_assignments(variable)
+          return if variable.name.to_s.start_with?('_')
 
-        def check_for_useless_assignment(body, args)
-          return unless body
+          variable.assignments.each do |assignment|
+            next if assignment.used?
 
-          if body.type == :begin
-            expression = body.children
-          else
-            expression = body
-          end
+            message = message_for_useless_assignment(assignment)
+
+            location = if assignment.regexp_named_capture?
+                         assignment.node.children.first.loc.expression
+                       else
+                         assignment.node.loc.name
+                       end
 
-          last_expr = expression.is_a?(Array) ? expression.last : expression
-          return unless last_expr
-
-          case last_expr.type
-          when :lvasgn
-            var_name, = *last_expr
-            add_offence(:warning, last_expr.loc.name, MSG.format(var_name))
-          when :send
-            receiver, method, _args = *last_expr
-            return unless receiver
-            return unless receiver.type == :lvar
-            return unless method =~ /\w=$/
-
-            var_name, = *receiver
-            return if contains_object_passed_as_argument?(var_name, body, args)
-
-            add_offence(:warning,
-                        receiver.loc.name,
-                        MSG.format(receiver.loc.name.source))
+            warning(nil, location, message)
           end
         end
 
-        def contains_object_passed_as_argument?(lvar_name, body, args)
-          variable_table = {}
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          message = sprintf(MSG, variable.name)
 
-          args.children.each do |arg_node|
-            arg_name, = *arg_node
-            variable_table[arg_name] = true
+          if assignment.multiple_assignment?
+            message << ". Use _ or _#{variable.name} as a variable name " +
+                       "to indicate that it won't be used."
+          elsif assignment.operator_assignment?
+            return_value_node = return_value_node_of_scope(variable.scope)
+            if assignment.meta_assignment_node.equal?(return_value_node)
+              non_assignment_operator = assignment.operator.sub(/=$/, '')
+              message << ". Use just operator #{non_assignment_operator}."
+            end
           end
 
-          on_node([:lvasgn, :ivasgn, :cvasgn, :gvasgn], body) do |asgn_node|
-            lhs_var_name, rhs_node = *asgn_node
+          message
+        end
 
-            if [:lvar, :ivar, :cvar, :gvar].include?(rhs_node.type)
-              rhs_var_name, = *rhs_node
-              variable_table[lhs_var_name] = variable_table[rhs_var_name]
-            else
-              variable_table[lhs_var_name] = false
-            end
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.type == :begin
+            body_node.children.last
+          else
+            body_node
           end
+        end
 
-          variable_table[lvar_name]
+        def check_for_unused_block_local_variable(variable)
+          return unless variable.block_local_variable?
+          return unless variable.assignments.empty?
+          message = sprintf(MSG, variable.name)
+          warning(variable.declaration_node, :expression, message)
         end
       end
     end