rubocop 1.12.1 → 1.16.1

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

@@ -43,8 +43,7 @@ module RuboCop
           receiver = node.receiver.source
           argument = expression.source
 
-          message = format(MSG, receiver: receiver, argument: argument,
-                                original: node.source)
+          message = format(MSG, receiver: receiver, argument: argument, original: node.source)
           add_offense(node, message: message) do |corrector|
             correct_access = "#{receiver}[#{argument}]"
             corrector.replace(node, correct_access)

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

@@ -81,8 +81,7 @@ module RuboCop
         end
 
         def eligible_method?(node)
-          node.send_node.receiver &&
-            method_names.include?(node.send_node.method_name)
+          node.send_node.receiver && method_names.include?(node.send_node.method_name)
         end
 
         def methods
@@ -108,9 +107,7 @@ module RuboCop
 
           # Prepending an underscore to mark an unused parameter is allowed, so
           # we remove any leading underscores before comparing.
-          actual_args_no_underscores = actual_args.map do |arg|
-            arg.to_s.sub(/^_+/, '')
-          end
+          actual_args_no_underscores = actual_args.map { |arg| arg.to_s.sub(/^_+/, '') }
 
           actual_args_no_underscores == target_args(method_name)
         end

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

@@ -42,9 +42,7 @@ module RuboCop
           return if node.endless?
           return if allow_empty? && !node.body
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
         alias on_defs on_def
 
@@ -70,6 +68,7 @@ module RuboCop
           return false unless endless_method_config['Enabled']
           return false if endless_method_config['EnforcedStyle'] == 'disallow'
           return false unless body_node
+          return false if body_node.parent.assignment_method?
 
           !(body_node.begin_type? || body_node.kwbegin_type?)
         end
@@ -93,7 +92,9 @@ module RuboCop
         def correct_to_endless(corrector, node)
           self_receiver = node.self_receiver? ? 'self.' : ''
           arguments = node.arguments.any? ? node.arguments.source : '()'
-          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{node.body.source}"
+          body_source = method_body_source(node.body)
+          replacement = "def #{self_receiver}#{node.method_name}#{arguments} = #{body_source}"
+
           corrector.replace(node, replacement)
         end
 
@@ -113,6 +114,21 @@ module RuboCop
             node: node, corrector: corrector
           )
         end
+
+        def method_body_source(method_body)
+          if require_parentheses?(method_body)
+            arguments_source = method_body.arguments.map(&:source).join(', ')
+            body_source = "#{method_body.method_name}(#{arguments_source})"
+
+            method_body.receiver ? "#{method_body.receiver.source}.#{body_source}" : body_source
+          else
+            method_body.source
+          end
+        end
+
+        def require_parentheses?(method_body)
+          method_body.send_type? && !method_body.arguments.empty? && !method_body.comparison_method?
+        end
       end
     end
   end

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

@@ -36,8 +36,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Consider merging nested conditions into '\
-              'outer `%<conditional_type>s` conditions.'
+        MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
 
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
@@ -81,10 +80,7 @@ module RuboCop
         def autocorrect(corrector, node, if_branch)
           corrector.wrap(node.condition, '(', ')') if node.condition.or_type?
 
-          if node.unless?
-            corrector.replace(node.loc.keyword, 'if')
-            corrector.insert_before(node.condition, '!')
-          end
+          correct_from_unless_to_if(corrector, node) if node.unless?
 
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
@@ -95,6 +91,17 @@ module RuboCop
           end
         end
 
+        def correct_from_unless_to_if(corrector, node)
+          corrector.replace(node.loc.keyword, 'if')
+
+          condition = node.condition
+          if condition.send_type? && condition.comparison_method? && !condition.parenthesized?
+            corrector.wrap(node.condition, '!(', ')')
+          else
+            corrector.insert_before(node.condition, '!')
+          end
+        end
+
         def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
           outer_condition = node.condition
           correct_outer_condition(corrector, outer_condition)
@@ -137,7 +144,8 @@ module RuboCop
         end
 
         def requrie_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized?
+          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+            !condition.comparison_method?
         end
 
         def arguments_range(node)

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

@@ -80,25 +80,15 @@ module RuboCop
           :$* => %i[$ARGV ARGV]
         }
 
-        PERL_VARS =
-          ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
-
-        ENGLISH_VARS.merge!(
-          ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
-        )
-        PERL_VARS.merge!(
-          PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h
-        )
+        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
+
+        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze
 
         # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new(%i[
