textbringer 0.1.8 → 0.1.9

data/lib/textbringer/commands/replace.rb

@@ -55,9 +55,10 @@ module Textbringer
             when ?n
               # do nothing
             when ?!
-              replace_match(to_str)
-              n += 1 + Buffer.current.replace_regexp_forward(regexp, to_str)
-              Buffer.current.merge_undo(2)
+              Buffer.current.composite_edit do
+                replace_match(to_str)
+                n += 1 + Buffer.current.replace_regexp_forward(regexp, to_str)
+              end
               break
             when ?q
               break

data/lib/textbringer/commands/windows.rb

@@ -2,63 +2,90 @@
 
 module Textbringer
   module Commands
-    define_command(:resize_window) do
+    define_command(:resize_window,
+                   doc: "Resize windows to fit the terminal size.") do
       Window.resize
     end
 
-    define_command(:recenter) do
+    define_command(:recenter,
+                   doc: "Center point in the current window.") do
       Window.current.recenter
       Window.redraw
     end
 
-    define_command(:scroll_up) do
+    define_command(:scroll_up,
+                   doc: "Scroll text of the current window upward.") do
       Window.current.scroll_up
     end
 
-    define_command(:scroll_down) do
+    define_command(:scroll_down,
+                   doc: "Scroll text of the current window downward.") do
       Window.current.scroll_down
     end
 
-    define_command(:delete_window) do
+    define_command(:delete_window,
+                   doc: "Delete the current window.") do
       Window.delete_window
     end
 
-    define_command(:delete_other_windows) do
+    define_command(:delete_other_windows,
+                   doc: "Delete windows other than the current one.") do
       Window.delete_other_windows
     end
 
-    define_command(:split_window) do
+    define_command(:split_window,
+                   doc: "Split the current window vertically.") do
       Window.current.split
     end
 
-    define_command(:other_window) do
+    define_command(:other_window,
+                   doc: "Switch to another window.") do
       Window.other_window
     end
 
-    define_command(:enlarge_window) do |n = number_prefix_arg|
+    define_command(:enlarge_window, doc: <<~EOD) do
+        Make the current window n lines taller.
+
+        If n is negative, shrink the window -n lines.
+        See [shrink_window] for details.
+      EOD
+      |n = number_prefix_arg|
       Window.current.enlarge(n)
     end
 
-    define_command(:switch_to_buffer) do
-      |buffer_name = read_buffer("Switch to buffer: ")|
-      if buffer_name.is_a?(Buffer)
-        buffer = buffer_name
-      else
-        buffer = Buffer[buffer_name]
+    define_command(:shrink_window, doc: <<~EOD) do |n = number_prefix_arg|
+        Make the current window n lines smaller.
+
+        If n is negative, enlarge the window -n lines.
+        See [enlarge_window] for details.
+      EOD
+      Window.current.shrink(n)
+    end
+
+    define_command(:shrink_window_if_larger_than_buffer, doc: <<~EOD) do
+        Shrink the current window if it's larger than the buffer.
+      EOD
+      Window.current.shrink_if_larger_than_buffer
+    end
+
+    define_command(:switch_to_buffer, doc: <<~EOD) do
+        Display buffer in the current window.
+      EOD
+      |buffer = read_buffer("Switch to buffer: ")|
+      if buffer.is_a?(String)
+        buffer = Buffer[buffer]
       end
       if buffer
         Window.current.buffer = Buffer.current = buffer
       else
-        raise EditorError, "No such buffer: #{buffer_name}"
+        raise EditorError, "No such buffer: #{buffer}"
       end
     end
 
-    define_command(:kill_buffer) do
-      |name = read_buffer("Kill buffer: ", default: Buffer.current.name)|
-      if name.is_a?(Buffer)
-        buffer = name
-      else
-        buffer = Buffer[name]
+    define_command(:kill_buffer, doc: "Kill buffer.") do
+      |buffer = read_buffer("Kill buffer: ", default: Buffer.current.name)|
+      if buffer.is_a?(String)
+        buffer = Buffer[buffer]
       end
       if buffer.modified?
         next unless yes_or_no?("The last change is not saved; kill anyway?")

data/lib/textbringer/config.rb

