vimamsa 0.1.22 → 0.1.24

data/modules/calculator/calculator.rb

@@ -0,0 +1,318 @@
+# Scientific calculator widget embeddable inline in a text buffer.
+#
+# Enable this module in Preferences → Modules → "Scientific Calculator".
+#
+# Usage (once enabled):
+#   :insert_calculator action  — inserts the widget at the cursor position
+#
+# The widget occupies a single U+FFFC (object replacement) character in the
+# Ruby buffer, keeping GTK/Ruby buffer offsets aligned.
+# Press ↩ inside the calculator to insert the current result after the widget.
+
+class VmaCalculator < Gtk::Box
+  BUTTON_LAYOUT = [
+    #  label   row  col  w    h
+    ["sin",    0,   0,   1,   1],
+    ["cos",    0,   1,   1,   1],
+    ["tan",    0,   2,   1,   1],
+    ["log",    0,   3,   1,   1],
+    ["ln",     0,   4,   1,   1],
+    ["√x",     1,   0,   1,   1],
+    ["x²",     1,   1,   1,   1],
+    ["xʸ",     1,   2,   1,   1],
+    ["π",      1,   3,   1,   1],
+    ["e",      1,   4,   1,   1],
+    ["C",      2,   0,   1,   1],
+    ["±",      2,   1,   1,   1],
+    ["%",      2,   2,   1,   1],
+    ["⌫",      2,   3,   1,   1],
+    ["↩",      2,   4,   1,   1],
+    ["7",      3,   0,   1,   1],
+    ["8",      3,   1,   1,   1],
+    ["9",      3,   2,   1,   1],
+    ["÷",      3,   3,   1,   1],
+    ["(",      3,   4,   1,   1],
+    ["4",      4,   0,   1,   1],
+    ["5",      4,   1,   1,   1],
+    ["6",      4,   2,   1,   1],
+    ["×",      4,   3,   1,   1],
+    [")",      4,   4,   1,   1],
+    ["1",      5,   0,   1,   1],
+    ["2",      5,   1,   1,   1],
+    ["3",      5,   2,   1,   1],
+    ["-",      5,   3,   1,   1],
+    ["=",      5,   4,   2,   1],
+    ["0",      6,   0,   2,   1],
+    [".",      6,   2,   1,   1],
+    ["+",      6,   3,   1,   1],
+  ].freeze
+
+  def initialize(anchor_pos, bufo)
+    super(:vertical, 2)
+    @anchor_pos = anchor_pos
+    @bufo = bufo
+    @expression = ""
+    @last_result = nil
+    @variables = {}  # name => value, updated on every assignment
+    # Persistent binding for eval so that assigned variables (e.g. x = 5)
+    # survive between calculations. Scoped to self so deg2rad and Math are accessible.
+    @eval_binding = instance_eval { binding }
+
+    self.margin_top    = 4
+    self.margin_bottom = 4
+    self.margin_start  = 4
+    self.margin_end    = 4
+
+    setup_ui
+  end
+
+  private
+
+  def setup_ui
+    @expr_label = Gtk::Label.new("")
+    @expr_label.xalign = 1.0
+    @expr_label.add_css_class("dim-label")
+    append(@expr_label)
+
+    @display = Gtk::Entry.new
+    @display.editable = true
+    @display.xalign = 1.0
+    @display.text = "0"
+    @display.add_css_class("monospace")
+    @display.width_chars = 20
+    append(@display)
+
+    # Variable assignment row: [→ var  [__name__]  [Assign]]
+    var_row = Gtk::Box.new(:horizontal, 4)
+    var_row.margin_top = 4
+
+    var_arrow = Gtk::Label.new("→ var")
+    var_arrow.add_css_class("dim-label")
+
+    @var_name_entry = Gtk::Entry.new
+    @var_name_entry.placeholder_text = "name"
+    @var_name_entry.width_chars = 8
+    @var_name_entry.hexpand = true
+    track_entry_focus(@var_name_entry)
+    track_entry_focus(@display)
+
+    assign_btn = Gtk::Button.new(label: "Assign")
+    assign_btn.signal_connect("clicked") { assign_variable }
+
+    var_row.append(var_arrow)
+    var_row.append(@var_name_entry)
+    var_row.append(assign_btn)
+    append(var_row)
+
+    # Flow of variable buttons; clicking one appends the name to the expression.
+    @var_buttons_box = Gtk::FlowBox.new
+    @var_buttons_box.selection_mode = :none
+    @var_buttons_box.column_spacing = 2
+    @var_buttons_box.row_spacing = 2
+    @var_buttons_box.margin_top = 2
+    @var_buttons_box.homogeneous = false
+    append(@var_buttons_box)
+
+    grid = Gtk::Grid.new
+    grid.row_spacing    = 2
+    grid.column_spacing = 2
+    grid.margin_top     = 4
+    append(grid)
+
+    BUTTON_LAYOUT.each do |label, row, col, w, h|
+      btn = Gtk::Button.new(label: label)
+      btn.width_request  = 42
+      btn.height_request = 36
+      btn.signal_connect("clicked") { on_button(label) }
+      btn.add_css_class("suggested-action")   if %w[= ↩].include?(label)
+      btn.add_css_class("destructive-action") if %w[C ⌫].include?(label)
+      grid.attach(btn, col, row, w, h)
+    end
+  end
+
+  def on_button(label)
+    case label
+    when "C"
+      @expression = ""
+      show_display("0")
+    when "⌫"
+      @expression = @expression[0..-2] || ""
+      show_display(@expression.empty? ? "0" : @expression)
+    when "="       then evaluate
+    when "↩"       then insert_result
+    when "sin"     then apply_unary("Math.sin(deg2rad(%s))")
+    when "cos"     then apply_unary("Math.cos(deg2rad(%s))")
+    when "tan"     then apply_unary("Math.tan(deg2rad(%s))")
+    when "log"     then apply_unary("Math.log10(%s)")
+    when "ln"      then apply_unary("Math.log(%s)")
+    when "√x"      then apply_unary("Math.sqrt(%s)")
+    when "x²"
+      @expression = "(#{@expression})**2"
+      evaluate
+    when "xʸ"
+      @expression += "**"
+      show_display(@expression)
+    when "π"
+      @expression += Math::PI.to_s
+      show_display(@expression)
+    when "e"
+      @expression += Math::E.to_s
+      show_display(@expression)
+    when "±"
+      @expression = @expression.start_with?("-") ? @expression[1..] : "-#{@expression}"
+      show_display(@expression.empty? ? "0" : @expression)
+    when "%"
+      @expression = "(#{@expression})/100.0"
+      evaluate
+    when "÷"
+      @expression += "/"
+      show_display(@expression)
+    when "×"
+      @expression += "*"
+      show_display(@expression)
+    else
+      @expression += label
+      show_display(@expression)
+    end
+  end
+
+  def apply_unary(template)
+    @expression = template % "(#{@expression}).to_f"
+    evaluate
+  end
+
+  def evaluate
+    # Pick up any text the user typed directly into the display field.
+    @expression = @display.text
+    expr = @expression
+    # Coerce bare integer literals to floats so that expressions like (1/6)**3
+    # use floating-point division instead of integer division.
+    # Lookbehind (?<![.\d]) and lookahead (?![.\d]) ensure digits that are
+    # already part of a float literal (e.g. the 53 in 1.53) are left alone.
+    eval_expr = expr.gsub(/(?<![.\d])(\d+)(?![.\d])/, '\1.0')
+    result = eval(eval_expr, @eval_binding)
+    @last_result = result.is_a?(Numeric) ? result.to_f : nil
+    formatted = result.is_a?(Float) && result == result.floor && result.abs < 1e15 ?
+      result.to_i.to_s : result.round(5).to_s
+    @expr_label.text = expr
+    @expression = formatted
+    show_display(formatted)
+    append_trail("#{expr} = #{formatted}")
+    # If the expression was a typed assignment (e.g. "x = 5"), record the variable.
+    if (m = expr.match(/\A\s*([a-zA-Z_]\w*)\s*=(?!=)/)) && @last_result
+      record_variable(m[1], @last_result)
+    end
+  rescue => e
+    @expr_label.text = @expression
+    show_display("Error")
+    @expression = ""
+  end
+
+  # Assign the current display value to the variable name typed in @var_name_entry.
+  # Attach a focus controller to an entry so the vimamsa key handler steps
+  # aside while the entry is active and resumes when it loses focus.
+  def track_entry_focus(entry)
+    fc = Gtk::EventControllerFocus.new
+    entry.add_controller(fc)
+    fc.signal_connect("enter") { vma.gui.notify_entry_focus(true) }
+    fc.signal_connect("leave") { vma.gui.notify_entry_focus(false) }
+  end
+
+  def assign_variable
+    name = @var_name_entry.text.strip
+    return if name.empty? || @last_result.nil?
+    return unless name.match?(/\A[a-zA-Z_]\w*\z/)  # must be a valid Ruby identifier
+    eval("#{name} = #{@last_result}", @eval_binding)
+    record_variable(name, @last_result)
+    append_trail("#{name} = #{@last_result}")
+    @expr_label.text = "#{name} assigned"
+  rescue => e
+    @expr_label.text = "Error"
+  end
+
+  # Store a variable name/value and refresh the variable list widget.
+  def record_variable(name, value)
+    @variables[name] = value
+    rebuild_var_list
+  end
+
+  # Rebuild variable buttons from @variables — one compact button per name.
+  def rebuild_var_list
+    while (child = @var_buttons_box.first_child)
+      @var_buttons_box.remove(child)
+    end
+    @variables.each_key do |name|
+      btn = Gtk::Button.new(label: name)
+      btn.signal_connect("clicked") do
+        @expression += name
+        show_display(@expression)
+      end
+      @var_buttons_box.append(btn)
+    end
+  end
+
+  # Insert one calculation line into the buffer just above the widget.
+  # Each insertion shifts the widget down, so @anchor_pos is updated to follow it.
+  def append_trail(text)
+    line = "#{text}\n"
+    @bufo.insert_txt_at(line, @anchor_pos)
+    @anchor_pos += line.length
+    # Flush Ruby buffer deltas to the GTK view so the text appears immediately.
+    @bufo.view.handle_deltas
+  end
+
+  def show_display(text)
+    @display.text = text
+  end
+
+  # Insert the current result into the buffer immediately after the widget.
+  def insert_result
+    return if @last_result.nil?
+    result_str = (@last_result == @last_result.floor && @last_result.abs < 1e15) ?
+      @last_result.to_i.to_s : @last_result.to_s
+    @bufo.insert_txt_at(result_str, @anchor_pos + 1)
+  end
+
+  def deg2rad(deg)
+    deg * Math::PI / 180.0
+  end
+end
+
+# Insert a VmaCalculator widget at the current cursor position.
+# U+FFFC is inserted in the Ruby buffer as a placeholder so that
+# Ruby and GTK buffer offsets stay aligned (both have exactly one
+# character at the anchor position).
+def insert_calculator_in_buffer
+  view = vma.gui.view
+  bufo = vma.buf
+  return if view.nil? || bufo.nil?
+
+  pos = bufo.pos
+
+  # Step 1: insert the placeholder in the Ruby buffer and flush it to GTK.
+  bufo.insert_txt_at("\uFFFC", pos)
+  view.handle_deltas
+
+  # Step 2: the GTK buffer now has a plain U+FFFC at pos.
+  # Replace it with a real child anchor, then attach the widget.
+  iter = view.buffer.get_iter_at(:offset => pos)
+  if iter && iter.char == "\uFFFC"
+    iter2 = view.buffer.get_iter_at(:offset => pos + 1)
+    view.buffer.delete(iter, iter2)
+    iter = view.buffer.get_iter_at(:offset => pos)
+    anchor = view.buffer.create_child_anchor(iter)
+    calc = VmaCalculator.new(pos, bufo)
+    view.add_child_at_anchor(calc, anchor)
+    calc.show
+  end
+end
+
+def calculator_init
+  reg_act(:insert_calculator, proc { insert_calculator_in_buffer }, "Insert scientific calculator widget at cursor")
+  vma.gui.menu.add_module_action(:insert_calculator, "Insert Calculator")
+end
+
+def calculator_disable
+  unreg_act(:insert_calculator)
+  vma.gui.menu.remove_module_action(:insert_calculator)
+end

