Gecko [ dallasfobana2023.variationbd.com ]

Name	Size	Permission
key_actor	[ DIR ]	drwxr-xr-x
unicode	[ DIR ]	drwxr-xr-x
ansi.rb	9.51 KB	-rw-r--r--
config.rb	9.96 KB	-rw-r--r--
face.rb	4.79 KB	-rw-r--r--
general_io.rb	1.58 KB	-rw-r--r--
history.rb	1.87 KB	-rw-r--r--
key_actor.rb	169 B	-rw-r--r--
key_stroke.rb	3.8 KB	-rw-r--r--
kill_ring.rb	2.37 KB	-rw-r--r--
line_editor.rb	81.1 KB	-rw-r--r--
terminfo.rb	4.34 KB	-rw-r--r--
unicode.rb	21.7 KB	-rw-r--r--
version.rb	38 B	-rw-r--r--
windows.rb	16.57 KB	-rw-r--r--

Code Editor : key_stroke.rb

class Reline::KeyStroke
  ESC_BYTE = 27
  CSI_PARAMETER_BYTES_RANGE = 0x30..0x3f
  CSI_INTERMEDIATE_BYTES_RANGE = (0x20..0x2f)

def initialize(config)
    @config = config
  end

def compress_meta_key(ary)
    return ary unless @config.convert_meta
    ary.inject([]) { |result, key|
      if result.size > 0 and result.last == "\e".ord
        result[result.size - 1] = Reline::Key.new(key, key | 0b10000000, true)
      else
        result << key
      end
      result
    }
  end

def start_with?(me, other)
    compressed_me = compress_meta_key(me)
    compressed_other = compress_meta_key(other)
    i = 0
    loop do
      my_c = compressed_me[i]
      other_c = compressed_other[i]
      other_is_last = (i + 1) == compressed_other.size
      me_is_last = (i + 1) == compressed_me.size
      if my_c != other_c
        if other_c == "\e".ord and other_is_last and my_c.is_a?(Reline::Key) and my_c.with_meta
          return true
        else
          return false
        end
      elsif other_is_last
        return true
      elsif me_is_last
        return false
      end
      i += 1
    end
  end

def equal?(me, other)
    case me
    when Array
      compressed_me = compress_meta_key(me)
      compressed_other = compress_meta_key(other)
      compressed_me.size == compressed_other.size and [compressed_me, compressed_other].transpose.all?{ |i| equal?(i[0], i[1]) }
    when Integer
      if other.is_a?(Reline::Key)
        if other.combined_char == "\e".ord
          false
        else
          other.combined_char == me
        end
      else
        me == other
      end
    when Reline::Key
      if other.is_a?(Integer)
        me.combined_char == other
      else
        me == other
      end
    end
  end

def match_status(input)
    key_mapping.keys.select { |lhs|
      start_with?(lhs, input)
    }.tap { |it|
      return :matched  if it.size == 1 && equal?(it[0], input)
      return :matching if it.size == 1 && !equal?(it[0], input)
      return :matched  if it.max_by(&:size)&.size&.< input.size
      return :matching if it.size > 1
    }
    if key_mapping.keys.any? { |lhs| start_with?(input, lhs) }
      :matched
    else
      match_unknown_escape_sequence(input).first
    end
  end

def expand(input)
    lhs = key_mapping.keys.select { |item| start_with?(input, item) }.sort_by(&:size).last
    unless lhs
      status, size = match_unknown_escape_sequence(input)
      case status
      when :matched
        return [:ed_unassigned] + expand(input.drop(size))
      when :matching
        return [:ed_unassigned]
      else
        return input
      end
    end
    rhs = key_mapping[lhs]

case rhs
    when String
      rhs_bytes = rhs.bytes
      expand(expand(rhs_bytes) + expand(input.drop(lhs.size)))
    when Symbol
      [rhs] + expand(input.drop(lhs.size))
    when Array
      rhs
    end
  end

private

# returns match status of CSI/SS3 sequence and matched length
  def match_unknown_escape_sequence(input)
    idx = 0
    return [:unmatched, nil] unless input[idx] == ESC_BYTE
    idx += 1
    idx += 1 if input[idx] == ESC_BYTE

case input[idx]
    when nil
      return [:matching, nil]
    when 91 # == '['.ord
      # CSI sequence
      idx += 1
      idx += 1 while idx < input.size && CSI_PARAMETER_BYTES_RANGE.cover?(input[idx])
      idx += 1 while idx < input.size && CSI_INTERMEDIATE_BYTES_RANGE.cover?(input[idx])
      input[idx] ? [:matched, idx + 1] : [:matching, nil]
    when 79 # == 'O'.ord
      # SS3 sequence
      input[idx + 1] ? [:matched, idx + 2] : [:matching, nil]
    else
      if idx == 1
        # `ESC char`, make it :unmatched so that it will be handled correctly in `read_2nd_character_of_key_sequence`
        [:unmatched, nil]
      else
        # `ESC ESC char`
        [:matched, idx + 1]
      end
    end
  end

def key_mapping
    @config.key_bindings
  end
end

${this.title}

Code Editor : key_stroke.rb