rubocop 0.28.0 → 0.29.0

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

@@ -36,6 +36,39 @@ module RuboCop
             format(MSG, 'self[:attr] = val', 'write_attribute(:attr, var)')
           end
         end
+
+        def autocorrect(node)
+          _receiver, method_name, _body = *node
+
+          case method_name
+          when :read_attribute
+            replacement = read_attribute_replacement(node)
+          when :write_attribute
+            replacement = write_attribute_replacement(node)
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+
+        private
+
+        def read_attribute_replacement(node)
+          _receiver, _method_name, body = *node
+
+          "self[#{body.loc.expression.source}]"
+        end
+
+        def write_attribute_replacement(node)
+          _receiver, _method_name, *args = *node
+          name, value = *args
+
+          name_source = name.loc.expression.source
+          value_source = value.loc.expression.source
+
+          "self[#{name_source}] = #{value_source}"
+        end
       end
     end
   end

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

@@ -65,13 +65,6 @@ module RuboCop
           format(MSG, style.capitalize, node.loc.selector.source)
         end
 
-        def class_constructor?(block_node)
-          send_node = block_node.children.first
-          receiver_node, method_name, *_ = *send_node
-          return false unless method_name == :new
-          %w(Class Module).include?(Util.const_name(receiver_node))
-        end
-
         def expected_indent_offset
           style == :outdent ? 0 : configured_indentation_width
         end

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

@@ -50,8 +50,10 @@ module RuboCop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             if braces?(node)
-              corrector.remove(node.loc.begin)
-              corrector.remove(node.loc.end)
+              right_range = range_with_surrounding_space(node.loc.begin, :right)
+              corrector.remove(right_range)
+              left_range = range_with_surrounding_space(node.loc.end, :left)
+              corrector.remove(left_range)
             else
               corrector.insert_before(node.loc.expression, '{')
               corrector.insert_after(node.loc.expression, '}')

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

@@ -5,35 +5,51 @@ module RuboCop
     module Style
       # This cop checks for uses of the class/module name instead of
       # self, when defining class/module methods.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def SomeClass.class_method
+      #       ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       ...
+      #     end
+      #   end
       class ClassMethods < Cop
         MSG = 'Use `self.%s` instead of `%s.%s`.'
 
         def on_class(node)
-          _name, _superclass, body = *node
-          check(body)
+          name, _superclass, body = *node
+          check(name, body)
         end
 
         def on_module(node)
-          _name, body = *node
-          check(body)
+          name, body = *node
+          check(name, body)
         end
 
         private
 
-        def check(node)
+        def check(name, node)
           return unless node
 
           if node.type == :defs
-            check_defs(node)
+            check_defs(name, node)
           elsif node.type == :begin
             defs_nodes = node.children.compact.select { |n| n.type == :defs }
-            defs_nodes.each { |n| check_defs(n) }
+            defs_nodes.each { |n| check_defs(name, n) }
           end
         end
 
-        def check_defs(node)
+        def check_defs(name, node)
           definee, method_name, _args, _body = *node
-          return unless definee.type == :const
+          # check if the class/module name matches the definee for the defs node
+          return unless name == definee
 
           _, class_name = *definee
           add_offense(definee, :name, message(class_name, method_name))

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

@@ -42,7 +42,9 @@ module RuboCop
         private
 
         def previous_line_empty?(previous_line)
-          class_def?(previous_line.lstrip) || previous_line.blank?
+          block_start?(previous_line.lstrip) ||
+            class_def?(previous_line.lstrip) ||
+            previous_line.blank?
         end
 
         def next_line_empty?(next_line)
@@ -61,6 +63,10 @@ module RuboCop
           %w(class module).any? { |keyword| line.start_with?(keyword) }
         end
 
