textbringer 0.1.8 → 0.1.9

data/lib/textbringer/commands/help.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    HELP_RING = Ring.new
+
+    def push_help_command(cmd)
+      if HELP_RING.empty? || HELP_RING.current != cmd
+        HELP_RING.push(cmd)
+      end
+    end
+    private :push_help_command
+
+    def show_help
+      help = Buffer.find_or_new("*Help*", undo_limit: 0)
+      help.read_only_edit do
+        help.clear
+        yield(help)
+        help.beginning_of_buffer
+        switch_to_buffer(help)
+        help_mode
+      end
+    end
+    private :show_help
+
+    define_command(:describe_bindings,
+                   doc: "Display the key bindings.") do
+      show_help do |help|
+        s = format("%-16s  %s\n", "Key", "Binding")
+        s << format("%-16s  %s\n", "---", "-------")
+        s << "\n"
+        bindings = {}
+        [
+          GLOBAL_MAP,
+          Buffer.current.keymap,
+          Controller.current.overriding_map
+        ].each do |map|
+          map&.each do |key_sequence, command|
+            bindings[key_sequence] = command
+          end
+        end
+        bindings.each do |key_sequence, command|
+          s << format("%-16s  [%s]\n",
+                      Keymap.key_sequence_string(key_sequence),
+                      command)
+        end
+        help.insert(s)
+      end
+      push_help_command([:describe_bindings])
+    end
+
+    def command_help(cmd)
+      s = format("%s:%d\n", *cmd.block.source_location)
+      s << "-" * (Window.columns - 2) + "\n"
+      s << "#{cmd.name}"
+      if !cmd.block.parameters.empty?
+        s << "("
+        s << cmd.block.parameters.map { |_, param| param }.join(", ")
+        s << ")"
+      end
+      s << "\n\n"
+      s << "-" * (Window.columns - 2) + "\n\n"
+      s << cmd.doc
+      s << "\n"
+      s
+    end
+
+    define_command(:describe_command,
+                   doc: "Display the documentation of the command.") do
+      |name = read_command_name("Describe command: ")|
+      cmd = Commands[name]
+      if cmd.nil?
+        raise EditorError, "No such command: #{name}"
+      end
+      show_help do |help|
+        help.insert(command_help(cmd))
+      end
+      push_help_command([:describe_command, name])
+    end
+
+    define_command(:describe_key,
+                   doc: <<~EOD) do
+        Display the documentation of the command invoked by key.
+      EOD
+      |key = read_key_sequence("Describe key: ")|
+      name = Buffer.current.keymap&.lookup(key) ||
+        GLOBAL_MAP.lookup(key)
+      cmd = Commands[name]
+      show_help do |help|
+        s = Keymap.key_sequence_string(key)
+        s << " runs the command #{name}, which is defined in\n"
+        s << command_help(cmd)
+        help.insert(s)
+      end
+      push_help_command([:describe_key, key])
+    end
+
+    define_command(:help_go_back, doc: "Go back to the previous help.") do
+      if !HELP_RING.empty?
+        HELP_RING.rotate(1)
+        cmd, *args = HELP_RING.current
+        send(cmd, *args)
+      end
+    end
+
+    define_command(:help_go_forward, doc: "Go back to the next help.") do
+      if !HELP_RING.empty?
+        HELP_RING.rotate(-1)
+        cmd, *args = HELP_RING.current
+        send(cmd, *args)
+      end
+    end
+  end
+end

data/lib/textbringer/commands/isearch.rb

@@ -18,7 +18,7 @@ module Textbringer
     ISEARCH_MODE_MAP.define_key(?\C-h, :isearch_delete_char)
     ISEARCH_MODE_MAP.define_key(?\C-s, :isearch_repeat_forward)
     ISEARCH_MODE_MAP.define_key(?\C-r, :isearch_repeat_backward)
-    ISEARCH_MODE_MAP.define_key(?\n, :isearch_exit)
+    ISEARCH_MODE_MAP.define_key(?\C-m, :isearch_exit)
     ISEARCH_MODE_MAP.define_key(?\C-g, :isearch_abort)
     
     ISEARCH_STATUS = {
@@ -30,11 +30,13 @@ module Textbringer
       recursive_edit: false
     }
 
-    define_command(:isearch_forward) do |**options|
+    define_command(:isearch_forward,
+                   doc: "Incrementally search forward.") do |**options|
       isearch_mode(true, **options)
     end
 
-    define_command(:isearch_backward) do |**options|
+    define_command(:isearch_backward,
+                   doc: "Incrementally search backward.") do |**options|
       isearch_mode(false, **options)
     end
 
@@ -78,23 +80,27 @@ module Textbringer
       end
     end
 
