textbringer 0.1.4 → 0.1.5

data/lib/textbringer/commands/misc.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    define_command(:version) do
+      message("Textbringer #{Textbringer::VERSION} "\
+              "(ruby #{RUBY_VERSION} [#{RUBY_PLATFORM}])")
+    end
+
+    define_command(:exit_textbringer) do |status = 0|
+      if Buffer.any? { |buffer| /\A\*/ !~ buffer.name && buffer.modified? }
+        return unless yes_or_no?("Unsaved buffers exist; exit anyway?")
+      end
+      exit(status)
+    end
+
+    define_command(:suspend_textbringer) do
+      Curses.close_screen
+      Process.kill(:STOP, $$)
+    end
+
+    define_command(:execute_command) do
+      |cmd = read_command_name("M-x ").strip.intern|
+      unless Commands.list.include?(cmd)
+        raise EditorError, "Undefined command: #{cmd}"
+      end
+      Controller.current.this_command = cmd
+      send(cmd)
+    end
+
+    define_command(:eval_expression) do
+      |s = read_from_minibuffer("Eval: ")|
+      result = eval(s, TOPLEVEL_BINDING, "(eval_expression)", 1)
+      message(result.inspect)
+      result
+    end
+
+    define_command(:eval_buffer) do
+      buffer = Buffer.current
+      result = eval(buffer.to_s, TOPLEVEL_BINDING,
+                    buffer.file_name || buffer.name, 1)
+      message(result.inspect)
+      result
+    end
+
+    define_command(:eval_region) do
+      buffer = Buffer.current
+      b, e = buffer.point, buffer.mark
+      if e < b
+        b, e = e, b
+      end
+      result = eval(buffer.substring(b, e), TOPLEVEL_BINDING,
+                    "(eval_region)", 1)
+      message(result.inspect)
+      result
+    end
+
+    define_command(:exit_recursive_edit) do
+      if Controller.current.recursive_edit_level == 0
+        raise EditorError, "No recursive edit is in progress"
+      end
+      throw RECURSIVE_EDIT_TAG, false
+    end
+
+    define_command(:abort_recursive_edit) do
+      if Controller.current.recursive_edit_level == 0
+        raise EditorError, "No recursive edit is in progress"
+      end
+      throw RECURSIVE_EDIT_TAG, true
+    end
+
+    define_command(:top_level) do
+      throw TOP_LEVEL_TAG
+    end
+
+    define_command(:keyboard_quit) do
+      raise Quit
+    end
+
+    define_command(:complete_minibuffer) do
+      minibuffer = Buffer.minibuffer
+      completion_proc = minibuffer[:completion_proc]
+      if completion_proc
+        s = completion_proc.call(minibuffer.to_s)
+        if s
+          minibuffer.delete_region(minibuffer.point_min,
+                                   minibuffer.point_max)
+          minibuffer.insert(s)
+        end
+      end
+    end
+
+    UNIVERSAL_ARGUMENT_MAP = Keymap.new
+    (?0..?9).each do |c|
+      UNIVERSAL_ARGUMENT_MAP.define_key(c, :digit_argument)
+      GLOBAL_MAP.define_key("\e#{c}", :digit_argument)
+    end
+    UNIVERSAL_ARGUMENT_MAP.define_key(?-, :negative_argument)
+    UNIVERSAL_ARGUMENT_MAP.define_key(?\C-u, :universal_argument_more)
+
+    def universal_argument_mode
+      set_transient_map(UNIVERSAL_ARGUMENT_MAP)
+    end
+
+    define_command(:universal_argument) do
+      Controller.current.prefix_arg = [4]
+      universal_argument_mode
+    end
+
+    def current_prefix_arg
+      Controller.current.current_prefix_arg
+    end
+
+    def number_prefix_arg
+      arg = current_prefix_arg
+      case arg
+      when Integer
+        arg
+      when Array
+        arg.first
+      when :-
+        -1
+      else
+        1
+      end
+    end
+
+    define_command(:digit_argument) do
+      |arg = current_prefix_arg|
+      n = Controller.current.last_key.to_i
+      Controller.current.prefix_arg =
+        case arg
+        when Integer
+          arg * 10 + (arg < 0 ? -n : n)
+        when :-
+          -n
+        else
+          n
+        end
+      universal_argument_mode
+    end
+
+    define_command(:negative_argument) do
+      |arg = current_prefix_arg|
+      Controller.current.prefix_arg =
+        case arg
+        when Integer
+          -arg
+        when :-
+          nil
+        else
+          :-
+        end
+      universal_argument_mode
+    end
+
+    define_command(:universal_argument_more) do
+      |arg = current_prefix_arg|
+      Controller.current.prefix_arg =
+        case arg
+        when Array
+          [4 * arg.first]
+        when :-
+          [-4]
+        else
+          nil
+        end
+      if Controller.current.prefix_arg
+        universal_argument_mode
+      end
+    end
+
+    define_command(:recursive_edit) do
+      Controller.current.recursive_edit
+    end
+
+    define_command(:shell_execute) do
+      |cmd = read_from_minibuffer("Shell execute: "),
+       buffer_name = "*Shell output*"|
+      buffer = Buffer.find_or_new(buffer_name)
+      switch_to_buffer(buffer)
+      buffer.read_only = false
+      buffer.clear
+      Window.redisplay
+      signals = [:INT, :TERM, :KILL]
+      begin
+        if /mswin32|mingw32/ =~ RUBY_PLATFORM
+          opts = {}
+        else
+          opts = {pgroup: true}
+        end
+        Open3.popen2e(cmd, opts) do |input, output, wait_thread|
+          input.close
+          loop do
+            status = output.wait_readable(0.5)
+            if status == false
+              break # EOF
+            end
+            if status
+              begin
+                s = output.read_nonblock(1024).force_encoding("utf-8").
+                  scrub("\u{3013}").gsub(/\r\n/, "\n")
+                buffer.insert(s)
+                Window.redisplay
+              rescue EOFError
+                break
+              rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+                next
+              end
+            end
+            if received_keyboard_quit?
+              if signals.empty?
+                keyboard_quit
+              else
+                sig = signals.shift
+                pid = wait_thread.pid
+                pid = -pid if /mswin32|mingw32/ !~ RUBY_PLATFORM
+                message("Send #{sig} to #{pid}")
+                Process.kill(sig, pid)
+              end
+            end
+          end
+          status = wait_thread.value
+          pid = status.pid
+          if status.exited?
+            code = status.exitstatus
+            message("Process #{pid} exited with status code #{code}")
+          elsif status.signaled?
+            signame = Signal.signame(status.termsig)
+            message("Process #{pid} was killed by #{signame}")
+          else
+            message("Process #{pid} exited")
+          end
+        end
+      ensure
+        buffer.read_only = true
+      end
+    end
+  end
+end

