@ai-ecoverse/wasix-ruby 3.4.11-3 → 3.4.11-4

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/parser/option.rb

@@ -1,178 +0,0 @@
-class Bundler::Thor
-  class Option < Argument #:nodoc:
-    attr_reader :aliases, :group, :lazy_default, :hide, :repeatable
-
-    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
-
-    def initialize(name, options = {})
-      @check_default_type = options[:check_default_type]
-      options[:required] = false unless options.key?(:required)
-      @repeatable     = options.fetch(:repeatable, false)
-      super
-      @lazy_default   = options[:lazy_default]
-      @group          = options[:group].to_s.capitalize if options[:group]
-      @aliases        = normalize_aliases(options[:aliases])
-      @hide           = options[:hide]
-    end
-
-    # This parse quick options given as method_options. It makes several
-    # assumptions, but you can be more specific using the option method.
-    #
-    #   parse :foo => "bar"
-    #   #=> Option foo with default value bar
-    #
-    #   parse [:foo, :baz] => "bar"
-    #   #=> Option foo with default value bar and alias :baz
-    #
-    #   parse :foo => :required
-    #   #=> Required option foo without default value
-    #
-    #   parse :foo => 2
-    #   #=> Option foo with default value 2 and type numeric
-    #
-    #   parse :foo => :numeric
-    #   #=> Option foo without default value and type numeric
-    #
-    #   parse :foo => true
-    #   #=> Option foo with default value true and type boolean
-    #
-    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
-    # is given a default type is assumed. This default type accepts arguments as
-    # string (--foo=value) or booleans (just --foo).
-    #
-    # By default all options are optional, unless :required is given.
-    #
-    def self.parse(key, value)
-      if key.is_a?(Array)
-        name, *aliases = key
-      else
-        name = key
-        aliases = []
-      end
-
-      name    = name.to_s
-      default = value
-
-      type = case value
-      when Symbol
-        default = nil
-        if VALID_TYPES.include?(value)
-          value
-        elsif required = (value == :required) # rubocop:disable Lint/AssignmentInCondition
-          :string
-        end
-      when TrueClass, FalseClass
-        :boolean
-      when Numeric
-        :numeric
-      when Hash, Array, String
-        value.class.name.downcase.to_sym
-      end
-
-      new(name.to_s, required: required, type: type, default: default, aliases: aliases)
-    end
-
-    def switch_name
-      @switch_name ||= dasherized? ? name : dasherize(name)
-    end
-
-    def human_name
-      @human_name ||= dasherized? ? undasherize(name) : name
-    end
-
-    def usage(padding = 0)
-      sample = if banner && !banner.to_s.empty?
-        "#{switch_name}=#{banner}".dup
-      else
-        switch_name
-      end
-
-      sample = "[#{sample}]".dup unless required?
-
-      if boolean? && name != "force" && !name.match(/\A(no|skip)[\-_]/)
-        sample << ", [#{dasherize('no-' + human_name)}], [#{dasherize('skip-' + human_name)}]"
-      end
-
-      aliases_for_usage.ljust(padding) + sample
-    end
-
-    def aliases_for_usage
-      if aliases.empty?
-        ""
-      else
-        "#{aliases.join(', ')}, "
-      end
-    end
-
-    def show_default?
-      case default
-      when TrueClass, FalseClass
-        true
-      else
-        super
-      end
-    end
-
-    VALID_TYPES.each do |type|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{type}?
-          self.type == #{type.inspect}
-        end
-      RUBY
-    end
-
-  protected
-
-    def validate!
-      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
-      validate_default_type!
-    end
-
-    def validate_default_type!
-      default_type = case @default
-      when nil
-        return
-      when TrueClass, FalseClass
-        required? ? :string : :boolean
-      when Numeric
-        :numeric
-      when Symbol
-        :string
-      when Hash, Array, String
-        @default.class.name.downcase.to_sym
-      end
-
-      expected_type = (@repeatable && @type != :hash) ? :array : @type
-
-      if default_type != expected_type
-        err = "Expected #{expected_type} default value for '#{switch_name}'; got #{@default.inspect} (#{default_type})"
-
-        if @check_default_type
-          raise ArgumentError, err
-        elsif @check_default_type == nil
-          Bundler::Thor.deprecation_warning "#{err}.\n" +
-            "This will be rejected in the future unless you explicitly pass the options `check_default_type: false`" +
-            " or call `allow_incompatible_default_type!` in your code"
-        end
-      end
-    end
-
-    def dasherized?
-      name.index("-") == 0
-    end
-
-    def undasherize(str)
-      str.sub(/^-{1,2}/, "")
-    end
-
-    def dasherize(str)
-      (str.length > 1 ? "--" : "-") + str.tr("_", "-")
-    end
-
-  private
-
-    def normalize_aliases(aliases)
-      Array(aliases).map { |short| short.to_s.sub(/^(?!\-)/, "-") }
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/parser/options.rb

