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

package/lib/ruby/3.4.11/reline/config.rb

@@ -1,373 +0,0 @@
-class Reline::Config
-  attr_reader :test_mode
-
-  KEYSEQ_PATTERN = /\\(?:C|Control)-[A-Za-z_]|\\(?:M|Meta)-[0-9A-Za-z_]|\\(?:C|Control)-\\(?:M|Meta)-[A-Za-z_]|\\(?:M|Meta)-\\(?:C|Control)-[A-Za-z_]|\\e|\\[\\\"\'abdfnrtv]|\\\d{1,3}|\\x\h{1,2}|./
-
-  class InvalidInputrc < RuntimeError
-    attr_accessor :file, :lineno
-  end
-
-  VARIABLE_NAMES = %w{
-    completion-ignore-case
-    convert-meta
-    disable-completion
-    history-size
-    keyseq-timeout
-    show-all-if-ambiguous
-    show-mode-in-prompt
-    vi-cmd-mode-string
-    vi-ins-mode-string
-    emacs-mode-string
-    enable-bracketed-paste
-    isearch-terminators
-  }
-  VARIABLE_NAME_SYMBOLS = VARIABLE_NAMES.map { |v| :"#{v.tr(?-, ?_)}" }
-  VARIABLE_NAME_SYMBOLS.each do |v|
-    attr_accessor v
-  end
-
-  attr_accessor :autocompletion
-
-  def initialize
-    reset_variables
-  end
-
-  def reset
-    if editing_mode_is?(:vi_command)
-      @editing_mode_label = :vi_insert
-    end
-    @oneshot_key_bindings.clear
-  end
-
-  def reset_variables
-    @additional_key_bindings = { # from inputrc
-      emacs: Reline::KeyActor::Base.new,
-      vi_insert: Reline::KeyActor::Base.new,
-      vi_command: Reline::KeyActor::Base.new
-    }
-    @oneshot_key_bindings = Reline::KeyActor::Base.new
-    @editing_mode_label = :emacs
-    @keymap_label = :emacs
-    @keymap_prefix = []
-    @default_key_bindings = {
-      emacs: Reline::KeyActor::Base.new(Reline::KeyActor::EMACS_MAPPING),
-      vi_insert: Reline::KeyActor::Base.new(Reline::KeyActor::VI_INSERT_MAPPING),
-      vi_command: Reline::KeyActor::Base.new(Reline::KeyActor::VI_COMMAND_MAPPING)
-    }
-    @vi_cmd_mode_string = '(cmd)'
-    @vi_ins_mode_string = '(ins)'
-    @emacs_mode_string = '@'
-    # https://tiswww.case.edu/php/chet/readline/readline.html#IDX25
-    @history_size = -1 # unlimited
-    @keyseq_timeout = 500
-    @test_mode = false
-    @autocompletion = false
-    @convert_meta = seven_bit_encoding?(Reline::IOGate.encoding)
-    @loaded = false
-    @enable_bracketed_paste = true
-    @show_mode_in_prompt = false
-    @default_inputrc_path = nil
-  end
-
-  def editing_mode
-    @default_key_bindings[@editing_mode_label]
-  end
-
-  def editing_mode=(val)
-    @editing_mode_label = val
-  end
-
-  def editing_mode_is?(*val)
-    val.any?(@editing_mode_label)
-  end
-
-  def keymap
-    @default_key_bindings[@keymap_label]
-  end
-
-  def loaded?
-    @loaded
-  end
-
-  def inputrc_path
-    case ENV['INPUTRC']
-    when nil, ''
-    else
-      return File.expand_path(ENV['INPUTRC'])
-    end
-
-    # In the XDG Specification, if ~/.config/readline/inputrc exists, then
-    # ~/.inputrc should not be read, but for compatibility with GNU Readline,
-    # if ~/.inputrc exists, then it is given priority.
-    home_rc_path = File.expand_path('~/.inputrc')
-    return home_rc_path if File.exist?(home_rc_path)
-
-    case path = ENV['XDG_CONFIG_HOME']
-    when nil, ''
-    else
-      path = File.join(path, 'readline/inputrc')
-      return path if File.exist?(path) and path == File.expand_path(path)
-    end
-
-    path = File.expand_path('~/.config/readline/inputrc')
-    return path if File.exist?(path)
-
-    return home_rc_path
-  end
-
-  private def default_inputrc_path
-    @default_inputrc_path ||= inputrc_path
-  end
-
-  def read(file = nil)
-    @loaded = true
-    file ||= default_inputrc_path
-    begin
-      if file.respond_to?(:readlines)
-        lines = file.readlines
-      else
-        lines = File.readlines(file)
-      end
-    rescue Errno::ENOENT
-      return nil
-    end
-
-    read_lines(lines, file)
-    self
-  rescue InvalidInputrc => e
-    warn e.message
-    nil
-  end
-
-  def key_bindings
-    # The key bindings for each editing mode will be overwritten by the user-defined ones.
-    Reline::KeyActor::Composite.new([@oneshot_key_bindings, @additional_key_bindings[@editing_mode_label], @default_key_bindings[@editing_mode_label]])
-  end
-
-  def add_oneshot_key_binding(keystroke, target)
-    # IRB sets invalid keystroke [Reline::Key]. We should ignore it.
-    return unless keystroke.all? { |c| c.is_a?(Integer) }
-
-    @oneshot_key_bindings.add(keystroke, target)
-  end
-
-  def reset_oneshot_key_bindings
-    @oneshot_key_bindings.clear
-  end
-
-  def add_default_key_binding_by_keymap(keymap, keystroke, target)
-    @default_key_bindings[keymap].add(keystroke, target)
-  end
-
-  def add_default_key_binding(keystroke, target)
-    add_default_key_binding_by_keymap(@keymap_label, keystroke, target)
-  end
-
-  def read_lines(lines, file = nil)
-    if not lines.empty? and lines.first.encoding != Reline.encoding_system_needs
-      begin
-        lines = lines.map do |l|
-          l.encode(Reline.encoding_system_needs)
-        rescue Encoding::UndefinedConversionError
-          mes = "The inputrc encoded in #{lines.first.encoding.name} can't be converted to the locale #{Reline.encoding_system_needs.name}."
-          raise Reline::ConfigEncodingConversionError.new(mes)
-        end
-      end
-    end
-    if_stack = []
-
-    lines.each_with_index do |line, no|
-      next if line.match(/\A\s*#/)
-
-      no += 1
-
-      line = line.chomp.lstrip
-      if line.start_with?('$')
-        handle_directive(line[1..-1], file, no, if_stack)
-        next
-      end
-
-      next if if_stack.any? { |_no, skip| skip }
-
-      case line
-      when /^set +([^ ]+) +(.+)/i
-        # value ignores everything after a space, raw_value does not.
-        var, value, raw_value = $1.downcase, $2.partition(' ').first, $2
-        bind_variable(var, value, raw_value)
-      when /^\s*(?:M|Meta)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
-        bind_key("\"\\M-#$1\"", $2)
-      when /^\s*(?:C|Control)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
-        bind_key("\"\\C-#$1\"", $2)
-      when /^\s*(?:(?:C|Control)-(?:M|Meta)|(?:M|Meta)-(?:C|Control))-([a-zA-Z_])\s*:\s*(.*)\s*$/o
-        bind_key("\"\\M-\\C-#$1\"", $2)
-      when /^\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
-        bind_key($1, $2)
-      end
-    end
-    unless if_stack.empty?
-      raise InvalidInputrc, "#{file}:#{if_stack.last[0]}: unclosed if"
-    end
-  end
-
-  def handle_directive(directive, file, no, if_stack)
-    directive, args = directive.split(' ')
-    case directive
-    when 'if'
-      condition = false
-      case args
-      when /^mode=(vi|emacs)$/i
-        mode = $1.downcase
-        # NOTE: mode=vi means vi-insert mode
-        mode = 'vi_insert' if mode == 'vi'
-        if @editing_mode_label == mode.to_sym
-          condition = true
-        end
-      when 'term'
-      when 'version'
-      else # application name
-        condition = true if args == 'Ruby'
-        condition = true if args == 'Reline'
-      end
-      if_stack << [no, !condition]
-    when 'else'
-      if if_stack.empty?
-        raise InvalidInputrc, "#{file}:#{no}: unmatched else"
-      end
-      if_stack.last[1] = !if_stack.last[1]
-    when 'endif'
-      if if_stack.empty?
-        raise InvalidInputrc, "#{file}:#{no}: unmatched endif"
-      end
-      if_stack.pop
-    when 'include'
-      read(File.expand_path(args))
-    end
-  end
-
-  def bind_variable(name, value, raw_value)
-    case name
-    when 'history-size'
-      begin
-        @history_size = Integer(value)
-      rescue ArgumentError
-        @history_size = 500
-      end
-    when 'isearch-terminators'
-      @isearch_terminators = retrieve_string(raw_value)
-    when 'editing-mode'
-      case value
-      when 'emacs'
-        @editing_mode_label = :emacs
-        @keymap_label = :emacs
-        @keymap_prefix = []
-      when 'vi'
-        @editing_mode_label = :vi_insert
-        @keymap_label = :vi_insert
-        @keymap_prefix = []
-      end
-    when 'keymap'
-      case value
-      when 'emacs', 'emacs-standard'
-        @keymap_label = :emacs
-        @keymap_prefix = []
-      when 'emacs-ctlx'
-        @keymap_label = :emacs
-        @keymap_prefix = [?\C-x.ord]
-      when 'emacs-meta'
-        @keymap_label = :emacs
-        @keymap_prefix = [?\e.ord]
-      when 'vi', 'vi-move', 'vi-command'
-        @keymap_label = :vi_command
-        @keymap_prefix = []
-      when 'vi-insert'
-        @keymap_label = :vi_insert
-        @keymap_prefix = []
-      end
-    when 'keyseq-timeout'
-      @keyseq_timeout = value.to_i
-    when 'show-mode-in-prompt'
-      case value
-      when 'off'
-        @show_mode_in_prompt = false
-      when 'on'
-        @show_mode_in_prompt = true
-      else
-        @show_mode_in_prompt = false
-      end
-    when 'vi-cmd-mode-string'
-      @vi_cmd_mode_string = retrieve_string(raw_value)
-    when 'vi-ins-mode-string'
-      @vi_ins_mode_string = retrieve_string(raw_value)
-    when 'emacs-mode-string'
-      @emacs_mode_string = retrieve_string(raw_value)
-    when *VARIABLE_NAMES then
-      variable_name = :"@#{name.tr(?-, ?_)}"
-      instance_variable_set(variable_name, value.nil? || value == '1' || value == 'on')
-    end
-  end
-
-  def retrieve_string(str)
-    str = $1 if str =~ /\A"(.*)"\z/
-    parse_keyseq(str).map { |c| c.chr(Reline.encoding_system_needs) }.join
-  end
-
-  def bind_key(key, value)
-    keystroke, func = parse_key_binding(key, value)
-    @additional_key_bindings[@keymap_label].add(@keymap_prefix + keystroke, func) if keystroke
-  end
-
-  def parse_key_binding(key, func_name)
-    if key =~ /\A"(.*)"\z/
-      keyseq = parse_keyseq($1)
-    else
-      keyseq = nil
-    end
-    if func_name =~ /"(.*)"/
-      func = parse_keyseq($1)
-    else
-      func = func_name.split.first.tr(?-, ?_).to_sym # It must be macro.
-    end
-    [keyseq, func]
-  end
-
-  def key_notation_to_code(notation)
-    case notation
-    when /(?:\\(?:C|Control)-\\(?:M|Meta)|\\(?:M|Meta)-\\(?:C|Control))-([A-Za-z_])/
-      [?\e.ord, $1.ord % 32]
-    when /\\(?:C|Control)-([A-Za-z_])/
-      ($1.upcase.ord % 32)
-    when /\\(?:M|Meta)-([0-9A-Za-z_])/
-      [?\e.ord, $1.ord]
-    when /\\(\d{1,3})/ then $1.to_i(8) # octal
-    when /\\x(\h{1,2})/ then $1.to_i(16) # hexadecimal
-    when "\\e" then ?\e.ord
-    when "\\\\" then ?\\.ord
-    when "\\\"" then ?".ord
-    when "\\'" then ?'.ord
-    when "\\a" then ?\a.ord
-    when "\\b" then ?\b.ord
-    when "\\d" then ?\d.ord
-    when "\\f" then ?\f.ord
-    when "\\n" then ?\n.ord
-    when "\\r" then ?\r.ord
-    when "\\t" then ?\t.ord
-    when "\\v" then ?\v.ord
-    else notation.ord
-    end
-  end
-
-  def parse_keyseq(str)
-    str.scan(KEYSEQ_PATTERN).flat_map do |notation|
-      key_notation_to_code(notation)
-    end
-  end
-
-  def reload
-    reset_variables
-    read
-  end
-
-  private def seven_bit_encoding?(encoding)
-    encoding == Encoding::US_ASCII
-  end
-end

package/lib/ruby/3.4.11/reline/face.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-class Reline::Face
-  SGR_PARAMETERS = {
-    foreground: {
-      black: 30,
-      red: 31,
-      green: 32,
-      yellow: 33,
-      blue: 34,
-      magenta: 35,
-      cyan: 36,
-      white: 37,
-      bright_black: 90,
-      gray: 90,
-      bright_red: 91,
-      bright_green: 92,
-      bright_yellow: 93,
-      bright_blue: 94,
-      bright_magenta: 95,
-      bright_cyan: 96,
-      bright_white: 97
-    },
-    background: {
-      black: 40,
-      red: 41,
-      green: 42,
-      yellow: 43,
-      blue: 44,
-      magenta: 45,
-      cyan: 46,
-      white: 47,
-      bright_black: 100,
-      gray: 100,
-      bright_red: 101,
-      bright_green: 102,
-      bright_yellow: 103,
-      bright_blue: 104,
-      bright_magenta: 105,
-      bright_cyan: 106,
-      bright_white: 107,
-    },
-    style: {
-      reset: 0,
-      bold: 1,
-      faint: 2,
-      italicized: 3,
-      underlined: 4,
-      slowly_blinking: 5,
-      blinking: 5,
-      rapidly_blinking: 6,
-      negative: 7,
-      concealed: 8,
-      crossed_out: 9
-    }
-  }.freeze
-
-  class Config
-    ESSENTIAL_DEFINE_NAMES = %i(default enhanced scrollbar).freeze
-    RESET_SGR = "\e[0m".freeze
-
-    def initialize(name, &block)
-      @definition = {}
-      block.call(self)
-      ESSENTIAL_DEFINE_NAMES.each do |name|
-        @definition[name] ||= { style: :reset, escape_sequence: RESET_SGR }
-      end
-    end
-
-    attr_reader :definition
-
-    def define(name, **values)
-      values[:escape_sequence] = format_to_sgr(values.to_a).freeze
-      @definition[name] = values
-    end
-
-    def reconfigure
-      @definition.each_value do |values|
-        values.delete(:escape_sequence)
-        values[:escape_sequence] = format_to_sgr(values.to_a).freeze
-      end
-    end
-
-    def [](name)
-      @definition.dig(name, :escape_sequence) or raise ArgumentError, "unknown face: #{name}"
-    end
-
-    private
-
-    def sgr_rgb(key, value)
-      return nil unless rgb_expression?(value)
-      if Reline::Face.truecolor?
-        sgr_rgb_truecolor(key, value)
-      else
-        sgr_rgb_256color(key, value)
-      end
-    end
-
-    def sgr_rgb_truecolor(key, value)
-      case key
-      when :foreground
-        "38;2;"
-      when :background
-        "48;2;"
-      end + value[1, 6].scan(/../).map(&:hex).join(";")
-    end
-
-    def sgr_rgb_256color(key, value)
-      # 256 colors are
-      # 0..15: standard colors, high intensity colors
-      # 16..232: 216 colors (R, G, B each 6 steps)
-      # 233..255: grayscale colors (24 steps)
-      # This methods converts rgb_expression to 216 colors
-      rgb = value[1, 6].scan(/../).map(&:hex)
-      # Color steps are [0, 95, 135, 175, 215, 255]
-      r, g, b = rgb.map { |v| v <= 95 ? v / 48 : (v - 35) / 40 }
-      color = (16 + 36 * r + 6 * g + b)
-      case key
-      when :foreground
-        "38;5;#{color}"
-      when :background
-        "48;5;#{color}"
-      end
-    end
-
-    def format_to_sgr(ordered_values)
-      sgr = "\e[" + ordered_values.map do |key_value|
-        key, value = key_value
-        case key
-        when :foreground, :background
-          case value
-          when Symbol
-            SGR_PARAMETERS[key][value]
-          when String
-            sgr_rgb(key, value)
-          end
-        when :style
-          [ value ].flatten.map do |style_name|
-            SGR_PARAMETERS[:style][style_name]
-          end.then do |sgr_parameters|
-            sgr_parameters.include?(nil) ? nil : sgr_parameters
-          end
-        end.then do |rendition_expression|
-          unless rendition_expression
-            raise ArgumentError, "invalid SGR parameter: #{value.inspect}"
-          end
-          rendition_expression
-        end
-      end.join(';') + "m"
-      sgr == RESET_SGR ? RESET_SGR : RESET_SGR + sgr
-    end
-
-    def rgb_expression?(color)
-      color.respond_to?(:match?) and color.match?(/\A#[0-9a-fA-F]{6}\z/)
-    end
-  end
-
-  private_constant :SGR_PARAMETERS, :Config
-
-  def self.truecolor?
-    @force_truecolor || %w[truecolor 24bit].include?(ENV['COLORTERM'])
-  end
-
-  def self.force_truecolor
-    @force_truecolor = true
-    @configs&.each_value(&:reconfigure)
-  end
-
-  def self.[](name)
-    @configs[name]
-  end
-
-  def self.config(name, &block)
-    @configs ||= {}
-    @configs[name] = Config.new(name, &block)
-  end
-
-  def self.configs
-    @configs.transform_values(&:definition)
-  end
-
-  def self.load_initial_configs
-    config(:default) do |conf|
-      conf.define :default, style: :reset
-      conf.define :enhanced, style: :reset
-      conf.define :scrollbar, style: :reset
-    end
-    config(:completion_dialog) do |conf|
-      conf.define :default, foreground: :bright_white, background: :gray
-      conf.define :enhanced, foreground: :black, background: :white
-      conf.define :scrollbar, foreground: :white, background: :gray
-    end
-  end
-
-  def self.reset_to_initial_configs
-    @configs = {}
-    load_initial_configs
-  end
-end

package/lib/ruby/3.4.11/reline/history.rb

@@ -1,76 +0,0 @@
-class Reline::History < Array
-  def initialize(config)
-    @config = config
-  end
-
-  def to_s
-    'HISTORY'
-  end
-
-  def delete_at(index)
-    index = check_index(index)
-    super(index)
-  end
-
-  def [](index)
-    index = check_index(index) unless index.is_a?(Range)
-    super(index)
-  end
-
-  def []=(index, val)
-    index = check_index(index)
-    super(index, Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
-  end
-
-  def concat(*val)
-    val.each do |v|
-      push(*v)
-    end
-  end
-
-  def push(*val)
-    # If history_size is zero, all histories are dropped.
-    return self if @config.history_size.zero?
-    # If history_size is negative, history size is unlimited.
-    if @config.history_size.positive?
-      diff = size + val.size - @config.history_size
-      if diff > 0
-        if diff <= size
-          shift(diff)
-        else
-          diff -= size
-          clear
-          val.shift(diff)
-        end
-      end
-    end
-    super(*(val.map{ |v|
-      Reline::Unicode.safe_encode(v, Reline.encoding_system_needs)
-    }))
-  end
-
-  def <<(val)
-    # If history_size is zero, all histories are dropped.
-    return self if @config.history_size.zero?
-    # If history_size is negative, history size is unlimited.
-    if @config.history_size.positive?
-      shift if size + 1 > @config.history_size
-    end
-    super(Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
-  end
-
-  private def check_index(index)
-    index += size if index < 0
-    if index < -2147483648 or 2147483647 < index
-      raise RangeError.new("integer #{index} too big to convert to 'int'")
-    end
-    # If history_size is negative, history size is unlimited.
-    if @config.history_size.positive?
-      if index < -@config.history_size or @config.history_size < index
-        raise RangeError.new("index=<#{index}>")
-      end
-    end
-    raise IndexError.new("index=<#{index}>") if index < 0 or size <= index
-    index
-  end
-end