data/lib/textbringer/commands/replace.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    RE_SEARCH_STATUS = {
+      last_regexp: nil
+    }
+
+    define_command(:re_search_forward) do
+      |s = read_from_minibuffer("RE search: ",
+                                default: RE_SEARCH_STATUS[:last_regexp])|
+      RE_SEARCH_STATUS[:last_regexp] = s
+      Buffer.current.re_search_forward(s)
+    end
+
+    define_command(:re_search_backward) do
+      |s = read_from_minibuffer("RE search backward: ",
+                                default: RE_SEARCH_STATUS[:last_regexp])|
+      RE_SEARCH_STATUS[:last_regexp] = s
+      Buffer.current.re_search_backward(s)
+    end
+
+    def match_beginning(n)
+      Buffer.current.match_beginning(n)
+    end
+
+    def match_end(n)
+      Buffer.current.match_end(n)
+    end
+
+    def match_string(n)
+      Buffer.current.match_string(n)
+    end
+
+    def replace_match(s)
+      Buffer.current.replace_match(s)
+    end
+
+    define_command(:query_replace_regexp) do
+      |regexp = read_from_minibuffer("Query replace regexp: "),
+       to_str = read_from_minibuffer("with: ")|
+      n = 0
+      begin
+        loop do
+          re_search_forward(regexp)
+          Window.current.recenter_if_needed
+          Buffer.current.set_visible_mark(match_beginning(0))
+          begin
+            Window.redisplay
+            c = read_single_char("Replace?", [?y, ?n, ?!, ?q, ?.])
+            case c
+            when ?y
+              replace_match(to_str)
+              n += 1
+            when ?n
+              # do nothing
+            when ?!
+              replace_match(to_str)
+              n += 1 + Buffer.current.replace_regexp_forward(regexp, to_str)
+              Buffer.current.merge_undo(2)
+              break
+            when ?q
+              break
+            when ?.
+              replace_match(to_str)
+              n += 1
+              break
+            end
+          ensure
+            Buffer.current.delete_visible_mark
+          end
+        end
+      rescue SearchError
+      end
+      if n == 1
+        message("Replaced 1 occurrence")
+      else
+        message("Replaced #{n} occurrences")
+      end
+    end
+  end
+end

