rubocop 1.5.2 → 1.6.0

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -84,7 +84,7 @@ module RuboCop
         private
 
         def next_line_empty?(line)
-          processed_source[line].blank?
+          processed_source[line].nil? || processed_source[line].blank?
         end
 
         def require_empty_line?(node)

data/lib/rubocop/cop/layout/line_length.rb

@@ -58,12 +58,13 @@ module RuboCop
       #     bar: "0000000000",
       #     baz: "0000000000",
       #   }
-      class LineLength < Cop
+      class LineLength < Base
         include CheckLineBreakable
         include ConfigurableMax
         include IgnoredPattern
         include RangeHelp
         include LineLengthHelp
+        extend AutoCorrector
 
         MSG = 'Line is too long. [%<length>d/%<max>d]'
 
@@ -78,28 +79,16 @@ module RuboCop
         alias on_hash on_potential_breakable_node
         alias on_send on_potential_breakable_node
 
-        def investigate(processed_source)
+        def on_new_investigation
           check_for_breakable_semicolons(processed_source)
         end
 
-        def investigate_post_walk(processed_source)
+        def on_investigation_end
           processed_source.lines.each_with_index do |line, line_index|
             check_line(line, line_index)
           end
         end
 
-        def correctable?
-          super && !breakable_range.nil?
-        end
-
-        def autocorrect(range)
-          return if range.nil?
-
-          lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
-        end
-
         private
 
         attr_accessor :breakable_range
@@ -203,8 +192,9 @@ module RuboCop
 
           self.breakable_range = breakable_range_by_line_index[line_index]
 
-          add_offense(breakable_range, location: loc, message: message) do
+          add_offense(loc, message: message) do |corrector|
             self.max = line_length(line)
+            corrector.insert_before(breakable_range, "\n") unless breakable_range.nil?
           end
         end
 

data/lib/rubocop/cop/migration/department_name.rb

@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def qualified_legacy_cop_name(cop_name)
-          legacy_cop_names = RuboCop::ConfigObsoletion::OBSOLETE_COPS.keys
+          legacy_cop_names = RuboCop::ConfigObsoletion.legacy_cop_names
 
           legacy_cop_names.detect do |legacy_cop_name|
             legacy_cop_name.split('/')[1] == cop_name

data/lib/rubocop/cop/mixin/string_help.rb

@@ -14,7 +14,10 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node) { opposite_style_detected }
+          add_offense(node) do |corrector|
+            opposite_style_detected
+            autocorrect(corrector, node) if respond_to?(:autocorrect, true)
+          end
         else
           correct_style_detected
         end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -3,7 +3,13 @@
 module RuboCop
   module Cop
     module Naming
-      # This cop makes sure that accessor methods are named properly.
+      # This cop makes sure that accessor methods are named properly. Applies
+      # to both instance and class methods.
+      #
+      # NOTE: Offenses are only registered for methods with the expected
+      # arity. Getters (`get_attribute`) must have no arguments to be
+      # registered, and setters (`set_attribute(value)`) must have exactly
+      # one.
       #
       # @example
       #   # bad
@@ -21,6 +27,14 @@ module RuboCop
       #   # good
       #   def attribute
       #   end
+      #
+      #   # accepted, incorrect arity for getter
+      #   def get_value(attr)
+      #   end
+      #
+      #   # accepted, incorrect arity for setter
+      #   def set_value
+      #   end
       class AccessorMethodName < Base
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'

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

@@ -14,8 +14,9 @@ module RuboCop
       #
       #   # good
       #   ?\C-\M-d
-      class CharacterLiteral < Cop
+      class CharacterLiteral < Base
         include StringHelp
+        extend AutoCorrector
 
         MSG = 'Do not use the character literal - ' \
               'use string literal instead.'
@@ -26,17 +27,15 @@ module RuboCop
             node.source.size.between?(2, 3)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            string = node.source[1..-1]
+        def autocorrect(corrector, node)
+          string = node.source[1..-1]
 