-                                     $LOAD_PATH
-                                     $LOADED_FEATURES
-                                     $PROGRAM_NAME
-                                     ARGV
-                                   ]).freeze
+        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
 
         def on_gvar(node)
           global_var, = *node
@@ -120,9 +110,7 @@ module RuboCop
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR,
-                   prefer: preferred_names(global_var).first,
-                   global: global_var)
+            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
           end
         end
 

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

@@ -24,8 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
           return unless redundant_parentheses?(node) || missing_parentheses?(node)

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

@@ -18,8 +18,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG =
-          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
         RESTRICT_ON_SEND = %i[puts].freeze
 
         # @!method stderr_puts?(node)
@@ -50,10 +49,7 @@ module RuboCop
         end
 
         def stderr_puts_range(send)
-          range_between(
-            send.loc.expression.begin_pos,
-            send.loc.selector.end_pos
-          )
+          range_between(send.loc.expression.begin_pos, send.loc.selector.end_pos)
         end
       end
     end

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

@@ -17,6 +17,7 @@ module RuboCop
       #   string.chars
       #
       class StringChars < Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `chars` instead of `%<current>s`.'
@@ -26,7 +27,7 @@ module RuboCop
         def on_send(node)
           return unless node.arguments.one? && BAD_ARGUMENTS.include?(node.first_argument.source)
 
-          range = node.loc.selector.begin.join(node.loc.end)
+          range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
 
           add_offense(range, message: format(MSG, current: range.source)) do |corrector|
             corrector.replace(range, 'chars')

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

@@ -29,6 +29,7 @@ module RuboCop
       #
       class StringConcatenation < Base
         include Util
+        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
@@ -102,10 +103,7 @@ module RuboCop
         end
 
         def uncorrectable?(part)
-          part.multiline? ||
-            part.dstr_type? ||
-            (part.str_type? && part.heredoc?) ||
-            part.each_descendant(:block).any?
+          part.multiline? || (part.str_type? && part.heredoc?) || part.each_descendant(:block).any?
         end
 
         def corrected_ancestor?(node)
@@ -115,12 +113,12 @@ module RuboCop
         def replacement(parts)
           interpolated_parts =
             parts.map do |part|
