rubocop 0.12.0 → 0.13.0

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

@@ -19,7 +19,7 @@ module Rubocop
           if OPS.include?(op)
             receiver, _method, args = *node
 
-            add_offence(:warning, node.loc.selector, MSG) if receiver == args
+            warning(node, :selector) if receiver == args
           end
         end
       end

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for setter call to local variable as the final
+      # expression of a function definition.
+      #
+      # @example
+      #
+      #  def something
+      #    x = Something.new
+      #    x.attr = 5
+      #  end
+      class UselessSetterCall < Cop
+        MSG = 'Useless setter call to local variable %s.'
+
+        def on_def(node)
+          _name, args, body = *node
+
+          check_for_useless_assignment(body, args)
+        end
+
+        def on_defs(node)
+          _target, _name, args, body = *node
+
+          check_for_useless_assignment(body, args)
+        end
+
+        private
+
+        def check_for_useless_assignment(body, args)
+          return unless body
+
+          if body.type == :begin
+            expression = body.children
+          else
+            expression = body
+          end
+
+          last_expr = expression.is_a?(Array) ? expression.last : expression
+
+          return unless setter_call_to_local_variable?(last_expr)
+
+          receiver, = *last_expr
+          var_name, = *receiver
+          return if contains_object_passed_as_argument?(var_name, body, args)
+
+          warning(receiver,
+                  :name,
+                  MSG.format(receiver.loc.name.source))
+        end
+
+        def setter_call_to_local_variable?(node)
+          return unless node && node.type == :send
+          receiver, method, _args = *node
+          return unless receiver && receiver.type == :lvar
+          method =~ /\w=$/
+        end
+
+        def contains_object_passed_as_argument?(lvar_name, body, args)
+          variable_table = {}
+
+          args.children.each do |arg_node|
+            arg_name, = *arg_node
+            variable_table[arg_name] = true
+          end
+
+          on_node([:lvasgn, :ivasgn, :cvasgn, :gvasgn], body) do |asgn_node|
+            lhs_var_name, rhs_node = *asgn_node
+
+            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
+          end
+
+          variable_table[lvar_name]
+        end
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ module Rubocop
         def on_begin(node)
           expressions = *node
 
-          expressions[0...-1].each do |expr|
+          expressions.drop_last(1).each do |expr|
             check_for_void_op(expr)
             check_for_literal(expr)
             check_for_var(expr)
@@ -32,22 +32,20 @@ module Rubocop
 
           op = node.loc.selector.source
 
-          if OPS.include?(op)
-            add_offence(:warning, node.loc.selector, sprintf(OP_MSG, op))
-          end
+          warning(node, :selector, sprintf(OP_MSG, op)) if OPS.include?(op)
         end
 
         def check_for_var(node)
           if VARS.include?(node.type)
-            add_offence(:warning, node.loc.name,
-                        sprintf(VAR_MSG, node.loc.name.source))
+            warning(node, :name,
+                    sprintf(VAR_MSG, node.loc.name.source))
           end
         end
 
         def check_for_literal(node)
           if LITERALS.include?(node.type)
-            add_offence(:warning, node.loc.expression,
-                        sprintf(LIT_MSG, node.loc.expression.source))
+            warning(node, :expression,
+                    sprintf(LIT_MSG, node.loc.expression.source))
           end
         end
       end

data/lib/rubocop/cop/rails/has_and_belongs_to_many.rb

@@ -11,7 +11,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && method_name == :has_and_belongs_to_many
-            add_offence(:convention, node.loc.selector, MSG)
+            convention(node, :selector)
           end
         end
       end

data/lib/rubocop/cop/rails/read_attribute.rb

@@ -19,7 +19,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && method_name == :read_attribute
-            add_offence(:convention, node.loc.selector, MSG)
+            convention(node, :selector)
           end
         end
       end

data/lib/rubocop/cop/rails/validation.rb

@@ -22,7 +22,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && BLACKLIST.include?(method_name)
-            add_offence(:convention, node.loc.selector, MSG)
+            convention(node, :selector)
           end
         end
       end

data/lib/rubocop/cop/style/access_control.rb