-            # special character like \n
-            # or ' which needs to use "" or be escaped.
-            if string.length == 2 || string == "'"
-              corrector.replace(node, %("#{string}"))
-            elsif string.length == 1 # normal character
-              corrector.replace(node, "'#{string}'")
-            end
+          # special character like \n
+          # or ' which needs to use "" or be escaped.
+          if string.length == 2 || string == "'"
+            corrector.replace(node, %("#{string}"))
+          elsif string.length == 1 # normal character
+            corrector.replace(node, "'#{string}'")
           end
         end
 

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

@@ -41,6 +41,8 @@ module RuboCop
       #   a.fdiv(b)
       class FloatDivision < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MESSAGES = {
           left_coerce: 'Prefer using `.to_f` on the left side.',
           right_coerce: 'Prefer using `.to_f` on the right side.',
@@ -64,7 +66,20 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node) if offense_condition?(node)
+          return unless offense_condition?(node)
+
+          add_offense(node) do |corrector|
+            case style
+            when :left_coerce, :single_coerce
+              add_to_f_method(corrector, node.receiver)
+              remove_to_f_method(corrector, node.first_argument)
+            when :right_coerce
+              remove_to_f_method(corrector, node.receiver)
+              add_to_f_method(corrector, node.first_argument)
+            when :fdiv
+              correct_from_slash_to_fdiv(corrector, node, node.receiver, node.first_argument)
+            end
+          end
         end
 
         private
@@ -87,6 +102,34 @@ module RuboCop
         def message(_node)
           MESSAGES[style]
         end
+
+        def add_to_f_method(corrector, node)
+          corrector.insert_after(node, '.to_f') unless node.send_type? && node.method?(:to_f)
+        end
+
+        def remove_to_f_method(corrector, send_node)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(send_node.loc.selector)
+        end
+
+        def correct_from_slash_to_fdiv(corrector, node, receiver, argument)
+          receiver_source = extract_receiver_source(receiver)
+          argument_source = extract_receiver_source(argument)
+
+          if argument.respond_to?(:parenthesized?) && !argument.parenthesized?
+            argument_source = "(#{argument_source})"
+          end
+
+          corrector.replace(node, "#{receiver_source}.fdiv#{argument_source}")
+        end
+
+        def extract_receiver_source(node)
+          if node.send_type? && node.method?(:to_f)
+            node.receiver.source
+          else
+            node.source
+          end
+        end
       end
     end
   end

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

@@ -46,6 +46,10 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
+        def self.autocorrect_incompatible_with
+          [Style::SoleNestedConditional]
+        end
+
         def on_if(node)
           msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
                   MSG_USE_MODIFIER

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       #   # good
       #   ip_address = ENV['DEPLOYMENT_IP_ADDRESS']
-      class IpAddresses < Cop
+      class IpAddresses < Base
         include StringHelp
 
         IPV6_MAX_SIZE = 45 # IPv4-mapped IPv6 is the longest

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of Perl-style regexp match
-      # backreferences like $1, $2, etc.
+      # backreferences and their English versions like
+      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -15,19 +16,95 @@ module RuboCop
       class PerlBackrefs < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of Perl-style backrefs.'