data/modules/calculator/calculator_info.rb

@@ -0,0 +1,3 @@
+def calculator_info
+  { name: "Scientific Calculator", no_restart: true }
+end

data/modules/terminal/terminal.rb

@@ -0,0 +1,140 @@
+class VmaTerminal < Gtk::Box
+  def initialize(anchor_pos, bufo)
+    super(:vertical, 0)
+    @anchor_pos = anchor_pos
+    @bufo = bufo
+
+    @term = Vte::Terminal.new
+    @term.hexpand = true
+    @term.vexpand = true
+    @term.set_size_request(800, 400)
+    @term.focusable = true
+
+    @term.signal_connect("realize") do
+      view_width = @bufo.view.allocated_width
+      w = view_width > 50 ? view_width - 50 : view_width
+      @term.set_size_request(w, 400)
+    end
+
+    click = Gtk::GestureClick.new
+    click.signal_connect("pressed") do
+      vma.gui.instance_variable_set(:@kbd_passthrough, true)
+      @term.grab_focus
+    end
+    @term.add_controller(click)
+
+    append(@term)
+
+    bar = Gtk::Box.new(:horizontal, 4)
+    bar.margin_start = 4
+    btn = Gtk::Button.new(label: "Copy to buffer")
+    btn.signal_connect("clicked") { copy_to_buffer }
+    bar.append(btn)
+    append(bar)
+
+    spawn_shell
+  end
+
+  private
+
+  def spawn_shell
+    # @term.spawn_async(
+      # Vte::PtyFlags::DEFAULT,
+      # nil,
+      # [ENV["SHELL"] || "/bin/bash"],
+      # GLib::Spawn::DEFAULT,
+      # # -1
+    # )
+    
+        # @term.spawn_async(
+      # Vte::PtyFlags::DEFAULT,
+      # # [ENV["SHELL"] || "/bin/bash"],
+      # "/bin/bash",
+      # [],
+      # [],
+      @term.spawn
+         # @term.spawn_async(
+      # "/home/sjs/",
+      # [],
+      # [],
+      # GLib::Spawn::DEFAULT,
+      # )
+      # [ENV["SHELL"] || "/bin/bash"],
+      # "/bin/bash",
+     
+      
+      # g_spawn_async (
+  # const gchar* working_directory,
+  # gchar** argv,
+  # gchar** envp,
+  # GSpawnFlags flags,
+  # GSpawnChildSetupFunc child_setup,
+  # gpointer user_data,
+  # GPid* child_pid,
+  # GError** error
+# )
+
+      # GLib::Spawn::DEFAULT,
+      # -1
+    # )
+
+  end
+
+  def copy_to_buffer
+    cols = @term.column_count
+    adj = @term.vadjustment
+    visible_rows = adj.page_size.to_i
+    first_row = adj.upper.to_i - visible_rows
+    last_row = adj.upper.to_i
+    text = @term.get_text_range_format(:text, first_row, 0, last_row, cols - 1)
+                .first
+                .gsub(/\s+$/, "")
+                .rstrip
+    return if text.empty?
+
+    insert_pos = @anchor_pos + 1
+    @bufo.insert_txt_at("\n" + text + "\n", insert_pos)
+    @bufo.view.handle_deltas
+  end
+end
+
+def insert_terminal_in_buffer
+  view = vma.gui.view
+  bufo = vma.buf
+  return if view.nil? || bufo.nil?
+
+  pos = bufo.pos
+
+  bufo.insert_txt_at("\uFFFC", pos)
+  view.handle_deltas
+
+  iter = view.buffer.get_iter_at(:offset => pos)
+  if iter && iter.char == "\uFFFC"
+    iter2 = view.buffer.get_iter_at(:offset => pos + 1)
+    view.buffer.delete(iter, iter2)
+    iter = view.buffer.get_iter_at(:offset => pos)
+    anchor = view.buffer.create_child_anchor(iter)
+    widget = VmaTerminal.new(pos, bufo)
+
+    char_w = view.pango_context.get_metrics(nil, nil).approximate_char_width / Pango::SCALE
+    columns = char_w > 0 ? (view.allocated_width / char_w) - 4 : 80
+    # require "pry";binding.pry
+    # widget.instance_variable_get(:@term).set_columns(columns)
+    widget.instance_variable_get(:@term).set_size(columns,20)
+
+    view.add_child_at_anchor(widget, anchor)
+    widget.show
+  end
+end
+
+def terminal_init
+  require "vte4"
+  reg_act(:insert_terminal, proc { insert_terminal_in_buffer }, "Insert embedded terminal at cursor")
+  add_keys "terminal", { "C , t" => :insert_terminal }
+  vma.gui.menu.add_module_action(:insert_terminal, "Insert Terminal")
+end
+
+def terminal_disable
+  unreg_act(:insert_terminal)
+  vma.gui.menu.remove_module_action(:insert_terminal)
+end