@@ -9,7 +9,8 @@ module Textbringer
     indent_tabs_mode: false,
     case_fold_search: true,
     buffer_dump_dir: File.expand_path("~/.textbringer/buffer_dump"),
-    tag_mark_limit: 16,
+    mark_ring_max: 16,
+    global_mark_ring_max: 16,
     window_min_height: 4,
     syntax_highlight: true,
     highlight_buffer_size_limit: 102400,

data/lib/textbringer/controller.rb

@@ -5,9 +5,11 @@ module Textbringer
   RECURSIVE_EDIT_TAG = Object.new
 
   class Controller
+    attr_reader :this_command_keys
     attr_accessor :this_command, :last_command, :overriding_map
     attr_accessor :prefix_arg, :current_prefix_arg
     attr_reader :key_sequence, :last_key, :recursive_edit_level
+    attr_reader :last_keyboard_macro
 
     @@current = nil
 
@@ -20,15 +22,20 @@ module Textbringer
     end
 
     def initialize
+      @top_self = eval("self", TOPLEVEL_BINDING)
       @key_sequence = []
       @last_key = nil
       @recursive_edit_level = 0
+      @this_command_keys = nil
       @this_command = nil
       @last_command = nil
       @overriding_map = nil
       @prefix_arg = nil
       @current_prefix_arg = nil
       @echo_immediately = false
+      @recording_keyboard_macro = nil
+      @last_keyboard_macro = nil
+      @executing_keyboard_macro = nil
     end
 
     def command_loop(tag)
@@ -43,14 +50,15 @@ module Textbringer
             @key_sequence << @last_key
             cmd = key_binding(@key_sequence)
             if cmd.is_a?(Symbol) || cmd.respond_to?(:call)
-              @key_sequence.clear
+              @this_command_keys = @key_sequence
+              @key_sequence = []
               @this_command = cmd
               @current_prefix_arg = @prefix_arg
               @prefix_arg = nil
               begin
                 run_hooks(:pre_command_hook, remove_on_error: true)
                 if cmd.is_a?(Symbol)
-                  send(cmd)
+                  @top_self.send(cmd)
                 else
                   cmd.call
                 end
@@ -61,31 +69,41 @@ module Textbringer
               end
             else
               if cmd.nil?
-                keys = @key_sequence.map { |ch| key_name(ch) }.join(" ")
+                keys = Keymap.key_sequence_string(@key_sequence)
                 @key_sequence.clear
                 @prefix_arg = nil
                 message("#{keys} is undefined")
               end
             end
+            Window.redisplay
           rescue Exception => e
             show_exception(e)
             @prefix_arg = nil
+            @recording_keyboard_macro = nil
+            Window.redisplay
+            if Window.echo_area.active?
+              wait_input(2000)
+              Window.echo_area.clear_message
+              Window.redisplay
+            end
           end
-          Window.redisplay
         end
       end
     end
 
     def wait_input(msecs)
+      if executing_keyboard_macro?
+        return @executing_keyboard_macro.first
+      end
       Window.current.wait_input(msecs)
     end
 
     def read_char
-      Window.current.read_char
+      read_char_with_keyboard_macro(:read_char)
     end
 
     def read_char_nonblock
-      Window.current.read_char_nonblock
+      read_char_with_keyboard_macro(:read_char_nonblock)
     end
 
     def received_keyboard_quit?
@@ -108,22 +126,8 @@ module Textbringer
       end
     end
 
-    def key_name(key)
-      case key
-      when Symbol
-        "<#{key}>"
-      when "\e"
-        "ESC"
-      when "\C-m"
-        "RET"
-      when /\A[\0-\b\v-\x1f\x7f]\z/
-        "C-" + (key.ord ^ 0x40).chr.downcase
-      else
-        key.to_s
-      end
-    end
-
     def echo_input
+      return if executing_keyboard_macro?
       if @prefix_arg || !@key_sequence.empty?
         if !@echo_immediately
           return if wait_input(1000)
@@ -138,7 +142,7 @@ module Textbringer
         end
         if !@key_sequence.empty?
           s << " " if !s.empty?