+        MESSAGE_FORMAT = 'Prefer `%<preferred_expression>s` over `%<original_expression>s`.'
+
+        def on_back_ref(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        def on_gvar(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
         def on_nth_ref(node)
-          add_offense(node) do |corrector|
-            backref, = *node
-            parent_type = node.parent ? node.parent.type : nil
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
-            if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node, "{Regexp.last_match(#{backref})}")
+        private
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def derived_from_braceless_interpolation?(node)
+          %i[
+            dstr
+            regexp
+            xstr
+          ].include?(node.parent&.type)
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @param [String] preferred_expression
+        # @return [String]
+        def format_message(node:, preferred_expression:)
+          original_expression = original_expression_of(node)
+          format(
+            MESSAGE_FORMAT,
+            original_expression: original_expression,
+            preferred_expression: preferred_expression
+          )
+        end
 
-            else
-              corrector.replace(node, "Regexp.last_match(#{backref})")
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def original_expression_of(node)
+          first = node.to_a.first
+          if first.is_a?(::Integer)
+            "$#{first}"
+          else
+            first.to_s
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to(node)
+          first = node.to_a.first
+          case first
+          when ::Integer
+            "Regexp.last_match(#{first})"
+          when :$&, :$MATCH
+            'Regexp.last_match(0)'
+          when :$`, :$PREMATCH
+            'Regexp.last_match.pre_match'
+          when :$', :$POSTMATCH
+            'Regexp.last_match.post_match'
+          when :$+, :$LAST_PAREN_MATCH
+            'Regexp.last_match(-1)'
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        def on_back_ref_or_gvar_or_nth_ref(node)
+          preferred_expression = preferred_expression_to(node)
+          return unless preferred_expression
+
+          add_offense(
+            node,
+            message: format_message(
+              node: node,
+              preferred_expression: preferred_expression
+            )
+          ) do |corrector|
+            if derived_from_braceless_interpolation?(node)
+              preferred_expression = "{#{preferred_expression}}"
             end
+
+            corrector.replace(node, preferred_expression)
           end
         end
       end

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

@@ -37,6 +37,9 @@ module RuboCop
       #   "first second".split
       #   A.foo
       class RedundantArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Argument %<arg>s is redundant because it is implied by default.'
 
         def on_send(node)
@@ -44,7 +47,9 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source))
+          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
+            corrector.remove(argument_range(node))
+          end
         end
 
         private
@@ -69,6 +74,14 @@ module RuboCop
               Parser::CurrentRuby.new(builder).parse(buffer)
             end
         end
+
+        def argument_range(node)
+          if node.parenthesized?
+            range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
+          else
+            range_with_surrounding_space(range: node.first_argument.source_range, newlines: false)
+          end
+        end
       end
     end
   end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     c + d
       #   end
       class SingleLineBlockParams < Base
+        extend AutoCorrector
+
         MSG = 'Name `%<method>s` block params `|%<params>s|`.'
 
         def on_block(node)
@@ -37,20 +39,41 @@ module RuboCop
           return unless eligible_method?(node)
           return unless eligible_arguments?(node)
 
-          return if args_match?(node.send_node.method_name, node.arguments)
+          method_name = node.send_node.method_name
+          return if args_match?(method_name, node.arguments)
+
+          preferred_block_arguments = build_preferred_arguments_map(node, target_args(method_name))
+          joined_block_arguments = preferred_block_arguments.values.join(', ')
 
-          message = message(node.arguments)
+          message = format(MSG, method: method_name, params: joined_block_arguments)
 
-          add_offense(node.arguments, message: message)
+          add_offense(node.arguments, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          end
         end
 
         private
 
-        def message(node)
-          method_name = node.parent.send_node.method_name
-          arguments   = target_args(method_name).join(', ')
+        def build_preferred_arguments_map(node, preferred_arguments)
+          preferred_arguments_map = {}
+          node.arguments.each_with_index do |current_lvar, index|
+            preferred_argument = preferred_arguments[index]
+            current_argument = current_lvar.source
+            preferred_argument = "_#{preferred_argument}" if current_argument.start_with?('_')
+            preferred_arguments_map[current_argument] = preferred_argument
+          end
+
+          preferred_arguments_map
+        end
+
+        def autocorrect(corrector, node, preferred_block_arguments, joined_block_arguments)
+          corrector.replace(node.arguments, "|#{joined_block_arguments}|")
 
-          format(MSG, method: method_name, params: arguments)
+          node.each_descendant(:lvar) do |lvar|
+            if (preferred_lvar = preferred_block_arguments[lvar.source])
+              corrector.replace(lvar, preferred_lvar)
+            end
+          end
         end
 
         def eligible_arguments?(node)