@@ -1,294 +0,0 @@
-class Bundler::Thor
-  class Options < Arguments #:nodoc:
-    LONG_RE     = /^(--\w+(?:-\w+)*)$/
-    SHORT_RE    = /^(-[a-z])$/i
-    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
-    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
-    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
-    OPTS_END    = "--".freeze
-
-    # Receives a hash and makes it switches.
-    def self.to_switches(options)
-      options.map do |key, value|
-        case value
-        when true
-          "--#{key}"
-        when Array
-          "--#{key} #{value.map(&:inspect).join(' ')}"
-        when Hash
-          "--#{key} #{value.map { |k, v| "#{k}:#{v}" }.join(' ')}"
-        when nil, false
-          nil
-        else
-          "--#{key} #{value.inspect}"
-        end
-      end.compact.join(" ")
-    end
-
-    # Takes a hash of Bundler::Thor::Option and a hash with defaults.
-    #
-    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
-    # an unknown option or a regular argument.
-    def initialize(hash_options = {}, defaults = {}, stop_on_unknown = false, disable_required_check = false, relations = {})
-      @stop_on_unknown = stop_on_unknown
-      @exclusives = (relations[:exclusive_option_names] || []).select{|array| !array.empty?}
-      @at_least_ones = (relations[:at_least_one_option_names] || []).select{|array| !array.empty?}
-      @disable_required_check = disable_required_check
-      options = hash_options.values
-      super(options)
-
-      # Add defaults
-      defaults.each do |key, value|
-        @assigns[key.to_s] = value
-        @non_assigned_required.delete(hash_options[key])
-      end
-
-      @shorts = {}
-      @switches = {}
-      @extra = []
-      @stopped_parsing_after_extra_index = nil
-      @is_treated_as_value = false
-
-      options.each do |option|
-        @switches[option.switch_name] = option
-
-        option.aliases.each do |name|
-          @shorts[name] ||= option.switch_name
-        end
-      end
-    end
-
-    def remaining
-      @extra
-    end
-
-    def peek
-      return super unless @parsing_options
-
-      result = super
-      if result == OPTS_END
-        shift
-        @parsing_options = false
-        @stopped_parsing_after_extra_index ||= @extra.size
-        super
-      else
-        result
-      end
-    end
-
-    def shift
-      @is_treated_as_value = false
-      super
-    end
-
-    def unshift(arg, is_value: false)
-      @is_treated_as_value = is_value
-      super(arg)
-    end
-
-    def parse(args) # rubocop:disable Metrics/MethodLength
-      @pile = args.dup
-      @is_treated_as_value = false
-      @parsing_options = true
-
-      while peek
-        if parsing_options?
-          match, is_switch = current_is_switch?
-          shifted = shift
-
-          if is_switch
-            case shifted
-            when SHORT_SQ_RE
-              unshift($1.split("").map { |f| "-#{f}" })
-              next
-            when EQ_RE
-              unshift($2, is_value: true)
-              switch = $1
-            when SHORT_NUM
-              unshift($2)
-              switch = $1
-            when LONG_RE, SHORT_RE
-              switch = $1
-            end
-
-            switch = normalize_switch(switch)
-            option = switch_option(switch)
-            result = parse_peek(switch, option)
-            assign_result!(option, result)
-          elsif @stop_on_unknown
-            @parsing_options = false
-            @extra << shifted
-            @stopped_parsing_after_extra_index ||= @extra.size
-            @extra << shift while peek
-            break
-          elsif match
-            @extra << shifted
-            @extra << shift while peek && peek !~ /^-/
-          else
-            @extra << shifted
-          end
-        else
-          @extra << shift
-        end
-      end
-
-      check_requirement! unless @disable_required_check
-      check_exclusive!
-      check_at_least_one!
-
-      assigns = Bundler::Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
-      assigns.freeze
-      assigns
-    end
-
-    def check_exclusive!
-      opts = @assigns.keys
-      # When option A and B are exclusive, if A and B are given at the same time,
-      # the diffrence of argument array size will decrease.
-      found = @exclusives.find{ |ex| (ex - opts).size < ex.size - 1 }
-      if found
-        names = names_to_switch_names(found & opts).map{|n| "'#{n}'"}
-        class_name = self.class.name.split("::").last.downcase
-        fail ExclusiveArgumentError, "Found exclusive #{class_name} #{names.join(", ")}"
-      end
-    end
-
-    def check_at_least_one!
-      opts = @assigns.keys
-      # When at least one is required of the options A and B,
-      # if the both options were not given, none? would be true.
-      found = @at_least_ones.find{ |one_reqs| one_reqs.none?{ |o| opts.include? o} }
-      if found
-        names = names_to_switch_names(found).map{|n| "'#{n}'"}
-        class_name = self.class.name.split("::").last.downcase
-        fail AtLeastOneRequiredArgumentError, "Not found at least one of required #{class_name} #{names.join(", ")}"
-      end
-    end
-
-    def check_unknown!
-      to_check = @stopped_parsing_after_extra_index ? @extra[0...@stopped_parsing_after_extra_index] : @extra
-
-      # an unknown option starts with - or -- and has no more --'s afterward.
-      unknown = to_check.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      raise UnknownArgumentError.new(@switches.keys, unknown) unless unknown.empty?
-    end
-
-  protected
-
-    # Option names changes to swith name or human name
-    def names_to_switch_names(names = [])
-      @switches.map do |_, o|
-        if names.include? o.name
-          o.respond_to?(:switch_name) ? o.switch_name : o.human_name
-        else
-          nil
-        end
-      end.compact
-    end
-
-    def assign_result!(option, result)
-      if option.repeatable && option.type == :hash
-        (@assigns[option.human_name] ||= {}).merge!(result)
-      elsif option.repeatable
-        (@assigns[option.human_name] ||= []) << result
-      else
-        @assigns[option.human_name] = result
-      end
-    end
-
-    # Check if the current value in peek is a registered switch.
-    #
-    # Two booleans are returned.  The first is true if the current value
-    # starts with a hyphen; the second is true if it is a registered switch.
-    def current_is_switch?
-      return [false, false] if @is_treated_as_value
-      case peek
-      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
-        [true, switch?($1)]
-      when SHORT_SQ_RE
-        [true, $1.split("").any? { |f| switch?("-#{f}") }]
-      else
-        [false, false]
-      end
-    end
-
-    def current_is_switch_formatted?
-      return false if @is_treated_as_value
-      case peek
-      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
-        true
-      else
-        false
-      end
-    end
-
-    def current_is_value?
-      return true if @is_treated_as_value
-      peek && (!parsing_options? || super)
-    end
-
-    def switch?(arg)
-      !switch_option(normalize_switch(arg)).nil?
-    end
-
-    def switch_option(arg)
-      if match = no_or_skip?(arg) # rubocop:disable Lint/AssignmentInCondition
-        @switches[arg] || @switches["--#{match}"]
-      else
-        @switches[arg]
-      end
-    end
-
-    # Check if the given argument is actually a shortcut.
-    #
-    def normalize_switch(arg)
-      (@shorts[arg] || arg).tr("_", "-")
-    end
-
-    def parsing_options?
-      peek
-      @parsing_options
-    end
-
-    # Parse boolean values which can be given as --foo=true or --foo for true values, or
-    # --foo=false, --no-foo or --skip-foo for false values.
-    #
-    def parse_boolean(switch)
-      if current_is_value?
-        if ["true", "TRUE", "t", "T", true].include?(peek)
-          shift
-          true
-        elsif ["false", "FALSE", "f", "F", false].include?(peek)
-          shift
-          false
-        else
-          @switches.key?(switch) || !no_or_skip?(switch)
-        end
-      else
-        @switches.key?(switch) || !no_or_skip?(switch)
-      end
-    end
-
-    # Parse the value at the peek analyzing if it requires an input or not.
-    #
-    def parse_peek(switch, option)
-      if parsing_options? && (current_is_switch_formatted? || last?)
-        if option.boolean?
-          # No problem for boolean types
-        elsif no_or_skip?(switch)
-          return nil # User set value to nil
-        elsif option.string? && !option.required?
-          # Return the default if there is one, else the human name
-          return option.lazy_default || option.default || option.human_name
-        elsif option.lazy_default
-          return option.lazy_default
-        else
-          raise MalformattedArgumentError, "No value provided for option '#{switch}'"
-        end
-      end
-
-      @non_assigned_required.delete(option)
-      send(:"parse_#{option.type}", switch)
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/parser.rb