+        def block_start?(line)
+          line.match(/ (do|{)( \|.*?\|)?\s?$/)
+        end
+
         def body_end?(line)
           line.start_with?('end')
         end

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

@@ -29,31 +29,46 @@ module RuboCop
         STR_NODE = s(:send, s(:const, nil, :String), :new)
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
-
           case node
           when ARRAY_NODE
             add_offense(node, :expression, ARR_MSG)
           when HASH_NODE
+            # If Hash.new takes a block, it can't be changed to {}.
+            return if node.parent && node.parent.block_type?
+
             add_offense(node, :expression, HASH_MSG)
           when STR_NODE
             add_offense(node, :expression, STR_MSG)
           end
         end
 
-        # TODO: Check block contents as well.
-        alias_method :on_block, :ignore_node
-
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            name = case node
-                   when ARRAY_NODE then '[]'
-                   when HASH_NODE then '{}'
-                   when STR_NODE then "''"
+          name = case node
+                 when ARRAY_NODE
+                   '[]'
+                 when HASH_NODE
+                   # `some_method {}` is not same as `some_method Hash.new`
+                   # because the braces are interpreted as a block, so we avoid
+                   # the correction. Parentheses around the arguments would
+                   # solve the problem, but we let the user add those manually.
+                   if first_arg_in_method_call_without_parentheses?(node)
+                     fail CorrectionNotPossible
                    end
+                   '{}'
+                 when STR_NODE
+                   "''"
+                 end
+          @corrections << lambda do |corrector|
             corrector.replace(node.loc.expression, name)
           end
         end
+
+        def first_arg_in_method_call_without_parentheses?(node)
+          return false unless node.parent && node.parent.send_type?
+
+          _receiver, _method_name, *args = *node.parent
+          node.object_id == args.first.object_id && !parentheses?(node.parent)
+        end
       end
     end
   end

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

@@ -14,33 +14,54 @@ module RuboCop
       #   # good
       #   if x.even?
       class EvenOdd < Cop
-        MSG_EVEN = 'Replace with `Fixnum#even?`.'
-        MSG_ODD = 'Replace with `Fixnum#odd?`.'
+        MSG = 'Replace with `Fixnum#%s?`.'
 
         ZERO = s(:int, 0)
         ONE = s(:int, 1)
         TWO = s(:int, 2)
 
         def on_send(node)
+          offense = offense_type(node)
+          add_offense(node, :expression, format(MSG, offense)) if offense
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            correction = "#{base_number(node)}.#{offense_type(node)}?"
+            corrector.replace(node.loc.expression, correction)
+          end
+        end
+
+        private
+
+        def base_number(node)
+          receiver, = *node
+          node = expression(receiver)
+          node.children[0].loc.expression.source
+        end
+
+        def offense_type(node)
           receiver, method, args = *node
 
           return unless [:==, :!=].include?(method)
           return unless div_by_2?(receiver)
 
           if args == ZERO
-            add_offense(node,
-                        :expression,
-                        method == :== ? MSG_EVEN : MSG_ODD)
+            method == :== ? :even : :odd
           elsif args == ONE
-            add_offense(node,
-                        :expression,
-                        method == :== ? MSG_ODD : MSG_EVEN)
+            method == :== ? :odd : :even
           end
         end
 
-        private
-
         def div_by_2?(node)
+          node = expression(node)
+
+          _receiver, method, args = *node
+
+          method == :% && args == TWO
+        end
+
+        def expression(node)
           return unless node
 
           # check for scenarios like (x % 2) == 0
@@ -49,10 +70,7 @@ module RuboCop
           end
 
           return unless node.type == :send
-
-          _receiver, method, args = *node
-
-          method == :% && args == TWO
+          node
         end
       end
     end

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

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the indentation of the first parameter in a method call.
+      # Parameters after the first one are checked by Style/AlignParameters, not
+      # by this cop.
+      #
+      # @example
+      #
+      #   # bad
+      #   some_method(
+      #   first_param,
+      #   second_param)
+      #
+      #   # good
+      #   some_method(
+      #     first_param,
+      #   second_param)
+      class FirstParameterIndentation < Cop
+        include AutocorrectAlignment
+        include ConfigurableEnforcedStyle
+
+        COMMENT_OR_BLANK_LINE = /^\s*(#.*)?$/
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return if args.empty?
+          return if operator?(method_name)
+
+          base_indentation = if special_inner_call_indentation?(node)
+                               column_of(base_range(node, args.first))
+                             else
+                               previous_code_line(args.first.loc.line) =~ /\S/
+                             end
+          check_alignment([args.first],
+                          base_indentation + configured_indentation_width)
+        end
+
+        private
+
+        def message(arg_node)
+          send_node = arg_node.parent
+          text = base_range(send_node, arg_node).source.strip
+          base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
+                   "`#{text}`"
+                 elsif text.lines.reverse_each.first =~ /^\s*#/
+                   'the previous line (not counting the comment)'
+                 else
+                   'the previous line'
+                 end
+          format('Indent the first parameter one step more than %s.', base)
+        end
+
+        def special_inner_call_indentation?(node)
+          return false if style == :consistent
+
+          parent = node.parent
+          return false unless parent
+          return false unless parent.send_type?
+
+          _receiver, method_name, *_args = *parent
+          # :[]= is a send node, but we want to treat it as an assignment.
+          return false if method_name == :[]=
+
+          return false if !parentheses?(parent) &&
+                          style == :special_for_inner_method_call_in_parentheses
+
+          # The node must begin inside the parent, otherwise node is the first
+          # part of a chained method call.
+          node.loc.expression.begin_pos > parent.loc.expression.begin_pos
+        end
+
+        def base_range(send_node, arg_node)
+          Parser::Source::Range.new(processed_source.buffer,
+                                    send_node.loc.expression.begin_pos,
+                                    arg_node.loc.expression.begin_pos)
+        end
+
+        # Returns the column of the given range. For single line ranges, this
+        # is simple. For ranges with line breaks, we look a the last code line.
+        def column_of(range)
+          source = range.source.strip
+          if source.include?("\n")
+            previous_code_line(range.line + source.count("\n") + 1) =~ /\S/
+          else
+            range.column
+          end
+        end
+
+        # Takes the line number of a given code line and returns a string
+        # containing the previous line that's not a comment line or a blank
+        # line.
+        def previous_code_line(line_number)
+          line = ''
+          while line =~ COMMENT_OR_BLANK_LINE
+            line_number -= 1
+            line = processed_source.lines[line_number - 1]
+          end
+          line
+        end
+      end
+    end
+  end
+end

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

@@ -31,13 +31,13 @@ module RuboCop
         end
 
         def format_method?(name, node)
-          receiver, method_name, args = *node
+          receiver, method_name, *args = *node
 
           # commands have no explicit receiver
           return false unless !receiver && method_name == name
 
           # we do an argument count check to reduce false positives
-          args && args.children.size >= 2
+          args.size >= 2
         end
 
         def format?(node)

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

@@ -44,11 +44,7 @@ module RuboCop
         ).map(&:to_sym)
 
         def user_vars
-          if cop_config['AllowedVariables']
-            cop_config['AllowedVariables'].map(&:to_sym)
-          else
-            []
-          end
+          cop_config['AllowedVariables'].map(&:to_sym)
         end
 
         def allowed_var?(global_var)

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

@@ -54,10 +54,6 @@ module RuboCop
 
         private
 
-        def space_before_operator?(op, key)
-          op.begin_pos - key.begin_pos - key.source.length > 0
-        end
-
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.loc.operator && pair.loc.operator.is?(delim)

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

@@ -7,12 +7,12 @@ module RuboCop
       #
       # @example
       #
-      # class A
-      #   def test
-      #     puts 'hello'
-      #      puts 'world'
+      #   class A
+      #     def test
+      #       puts 'hello'
+      #        puts 'world'
+      #     end
       #   end
-      # end
       class IndentationConsistency < Cop
         include AutocorrectAlignment
         include AccessModifierNode