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/trailing_underscore_variable.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for extra underscores in variable assignment.
-      #
-      # @example
-      #   # bad
-      #   a, b, _ = foo()
-      #   a, b, _, = foo()
-      #   a, _, _ = foo()
-      #   a, _, _, = foo()
-      #
-      #   # good
-      #   a, b, = foo()
-      #   a, = foo()
-      #   *a, b, _ = foo()
-      #   # => We need to know to not include 2 variables in a
-      #   a, *b, _ = foo()
-      #   # => The correction `a, *b, = foo()` is a syntax error
-      #
-      # @example AllowNamedUnderscoreVariables: true (default)
-      #   # good
-      #   a, b, _something = foo()
-      #
-      # @example AllowNamedUnderscoreVariables: false
-      #   # bad
-      #   a, b, _something = foo()
-      #
-      class TrailingUnderscoreVariable < Base
-        include SurroundingSpace
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Do not use trailing `_`s in parallel assignment. Prefer `%<code>s`.'
-        UNDERSCORE = '_'
-        DISALLOW = %i[lvasgn splat].freeze
-        private_constant :DISALLOW
-
-        def on_masgn(node)
-          ranges = unneeded_ranges(node)
-
-          ranges.each do |range|
-            good_code = node.source
-            offset = range.begin_pos - node.source_range.begin_pos
-            good_code[offset, range.size] = ''
-
-            add_offense(range, message: format(MSG, code: good_code)) do |corrector|
-              corrector.remove(range)
-            end
-          end
-        end
-
-        private
-
-        def find_first_offense(variables)
-          first_offense = find_first_possible_offense(variables.reverse)
-
-          return unless first_offense
-          return if splat_variable_before?(first_offense, variables)
-
-          first_offense
-        end
-
-        def find_first_possible_offense(variables)
-          variables.reduce(nil) do |offense, variable|
-            break offense unless DISALLOW.include?(variable.type)
-
-            var, = *variable
-            var, = *var
-
-            break offense if (allow_named_underscore_variables && var != :_) ||
-                             !var.to_s.start_with?(UNDERSCORE)
-
-            variable
-          end
-        end
-
-        def splat_variable_before?(first_offense, variables)
-          # Account for cases like `_, *rest, _`, where we would otherwise get
-          # the index of the first underscore.
-          first_offense_index = reverse_index(variables, first_offense)
-
-          variables[0...first_offense_index].any?(&:splat_type?)
-        end
-
-        def reverse_index(collection, item)
-          collection.size - 1 - collection.reverse.index(item)
-        end
-
-        def allow_named_underscore_variables
-          @allow_named_underscore_variables ||= cop_config['AllowNamedUnderscoreVariables']
-        end
-
-        def unneeded_ranges(node)
-          node.masgn_type? ? (mlhs_node, = *node) : mlhs_node = node
-          variables = *mlhs_node
-
-          main_offense = main_node_offense(node)
-          if main_offense.nil?
-            children_offenses(variables)
-          else
-            children_offenses(variables) << main_offense
-          end
-        end
-
-        def main_node_offense(node)
-          node.masgn_type? ? (mlhs_node, right = *node) : mlhs_node = node
-
-          variables = *mlhs_node
-          first_offense = find_first_offense(variables)
-
-          return unless first_offense
-
-          if unused_variables_only?(first_offense, variables)
-            return unused_range(node.type, mlhs_node, right)
-          end
-
-          return range_for_parentheses(first_offense, mlhs_node) if Util.parentheses?(mlhs_node)
-
-          range_between(first_offense.source_range.begin_pos, node.loc.operator.begin_pos)
-        end
-
-        def children_offenses(variables)
-          variables.select(&:mlhs_type?).flat_map { |v| unneeded_ranges(v) }
-        end
-
-        def unused_variables_only?(offense, variables)
-          offense.source_range == variables.first.source_range
-        end
-
-        def unused_range(node_type, mlhs_node, right)
-          start_range = mlhs_node.source_range.begin_pos
-
-          end_range = case node_type
-                      when :masgn
-                        right.source_range.begin_pos
-                      when :mlhs
-                        mlhs_node.source_range.end_pos
-                      end
-
-          range_between(start_range, end_range)
-        end
-
-        def range_for_parentheses(offense, left)
-          range_between(offense.source_range.begin_pos - 1, left.source_range.end_pos - 1)
-        end
-      end
-    end
-  end
-end

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

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Looks for trivial reader/writer methods, that could
-      # have been created with the attr_* family of functions automatically.
-      # `to_ary`, `to_a`, `to_c`, `to_enum`, `to_h`, `to_hash`, `to_i`, `to_int`, `to_io`,
-      # `to_open`, `to_path`, `to_proc`, `to_r`, `to_regexp`, `to_str`, `to_s`, and `to_sym` methods
-      # are allowed by default. These are customizable with `AllowedMethods` option.
-      #
-      # @example
-      #   # bad
-      #   def foo
-      #     @foo
-      #   end
-      #
-      #   def bar=(val)
-      #     @bar = val
-      #   end
-      #
-      #   def self.baz
-      #     @baz
-      #   end
-      #
-      #   # good
-      #   attr_reader :foo
-      #   attr_writer :bar
-      #
-      #   class << self
-      #     attr_reader :baz
-      #   end
-      #
-      # @example ExactNameMatch: true (default)
-      #   # good
-      #   def name
-      #     @other_name
-      #   end
-      #
-      # @example ExactNameMatch: false
-      #   # bad
-      #   def name
-      #     @other_name
-      #   end
-      #
-      # @example AllowPredicates: true (default)
-      #   # good
-      #   def foo?
-      #     @foo
-      #   end
-      #
-      # @example AllowPredicates: false
-      #   # bad
-      #   def foo?
-      #     @foo
-      #   end
-      #
-      #   # good
-      #   attr_reader :foo
-      #
-      # @example AllowDSLWriters: true (default)
-      #   # good
-      #   def on_exception(action)
-      #     @on_exception=action
-      #   end
-      #
-      # @example AllowDSLWriters: false
-      #   # bad
-      #   def on_exception(action)
-      #     @on_exception=action
-      #   end
-      #
-      #   # good
-      #   attr_writer :on_exception
-      #
-      # @example IgnoreClassMethods: false (default)
-      #   # bad
-      #   def self.foo
-      #     @foo
-      #   end
-      #
-      #   # good
-      #   class << self
-      #     attr_reader :foo
-      #   end
-      #
-      # @example IgnoreClassMethods: true
-      #   # good
-      #   def self.foo
-      #     @foo
-      #   end
-      #
-      # @example AllowedMethods: ['allowed_method']
-      #   # good
-      #   def allowed_method
-      #     @foo
-      #   end
-      class TrivialAccessors < Base
-        include AllowedMethods
-        extend AutoCorrector
-
-        MSG = 'Use `attr_%<kind>s` to define trivial %<kind>s methods.'
-
-        def on_def(node)
-          return if top_level_node?(node)
-          return if in_module_or_instance_eval?(node)
-          return if ignore_class_methods? && node.defs_type?
-
-          on_method_def(node)
-        end
-        alias on_defs on_def
-
-        private
-
-        def in_module_or_instance_eval?(node)
-          node.each_ancestor(:block, :class, :sclass, :module).each do |pnode|
-            case pnode.type
-            when :class, :sclass
-              return false
-            when :module
-              return true
-            else
-              return true if pnode.method?(:instance_eval)
-            end
-          end
-          false
-        end
-
-        def on_method_def(node)
-          kind = if trivial_reader?(node)
-                   'reader'
-                 elsif trivial_writer?(node)
-                   'writer'
-                 end
-          return unless kind
-
-          add_offense(node.loc.keyword, message: format(MSG, kind: kind)) do |corrector|
-            autocorrect(corrector, node)
-          end
-        end
-
-        def autocorrect(corrector, node)
-          parent = node.parent
-          return if parent&.send_type?
-
-          if node.def_type?
-            autocorrect_instance(corrector, node)
-          elsif node.defs_type? && node.children.first.self_type?
-            autocorrect_class(corrector, node)
-          end
-        end
-
-        def exact_name_match?
-          cop_config['ExactNameMatch']
-        end
-
-        def allow_predicates?
-          cop_config['AllowPredicates']
-        end
-
-        def allow_dsl_writers?
-          cop_config['AllowDSLWriters']
-        end
-
-        def ignore_class_methods?
-          cop_config['IgnoreClassMethods']
-        end
-
-        def allowed_method_names
-          allowed_methods.map(&:to_sym) + [:initialize]
-        end
-
-        def dsl_writer?(node)
-          !node.assignment_method?
-        end
-
-        def trivial_reader?(node)
-          looks_like_trivial_reader?(node) && !allowed_method_name?(node) && !allowed_reader?(node)
-        end
-
-        def looks_like_trivial_reader?(node)
-          !node.arguments? && node.body && node.body.ivar_type?
-        end
-
-        def trivial_writer?(node)
-          looks_like_trivial_writer?(node) && !allowed_method_name?(node) && !allowed_writer?(node)
-        end
-
-        # @!method looks_like_trivial_writer?(node)
-        def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
-          {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
-           (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}
-        PATTERN
-
-        def allowed_method_name?(node)
-          allowed_method_names.include?(node.method_name) ||
-            (exact_name_match? && !names_match?(node))
-        end
-
-        def allowed_writer?(node)
-          allow_dsl_writers? && dsl_writer?(node)
-        end
-
-        def allowed_reader?(node)
-          allow_predicates? && node.predicate_method?
-        end
-
-        def names_match?(node)
-          ivar_name, = *node.body
-
-          node.method_name.to_s.sub(/[=?]$/, '') == ivar_name[1..]
-        end
-
-        def trivial_accessor_kind(node)
-          if trivial_writer?(node) && !dsl_writer?(node)
-            'writer'
-          elsif trivial_reader?(node)
-            'reader'
-          end
-        end
-
-        def accessor(kind, method_name)
-          "attr_#{kind} :#{method_name.to_s.chomp('=')}"
-        end
-
-        def autocorrect_instance(corrector, node)
-          kind = trivial_accessor_kind(node)
-
-          return unless names_match?(node) && !node.predicate_method? && kind
-
-          corrector.replace(node, accessor(kind, node.method_name))
-        end
-
-        def autocorrect_class(corrector, node)
-          kind = trivial_accessor_kind(node)
-
-          return unless names_match?(node) && kind
-
-          indent = ' ' * node.loc.column
-          corrector.replace(
-            node,
-            ['class << self',
-             "#{indent}  #{accessor(kind, node.method_name)}",
-             "#{indent}end"].join("\n")
-          )
-        end
-
-        def top_level_node?(node)
-          node.parent.nil?
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Looks for `unless` expressions with `else` clauses.
-      #
-      # @example
-      #   # bad
-      #   unless foo_bar.nil?
-      #     # do something...
-      #   else
-      #     # do a different thing...
-      #   end
-      #
-      #   # good
-      #   if foo_bar.present?
-      #     # do something...
-      #   else
-      #     # do a different thing...
-      #   end
-      class UnlessElse < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Do not use `unless` with `else`. Rewrite these with the positive case first.'
-
-        def on_if(node)
-          return unless node.unless? && node.else?
-
-          add_offense(node) do |corrector|
-            body_range = range_between_condition_and_else(node, node.condition)
-            else_range = range_between_else_and_end(node)
-
-            next if part_of_ignored_node?(node)
-
-            corrector.replace(node.loc.keyword, 'if')
-            corrector.replace(body_range, else_range.source)
-            corrector.replace(else_range, body_range.source)
-          end
-
-          ignore_node(node)
-        end
-
-        def range_between_condition_and_else(node, condition)
-          range_between(condition.source_range.end_pos, node.loc.else.begin_pos)
-        end
-
-        def range_between_else_and_end(node)
-          range_between(node.loc.else.end_pos, node.loc.end.begin_pos)
-        end
-      end
-    end
-  end
-end

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

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for the use of logical operators in an `unless` condition.
-      # It discourages such code, as the condition becomes more difficult
-      # to read and understand.
-      #
-      # This cop supports two styles:
-      #
-      # - `forbid_mixed_logical_operators` (default)
-      # - `forbid_logical_operators`
-      #
-      # `forbid_mixed_logical_operators` style forbids the use of more than one type
-      # of logical operators. This makes the `unless` condition easier to read
-      # because either all conditions need to be met or any condition need to be met
-      # in order for the expression to be truthy or falsey.
-      #
-      # `forbid_logical_operators` style forbids any use of logical operator.
-      # This makes it even more easy to read the `unless` condition as
-      # there is only one condition in the expression.
-      #
-      # @example EnforcedStyle: forbid_mixed_logical_operators (default)
-      #   # bad
-      #   return unless a || b && c
-      #   return unless a && b || c
-      #   return unless a && b and c
-      #   return unless a || b or c
-      #   return unless a && b or c
-      #   return unless a || b and c
-      #
-      #   # good
-      #   return unless a && b && c
-      #   return unless a || b || c
-      #   return unless a and b and c
-      #   return unless a or b or c
-      #   return unless a?
-      #
-      # @example EnforcedStyle: forbid_logical_operators
-      #   # bad
-      #   return unless a || b
-      #   return unless a && b
-      #   return unless a or b
-      #   return unless a and b
-      #
-      #   # good
-      #   return unless a
-      #   return unless a?
-      class UnlessLogicalOperators < Base
-        include ConfigurableEnforcedStyle
-
-        FORBID_MIXED_LOGICAL_OPERATORS = 'Do not use mixed logical operators in an `unless`.'
-        FORBID_LOGICAL_OPERATORS = 'Do not use any logical operator in an `unless`.'
-
-        # @!method or_with_and?(node)
-        def_node_matcher :or_with_and?, <<~PATTERN
-          (if (or <`and ...> ) ...)
-        PATTERN
-
-        # @!method and_with_or?(node)
-        def_node_matcher :and_with_or?, <<~PATTERN
-          (if (and <`or ...> ) ...)
-        PATTERN
-
-        # @!method logical_operator?(node)
-        def_node_matcher :logical_operator?, <<~PATTERN
-          (if ({and or} ... ) ...)
-        PATTERN
-
-        def on_if(node)
-          return unless node.unless?
-
-          if style == :forbid_mixed_logical_operators && mixed_logical_operator?(node)
-            add_offense(node, message: FORBID_MIXED_LOGICAL_OPERATORS)
-          elsif style == :forbid_logical_operators && logical_operator?(node)
-            add_offense(node, message: FORBID_LOGICAL_OPERATORS)
-          end
-        end
-
-        private
-
-        def mixed_logical_operator?(node)
-          or_with_and?(node) ||
-            and_with_or?(node) ||
-            mixed_precedence_and?(node) ||
-            mixed_precedence_or?(node)
-        end
-
-        def mixed_precedence_and?(node)
-          and_sources = node.condition.each_descendant(:and).map(&:operator)
-          and_sources << node.condition.operator if node.condition.and_type?
-
-          !(and_sources.all?('&&') || and_sources.all?('and'))
-        end
-
-        def mixed_precedence_or?(node)
-          or_sources = node.condition.each_descendant(:or).map(&:operator)
-          or_sources << node.condition.operator if node.condition.or_type?
-
-          !(or_sources.all?('||') || or_sources.all?('or'))
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for accessing the first element of `String#unpack`
-      # which can be replaced with the shorter method `unpack1`.
-      #
-      # @example
-      #
-      #   # bad
-      #   'foo'.unpack('h*').first
-      #   'foo'.unpack('h*')[0]
-      #   'foo'.unpack('h*').slice(0)
-      #   'foo'.unpack('h*').at(0)
-      #
-      #   # good
-      #   'foo'.unpack1('h*')
-      #
-      class UnpackFirst < Base
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 2.4
-
-        MSG = 'Use `unpack1(%<format>s)` instead of `%<current>s`.'
-        RESTRICT_ON_SEND = %i[first [] slice at].freeze
-
-        # @!method unpack_and_first_element?(node)
-        def_node_matcher :unpack_and_first_element?, <<~PATTERN
-          {
-            (call $(call (...) :unpack $(...)) :first)
-            (call $(call (...) :unpack $(...)) {:[] :slice :at} (int 0))
-          }
-        PATTERN
-
-        def on_send(node)
-          unpack_and_first_element?(node) do |unpack_call, unpack_arg|
-            first_element_range = first_element_range(node, unpack_call)
-            offense_range = unpack_call.loc.selector.join(node.source_range.end)
-            message = format(MSG, format: unpack_arg.source, current: offense_range.source)
-
-            add_offense(offense_range, message: message) do |corrector|
-              corrector.remove(first_element_range)
-              corrector.replace(unpack_call.loc.selector, 'unpack1')
-            end
-          end
-        end
-        alias on_csend on_send
-
-        private
-
-        def first_element_range(node, unpack_call)
-          unpack_call.source_range.end.join(node.source_range.end)
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for variable interpolation (like "#@ivar").
-      #
-      # @example
-      #   # bad
-      #   "His name is #$name"
-      #   /check #$pattern/
-      #   "Let's go to the #@store"
-      #
-      #   # good
-      #   "His name is #{$name}"
-      #   /check #{$pattern}/
-      #   "Let's go to the #{@store}"
-      class VariableInterpolation < Base
-        include Interpolation
-        extend AutoCorrector
-
-        MSG = 'Replace interpolated variable `%<variable>s` ' \
-              'with expression `#{%<variable>s}`.' # rubocop:disable Lint/InterpolationCheck
-
-        def on_node_with_interpolations(node)
-          var_nodes(node.children).each do |var_node|
-            add_offense(var_node) do |corrector|
-              corrector.replace(var_node, "{#{var_node.source}}")
-            end
-          end
-        end
-
-        private
-
-        def message(range)
-          format(MSG, variable: range.source)
-        end
-
-        def var_nodes(nodes)
-          nodes.select { |n| n.variable? || n.reference? }
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for `when;` uses in `case` expressions.
-      #
-      # @example
-      #   # bad
-      #   case foo
-      #   when 1; 'baz'
-      #   when 2; 'bar'
-      #   end
-      #
-      #   # good
-      #   case foo
-      #   when 1 then 'baz'
-      #   when 2 then 'bar'
-      #   end
-      class WhenThen < Base
-        extend AutoCorrector
-
-        MSG = 'Do not use `when %<expression>s;`. Use `when %<expression>s then` instead.'
-
-        def on_when(node)
-          return if node.multiline? || node.then? || !node.body
-
-          message = format(MSG, expression: node.conditions.map(&:source).join(', '))
-
-          add_offense(node.loc.begin, message: message) do |corrector|
-            corrector.replace(node.loc.begin, ' then')
-          end
-        end
-      end
-    end
-  end
-end