@@ -1,4 +0,0 @@
-require_relative "parser/argument"
-require_relative "parser/arguments"
-require_relative "parser/option"
-require_relative "parser/options"

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/rake_compat.rb

@@ -1,72 +0,0 @@
-require "rake"
-require "rake/dsl_definition"
-
-class Bundler::Thor
-  # Adds a compatibility layer to your Bundler::Thor classes which allows you to use
-  # rake package tasks. For example, to use rspec rake tasks, one can do:
-  #
-  #   require 'bundler/vendor/thor/lib/thor/rake_compat'
-  #   require 'rspec/core/rake_task'
-  #
-  #   class Default < Bundler::Thor
-  #     include Bundler::Thor::RakeCompat
-  #
-  #     RSpec::Core::RakeTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', './.rspec']
-  #       t.spec_files = FileList['spec/**/*_spec.rb']
-  #     end
-  #   end
-  #
-  module RakeCompat
-    include Rake::DSL if defined?(Rake::DSL)
-
-    def self.rake_classes
-      @rake_classes ||= []
-    end
-
-    def self.included(base)
-      super(base)
-      # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
-      rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
-      Rake.application.instance_variable_set(:@rakefile, rakefile)
-      rake_classes << base
-    end
-  end
-end
-
-# override task on (main), for compatibility with Rake 0.9
-instance_eval do
-  alias rake_namespace namespace
-
-  def task(*)
-    task = super
-
-    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
-      non_namespaced_name = task.name.split(":").last
-
-      description = non_namespaced_name
-      description << task.arg_names.map { |n| n.to_s.upcase }.join(" ")
-      description.strip!
-
-      klass.desc description, Rake.application.last_description || non_namespaced_name
-      Rake.application.last_description = nil
-      klass.send :define_method, non_namespaced_name do |*args|
-        Rake::Task[task.name.to_sym].invoke(*args)
-      end
-    end
-
-    task
-  end
-
-  def namespace(name)
-    if klass = Bundler::Thor::RakeCompat.rake_classes.last # rubocop:disable Lint/AssignmentInCondition
-      const_name = Bundler::Thor::Util.camel_case(name.to_s).to_sym
-      klass.const_set(const_name, Class.new(Bundler::Thor))
-      new_klass = klass.const_get(const_name)
-      Bundler::Thor::RakeCompat.rake_classes << new_klass
-    end
-
-    super
-    Bundler::Thor::RakeCompat.rake_classes.pop
-  end
-end