getargv 0.3.3-universal-darwin → 0.3.4-universal-darwin

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.59.0/lib/rubocop/cop/style/redundant_initialize.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for `initialize` methods that are redundant.
-      #
-      # An initializer is redundant if it does not do anything, or if it only
-      # calls `super` with the same arguments given to it. If the initializer takes
-      # an argument that accepts multiple values (`restarg`, `kwrestarg`, etc.) it
-      # will not register an offense, because it allows the initializer to take a different
-      # number of arguments as its superclass potentially does.
-      #
-      # NOTE: If an initializer argument has a default value, RuboCop assumes it
-      # to *not* be redundant.
-      #
-      # NOTE: Empty initializers are registered as offenses, but it is possible
-      # to purposely create an empty `initialize` method to override a superclass's
-      # initializer.
-      #
-      # @safety
-      #   This cop is unsafe because if subclass overrides `initialize` method with
-      #   a different arity than superclass.
-      #
-      # @example
-      #   # bad
-      #   def initialize
-      #   end
-      #
-      #   # bad
-      #   def initialize
-      #     super
-      #   end
-      #
-      #   # bad
-      #   def initialize(a, b)
-      #     super
-      #   end
-      #
-      #   # bad
-      #   def initialize(a, b)
-      #     super(a, b)
-      #   end
-      #
-      #   # good
-      #   def initialize
-      #     do_something
-      #   end
-      #
-      #   # good
-      #   def initialize
-      #     do_something
-      #     super
-      #   end
-      #
-      #   # good (different number of parameters)
-      #   def initialize(a, b)
-      #     super(a)
-      #   end
-      #
-      #   # good (default value)
-      #   def initialize(a, b = 5)
-      #     super
-      #   end
-      #
-      #   # good (default value)
-      #   def initialize(a, b: 5)
-      #     super
-      #   end
-      #
-      #   # good (changes the parameter requirements)
-      #   def initialize(*)
-      #   end
-      #
-      #   # good (changes the parameter requirements)
-      #   def initialize(**)
-      #   end
-      #
-      #   # good (changes the parameter requirements)
-      #   def initialize(...)
-      #   end
-      #
-      # @example AllowComments: true (default)
-      #
-      #   # good
-      #   def initialize
-      #     # Overriding to negate superclass `initialize` method.
-      #   end
-      #
-      # @example AllowComments: false
-      #
-      #   # bad
-      #   def initialize
-      #     # Overriding to negate superclass `initialize` method.
-      #   end
-      #
-      class RedundantInitialize < Base
-        include CommentsHelp
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Remove unnecessary `initialize` method.'
-        MSG_EMPTY = 'Remove unnecessary empty `initialize` method.'
-
-        # @!method initialize_forwards?(node)
-        def_node_matcher :initialize_forwards?, <<~PATTERN
-          (def _ (args $arg*) $({super zsuper} ...))
-        PATTERN
-
-        def on_def(node)
-          return if acceptable?(node)
-
-          if node.body.nil?
-            register_offense(node, MSG_EMPTY)
-          else
-            return if node.body.begin_type?
-
-            if (args, super_node = initialize_forwards?(node))
-              return unless same_args?(super_node, args)
-
-              register_offense(node, MSG)
-            end
-          end
-        end
-
-        private
-
-        def register_offense(node, message)
-          add_offense(node, message: message) do |corrector|
-            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
-          end
-        end
-
-        def acceptable?(node)
-          !node.method?(:initialize) || forwards?(node) || allow_comments?(node)
-        end
-
-        def forwards?(node)
-          node.arguments.each_child_node(:restarg, :kwrestarg, :forward_args, :forward_arg).any?
-        end
-
-        def allow_comments?(node)
-          return false unless cop_config['AllowComments']
-
-          contains_comments?(node) && !comments_contain_disables?(node, name)
-        end
-
-        def same_args?(super_node, args)
-          return true if super_node.zsuper_type?
-
-          args.map(&:name) == super_node.arguments.map { |a| a.children[0] }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.59.0/lib/rubocop/cop/style/redundant_interpolation.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for strings that are just an interpolated expression.
-      #
-      # @safety
-      #   Autocorrection is unsafe because when calling a destructive method to string,
-      #   the resulting string may have different behavior or raise `FrozenError`.
-      #
-      #   [source,ruby]
-      #   ----
-      #   x = 'a'
-      #   y = "#{x}"
-      #   y << 'b'   # return 'ab'
-      #   x          # return 'a'
-      #   y = x.to_s
-      #   y << 'b'   # return 'ab'
-      #   x          # return 'ab'
-      #
-      #   x = 'a'.freeze
-      #   y = "#{x}"
-      #   y << 'b'   # return 'ab'.
-      #   y = x.to_s
-      #   y << 'b'   # raise `FrozenError`.
-      #   ----
-      #
-      # @example
-      #
-      #   # bad
-      #   "#{@var}"
-      #
-      #   # good
-      #   @var.to_s
-      #
-      #   # good if @var is already a String
-      #   @var
-      class RedundantInterpolation < Base
-        include PercentLiteral
-        extend AutoCorrector
-
-        MSG = 'Prefer `to_s` over string interpolation.'
-
-        def self.autocorrect_incompatible_with
-          [Style::LineEndConcatenation]
-        end
-
-        def on_dstr(node)
-          return unless single_interpolation?(node)
-
-          add_offense(node) do |corrector|
-            embedded_node = node.children.first
-
-            if variable_interpolation?(embedded_node)
-              autocorrect_variable_interpolation(corrector, embedded_node, node)
-            elsif single_variable_interpolation?(embedded_node)
-              autocorrect_single_variable_interpolation(corrector, embedded_node, node)
-            else
-              autocorrect_other(corrector, embedded_node, node)
-            end
-          end
-        end
-
-        private
-
-        def single_interpolation?(node)
-          node.children.one? &&
-            interpolation?(node.children.first) &&
-            !implicit_concatenation?(node) &&
-            !embedded_in_percent_array?(node)
-        end
-
-        def single_variable_interpolation?(node)
-          return false unless node.children.one?
-
-          first_child = node.children.first
-
-          variable_interpolation?(first_child) ||
-            (first_child.send_type? && !first_child.operator_method?)
-        end
-
-        def interpolation?(node)
-          variable_interpolation?(node) || node.begin_type?
-        end
-
-        def variable_interpolation?(node)
-          node.variable? || node.reference?
-        end
-
-        def implicit_concatenation?(node)
-          node.parent&.dstr_type?
-        end
-
-        def embedded_in_percent_array?(node)
-          node.parent&.array_type? && percent_literal?(node.parent)
-        end
-
-        def autocorrect_variable_interpolation(corrector, embedded_node, node)
-          replacement = "#{embedded_node.source}.to_s"
-
-          corrector.replace(node, replacement)
-        end
-
-        def autocorrect_single_variable_interpolation(corrector, embedded_node, node)
-          embedded_var = embedded_node.children.first
-
-          source = if require_parentheses?(embedded_var)
-                     receiver = range_between(
-                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
-                     )
-                     arguments = embedded_var.arguments.map(&:source).join(', ')
-
-                     "#{receiver.source}(#{arguments})"
-                   else
-                     embedded_var.source
-                   end
-
-          corrector.replace(node, "#{source}.to_s")
-        end
-
-        def autocorrect_other(corrector, embedded_node, node)
-          loc = node.loc
-          embedded_loc = embedded_node.loc
-
-          corrector.replace(loc.begin, '')
-          corrector.replace(loc.end, '')
-          corrector.replace(embedded_loc.begin, '(')
-          corrector.replace(embedded_loc.end, ').to_s')
-        end
-
-        def require_parentheses?(node)
-          node.send_type? && !node.arguments.count.zero? && !node.parenthesized_call?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.59.0/lib/rubocop/cop/style/redundant_line_continuation.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Check for redundant line continuation.
-      #
-      # This cop marks a line continuation as redundant if removing the backslash
-      # does not result in a syntax error.
-      # However, a backslash at the end of a comment or
-      # for string concatenation is not redundant and is not considered an offense.
-      #
-      # @example
-      #   # bad
-      #   foo. \
-      #     bar
-      #   foo \
-      #     &.bar \
-      #       .baz
-      #
-      #   # good
-      #   foo.
-      #     bar
-      #   foo
-      #     &.bar
-      #       .baz
-      #
-      #   # bad
-      #   [foo, \
-      #     bar]
-      #   {foo: \
-      #     bar}
-      #
-      #   # good
-      #   [foo,
-      #     bar]
-      #   {foo:
-      #     bar}
-      #
-      #   # bad
-      #   foo(bar, \
-      #     baz)
-      #
-      #   # good
-      #   foo(bar,
-      #     baz)
-      #
-      #   # also good - backslash in string concatenation is not redundant
-      #   foo('bar' \
-      #     'baz')
-      #
-      #   # also good - backslash at the end of a comment is not redundant
-      #   foo(bar, # \
-      #     baz)
-      #
-      #   # also good - backslash at the line following the newline begins with a + or -,
-      #   # it is not redundant
-      #   1 \
-      #     + 2 \
-      #       - 3
-      #
-      #   # also good - backslash with newline between the method name and its arguments,
-      #   # it is not redundant.
-      #   some_method \
-      #     (argument)
-      #
-      class RedundantLineContinuation < Base
-        include MatchRange
-        extend AutoCorrector
-
-        MSG = 'Redundant line continuation.'
-        ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
-        ARGUMENT_TYPES = %i[
-          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
-        ].freeze
-
-        def on_new_investigation
-          return unless processed_source.ast
-
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
-            next if require_line_continuation?(range)
-            next unless redundant_line_continuation?(range)
-
-            add_offense(range) do |corrector|
-              corrector.remove_leading(range, 1)
-            end
-          end
-        end
-
-        private
-
-        def require_line_continuation?(range)
-          !ends_with_backslash_without_comment?(range.source_line) ||
-            string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(processed_source[range.line]) ||
-            inside_string_literal_or_method_with_argument?(range)
-        end
-
-        def ends_with_backslash_without_comment?(source_line)
-          source_line.gsub(/#.+/, '').end_with?('\\')
-        end
-
-        def string_concatenation?(source_line)
-          /["']\s*\\\z/.match?(source_line)
-        end
-
-        def inside_string_literal_or_method_with_argument?(range)
-          processed_source.tokens.each_cons(2).any? do |token, next_token|
-            next if token.line == next_token.line
-
-            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
-          end
-        end
-
-        def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.line))
-          return false if argument_newline?(node)
-
-          source = node.parent ? node.parent.source : node.source
-          parse(source.gsub("\\\n", "\n")).valid_syntax?
-        end
-
-        def inside_string_literal?(range, token)
-          ALLOWED_STRING_TOKENS.include?(token.type) && token.pos.overlaps?(range)
-        end
-
-        # A method call without parentheses such as the following cannot remove `\`:
-        #
-        #   do_something \
-        #     argument
-        def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
-        end
-
-        def argument_newline?(node)
-          node = node.children.first if node.root? && node.begin_type?
-
-          if argument_is_method?(node)
-            argument_newline?(node.first_argument)
-          else
-            return false unless method_call_with_arguments?(node)
-
-            node.loc.selector.line != node.first_argument.loc.line
-          end
-        end
-
-        def find_node_for_line(line)
-          processed_source.ast.each_node do |node|
-            return node if same_line?(node, line)
-          end
-        end
-
-        def same_line?(node, line)
-          return false unless (source_range = node.source_range)
-
-          if node.is_a?(AST::StrNode)
-            if node.heredoc?
-              (node.loc.heredoc_body.line..node.loc.heredoc_body.last_line).cover?(line)
-            else
-              (source_range.line..source_range.last_line).cover?(line)
-            end
-          else
-            source_range.line == line
-          end
-        end
-
-        def argument_is_method?(node)
-          return false unless node.send_type?
-          return false unless (first_argument = node.first_argument)
-
-          method_call_with_arguments?(first_argument)
-        end
-
-        def method_call_with_arguments?(node)
-          node.call_type? && !node.arguments.empty?
-        end
-
-        def start_with_arithmetic_operator?(source_line)
-          %r{\A\s*[+\-*/%]}.match?(source_line)
-        end
-      end
-    end
-  end
-end