@@ -33,18 +33,16 @@ module Rubocop
                   selector = send_node.loc.selector.source
 
                   if send_start_col - 2 != class_start_col
-                    add_offence(:convention,
-                                send_node.loc.expression,
-                                format(INDENT_MSG, selector))
+                    convention(send_node, :expression,
+                               format(INDENT_MSG, selector))
                   end
 
                   send_line = send_node.loc.line
 
                   unless processed_source[send_line].chomp.empty? &&
                       processed_source[send_line - 2].chomp.empty?
-                    add_offence(:convention,
-                                send_node.loc.expression,
-                                format(BLANK_MSG, selector))
+                    convention(send_node, :expression,
+                               format(BLANK_MSG, selector))
                   end
                 end
               end

data/lib/rubocop/cop/style/alias.rb

@@ -16,9 +16,7 @@ module Rubocop
 
           return if new.type == :gvar && old.type == :gvar
 
-          add_offence(:convention,
-                      node.loc.keyword,
-                      MSG)
+          convention(node, :keyword)
         end
       end
     end

data/lib/rubocop/cop/style/align_array.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Here we check if the elements of a multi-line array literal are
+      # aligned.
+      class AlignArray < Cop
+        MSG = 'Align the elements of an array literal if they span more ' +
+          'than one line.'
+
+        def on_array(node)
+          first_element = node.children.first
+
+          node.children.each_cons(2) do |prev, current|
+            if current.loc.line != prev.loc.line
+              @column_delta = first_element.loc.column - current.loc.column
+              if current.loc.column != first_element.loc.column
+                convention(current, :expression)
+              end
+            end
+          end
+        end
+
+        def autocorrect_action(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get
+          # the last value of @column_delta. A local variable fixes the
+          # problem.
+          column_delta = @column_delta
+
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            if column_delta > 0
+              corrector.replace(expr, ' ' * column_delta + expr.source)
+            else
+              range = Parser::Source::Range.new(expr.source_buffer,
+                                                expr.begin_pos + column_delta,
+                                                expr.end_pos)
+              corrector.replace(range, expr.source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/align_hash.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Here we check if the keys, separators, and values of a multi-line hash
+      # literal are aligned.
+      class AlignHash < Cop
+        MSG = 'Align the elements of a hash literal if they span more than ' +
+          'one line.'
+
+        def on_hash(node)
+          first_pair = node.children.first
+
+          if [cop_config['EnforcedHashRocketStyle'],
+              cop_config['EnforcedColonStyle']].include?('table')
+            key_widths = node.children.map do |pair|
+              key, _value = *pair
+              key.loc.expression.source.length
+            end
+            @max_key_width = key_widths.max
+            if first_pair && value_delta(nil, first_pair, @max_key_width) != 0
+              @column_deltas = {}
+              convention(first_pair, :expression)
+            end
+          end
+
+          node.children.each_cons(2) do |prev, current|
+            @column_deltas = deltas(first_pair, prev, current, @max_key_width)
+            convention(current, :expression) unless good_alignment?
+          end
+        end
+
+        def autocorrect_action(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get the
+          # last value of each. Some local variables fix the problem.
+          max_key_width = @max_key_width
+          key_delta = @column_deltas[:key] || 0
+
+          key, value = *node
+
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            b = expr.begin_pos
+            b -= key_delta.abs if key_delta < 0
+            range = Parser::Source::Range.new(expr.source_buffer, b,
+                                              expr.end_pos)
+            source = ' ' * [key_delta, 0].max +
+              if enforced_style(node) == 'key'
+                expr.source
+              else
+                key_source = key.loc.expression.source
+                padded_separator = case enforced_style(node)
+                                   when 'separator'
+                                     spaced_separator(node)
+                                   when 'table'
+                                     space = ' ' * (max_key_width -
+                                                    key_source.length)
+                                     if node.loc.operator.is?('=>')
+                                       space + spaced_separator(node)
+                                     else
+                                       spaced_separator(node) + space
+                                     end
+                                   end
+                key_source + padded_separator + value.loc.expression.source
+              end
+            corrector.replace(range, source)
+          end
+        end
+
+        private
+
+        def good_alignment?
+          @column_deltas.values.compact.none? { |v| v != 0 }
+        end
+
+        def deltas(first_pair, prev_pair, current_pair, max_key_width)
+          enforced_style = enforced_style(current_pair)
+          unless %w(key separator table).include?(enforced_style)
+            fail "Unknown #{config_parameter(current_pair)}: #{enforced_style}"
+          end
+
+          return {} if current_pair.loc.line == prev_pair.loc.line
+
+          key_left_alignment_delta = (first_pair.loc.column -
+                                      current_pair.loc.column)
+          if enforced_style == 'key'
+            { key: key_left_alignment_delta }
+          else
+            {
+              key: if enforced_style == 'table'
+                     key_left_alignment_delta
+                   else
+                     key_end_column(first_pair) - key_end_column(current_pair)
+                   end,
+              separator: if current_pair.loc.operator.is?(':') &&
+                             enforced_style == 'table'
+                           # Colon follows directly after key
+                           (key_end_column(current_pair) -
+                            current_pair.loc.operator.column)
+                         else
+                           # Aligned separator
+                           (first_pair.loc.operator.column -
+                            current_pair.loc.operator.column)
+                         end,
+              value: value_delta(first_pair, current_pair, max_key_width)
+            }
+          end
+        end
+
+        def key_end_column(pair)
+          key, _value = *pair
+          key.loc.column + key.loc.expression.source.length
+        end
+
+        def value_delta(first_pair, current_pair, max_key_width)
+          key, value = *current_pair
+          correct_value_column = if enforced_style(current_pair) == 'table'
+                                   key.loc.column +
+                                     spaced_separator(current_pair).length +
+                                     max_key_width
+                                 else
+                                   _key1, value1 = *first_pair
+                                   value1.loc.column
+                                 end
+          correct_value_column - value.loc.column
+        end
+
+        def spaced_separator(node)
+          node.loc.operator.is?('=>') ? ' => ' : ': '
+        end
+
+        def enforced_style(node)
+          cop_config[config_parameter(node)]
+        end
+
+        def config_parameter(node)
+          separator = node.loc.operator.is?('=>') ? 'HashRocket' : 'Colon'
+          "Enforced#{separator}Style"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/align_parameters.rb

@@ -22,13 +22,19 @@ module Rubocop
 
             if current_pos.line > prev.loc.expression.line &&
                 current_pos.column != first_arg_column
-              add_offence(:convention, current_pos, MSG)
-              do_autocorrect(current, first_arg_column - current_pos.column)
+              @column_delta = first_arg_column - current_pos.column
+              convention(current, current_pos)
             end
           end
         end
 
-        def autocorrect_action(node, column_delta)
+        def autocorrect_action(node)
+          # We can't use the instance variable inside the lambda. That would
+          # just give each lambda the same reference and they would all get
+          # the last value of @column_delta. A local variable fixes the
+          # problem.
+          column_delta = @column_delta
+
           @corrections << lambda do |corrector|
             expr = node.loc.expression
             if column_delta > 0

data/lib/rubocop/cop/style/and_or.rb

@@ -24,10 +24,9 @@ module Rubocop
           op_type = node.type.to_s
 
           if op == op_type
-            add_offence(:convention,
-                        node.loc.operator,
-                        sprintf(MSG, OPS[op], op))
-            do_autocorrect(node)
+            convention(node,
+                       :operator,
+                       sprintf(MSG, OPS[op], op))
           end
         end
 

data/lib/rubocop/cop/style/ascii_comments.rb

@@ -10,9 +10,7 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            if comment.text =~ /[^\x00-\x7f]/
-              add_offence(:convention, comment.loc.expression, MSG)
-            end
+            convention(comment, :expression) if comment.text =~ /[^\x00-\x7f]/
           end
         end
       end

data/lib/rubocop/cop/style/ascii_identifiers.rb

@@ -12,7 +12,7 @@ module Rubocop
         def investigate(processed_source)
           processed_source.tokens.each do |t|
             if t.type == :tIDENTIFIER && t.text =~ /[^\x00-\x7f]/
-              add_offence(:convention, t.pos, MSG)
+              convention(nil, t.pos)
             end
           end
         end