Combine MAPPINGS(single byte input to symbol) with key_bindings(escape sequence to symbol)

Author: tompng

lib/reline.rb

@@ -18,10 +18,12 @@ module Reline
 
   class ConfigEncodingConversionError < StandardError; end
 
-  Key = Struct.new(:char, :combined_char, :with_meta) do
+  # EOF key: { char: nil, method_symbol: nil }
+  # Other key: { char: String, method_symbol: Symbol }
+  Key = Struct.new(:char, :method_symbol, :unused_boolean) do
     # For dialog_proc `key.match?(dialog.name)`
     def match?(sym)
-      combined_char.is_a?(Symbol) && combined_char == sym
+      method_symbol && method_symbol == sym
     end
   end
   CursorPos = Struct.new(:x, :y)
@@ -341,7 +343,7 @@ def readline(prompt = '', add_hist = false)
           read_io(config.keyseq_timeout) { |inputs|
             line_editor.set_pasting_state(io_gate.in_pasting?)
             inputs.each do |key|
-              if key.char == :bracketed_paste_start
+              if key.method_symbol == :bracketed_paste_start
                 text = io_gate.read_bracketed_paste
                 line_editor.insert_pasted_text(text)
                 line_editor.scroll_into_view

lib/reline/key_actor/base.rb

@@ -1,12 +1,18 @@
 class Reline::KeyActor::Base
-  def initialize(mapping = [])
-    @mapping = mapping
+  def initialize(mappings = nil)
     @matching_bytes = {}
     @key_bindings = {}
+    add_mappings(mappings) if mappings
   end
 
-  def get_method(key)
-    @mapping[key]
+  def add_mappings(mappings)
+    add([27], :ed_ignore)
+    128.times do |key|
+      func = mappings[key]
+      meta_func = mappings[key | 0b10000000]
+      add([key], func) unless func == :ed_unassigned
+      add([27, key], meta_func) unless meta_func == :ed_unassigned
+    end
   end
 
   def add(key, func)

lib/reline/key_stroke.rb

@@ -20,11 +20,6 @@ def initialize(config, encoding)
   def match_status(input)
     matching = key_mapping.matching?(input)
     matched = key_mapping.get(input)
-
-    # FIXME: Workaround for single byte. remove this after MAPPING is merged into KeyActor.
-    matched ||= input.size == 1 && input[0] < 0x80
-    matching ||= input == [ESC_BYTE]
-
     if matching && matched
       MATCHING_MATCHED
     elsif matching
@@ -55,16 +50,14 @@ def expand(input)
     return [[], []] unless matched_bytes
 
     func = key_mapping.get(matched_bytes)
+    s = matched_bytes.pack('c*').force_encoding(@encoding)
     if func.is_a?(Array)
-      keys = func.map { |c| Reline::Key.new(c, c, false) }
+      keys = func.map { |c| Reline::Key.new(c.chr(@encoding), :ed_insert, false) }
     elsif func
-      keys = [Reline::Key.new(func, func, false)]
-    elsif matched_bytes.size == 2 && matched_bytes[0] == ESC_BYTE
-      keys = [Reline::Key.new(matched_bytes[1], matched_bytes[1] | 0b10000000, true)]
+      keys = [Reline::Key.new(s, func, false)]
     else
-      s = matched_bytes.pack('c*').force_encoding(@encoding)
       if s.valid_encoding? && s.size == 1
-        keys = [Reline::Key.new(s.ord, s.ord, false)]
+        keys = [Reline::Key.new(s, :ed_insert, false)]
       else
         keys = []
       end