rubocop 0.51.0 → 0.87.0

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

@@ -8,24 +8,52 @@ module RuboCop
       # @example
       #   # bad
       #   class Person < Struct.new(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
       #   end
       #
       #   # good
-      #   Person = Struct.new(:first_name, :last_name)
+      #   Person = Struct.new(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
       class StructInheritance < Cop
-        MSG = "Don't extend an instance initialized by `Struct.new`.".freeze
+        include RangeHelp
+
+        MSG = "Don't extend an instance initialized by `Struct.new`. " \
+              'Use a block to customize the struct.'
 
         def on_class(node)
-          _name, superclass, _body = *node
-          return unless struct_constructor?(superclass)
+          return unless struct_constructor?(node.parent_class)
+
+          add_offense(node, location: node.parent_class.source_range)
+        end
 
-          add_offense(node, location: superclass.source_range)
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.keyword))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
         end
 
-        def_node_matcher :struct_constructor?, <<-PATTERN
-           {(send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)}
+        def_node_matcher :struct_constructor?, <<~PATTERN
+          {(send (const {nil? cbase} :Struct) :new ...)
+           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
         PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+          else
+            corrector.insert_after(parent.loc.expression, ' do')
+          end
+        end
       end
     end
   end

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

@@ -11,21 +11,17 @@ module RuboCop
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
-      # cop. For example, a `MinSize of `3` will not enforce a style on an array
-      # of 2 or fewer elements.
-      #
-      # @example
-      #   EnforcedStyle: percent (default)
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
       #
+      # @example EnforcedStyle: percent (default)
       #   # good
       #   %i[foo bar baz]
       #
       #   # bad
       #   [:foo, :bar, :baz]
       #
-      # @example
-      #   EnforcedStyle: brackets
-      #
+      # @example EnforcedStyle: brackets
       #   # good
       #   [:foo, :bar, :baz]
       #
@@ -35,11 +31,10 @@ module RuboCop
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
-        include PercentLiteral
         include PercentArray
 
-        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
-        ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -55,30 +50,69 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           if style == :percent
-            correct_percent(node, 'i')
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'i')
           else
             correct_bracketed(node)
           end
         end
 
+        private
+
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
-            content =~ / /
+            / /.match?(content)
           end
         end
 
         def correct_bracketed(node)
-          syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
+          syms = node.children.map do |c|
+            if c.dsym_type?
+              string_literal = to_string_literal(c.source)
+
+              ':' + trim_string_interporation_escape_character(string_literal)
+            else
+              to_symbol_literal(c.value.to_s)
+            end
+          end
 
           lambda do |corrector|
-            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+            corrector.replace(node, "[#{syms.join(', ')}]")
           end
         end