data/modules/terminal/terminal_info.rb

@@ -0,0 +1,3 @@
+def terminal_info
+  { name: "Embedded Terminal (VTE)", no_restart: true }
+end

data/run_tests.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+$stdout.sync = true
+$stderr.sync = true
+# run_tests.rb — Discover and run all vimamsa tests, write a report.
+#
+# Usage:
+#   ruby run_tests.rb [REPORT_FILE]    default report: test_report.txt
+#
+# For headless / CI use:
+#   xvfb-run ruby run_tests.rb
+
+require "open3"
+
+SCRIPT_DIR = File.expand_path("..", __FILE__)
+REPORT     = File.expand_path(ARGV.first || "test_report.txt", SCRIPT_DIR)
+
+# ── Discover test files ───────────────────────────────────────────────────────
+test_files = Dir.glob(File.join(SCRIPT_DIR, "tests", "test_*.rb")).sort
+
+if test_files.empty?
+  warn "ERROR: No test files found in tests/"
+  exit 1
+end
+
+# ── Guard: need a display ─────────────────────────────────────────────────────
+unless ENV["DISPLAY"] || ENV["WAYLAND_DISPLAY"]
+  xvfb = `which xvfb-run 2>/dev/null`.strip
+  if xvfb.empty?
+    warn "ERROR: No display found (DISPLAY/WAYLAND_DISPLAY unset) and xvfb-run not available."
+    warn "       Install xvfb or run from a desktop session."
+    exit 1
+  end
+  puts "No display detected — re-running under xvfb-run."
+  exec("xvfb-run", "-a", RbConfig.ruby, __FILE__, *ARGV)
+end
+
+# ── Print header ──────────────────────────────────────────────────────────────
+puts "=== Vimamsa test runner ==="
+puts "Running #{test_files.size} test file(s):"
+test_files.each { |f| puts "  #{File.basename(f)}" }
+puts ""
+
+# ── Run tests ─────────────────────────────────────────────────────────────────
+# All files loaded in a single vimamsa session (one GTK startup).
+# stdout  → streamed live and captured for the report
+# stderr  → suppressed (GTK/GLib noise)
+cmd = [RbConfig.ruby, "exe/run_tests.rb", "--test", *test_files]
+raw = ""
+IO.popen([*cmd, err: File::NULL], chdir: SCRIPT_DIR) do |io|
+  io.each_line do |line|
+    print line
+    raw << line
+  end
+end
+puts ""
+
+# ── Parse summary ─────────────────────────────────────────────────────────────
+summary_line = raw.lines.grep(/^Results:/).last.to_s
+passed = summary_line[/(\d+) passed/, 1].to_i
+failed = summary_line[/(\d+) failed/, 1].to_i
+errors = raw.lines.count { |l| l.match?(/^\s+ERROR\s/) }
+
+timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+
+# ── Write report ──────────────────────────────────────────────────────────────
+File.open(REPORT, "w") do |f|
+  f.puts "Vimamsa Test Report — #{timestamp}"
+  f.puts "=" * 52
+  f.puts ""
+  f.puts "Test files (#{test_files.size}):"
+  test_files.each { |tf| f.puts "  #{File.basename(tf)}" }
+  f.puts ""
+  f.puts "-" * 52
+  f.puts raw
+  f.puts "-" * 52
+  f.puts ""
+  f.puts "Summary"
+  f.puts "-" * 52
+  f.puts "  Passed : #{passed}"
+  f.puts "  Failed : #{failed}"
+  f.puts "  Errors : #{errors}"
+  f.puts "\n  ALL TESTS PASSED" if failed + errors == 0
+  f.puts ""
+end
+
+puts "Report written to: #{REPORT}"
+puts "  Passed: #{passed}  Failed: #{failed}  Errors: #{errors}"
+
+exit(failed + errors == 0 ? 0 : 1)