-    define_command(:isearch_exit) do
+    define_command(:isearch_exit, doc: "Exit incremental search.") do
       isearch_done
     end
 
-    define_command(:isearch_abort) do
+    define_command(:isearch_abort, doc: "Abort incremental search.") do
       goto_char(Buffer.current[:isearch_start])
       isearch_done
       raise Quit
     end
 
-    define_command(:isearch_printing_char) do
+    define_command(:isearch_printing_char, doc: <<~EOD) do
+        Add the typed character to the search string and search.
+      EOD
       c = Controller.current.last_key
       ISEARCH_STATUS[:string].concat(c)
       isearch_search
     end
 
-    define_command(:isearch_delete_char) do
+    define_command(:isearch_delete_char, doc: <<~EOD) do
+        Delete the last character from the search string and search.
+      EOD
       ISEARCH_STATUS[:string].chop!
       isearch_search
     end

data/lib/textbringer/commands/keyboard_macro.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    KEYBOARD_MACROS = {}
+
+    define_command(:start_keyboard_macro) do
+      message("Recording keyboard macro...")
+      Controller.current.start_keyboard_macro
+    end
+
+    define_command(:end_keyboard_macro) do
+      Controller.current.end_keyboard_macro
+      message("Keyboard macro defined")
+    end
+
+    define_command(:call_last_keyboard_macro) do |n = number_prefix_arg|
+      key = Controller.current.last_key
+      Controller.current.call_last_keyboard_macro(n)
+      map = Keymap.new
+      map.define_key(key, :call_last_keyboard_macro)
+      set_transient_map(map)
+    end
+
+    define_command(:end_and_call_keyboard_macro) do |n = number_prefix_arg|
+      if Controller.current.recording_keyboard_macro?
+        end_keyboard_macro
+      end
+      call_last_keyboard_macro(n)
+    end
+
+    define_command(:end_or_call_keyboard_macro) do |n = number_prefix_arg|
+      if Controller.current.recording_keyboard_macro?
+        end_keyboard_macro
+      else
+        call_last_keyboard_macro(n)
+      end
+    end
+
+    def execute_keyboard_macro(macro, n = 1)
+      Controller.current.execute_keyboard_macro(macro, n)
+    end
+
+    define_command(:name_last_keyboard_macro) do
+      |name = read_from_minibuffer("Name for last keyboard macro: ")|
+      last_keyboard_macro = Controller.current.last_keyboard_macro
+      if last_keyboard_macro.nil?
+        raise EditorError, "Keyboard macro not defined"
+      end
+      KEYBOARD_MACROS[name] = last_keyboard_macro
+      define_command(name) do |n = number_prefix_arg|
+        execute_keyboard_macro(last_keyboard_macro, n)
+      end
+    end
+
+    def read_keyboard_macro(prompt)
+      macros = KEYBOARD_MACROS.keys.map(&:to_s)
+      f = ->(s) { complete_for_minibuffer(s, macros) }
+      read_from_minibuffer(prompt, completion_proc: f)
+    end
+
+    module SymbolDump
+      refine Symbol do
+        def dump
+          ":" + to_s.dump
+        end
+      end
+    end
+
+    using SymbolDump
+
+    define_command(:insert_keyboard_macro) do
+      |name = read_keyboard_macro("Insert keyboard macro: ")|
+      macro = KEYBOARD_MACROS[name]
+      if macro.nil?
+        raise EditorError, "No such macro: #{name}"
+      end
+      macro_literal = "[" + macro.map { |key| key.dump }.join(",") + "]"
+      insert(<<~EOF)
+        define_command(:#{name}) do |n = number_prefix_arg|
+          execute_keyboard_macro(#{macro_literal}, n)
+        end
+      EOF
+    end
+  end
+end

data/lib/textbringer/commands/misc.rb

@@ -162,8 +162,7 @@ module Textbringer
       Controller.current.current_prefix_arg
     end
 
-    def number_prefix_arg
-      arg = current_prefix_arg
+    def prefix_numeric_value(arg)
       case arg
       when Integer
         arg
@@ -176,6 +175,10 @@ module Textbringer
       end
     end
 
+    def number_prefix_arg
+      prefix_numeric_value(current_prefix_arg)
+    end
+
     define_command(:digit_argument) do
       |arg = current_prefix_arg|
       n = Controller.current.last_key.to_i
@@ -225,6 +228,44 @@ module Textbringer
       Controller.current.recursive_edit
     end
 
+    def goto_global_mark
+      global_mark_ring = Buffer.global_mark_ring
+      mark = yield(global_mark_ring)
+      if mark.buffer&.current? && Buffer.current.point_at_mark?(mark)
+        mark = yield(global_mark_ring)
+      end
+      if mark.detached?
+        find_file(mark.file_name)
+        goto_char(mark.location)
+      else
+        switch_to_buffer(mark.buffer)
+        mark.buffer.point_to_mark(mark)
+      end
+    end
+    private :goto_global_mark
+
+    define_command(:next_global_mark) do
+      if Buffer.global_mark_ring.empty?
+        raise EditorError, "Global mark ring is empty"
+      end
+      if Buffer.current.push_global_mark
+        Buffer.global_mark_ring.pop
+      end
+      goto_global_mark do |mark_ring|
+        mark_ring.pop
+      end
+    end
+
+    define_command(:previous_global_mark) do
+      if Buffer.global_mark_ring.empty?
+        raise EditorError, "Global mark ring is empty"
+      end
+      Buffer.current.push_global_mark
+      goto_global_mark do |mark_ring|
+        mark_ring.rotate(-1)
+      end
+    end
+
     define_command(:shell_execute) do
       |cmd = read_from_minibuffer("Shell execute: "),
        buffer_name: "*Shell output*",

data/lib/textbringer/commands/register.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    class BufferPosition
+      attr_reader :buffer, :mark
+      
+      def initialize(buffer, mark)
+        @buffer = buffer
+        @mark = mark
+      end
+
+      def to_s
+        @mark.location.to_s
+      end
+    end
+
+    REGISTERS = {}
+
+    def REGISTERS.[]=(name, val)
+      old_val = REGISTERS[name]
+      if old_val.is_a?(BufferPosition)
+        old_val.mark.delete
+      end
+      super(name, val)
+    end
+
+    def read_register(prompt)
+      Window.echo_area.show(prompt)
+      Window.redisplay
+      begin
+        register = read_char
+        register
+      ensure
+        Window.echo_area.clear
+        Window.redisplay
+      end
+    end
+
+    define_command(:point_to_register) do
+      |register = read_register("Point to register:")|
+      unless register.is_a?(String)
+        raise ArgumentError, "Invalid register: #{register}"
+      end
+      buffer = Buffer.current
+      mark = buffer.new_mark
+      REGISTERS[register] = BufferPosition.new(buffer, mark)
+    end
+
+    define_command(:jump_to_register) do
+      |register = read_register("Jump to register:")|
+      if !register.is_a?(String)
+        raise ArgumentError, "Invalid register: #{register}"
+      end
+      position = REGISTERS[register]
+      if !position.is_a?(BufferPosition)
+        raise ArgumentError, "Register doesn't contain a buffer position"
+      end
+      switch_to_buffer(position.buffer)
+      position.buffer.point_to_mark(position.mark)
+    end
+
+    define_command(:copy_to_register) do
+      |register = read_register("Copy to register:"),
+        s = Buffer.current.mark, e = Buffer.current.point,
+        delete_flag = current_prefix_arg|
+      buffer = Buffer.current
+      str = s <= e ? buffer.substring(s, e) : buffer.substring(e, s)
+      REGISTERS[register] = str
+      if delete_flag
+        buffer.delete_region(s, e)
+      end
+    end
+
+    define_command(:append_to_register) do
+      |register = read_register("Append to register:"),
+        s = Buffer.current.mark, e = Buffer.current.point,
+        delete_flag = current_prefix_arg|
+      buffer = Buffer.current
+      str = s <= e ? buffer.substring(s, e) : buffer.substring(e, s)
+      val = REGISTERS[register]
+      if !val.is_a?(String)
+        raise ArgumentError, "Register doesn't contain text"
+      end
+      REGISTERS[register] = val + str
+      if delete_flag
+        buffer.delete_region(s, e)
+      end
+    end
+
+    define_command(:insert_register) do
+      |register = read_register("Insert register:"),
+        arg = current_prefix_arg|
+      buffer = Buffer.current
+      str = REGISTERS[register]
+      if arg
+        buffer.push_mark
+      end
+      pos = buffer.point
+      insert(str)
+      if !arg
+        buffer.push_mark
+        buffer.goto_char(pos)
+      end
+    end
+
+    define_command(:number_to_register) do
+      |n = number_prefix_arg,
+        register = read_register("Number to register:")|
+      REGISTERS[register] = n
+    end
+
+    define_command(:increment_register) do
+      |n = current_prefix_arg,
+        register = read_register("Increment register:")|
+      i = REGISTERS[register]
+      case i
+      when Integer
+        REGISTERS[register] = i + prefix_numeric_value(n)
+      when String
+        append_to_register(register, 
+                           Buffer.current.mark, Buffer.current.point, n)
+      else
+        raise ArgumentError, "Register doesn't contain a number or text"
+      end
+    end
+  end
+end