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

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

@@ -1,178 +0,0 @@
-class Bundler::Thor
-  module Invocation
-    def self.included(base) #:nodoc:
-      super(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # This method is responsible for receiving a name and find the proper
-      # class and command for it. The key is an optional parameter which is
-      # available only in class methods invocations (i.e. in Bundler::Thor::Group).
-      def prepare_for_invocation(key, name) #:nodoc:
-        case name
-        when Symbol, String
-          Bundler::Thor::Util.find_class_and_command_by_namespace(name.to_s, !key)
-        else
-          name
-        end
-      end
-    end
-
-    # Make initializer aware of invocations and the initialization args.
-    def initialize(args = [], options = {}, config = {}, &block) #:nodoc:
-      @_invocations = config[:invocations] || Hash.new { |h, k| h[k] = [] }
-      @_initializer = [args, options, config]
-      super
-    end
-
-    # Make the current command chain accessible with in a Bundler::Thor-(sub)command
-    def current_command_chain
-      @_invocations.values.flatten.map(&:to_sym)
-    end
-
-    # Receives a name and invokes it. The name can be a string (either "command" or
-    # "namespace:command"), a Bundler::Thor::Command, a Class or a Bundler::Thor instance. If the
-    # command cannot be guessed by name, it can also be supplied as second argument.
-    #
-    # You can also supply the arguments, options and configuration values for
-    # the command to be invoked, if none is given, the same values used to
-    # initialize the invoker are used to initialize the invoked.
-    #
-    # When no name is given, it will invoke the default command of the current class.
-    #
-    # ==== Examples
-    #
-    #   class A < Bundler::Thor
-    #     def foo
-    #       invoke :bar
-    #       invoke "b:hello", ["Erik"]
-    #     end
-    #
-    #     def bar
-    #       invoke "b:hello", ["Erik"]
-    #     end
-    #   end
-    #
-    #   class B < Bundler::Thor
-    #     def hello(name)
-    #       puts "hello #{name}"
-    #     end
-    #   end
-    #
-    # You can notice that the method "foo" above invokes two commands: "bar",
-    # which belongs to the same class and "hello" which belongs to the class B.
-    #
-    # By using an invocation system you ensure that a command is invoked only once.
-    # In the example above, invoking "foo" will invoke "b:hello" just once, even
-    # if it's invoked later by "bar" method.
-    #
-    # When class A invokes class B, all arguments used on A initialization are
-    # supplied to B. This allows lazy parse of options. Let's suppose you have
-    # some rspec commands:
-    #
-    #   class Rspec < Bundler::Thor::Group
-    #     class_option :mock_framework, :type => :string, :default => :rr
-    #
-    #     def invoke_mock_framework
-    #       invoke "rspec:#{options[:mock_framework]}"
-    #     end
-    #   end
-    #
-    # As you noticed, it invokes the given mock framework, which might have its
-    # own options:
-    #
-    #   class Rspec::RR < Bundler::Thor::Group
-    #     class_option :style, :type => :string, :default => :mock
-    #   end
-    #
-    # Since it's not rspec concern to parse mock framework options, when RR
-    # is invoked all options are parsed again, so RR can extract only the options
-    # that it's going to use.
-    #
-    # If you want Rspec::RR to be initialized with its own set of options, you
-    # have to do that explicitly:
-    #
-    #   invoke "rspec:rr", [], :style => :foo
-    #
-    # Besides giving an instance, you can also give a class to invoke:
-    #
-    #   invoke Rspec::RR, [], :style => :foo
-    #
-    def invoke(name = nil, *args)
-      if name.nil?
-        warn "[Bundler::Thor] Calling invoke() without argument is deprecated. Please use invoke_all instead.\n#{caller.join("\n")}"
-        return invoke_all
-      end
-
-      args.unshift(nil) if args.first.is_a?(Array) || args.first.nil?
-      command, args, opts, config = args
-
-      klass, command = _retrieve_class_and_command(name, command)
-      raise "Missing Bundler::Thor class for invoke #{name}" unless klass
-      raise "Expected Bundler::Thor class, got #{klass}" unless klass <= Bundler::Thor::Base
-
-      args, opts, config = _parse_initialization_options(args, opts, config)
-      klass.send(:dispatch, command, args, opts, config) do |instance|
-        instance.parent_options = options
-      end
-    end
-
-    # Invoke the given command if the given args.
-    def invoke_command(command, *args) #:nodoc:
-      current = @_invocations[self.class]
-
-      unless current.include?(command.name)
-        current << command.name
-        command.run(self, *args)
-      end
-    end
-    alias_method :invoke_task, :invoke_command
-
-    # Invoke all commands for the current instance.
-    def invoke_all #:nodoc:
-      self.class.all_commands.map { |_, command| invoke_command(command) }
-    end
-
-    # Invokes using shell padding.
-    def invoke_with_padding(*args)
-      with_padding { invoke(*args) }
-    end
-
-  protected
-
-    # Configuration values that are shared between invocations.
-    def _shared_configuration #:nodoc:
-      {invocations: @_invocations}
-    end
-
-    # This method simply retrieves the class and command to be invoked.
-    # If the name is nil or the given name is a command in the current class,
-    # use the given name and return self as class. Otherwise, call
-    # prepare_for_invocation in the current class.
-    def _retrieve_class_and_command(name, sent_command = nil) #:nodoc:
-      if name.nil?
-        [self.class, nil]
-      elsif self.class.all_commands[name.to_s]
-        [self.class, name.to_s]
-      else
-        klass, command = self.class.prepare_for_invocation(nil, name)
-        [klass, command || sent_command]
-      end
-    end
-    alias_method :_retrieve_class_and_task, :_retrieve_class_and_command
-
-    # Initialize klass using values stored in the @_initializer.
-    def _parse_initialization_options(args, opts, config) #:nodoc:
-      stored_args, stored_opts, stored_config = @_initializer
-
-      args ||= stored_args.dup
-      opts ||= stored_opts.dup
-
-      config ||= {}
-      config = stored_config.merge(_shared_configuration).merge!(config)
-
-      [args, opts, config]
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/line_editor/basic.rb

@@ -1,37 +0,0 @@
-class Bundler::Thor
-  module LineEditor
-    class Basic
-      attr_reader :prompt, :options
-
-      def self.available?
-        true
-      end
-
-      def initialize(prompt, options)
-        @prompt = prompt
-        @options = options
-      end
-
-      def readline
-        $stdout.print(prompt)
-        get_input
-      end
-
-    private
-
-      def get_input
-        if echo?
-          $stdin.gets
-        else
-          # Lazy-load io/console since it is gem-ified as of 2.3
-          require "io/console"
-          $stdin.noecho(&:gets)
-        end
-      end
-
-      def echo?
-        options.fetch(:echo, true)
-      end
-    end
-  end
-end

package/lib/ruby/3.4.11/bundler/vendor/thor/lib/thor/line_editor/readline.rb

@@ -1,88 +0,0 @@
-class Bundler::Thor
-  module LineEditor
-    class Readline < Basic
-      def self.available?
-        begin
-          require "readline"
-        rescue LoadError
-        end
-
-        Object.const_defined?(:Readline)
-      end
-
-      def readline
-        if echo?
-          ::Readline.completion_append_character = nil
-          # rb-readline does not allow Readline.completion_proc= to receive nil.
-          if complete = completion_proc
-            ::Readline.completion_proc = complete
-          end
-          ::Readline.readline(prompt, add_to_history?)
-        else
-          super
-        end
-      end
-
-    private
-
-      def add_to_history?
-        options.fetch(:add_to_history, true)
-      end
-
-      def completion_proc
-        if use_path_completion?
-          proc { |text| PathCompletion.new(text).matches }
-        elsif completion_options.any?
-          proc do |text|
-            completion_options.select { |option| option.start_with?(text) }
-          end
-        end
-      end
-
-      def completion_options
-        options.fetch(:limited_to, [])
-      end
-
-      def use_path_completion?
-        options.fetch(:path, false)
-      end
-
-      class PathCompletion
-        attr_reader :text
-        private :text
-
-        def initialize(text)
-          @text = text
-        end
-
-        def matches
-          relative_matches
-        end
-
-      private
-
-        def relative_matches
-          absolute_matches.map { |path| path.sub(base_path, "") }
-        end
-
-        def absolute_matches
-          Dir[glob_pattern].map do |path|
-            if File.directory?(path)
-              "#{path}/"
-            else
-              path
-            end
-          end
-        end
-
-        def glob_pattern
-          "#{base_path}#{text}*"
-        end
-
-        def base_path
-          "#{Dir.pwd}/"
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require_relative "line_editor/basic"
-require_relative "line_editor/readline"
-
-class Bundler::Thor
-  module LineEditor
-    def self.readline(prompt, options = {})
-      best_available.new(prompt, options).readline
-    end
-
-    def self.best_available
-      [
-        Bundler::Thor::LineEditor::Readline,
-        Bundler::Thor::LineEditor::Basic
-      ].detect(&:available?)
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-class Bundler::Thor
-  class NestedContext
-    def initialize
-      @depth = 0
-    end
-
-    def enter
-      push
-
-      yield
-    ensure
-      pop
-    end
-
-    def entered?
-      @depth.positive?
-    end
-
-  private
-
-    def push
-      @depth += 1
-    end
-
-    def pop
-      @depth -= 1
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-class Bundler::Thor
-  class Argument #:nodoc:
-    VALID_TYPES = [:numeric, :hash, :array, :string]
-
-    attr_reader :name, :description, :enum, :required, :type, :default, :banner
-    alias_method :human_name, :name
-
-    def initialize(name, options = {})
-      class_name = self.class.name.split("::").last
-
-      type = options[:type]
-
-      raise ArgumentError, "#{class_name} name can't be nil."                         if name.nil?
-      raise ArgumentError, "Type :#{type} is not valid for #{class_name.downcase}s."  if type && !valid_type?(type)
-
-      @name        = name.to_s
-      @description = options[:desc]
-      @required    = options.key?(:required) ? options[:required] : true
-      @type        = (type || :string).to_sym
-      @default     = options[:default]
-      @banner      = options[:banner] || default_banner
-      @enum        = options[:enum]
-
-      validate! # Trigger specific validations
-    end
-
-    def print_default
-      if @type == :array and @default.is_a?(Array)
-        @default.map(&:dump).join(" ")
-      else
-        @default
-      end
-    end
-
-    def usage
-      required? ? banner : "[#{banner}]"
-    end
-
-    def required?
-      required
-    end
-
-    def show_default?
-      case default
-      when Array, String, Hash
-        !default.empty?
-      else
-        default
-      end
-    end
-
-    def enum_to_s
-      if enum.respond_to? :join
-        enum.join(", ")
-      else
-        "#{enum.first}..#{enum.last}"
-      end
-    end
-
-  protected
-
-    def validate!
-      raise ArgumentError, "An argument cannot be required and have default value." if required? && !default.nil?
-      raise ArgumentError, "An argument cannot have an enum other than an enumerable." if @enum && !@enum.is_a?(Enumerable)
-    end
-
-    def valid_type?(type)
-      self.class::VALID_TYPES.include?(type.to_sym)
-    end
-
-    def default_banner
-      case type
-      when :boolean
-        nil
-      when :string, :default
-        human_name.upcase
-      when :numeric
-        "N"
-      when :hash
-        "key:value"
-      when :array
-        "one two three"
-      end
-    end
-  end
-end

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

@@ -1,195 +0,0 @@
-class Bundler::Thor
-  class Arguments #:nodoc:
-    NUMERIC = /[-+]?(\d*\.\d+|\d+)/
-
-    # Receives an array of args and returns two arrays, one with arguments
-    # and one with switches.
-    #
-    def self.split(args)
-      arguments = []
-
-      args.each do |item|
-        break if item.is_a?(String) && item =~ /^-/
-        arguments << item
-      end
-
-      [arguments, args[Range.new(arguments.size, -1)]]
-    end
-
-    def self.parse(*args)
-      to_parse = args.pop
-      new(*args).parse(to_parse)
-    end
-
-    # Takes an array of Bundler::Thor::Argument objects.
-    #
-    def initialize(arguments = [])
-      @assigns = {}
-      @non_assigned_required = []
-      @switches = arguments
-
-      arguments.each do |argument|
-        if !argument.default.nil?
-          @assigns[argument.human_name] = argument.default.dup
-        elsif argument.required?
-          @non_assigned_required << argument
-        end
-      end
-    end
-
-    def parse(args)
-      @pile = args.dup
-
-      @switches.each do |argument|
-        break unless peek
-        @non_assigned_required.delete(argument)
-        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
-      end
-
-      check_requirement!
-      @assigns
-    end
-
-    def remaining
-      @pile
-    end
-
-  private
-
-    def no_or_skip?(arg)
-      arg =~ /^--(no|skip)-([-\w]+)$/
-      $2
-    end
-
-    def last?
-      @pile.empty?
-    end
-
-    def peek
-      @pile.first
-    end
-
-    def shift
-      @pile.shift
-    end
-
-    def unshift(arg)
-      if arg.is_a?(Array)
-        @pile = arg + @pile
-      else
-        @pile.unshift(arg)
-      end
-    end
-
-    def current_is_value?
-      peek && peek.to_s !~ /^-{1,2}\S+/
-    end
-
-    # Runs through the argument array getting strings that contains ":" and
-    # mark it as a hash:
-    #
-    #   [ "name:string", "age:integer" ]
-    #
-    # Becomes:
-    #
-    #   { "name" => "string", "age" => "integer" }
-    #
-    def parse_hash(name)
-      return shift if peek.is_a?(Hash)
-      hash = {}
-
-      while current_is_value? && peek.include?(":")
-        key, value = shift.split(":", 2)
-        raise MalformattedArgumentError, "You can't specify '#{key}' more than once in option '#{name}'; got #{key}:#{hash[key]} and #{key}:#{value}" if hash.include? key
-        hash[key] = value
-      end
-      hash
-    end
-
-    # Runs through the argument array getting all strings until no string is
-    # found or a switch is found.
-    #
-    #   ["a", "b", "c"]
-    #
-    # And returns it as an array:
-    #
-    #   ["a", "b", "c"]
-    #
-    def parse_array(name)
-      return shift if peek.is_a?(Array)
-
-      array = []
-
-      while current_is_value?
-        value = shift
-
-        if !value.empty?
-          validate_enum_value!(name, value, "Expected all values of '%s' to be one of %s; got %s")
-        end
-
-        array << value
-      end
-      array
-    end
-
-    # Check if the peek is numeric format and return a Float or Integer.
-    # Check if the peek is included in enum if enum is provided.
-    # Otherwise raises an error.
-    #
-    def parse_numeric(name)
-      return shift if peek.is_a?(Numeric)
-
-      unless peek =~ NUMERIC && $& == peek
-        raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
-      end
-
-      value = $&.index(".") ? shift.to_f : shift.to_i
-
-      validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
-
-      value
-    end
-
-    # Parse string:
-    # for --string-arg, just return the current value in the pile
-    # for --no-string-arg, nil
-    # Check if the peek is included in enum if enum is provided. Otherwise raises an error.
-    #
-    def parse_string(name)
-      if no_or_skip?(name)
-        nil
-      else
-        value = shift
-
-        validate_enum_value!(name, value, "Expected '%s' to be one of %s; got %s")
-
-        value
-      end
-    end
-
-    # Raises an error if the switch is an enum and the values aren't included on it.
-    #
-    def validate_enum_value!(name, value, message)
-      return unless @switches.is_a?(Hash)
-
-      switch = @switches[name]
-
-      return unless switch
-
-      if switch.enum && !switch.enum.include?(value)
-        raise MalformattedArgumentError, message % [name, switch.enum_to_s, value]
-      end
-    end
-
-    # Raises an error if @non_assigned_required array is not empty.
-    #
-    def check_requirement!
-      return if @non_assigned_required.empty?
-      names = @non_assigned_required.map do |o|
-        o.respond_to?(:switch_name) ? o.switch_name : o.human_name
-      end.join("', '")
-      class_name = self.class.name.split("::").last.downcase
-      raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
-    end
-  end
-end