data/styles/dark.xml

@@ -128,7 +128,7 @@
   
   <style name="def:title"                scale="2.0" bold="true" />
   <style name="def:hyperlink"                foreground="lightblue" bold="true" />
-  <style name="def:heading0"                scale="5.0" bold="true" foreground="heading" />
+  <style name="def:heading0"                scale="2.0" bold="true" foreground="heading" />
   <style name="def:heading1"                scale="1.75" bold="true" foreground="heading" />
   <style name="def:heading2"                scale="1.5" bold="true" foreground="heading" />
   <style name="def:heading3"                scale="1.25" bold="true" foreground="heading" />

data/styles/molokai_edit.xml

@@ -31,7 +31,7 @@
     <style foreground="#66D9EF" name="def:type"/>
     <!--style background="#272822" foreground="#F8F8F2" name="text"/-->
     <style background="#000000" foreground="#F8F8F2" name="text"/>
-    <style foreground="#75715E" name="def:comment"/>
+    <style foreground="#b0b0b0" name="def:comment"/>
     <style background="#3E3D32" name="current-line"/>
     <style background="#222222" foreground="#F8F8F2" name="text"/>
     <!--style foreground="#465457" name="def:comment"/-->
@@ -40,7 +40,7 @@
 
   <style name="def:title"                scale="2.0" bold="true" />
   <style name="def:hyperlink"                foreground="lightblue" bold="true" />