-              if part.str_type?
-                if single_quoted?(part)
-                  part.value.gsub(/(\\|")/, '\\\\\&')
-                else
-                  part.value.inspect[1..-2]
-                end
+              case part.type
+              when :str
+                value = part.value
+                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
+              when :dstr
+                contents_range(part).source
               else
                 "\#{#{part.source}}"
               end

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

@@ -29,6 +29,7 @@ module RuboCop
       class StringLiterals < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
         extend AutoCorrector
 
         MSG_INCONSISTENT = 'Inconsistent quote style.'
@@ -110,8 +111,7 @@ module RuboCop
           if unexpected_single_quotes?(quote)
             all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
             register_offense(node) if all_children_with_quotes
-          elsif unexpected_double_quotes?(quote) &&
-                !accept_child_double_quotes?(children)
+          elsif unexpected_double_quotes?(quote) && !accept_child_double_quotes?(children)
             register_offense(node)
           end
         end
@@ -125,9 +125,7 @@ module RuboCop
         end
 
         def accept_child_double_quotes?(nodes)
-          nodes.any? do |n|
-            n.dstr_type? || double_quotes_required?(n.source)
-          end
+          nodes.any? { |n| n.dstr_type? || double_quotes_required?(n.source) }
         end
       end
     end

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

@@ -22,6 +22,7 @@ module RuboCop
       class StringLiteralsInInterpolation < Base
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
+        include StringHelp
         extend AutoCorrector
 
         def autocorrect(corrector, node)

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

@@ -49,11 +49,19 @@ module RuboCop
           if parent.block_type?
             corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
           elsif (class_node = parent.parent).body.nil?
-            corrector.remove(range_by_whole_lines(class_node.loc.end, include_final_newline: true))
+            corrector.remove(range_for_empty_class_body(class_node, parent))
           else
             corrector.insert_after(parent.loc.expression, ' do')
           end
         end
+
+        def range_for_empty_class_body(class_node, struct_new)
+          if class_node.single_line?
+            range_between(struct_new.source_range.end_pos, class_node.source_range.end_pos)
+          else
+            range_by_whole_lines(class_node.loc.end, include_final_newline: true)
+          end
+        end
       end
     end
   end

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

@@ -20,9 +20,7 @@ module RuboCop
         def on_sym(node)
           return unless /\A:["'][A-Za-z_]\w*["']\z/.match?(node.source)
 
-          add_offense(node) do |corrector|
-            corrector.replace(node, node.source.delete(%q('")))
-          end
+          add_offense(node) { |corrector| corrector.replace(node, node.source.delete(%q('"))) }
         end
       end
     end

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

@@ -31,8 +31,7 @@ module RuboCop
         include IgnoredMethods
         extend AutoCorrector
 
-        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` ' \
-              'instead of a block.'
+        MSG = 'Pass `&:%<method>s` as an argument to `%<block_method>s` instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
         # @!method proc_node?(node)
@@ -81,9 +80,7 @@ module RuboCop
           range = range_between(block_start, block_end)
           message = format(MSG, method: method_name, block_method: block_method_name)
 
-          add_offense(range, message: message) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(range, message: message) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -95,8 +92,7 @@ module RuboCop
         end
 
         def autocorrect_without_args(corrector, node)
-          corrector.replace(block_range_with_space(node),
-                            "(&:#{node.body.method_name})")
+          corrector.replace(block_range_with_space(node), "(&:#{node.body.method_name})")
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
@@ -109,8 +105,7 @@ module RuboCop
         end
 
         def block_range_with_space(node)
-          block_range = range_between(begin_pos_for_replacement(node),
-                                      node.loc.end.end_pos)
+          block_range = range_between(begin_pos_for_replacement(node), node.loc.end.end_pos)
           range_with_surrounding_space(range: block_range, side: :left)
         end
 

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

@@ -64,8 +64,7 @@ module RuboCop
         NON_COMPLEX_TYPES = [*VARIABLE_TYPES, :const, :defined?, :yield].freeze
 
         MSG = '%<command>s parentheses for ternary conditions.'
-        MSG_COMPLEX = '%<command>s parentheses for ternary expressions with' \
-          ' complex 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)
@@ -88,8 +87,7 @@ module RuboCop
           condition = node.condition
 
           return nil if parenthesized?(condition) &&
-                        (safe_assignment?(condition) ||
-                        unsafe_autocorrect?(condition))
+                        (safe_assignment?(condition) || unsafe_autocorrect?(condition))
 
           if parenthesized?(condition)
             correct_parenthesized(corrector, condition)
@@ -127,8 +125,7 @@ module RuboCop
         # Anything that is not a variable, constant, or method/.method call
         # will be counted as a complex expression.
         def non_complex_expression?(condition)
-          NON_COMPLEX_TYPES.include?(condition.type) ||
-            non_complex_send?(condition)
+          NON_COMPLEX_TYPES.include?(condition.type) || non_complex_send?(condition)
         end
 
         def non_complex_send?(node)

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Newcomers to ruby applications may write top-level methods,
+      # when ideally they should be organized in appropriate classes or modules.
+      # This cop looks for definitions of top-level methods and warns about them.
+      #
+      # However for ruby scripts it is perfectly fine to use top-level methods.
+      # Hence this cop is disabled by default.
+      #
+      # @example
+      #   # bad
+      #   def some_method
+      #   end
+      #
+      #   # bad
+      #   def self.some_method
+      #   end
+      #
+      #   # bad
+      #   define_method(:foo) { puts 1 }
+      #
+      #   # good
+      #   module Foo
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   Struct.new do
+      #     def some_method
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     define_method(:foo) { puts 1 }
+      #   end
+      class TopLevelMethodDefinition < Base
+        MSG = 'Do not define methods at the top-level.'
+
+        RESTRICT_ON_SEND = %i[define_method].freeze
+
+        def on_def(node)
+          return unless top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+        alias on_send on_def
+
+        def on_block(node)
+          return unless define_method_block?(node) && top_level_method_definition?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def top_level_method_definition?(node)
+          if node.parent&.begin_type?
+            node.parent.root?
+          else
+            node.root?
+          end
+        end
+
+        # @!method define_method_block?(node)
+        def_node_matcher :define_method_block?, <<~PATTERN
+          (block (send _ {:define_method} _) ...)
+        PATTERN
+      end
+    end
+  end
+end