rubyterm 0.1.0

data/lib/escapeparser.rb

@@ -0,0 +1,71 @@
+# See:
+# https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Controls-beginning-with-ESC
+#
+class EscapeParser
+  attr_reader :str, :state
+
+  def initialize
+    @state = :start
+    @str = ""
+  end
+
+  def put(ch)
+    # ch is a codepoint, which for OSC/DCS string payloads (e.g. a window
+    # title) can be a multibyte UTF-8 character - decode it as UTF-8.
+    # Bare Integer#chr only handles 0..255 and raises RangeError on
+    # anything larger (e.g. a spinner glyph in claude's title sequence).
+    c = ch.chr(Encoding::UTF_8)
+    case @state
+    when :start
+      return false if ch < 32
+      @str << c
+      case c
+      when '['
+        @state = :csi
+      when ']'
+        @state = :oc
+      when 'P', 'X', '^', '_'
+        # DCS, SOS, PM, APC - string sequences terminated by ST (ESC \) or BEL
+        @state = :string
+      when /\w|[=>|}~6-9]/
+        @state = :complete
+      end
+    when :csi
+      # A C0 control byte inside a CSI is executed immediately and the
+      # sequence keeps parsing (per ECMA-48) - it must NOT be folded into
+      # the sequence or terminate it. Returning false routes it to Term's
+      # handle_control while @esc stays in :csi; ESC (27) restarts the
+      # sequence there. (vttest "cursor-control chars inside ESC sequences".)
+      return false if ch < 32
+      @str << c
+      @state = :complete if /[[:alpha:]]|[@]/.match(c)
+    when :oc
+      if ch == 7 then @state = :complete
+      elsif ch < 32 then return false
+      else @str << c
+      end
+    when :string
+      if ch == 7
+        @state = :complete
+      elsif ch == 27
+        @state = :string_esc
+      elsif ch < 32
+        return false
+      else
+        @str << c
+      end
+    when :string_esc
+      if c == '\\'
+        @state = :complete
+      else
+        @str << 27.chr << c
+        @state = :string
+      end
+    else
+      return false
+    end
+    true
+  end
+
+  def complete?; @state == :complete; end
+end

data/lib/keymap.rb

@@ -0,0 +1,112 @@
+
+
+$kmap = nil
+def update_keymap(dpy)
+  reply = dpy.get_keyboard_mapping
+
+
+  if reply
+    $kmap = reply.keysyms.map do |c|
+      if c == 0
+        nil
+      elsif X11::KeySyms[c]
+        X11::KeySyms[c]
+      elsif c < 0x100
+        c.chr(Encoding::ISO_8859_1)
+      elsif c.between?(0xffb0, 0xffb9)
+        "KP_#{c-0xffb0}".to_sym
+      elsif c.between?(0xffbe, 0xffe0)
+        "f#{c-0xffbe+1}".to_sym
+      elsif c.between?(0xff08, 0xffff)
+        # FIXME:
+        raise "keyboard_#{c.to_s(16)}".to_s
+      elsif c.between?(0x01000100, 0x0110FFFF)
+        (c-0x01000100).
+        chr(Encoding::UTF_32) rescue c.to_s(16)
+      else
+        STDERR.puts "keymap: unknown_#{c.to_s(16)}"
+      end
+    end.each_slice(reply.keysyms_per_keycode).to_a
+    #ks = ks.map {|s| s.compact.sort_by{|x| x.to_s}.uniq }.to_a # This is for testing/ease of reading only
+  end
+end
+
+def lookup_keysym(dpy,  event)
+  update_keymap(dpy) if !$kmap
+  $kmap[event.detail-dpy.display_info.min_keycode] rescue nil
+end
+
+SPECIALS = {
+  "+" => :"ctrl_+",
+  "-" => :"ctrl_-"
+}
+
+def lookup_string(dpy, event)
+  ks = Array(lookup_keysym(dpy, event))
+  str = ""
+  shift = event.state.anybits?(0x01)
+  meta  = event.state.anybits?(0x08)
+  ctrl  = event.state.anybits?(0x04)
+  i = shift && ks[1] ? 1 : 0
+
+  return SPECIALS[ks[i]] if ctrl && SPECIALS[ks[i]]
+
+  if shift
+    case ks[i]
+      # FIXME: This is messed up.
+    when :XK_ISO_Left_Tab then return :shift_tab, nil
+    when :XK_Down; then return :shift_down, nil
+    when :XK_Up; then return :shift_up, nil
+    when :XK_Page_Up; then return :shift_page_up, nil
+    when :XK_Page_Down; then return :shift_page_down, nil
+    end
+  end
+  
+  if ks[i].is_a?(String)
+    if ctrl
+      str = (ks[i][0].ord & 0x9f).chr # Strip 0x60
+    elsif meta
+      str = "\e#{ks[i]}"
+    else
+      str = ks[i]
+    end
+  end
+  return ks[i], str
+end
+
+
+
+# Map X key events to escapes
+KEYMAP = {
+  :enter => "\r",
+  :backspace => "\x7F",
+  :tab => "\t",
+  :XK_Escape => "\e",
+  :f1 => "\e[11~",
+  :f2 => "\e[12~",
+  :f3 => "\e[13~",
+  :f4 => "\e[14~",
+  :f5 => "\e[15~",
+  :f6 => "\e[16~",
+  :f7 => "\e[17~",
+  :f8 => "\e[18~",
+  :f9 => "\e[19~",
+  :f10 => "\e[20~",
+  :f11 => "\e[21~",
+  :f12 => "\e[22~",
+  :shift_up => "\e[1;2A",
+  :shift_down => "\e[1;2B",
+  :shift_tab => "\e[Z",
+  :XK_Left => "\e[D",
+  :XK_Right => "\e[C",
+  :XK_Down => "\e[B",
+  :XK_ISO_Left_Tab => "\t",
+  :XK_Up => "\e[A",
+  :XK_Delete => "\e[P",
+  :XK_Page_Up => "\x1b[5~",
+  :XK_Page_Down => "\x1b[6~",
+}
+
+def keysym_to_vt102(ks)
+  KEYMAP[ks]
+end

data/lib/palette.rb

@@ -0,0 +1,14 @@
+PALETTE_BASIC = [
+  0x000000, 0xd73737, 0x60ac39, 0xae9513, 0x6684e1, 0xb854d4, 0x1fad83, 0xcccccc,
+  0x7d7a68, 0xff3737, 0x80dc39, 0xfff013, 0x6694ff, 0xd854ff, 0x1fdda3, 0xffffff]
+
+PALETTE256= PALETTE_BASIC +
+  [0,0x5f, 0x87, 0xaf, 0xd7, 0xff].repeated_permutation(3).sort.map{|ary| (ary[0]<<16)+(ary[1]<<8)+ary[2]}+
+  (8..244).step(10).map{|n| (n<<16)+(n<<8)+n}
+
+# Default foreground/background, stored as basic-palette indices (strings;
+# Term resolves them to colours). Defined here so the library is
+# self-contained; guarded so callers that pre-define them (tests, harness)
+# don't clash.
+FG = "7" unless defined?(FG)
+BG = "0" unless defined?(BG)