+
+        def to_symbol_literal(string)
+          if symbol_without_quote?(string)
+            ":#{string}"
+          else
+            ":#{to_string_literal(string)}"
+          end
+        end
+
+        def symbol_without_quote?(string)
+          special_gvars = %w[
+            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+          ]
+          redefinable_operators = %w(
+            | ^ & <=> == === =~ > >= < <= << >>
+            + - * / % ** ~ +@ -@ [] []= ` ! != !~
+          )
+
+          # method name
+          /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
+            # instance / class variable
+            /\A@@?[a-zA-Z_]\w*\z/.match?(string) ||
+            # global variable
+            /\A\$[1-9]\d*\z/.match?(string) ||
+            /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
+            special_gvars.include?(string) ||
+            redefinable_operators.include?(string)
+        end
       end
     end
   end

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

@@ -13,17 +13,17 @@ module RuboCop
       #   # good
       #   :symbol
       class SymbolLiteral < Cop
-        MSG = 'Do not use strings for word-like symbol literals.'.freeze
+        MSG = 'Do not use strings for word-like symbol literals.'
 
         def on_sym(node)
-          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
+          return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
           add_offense(node)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, node.source.delete(%q('")))
+            corrector.replace(node, node.source.delete(%q('")))
           end
         end
       end

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

@@ -12,14 +12,18 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
-        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        include RangeHelp
+        include IgnoredMethods
+
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
+              'instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
-        def_node_matcher :proc_node?, '(send (const nil? :Proc) :new)'
-        def_node_matcher :symbol_proc?, <<-PATTERN
+        def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<~PATTERN
           (block
             ${(send ...) (super ...) zsuper}
-            (args (arg _var))
+            $(args (arg _var))
             (send (lvar _var) $_))
         PATTERN
 
@@ -28,44 +32,38 @@ module RuboCop
         end
 
         def on_block(node)
-          symbol_proc?(node) do |send_or_super, method|
-            block_method_name = resolve_block_method_name(send_or_super)
-
+          symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/bbatsov/rubocop/issues/1485
+            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
             # we should ignore lambdas & procs
-            return if proc_node?(send_or_super)
-            return if %i[lambda proc].include?(block_method_name)
-            return if ignored_method?(block_method_name)
+            return if proc_node?(dispatch_node)
+            return if %i[lambda proc].include?(dispatch_node.method_name)
+            return if ignored_method?(dispatch_node.method_name)
+            return if destructuring_block_argument?(arguments_node)
 
-            offense(node, method, block_method_name)
+            register_offense(node, method_name, dispatch_node.method_name)
           end
         end
 
+        def destructuring_block_argument?(argument_node)
+          argument_node.one? && argument_node.source.include?(',')
+        end
+
         def autocorrect(node)
           lambda do |corrector|
-            block_send_or_super, _block_args, block_body = *node
-            _receiver, method_name, _args = *block_body
-
-            if super?(block_send_or_super)
-              args = *block_send_or_super
+            if node.send_node.arguments?
+              autocorrect_with_args(corrector, node,
+                                    node.send_node.arguments,
+                                    node.body.method_name)
             else
-              _breceiver, _bmethod_name, *args = *block_send_or_super
+              autocorrect_without_args(corrector, node)
             end
-            autocorrect_method(corrector, node, args, method_name)
           end
         end
 
         private
 
-        def resolve_block_method_name(block_send_or_super)
-          return :super if super?(block_send_or_super)
-
-          _receiver, method_name, _args = *block_send_or_super
-          method_name
-        end
-
-        def offense(node, method_name, block_method_name)
+        def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
           range = range_between(block_start, block_end)
@@ -73,20 +71,13 @@ module RuboCop
           add_offense(node,
                       location: range,
                       message: format(MSG,
-                                      method_name,
-                                      block_method_name))
-        end
-
-        def autocorrect_method(corrector, node, args, method_name)
-          if args.empty?
-            autocorrect_no_args(corrector, node, method_name)
-          else
-            autocorrect_with_args(corrector, node, args, method_name)
-          end
+                                      method: method_name,
+                                      block_method: block_method_name))
         end
 
-        def autocorrect_no_args(corrector, node, method_name)
-          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        def autocorrect_without_args(corrector, node)
+          corrector.replace(block_range_with_space(node),
+                            "(&:#{node.body.method_name})")
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
@@ -101,12 +92,11 @@ module RuboCop
         def block_range_with_space(node)
           block_range = range_between(begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
-          range_with_surrounding_space(block_range, :left)
+          range_with_surrounding_space(range: block_range, side: :left)
         end
 
         def begin_pos_for_replacement(node)
-          block_send_or_super, _block_args, _block_body = *node
-          expr = block_send_or_super.source_range
+          expr = node.send_node.source_range
 
           if (paren_pos = (expr.source =~ /\(\s*\)$/))
             expr.begin_pos + paren_pos
@@ -114,18 +104,6 @@ module RuboCop
             node.loc.begin.begin_pos
           end
         end
-
-        def ignored_methods
-          cop_config['IgnoredMethods']
-        end
-
-        def ignored_method?(name)
-          ignored_methods.include?(name.to_s)
-        end
-
-        def super?(node)
-          SUPER_TYPES.include?(node.type)
-        end
       end
     end
   end

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

@@ -8,47 +8,52 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
-      # @example
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
       #
-      #   EnforcedStyle: require_no_parentheses (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: require_no_parentheses (default)
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses
+      #   # bad
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = (bar && baz) ? a : b
       #
-      # @example
-      #
-      #   EnforcedStyle: require_parentheses_when_complex
-      #
-      #   @bad
+      # @example EnforcedStyle: require_parentheses_when_complex
+      #   # bad
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz?) ? a : b
       #   foo = bar && baz ? a : b
       #
-      #   @good
+      #   # good
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
       class TernaryParentheses < Cop
         include SafeAssignment
         include ConfigurableEnforcedStyle
@@ -57,16 +62,35 @@ module RuboCop
         VARIABLE_TYPES = AST::Node::VARIABLES
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
-        MSG = '%s parentheses for ternary conditions.'.freeze
-        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
-          ' complex conditions.'.freeze
+        MSG = '%<command>s parentheses for ternary conditions.'
+        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
+          ' complex conditions.'
 
         def on_if(node)
+          return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           add_offense(node, location: node.source_range)
         end
 
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        end
+
+        def autocorrect(node)
+          condition = node.condition
+
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
+          if parenthesized?(condition)
+            correct_parenthesized(condition)
+          else
+            correct_unparenthesized(condition)
+          end
+        end
+
         private
 
         def offense?(node)
@@ -85,20 +109,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          condition = node.condition
-
-          return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
-
-          if parenthesized?(condition)
-            correct_parenthesized(condition)
-          else
-            correct_unparenthesized(condition)
-          end
-        end
-
         # If the condition is parenthesized we recurse and check for any
         # complex expressions within it.
         def complex_condition?(condition)
@@ -117,18 +127,18 @@ module RuboCop
         end
 
         def non_complex_send?(node)
-          return false unless node.send_type?
+          return false unless node.call_type?
 
           !node.operator_method? || node.method?(:[])
         end
 
         def message(node)
           if require_parentheses_when_complex?
-            omit = parenthesized?(node.condition) ? 'Only use' : 'Use'
-            format(MSG_COMPLEX, omit)
+            command = parenthesized?(node.condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, command: command)
           else
-            verb = require_parentheses? ? 'Use' : 'Omit'
-            format(MSG, verb)
+            command = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, command: command)
           end
         end
 
@@ -152,24 +162,33 @@ module RuboCop
         # `RedundantParentheses` cop is enabled, it will cause an infinite loop
         # as they compete to add and remove the parentheses respectively.
         def infinite_loop?
-          require_parentheses? &&
+          (require_parentheses? || require_parentheses_when_complex?) &&
             redundant_parentheses_enabled?
         end
 
         def unsafe_autocorrect?(condition)
           condition.children.any? do |child|
-            unparenthesized_method_call?(child)
+            unparenthesized_method_call?(child) ||
+              below_ternary_precedence?(child)
           end
         end
 
         def unparenthesized_method_call?(child)
-          argument = method_call_argument(child)
-          argument && argument !~ /^\(/
+          /^[a-z]/i.match?(method_name(child)) && !child.parenthesized?
         end
 
-        def_node_matcher :method_call_argument, <<-PATTERN
-          {(:defined? $...)
-           (send {_ nil?} _ $(send nil? _)...)}
+        def below_ternary_precedence?(child)
+          # Handle English "or", e.g. 'foo or bar ? a : b'
+          (child.or_type? && child.semantic_operator?) ||
+            # Handle English "and", e.g. 'foo and bar ? a : b'
+            (child.and_type? && child.semantic_operator?) ||
+            # Handle English "not", e.g. 'not foo ? a : b'
+            (child.send_type? && child.prefix_not?)
+        end
+
+        def_node_matcher :method_name, <<~PATTERN
+          {($:defined? (send nil? _) ...)
+           (send {_ nil?} $_ _ ...)}
         PATTERN
 
         def correct_parenthesized(condition)
@@ -180,23 +199,20 @@ module RuboCop
             # Ruby allows no space between the question mark and parentheses.
             # If we remove the parentheses, we need to add a space or we'll
             # generate invalid code.
-            unless whitespace_after?(condition)
-              corrector.insert_after(condition.loc.end, ' ')
-            end
+            corrector.insert_after(condition.loc.end, ' ') unless whitespace_after?(condition)
           end
         end
 
         def correct_unparenthesized(condition)
           lambda do |corrector|
-            corrector.insert_before(condition.source_range, '(')
-            corrector.insert_after(condition.source_range, ')')
+            corrector.wrap(condition, '(', ')')
           end
         end
 
         def whitespace_after?(node)
           index = index_of_last_token(node)
-          last_token, next_token = processed_source.tokens[index, 2]
-          space_between?(last_token, next_token)
+          last_token = processed_source.tokens[index]
+          last_token.space_after?
         end
       end
     end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the class definition.
+      #
+      # @example
+      #   # bad
+      #   class Foo; def foo; end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def foo; end
+      #   end
+      #
+      class TrailingBodyOnClass < Cop
+        include Alignment
+        include TrailingBody
+
+        MSG = 'Place the first line of class body on its own line.'
+
+        def on_class(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.to_a.last))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing code after the method definition.
+      #
+      # @example
+      #   # bad
+      #   def some_method; do_stuff
+      #   end
+      #
+      #   def f(x); b = foo
+      #     b[c: x]
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_stuff
+      #   end
+      #
+      #   def f(x)
+      #     b = foo
+      #     b[c: x]
+      #   end
+      #
+      class TrailingBodyOnMethodDefinition < Cop
+        include Alignment
+        include TrailingBody
+
+        MSG = "Place the first line of a multi-line method definition's " \
+              'body on its own line.'
+
+        def on_def(node)
+          return unless trailing_body?(node)
+
+          add_offense(node, location: first_part_of(node.body))
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            LineBreakCorrector.correct_trailing_body(
+              configured_width: configured_indentation_width,
+              corrector: corrector,
+              node: node,
+              processed_source: processed_source
+            )
+          end
+        end
+      end
+    end
+  end
+end