-          s << @key_sequence.map { |ch| key_name(ch) }.join(" ")
+          s << Keymap.key_sequence_string(@key_sequence)
         end
         s << "-"
         Window.echo_area.show(s)
@@ -150,12 +154,74 @@ module Textbringer
       end
     end
 
-    private
+    def start_keyboard_macro
+      if @recording_keyboard_macro
+        @recording_keyboard_macro = nil
+        raise EditorError, "Already recording keyboard macro"
+      end
+      @recording_keyboard_macro = []
+    end
+
+    def end_keyboard_macro
+      if @recording_keyboard_macro.nil?
+        raise EditorError, "Not recording keyboard macro"
+      end
+      if @recording_keyboard_macro.empty?
+        raise EditorError, "Empty keyboard macro"
+      end
+      @recording_keyboard_macro.pop(@this_command_keys.size)
+      @last_keyboard_macro = @recording_keyboard_macro
+      @recording_keyboard_macro = nil
+    end
+
+    def execute_keyboard_macro(macro, n = 1)
+      n.times do
+        @executing_keyboard_macro = macro.dup
+        begin
+          recursive_edit
+        ensure
+          @executing_keyboard_macro = nil
+        end
+      end
+    end
+
+    def call_last_keyboard_macro(n)
+      if @last_keyboard_macro.nil?
+        raise EditorError, "Keyboard macro not defined"
+      end
+      execute_keyboard_macro(@last_keyboard_macro, n)
+    end
+
+    def recording_keyboard_macro?
+      !@recording_keyboard_macro.nil?
+    end
+
+    def executing_keyboard_macro?
+      !@executing_keyboard_macro.nil?
+    end
 
     def key_binding(key_sequence)
       @overriding_map&.lookup(key_sequence) ||
       Buffer.current&.keymap&.lookup(key_sequence) ||
         GLOBAL_MAP.lookup(key_sequence)
     end
+
+    private
+
+    def read_char_with_keyboard_macro(read_char_method)
+      if !executing_keyboard_macro?
+        c = call_read_char_method(read_char_method)
+        if @recording_keyboard_macro
+          @recording_keyboard_macro.push(c)
+        end
+        c
+      else
+        @executing_keyboard_macro.shift
+      end
+    end
+
+    def call_read_char_method(read_char_method)
+      Window.current.send(read_char_method)
+    end
   end
 end

data/lib/textbringer/keymap.rb

@@ -4,6 +4,8 @@ require "curses"
 
 module Textbringer
   class Keymap
+    include Enumerable
+
     def initialize
       @map = {}
     end
@@ -35,10 +37,43 @@ module Textbringer
       end
     end
 
+    def each(prefixes = [], &block)
+      @map.each do |key, val|
+        if val.is_a?(Keymap)
+          val.each([*prefixes, key], &block)
+        else
+          yield([*prefixes, key], val)
+        end
+      end
+    end
+
     def handle_undefined_key
       @map.default_proc = Proc.new { |h, k| yield(k) }
     end
 
+    def self.key_name(key)
+      case key
+      when Symbol
+        "<#{key}>"
+      when " "
+        "SPC"
+      when "\t"
+        "TAB"
+      when "\e"
+        "ESC"
+      when "\C-m"
+        "RET"
+      when /\A[\0-\x1f\x7f]\z/
+        "C-" + (key.ord ^ 0x40).chr.downcase
+      else
+        key.to_s
+      end
+    end
+
+    def self.key_sequence_string(key_sequence)
+      key_sequence.map { |key| key_name(key) }.join(" ")
+    end
+
     private
 
     def kbd(key)
@@ -85,7 +120,10 @@ module Textbringer
   end
   GLOBAL_MAP.define_key(?\t, :self_insert)
   GLOBAL_MAP.define_key(?\C-q, :quoted_insert)
-  GLOBAL_MAP.define_key("\C- ", :set_mark_command)
+  GLOBAL_MAP.define_key("\C-@", :set_mark_command)
+  GLOBAL_MAP.define_key("\C-x\C-@", :pop_global_mark)
+  GLOBAL_MAP.define_key("\e*", :next_global_mark)
+  GLOBAL_MAP.define_key("\e?", :previous_global_mark)
   GLOBAL_MAP.define_key("\C-x\C-x", :exchange_point_and_mark)
   GLOBAL_MAP.define_key("\ew", :copy_region)
   GLOBAL_MAP.define_key(?\C-w, :kill_region)
