rubocop 0.80.1 → 0.85.0

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

@@ -104,7 +104,7 @@ module RuboCop
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
 
-          corrector.replace(node.loc.expression, corrected)
+          corrector.replace(node, corrected)
         end
 
         def autocorrect_to_percent(corrector, node)
@@ -119,7 +119,7 @@ module RuboCop
                    "[#{param_args.map(&:source).join(', ')}]"
                  end
 
-          corrector.replace(node.loc.expression, "#{format} % #{args}")
+          corrector.replace(node, "#{format} % #{args}")
         end
       end
     end

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

@@ -5,11 +5,10 @@ module RuboCop
     module Style
       # Use a consistent style for named format string tokens.
       #
-      # **Note:**
-      # `unannotated` style cop only works for strings
+      # NOTE: `unannotated` style cop only works for strings
       # which are passed as arguments to those methods:
       # `printf`, `sprintf`, `format`, `%`.
-      # The reason is that *unannotated* format is very similar
+      # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
       # @example EnforcedStyle: annotated (default)

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

@@ -8,8 +8,7 @@ module RuboCop
       # It will add the comment `# frozen_string_literal: true` to the top of
       # files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
-      # encoding comment. The frozen string literal comment is only valid in
-      # Ruby 2.3+.
+      # encoding comment.
       #
       # Note that the cop will ignore files where the comment exists but is set
       # to `false` instead of `true`.
@@ -149,9 +148,7 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
-            token = next_token
-          end
+          token = next_token if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
 
           token
         end
@@ -216,7 +213,7 @@ module RuboCop
           if comment
             corrector.insert_after(line_range(comment.line), following_comment)
           else
-            corrector.insert_before(line_range(1), preceding_comment)
+            corrector.insert_before(processed_source.buffer.source_range, preceding_comment)
           end
         end
 

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

@@ -35,6 +35,17 @@ module RuboCop
       #   # good
       #   raise 'exception' if something
       #   ok
+      #
+      #   # bad
+      #   if something
+      #     foo || raise('exception')
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   foo || raise('exception') if something
+      #   ok
       class GuardClause < Cop
         include MinBodyLength
         include StatementModifier
@@ -69,7 +80,8 @@ module RuboCop
                else
                  opposite_keyword(node)
                end
-          register_offense(node, guard_clause.source, kw)
+
+          register_offense(node, guard_clause_source(guard_clause), kw)
         end
 
         private
@@ -98,13 +110,24 @@ module RuboCop
                       message: format(MSG, example: example))
         end
 
+        def guard_clause_source(guard_clause)
+          parent = guard_clause.parent
+
+          if parent.and_type? || parent.or_type?
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        end
+
         def too_long_for_single_line?(node, example)
           max = max_line_length
           max && node.source_range.column + example.length > max
         end
 
         def accepted_form?(node, ending = false)
-          accepted_if?(node, ending) || node.condition.multiline?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of `each_key` and `each_value` Hash methods.
       #
-      # Note: If you have an array of two-element arrays, you can put
+      # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #
@@ -40,6 +40,8 @@ module RuboCop
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
+            return unless target.receiver.receiver
+
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 
@@ -58,7 +60,7 @@ module RuboCop
         end
 
         def correct_implicit(node, corrector, method_name)
-          corrector.replace(node.loc.expression, method_name)
+          corrector.replace(node, method_name)
           correct_args(node, corrector)
         end
 
@@ -68,14 +70,14 @@ module RuboCop
           return correct_implicit(node, corrector, name) unless receiver
 
           new_source = receiver.source + ".#{name}"
-          corrector.replace(node.loc.expression, new_source)
+          corrector.replace(node, new_source)
         end
 
         def correct_args(node, corrector)
           args = node.parent.arguments
           name, = *args.children.find { |arg| used?(arg) }
 
-          corrector.replace(args.source_range, "|#{name}|")
+          corrector.replace(args, "|#{name}|")
         end
 
         def kv_range(outer_node)

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

@@ -13,11 +13,11 @@ module RuboCop
       # The supported styles are:
       #
       # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
-      #   all symbols for keys
+      # all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
-      #   syntax hashes
+      # syntax hashes
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -144,11 +144,11 @@ module RuboCop
             # Prefer { :production? => false } over { production?: false } and
             # similarly for other non-alnum final characters (except quotes,
             # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless sym_name =~ /[\p{Alnum}"']\z/
+            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
           end
 
           # Most hash keys can be matched against a simple regex.
-          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+          return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
           parse("{ #{sym_name}: :foo }").valid_syntax?