data/lib/textbringer/commands/windows.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    define_command(:resize_window) do
+      Window.resize
+    end
+
+    define_command(:recenter) do
+      Window.current.recenter
+      Window.redraw
+    end
+
+    define_command(:scroll_up) do
+      Window.current.scroll_up
+    end
+
+    define_command(:scroll_down) do
+      Window.current.scroll_down
+    end
+
+    define_command(:delete_window) do
+      Window.delete_window
+    end
+
+    define_command(:delete_other_windows) do
+      Window.delete_other_windows
+    end
+
+    define_command(:split_window) do
+      Window.current.split
+    end
+
+    define_command(:other_window) do
+      Window.other_window
+    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]
+      end
+      if buffer
+        Window.current.buffer = Buffer.current = buffer
+      else
+        raise EditorError, "No such buffer: #{buffer_name}"
+      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]
+      end
+      if buffer.modified?
+        next unless yes_or_no?("The last change is not saved; kill anyway?")
+        message("Arioch! Arioch! Blood and souls for my Lord Arioch!")
+      end
+      buffer.kill
+      if Buffer.count == 0
+        buffer = Buffer.new_buffer("*scratch*")
+        switch_to_buffer(buffer)
+      elsif Buffer.current.nil?
+        switch_to_buffer(Buffer.last)
+      end
+    end
+  end
+end

data/lib/textbringer/controller.rb

@@ -7,7 +7,7 @@ module Textbringer
   class Controller
     attr_accessor :this_command, :last_command, :overriding_map
     attr_accessor :prefix_arg, :current_prefix_arg
-    attr_reader :last_key
+    attr_reader :last_key, :recursive_edit_level
 
     @@current = nil
 
@@ -34,7 +34,7 @@ module Textbringer
       catch(tag) do
         loop do
           begin
-            c = Window.current.read_char
+            c = read_char
             Window.echo_area.clear_message
             @last_key = c
             @key_sequence << @last_key
@@ -60,11 +60,11 @@ module Textbringer
               if cmd.nil?
                 keys = @key_sequence.map { |ch| key_name(ch) }.join(" ")
                 @key_sequence.clear
-                Window.echo_area.show("#{keys} is undefined")
+                message("#{keys} is undefined")
               end
             end
           rescue Exception => e
-            handle_exception(e)
+            show_exception(e)
           end
           Window.redisplay
         end
@@ -79,8 +79,12 @@ module Textbringer
       Window.current.read_char
     end
 
+    def read_char_nonblock
+      Window.current.read_char_nonblock
+    end
+
     def received_keyboard_quit?
-      while key = Window.current.read_char_nonblock
+      while key = read_char_nonblock
         if GLOBAL_MAP.lookup([key]) == :keyboard_quit
           return true
         end
@@ -99,27 +103,21 @@ module Textbringer
       end
     end
 
-    private
-
     def key_name(key)
       case key
-      when Integer
-        if key < 0x80
-          s = Curses.keyname(key)
-          case s
-          when /\AKEY_(.*)/
-            "<#{$1.downcase}>"
-          else
-            s
-          end
-        else
-          key.chr(Encoding::UTF_8)
-        end
+      when Symbol
+        "<#{key}>"
+      when "\e"
+        "ESC"
+      when /\A[\0-\b\v-\x1f\x7f]\z/
+        "C-" + (key.ord ^ 0x40).chr.downcase
       else
         key.to_s
       end
     end
 
+    private
+
     def key_binding(key_sequence)
       @overriding_map&.lookup(key_sequence) ||
       Buffer.current&.keymap&.lookup(key_sequence) ||