@@ -94,10 +132,12 @@ module Textbringer
   GLOBAL_MAP.define_key(?\C-y, :yank)
   GLOBAL_MAP.define_key("\ey", :yank_pop)
   GLOBAL_MAP.define_key(?\C-_, :undo)
-  GLOBAL_MAP.define_key("\C-x\C-_", :redo)
+  GLOBAL_MAP.define_key("\C-x\C-_", :redo_command)
   GLOBAL_MAP.define_key("\C-t", :transpose_chars)
   GLOBAL_MAP.define_key("\C-j", :newline)
   GLOBAL_MAP.define_key("\C-m", :newline)
+  GLOBAL_MAP.define_key("\em", :back_to_indentation)
+  GLOBAL_MAP.define_key("\e^", :delete_indentation)
   GLOBAL_MAP.define_key("\C-l", :recenter)
   GLOBAL_MAP.define_key("\C-v", :scroll_up)
   GLOBAL_MAP.define_key(:npage, :scroll_up)
@@ -108,6 +148,7 @@ module Textbringer
   GLOBAL_MAP.define_key("\C-x2", :split_window)
   GLOBAL_MAP.define_key("\C-xo", :other_window)
   GLOBAL_MAP.define_key("\C-x^", :enlarge_window)
+  GLOBAL_MAP.define_key("\C-x-", :shrink_window_if_larger_than_buffer)
   GLOBAL_MAP.define_key("\C-x\C-c", :exit_textbringer)
   GLOBAL_MAP.define_key("\C-z", :suspend_textbringer)
   GLOBAL_MAP.define_key("\C-x\C-f", :find_file)
@@ -117,6 +158,7 @@ module Textbringer
   GLOBAL_MAP.define_key("\C-xk", :kill_buffer)
   GLOBAL_MAP.define_key("\C-x\C-mf", :set_buffer_file_encoding)
   GLOBAL_MAP.define_key("\C-x\C-mn", :set_buffer_file_format)
+  GLOBAL_MAP.define_key("\e.", :find_tag)
   GLOBAL_MAP.define_key("\ex", :execute_command)
   GLOBAL_MAP.define_key("\e:", :eval_expression)
   GLOBAL_MAP.define_key(?\C-u, :universal_argument)
@@ -125,6 +167,22 @@ module Textbringer
   GLOBAL_MAP.define_key(?\C-r, :isearch_backward)
   GLOBAL_MAP.define_key("\e%", :query_replace_regexp)
   GLOBAL_MAP.define_key("\e!", :shell_execute)
+  GLOBAL_MAP.define_key("\C-xr ", :point_to_register)
+  GLOBAL_MAP.define_key("\C-xrj", :jump_to_register)
+  GLOBAL_MAP.define_key("\C-xrx", :copy_to_register)
+  GLOBAL_MAP.define_key("\C-xrs", :copy_to_register)
+  GLOBAL_MAP.define_key("\C-xrg", :insert_register)
+  GLOBAL_MAP.define_key("\C-xri", :insert_register)
+  GLOBAL_MAP.define_key("\C-xrn", :number_to_register)
+  GLOBAL_MAP.define_key("\C-xr+", :increment_register)
+  GLOBAL_MAP.define_key("\C-x(", :start_keyboard_macro)
+  GLOBAL_MAP.define_key(:f3, :start_keyboard_macro)
+  GLOBAL_MAP.define_key("\C-x)", :end_keyboard_macro)
+  GLOBAL_MAP.define_key("\C-xe", :end_and_call_keyboard_macro)
+  GLOBAL_MAP.define_key(:f4, :end_or_call_keyboard_macro)
+  GLOBAL_MAP.define_key([:f1, "b"], :describe_bindings)
+  GLOBAL_MAP.define_key([:f1, "f"], :describe_command)
+  GLOBAL_MAP.define_key([:f1, "k"], :describe_key)
   GLOBAL_MAP.handle_undefined_key do |key|
     if key.is_a?(String) && /[\0-\x7f]/ !~ key 
       :self_insert