-  <style name="def:heading0"                scale="5.0" bold="true" foreground="heading" />
+  <style name="def:heading0"                scale="2.0" bold="true" foreground="heading" />
   <style name="def:heading1"                scale="1.75" bold="true" foreground="heading" />
   <style name="def:heading2"                scale="1.5" bold="true" foreground="heading" />
   <style name="def:heading3"                scale="1.25" bold="true" foreground="heading" />

data/tests/key_bindings.rb

@@ -0,0 +1,2 @@
+require "lib/vimamsa/key_binding_tree.rb"
+require "minitest/autorun"

data/tests/test_basic_editing.rb

@@ -0,0 +1,86 @@
+class TestBasicEditing < VmaTest
+
+  def test_insert_text
+    act 'buf.insert_txt("hello")'
+    assert_buf "hello\n"
+  end
+
+  def test_delete_char_forward
+    act 'buf.insert_txt("abcde")'
+    act :jump_to_start_of_buffer
+    act :delete_char_forward
+    act :delete_char_forward
+    assert_buf "cde\n"
+  end
+
+  def test_delete_backward
+    act 'buf.insert_txt("abcde")'
+    act "buf.delete(BACKWARD_CHAR)"
+    act "buf.delete(BACKWARD_CHAR)"
+    assert_buf "abc\n"
+  end
+
+  def test_undo_redo
+    act 'buf.insert_txt("hello")'
+    assert_buf "hello\n"
+    act :undo
+    assert_buf "\n"
+    act :redo
+    assert_buf "hello\n"
+  end
+
+  def test_new_line
+    act 'buf.insert_txt("first")'
+    act 'buf.insert_txt("\n")'
+    act 'buf.insert_txt("second")'
+    assert_buf "first\nsecond\n"
+  end
+
+  def test_jump_start_end
+    act 'buf.insert_txt("hello")'
+    act :jump_to_start_of_buffer
+    assert_pos 0, 0
+    act :jump_to_end_of_buffer
+    assert_pos 0, 5
+  end
+
+  def test_copy_paste
+    #Note: Buffer contains a single "\n" by default
+    act 'buf.insert_txt("hello\n")'
+    act :jump_to_start_of_buffer
+    act :copy_cur_line
+    act :jump_to_end_of_buffer
+    act :paste_after_cursor
+    assert_buf "hello\n\nhello\n"
+  end
+
+  def test_delete_line
+    act 'buf.insert_txt("first\n")'
+    act 'buf.insert_txt("second")'
+    act :jump_to_start_of_buffer
+    act :delete_line
+    assert_buf "second\n"
+  end
+
+end
+
+class TestKeySequences < VmaTest
+
+  def test_insert_mode_via_keys
+    # 'i' enters insert mode in command mode
+    keys "i"
+    assert_mode :insert
+    keys "esc"
+    assert_mode :command
+  end
+
+  def test_type_and_escape
+    keys "i"
+    # Type individual characters
+    "hello".each_char { |c| keys c }
+    keys "esc"
+    assert_buf "hello\n"
+    assert_mode :command
+  end
+
+end