@@ -168,11 +168,7 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, pair_node)
-          key = pair_node.key.source_range
-          op = pair_node.loc.operator
-
-          range = key.join(op)
-          range = range_with_surrounding_space(range: range, side: :right)
+          range = range_for_autocorrect_ruby19(pair_node)
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
@@ -180,6 +176,19 @@ module RuboCop
             range,
             range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
           )
+
+          hash_node = pair_node.parent
+          return unless hash_node.parent&.return_type? && !hash_node.braces?
+
+          corrector.wrap(hash_node, '{', '}')
+        end
+
+        def range_for_autocorrect_ruby19(pair_node)
+          key = pair_node.key.source_range
+          operator = pair_node.loc.operator
+
+          range = key.join(operator)
+          range_with_surrounding_space(range: range, side: :right)
         end
 
         def argument_without_space?(node)
@@ -188,11 +197,9 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          key = pair_node.key.source_range
           op = pair_node.loc.operator
 
-          corrector.insert_after(key, pair_node.inverse_delimiter(true))
-          corrector.insert_before(key, ':')
+          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
           corrector.remove(range_with_surrounding_space(range: op))
         end
 

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

@@ -31,7 +31,9 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !(send _ :each_with_index) :each_with_object (hash))
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -55,7 +57,9 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                {:map :collect})
               (args
                 (arg $_)
                 (arg _val))

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

@@ -24,14 +24,13 @@ module RuboCop
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
       class HashTransformValues < Cop
-        extend TargetRubyVersion
         include HashTransformMethod
 
-        minimum_target_ruby_version 2.4
-
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !(send _ :each_with_index) :each_with_object (hash))
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -55,7 +54,9 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
-              ({send csend} !(send _ :each_with_index) {:map :collect})
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                 {:map :collect})
               (args
                 (arg _key)
                 (arg $_))

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
-      # `Layout/Tab` cop.
+      # `Layout/IndentationStyle` cop.
       #
       # @example
       #   # bad
@@ -47,7 +47,7 @@ module RuboCop
         def on_if(node)
           msg = if eligible_node?(node)
                   MSG_USE_MODIFIER unless named_capture_in_condition?(node)
-                elsif node.modifier_form? && too_long_single_line?(node)
+                elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
                 end
           return unless msg
@@ -63,11 +63,16 @@ module RuboCop
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         private
 
+        def too_long_due_to_modifier?(node)
+          node.modifier_form? && too_long_single_line?(node) &&
+            !another_statement_on_same_line?(node)
+        end
+
         def ignored_patterns
           config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
         end
@@ -129,6 +134,21 @@ module RuboCop
           node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
+
+          # traverse the AST upwards until we find a 'begin' node
+          # we want to look at the following child and see if it is on the
+          #   same line as this 'if' node
+          while node && !node.begin_type?
+            index = node.sibling_index
+            node  = node.parent
+          end
+
+          node && (sibling = node.children[index + 1]) &&
+            sibling.source_range.first_line == line_no
+        end
+
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression

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

@@ -19,11 +19,27 @@ module RuboCop
         MSG = 'Do not use if x; Use the ternary operator instead.'
 
         def on_normal_if_unless(node)
+          return unless node.else_branch
+
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correct_to_ternary(node))
+          end
+        end
+
+        private
+
+        def correct_to_ternary(node)
+          else_code = node.else_branch ? node.else_branch.source : 'nil'
+
+          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
 
             add_offense(comment)
           end

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

@@ -44,7 +44,7 @@ module RuboCop
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::Not]
+          [Style::Not, Style::SymbolProc]
         end
 
         def_node_matcher :inverse_candidate?, <<~PATTERN

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

@@ -73,6 +73,7 @@ module RuboCop
                       location: node.send_node.source_range,
                       message: message(node, selector))
         end
+        alias on_numblock on_block
 
         def autocorrect(node)
           if node.send_node.source == 'lambda'
@@ -108,13 +109,13 @@ module RuboCop
         end
 
         def autocorrect_method_to_literal(corrector, node)
-          corrector.replace(node.send_node.source_range, '->')
+          corrector.replace(node.send_node, '->')
 
           return unless node.arguments?
 
           arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 

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

@@ -37,7 +37,7 @@ module RuboCop
               receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node.source_range, replacement)
+              corrector.replace(node, replacement)
             else
               add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
@@ -52,26 +52,6 @@ module RuboCop
             implicit_style? && !node.implicit_call?
         end
 
-        def add_parentheses(node, corrector)
-          if node.arguments.empty?
-            corrector.insert_after(node.source_range, '()')
-          else
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
-          end
-        end
-
-        def args_begin(node)
-          loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
-        end
-
-        def args_end(node)
-          node.loc.expression.end
-        end
-
         def message(_node)
           if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'