textbringer 13 → 15

data/lib/textbringer/commands/ispell.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "open3"
+require "uri"
+
+module Textbringer
+  module Commands
+    class Ispell
+      def initialize
+        @personal_dictionary_modified = false
+        @stdin, @stdout, @stderr, @wait_thr =
+          Open3.popen3(CONFIG[:ispell_command])
+        @stdout.gets # consume the banner
+      end
+
+      def check_word(word)
+        send_command("^" + word)
+        result = @stdout.gets
+        if result.nil? || result == "\n"
+          # aspell can't handle word, which may contain multibyte characters
+          return [word, nil]
+        end
+        @stdout.gets
+        case result
+        when /\A&\s+([^\s]+)\s+\d+\s+\d+:\s+(.*)/
+          [$1, $2.split(/, /)]
+        when /\A\*/, /\A\+/, /\A\-/, /\A\%/
+          [word, []]
+        when /\A#/
+          [word, nil]
+        else
+          raise "unexpected output from aspell: #{result}"
+        end
+      end
+
+      def add_to_session_dictionary(word)
+        send_command("@" + word)
+      end
+
+      def add_to_personal_dictionary(word)
+        send_command("*" + word)
+        @personal_dictionary_modified = true
+      end
+
+      def personal_dictionary_modified?
+        @personal_dictionary_modified
+      end
+
+      def save_personal_dictionary
+        send_command("#")
+      end
+
+      def send_command(line)
+        @stdin.puts(line)
+        @stdin.flush
+      end
+
+      def close
+        @stdin.close
+        @stdout.close
+        @stderr.close
+      end
+    end
+
+    define_keymap :ISPELL_MODE_MAP
+    (?\x20..?\x7e).each do |c|
+      ISPELL_MODE_MAP.define_key(c, :ispell_unknown_command)
+    end
+    ISPELL_MODE_MAP.define_key(?\t, :ispell_unknown_command)
+    ISPELL_MODE_MAP.handle_undefined_key do |key|
+      ispell_unknown_command
+    end
+    ISPELL_MODE_MAP.define_key(?r, :ispell_replace)
+    ISPELL_MODE_MAP.define_key(?a, :ispell_accept)
+    ISPELL_MODE_MAP.define_key(?i, :ispell_insert)
+    ISPELL_MODE_MAP.define_key(" ", :ispell_skip)
+    ISPELL_MODE_MAP.define_key(?q, :ispell_quit)
+    ISPELL_MODE_MAP.define_key("\C-g", :ispell_quit)
+
+    ISPELL_STATUS = {}
+
+    URI_REGEXP = URI::RFC2396_PARSER.make_regexp(["http", "https", "ftp", "mailto"])
+    EMAIL_REGEXP = /
+      # local-part
+      (  # dot-atom
+         (?<atom>[0-9a-z!\#$%&'*+\-\/=?^_`{|}~]+)
+         (\.\g<atom>)*
+      |  # quoted-string
+        \"([\x20\x21\x23-\x5b\x5d-\x7e]
+           |\\[\x20-\x7e])*\"
+      )@
+      # domain
+      (?<sub_domain>[0-9a-z]([0-9a-z-]*[0-9a-z])?)
+      (\.\g<sub_domain>)*
+    /ix
+    ISPELL_WORD_REGEXP = /
+        (?<uri>#{URI_REGEXP})
+      | (?<email>#{EMAIL_REGEXP})
+      | (?<word>[[:alpha:]]+(?:'[[:alpha:]]+)*)
+    /x
+
+    define_command(:ispell_buffer) do |recursive_edit: false|
+      ISPELL_STATUS[:recursive_edit] = false
+      Buffer.current.beginning_of_buffer
+      ispell_mode
+      if !ispell_forward
+        ISPELL_STATUS[:recursive_edit] = recursive_edit
+        if recursive_edit
+          recursive_edit()
+        end
+      end
+    end
+
+    def ispell_done
+      # Don't delete visible_mark if mark is active (transient mark mode)
+      unless Buffer.current.mark_active?
+        Buffer.current.delete_visible_mark
+      end
+      Controller.current.overriding_map = nil
+      ISPELL_STATUS[:ispell]&.close
+      ISPELL_STATUS[:ispell] = nil
+      if ISPELL_STATUS[:recursive_edit]
+        exit_recursive_edit
+      end
+      ISPELL_STATUS[:recursive_edit] = false
+    end
+
+    def ispell_mode
+      ISPELL_STATUS[:ispell] = Ispell.new
+      Controller.current.overriding_map = ISPELL_MODE_MAP
+    end
+
+    def ispell_forward
+      buffer = Buffer.current
+      while buffer.re_search_forward(ISPELL_WORD_REGEXP, raise_error: false,
+                                     goto_beginning: true)
+        if buffer.last_match[:word].nil?
+          buffer.goto_char(buffer.match_end(0))
+          next
+        end
+        ispell_beginning = buffer.point
+        # Don't update visible_mark if mark is already active (transient mark mode)
+        unless buffer.mark_active?
+          buffer.set_visible_mark
+        end
+        buffer.goto_char(buffer.match_end(0))
+        word = buffer.match_string(0)
+        _original, suggestions = ISPELL_STATUS[:ispell].check_word(word)
+        if !suggestions.nil? && !suggestions.empty?
+          ISPELL_STATUS[:beginning] = ispell_beginning
+          ISPELL_STATUS[:word] = word
+          ISPELL_STATUS[:suggestions] = suggestions
+          message_misspelled
+          recenter
+          return false
+        end
+      end
+      Controller.current.overriding_map = nil
+      if ISPELL_STATUS[:ispell]&.personal_dictionary_modified? &&
+          y_or_n?("Personal dictionary modified.  Save?")
+        ISPELL_STATUS[:ispell].save_personal_dictionary
+      end
+      message("Finished spelling check.")
+      ispell_done
+      true
+    end
+
+    define_command(:ispell_replace) do
+      ensure_ispell_active
+      word = ISPELL_STATUS[:word]
+      suggestions = ISPELL_STATUS[:suggestions]
+      Controller.current.overriding_map = nil
+      begin
+        s = read_from_minibuffer("Correct #{word} with: ",
+                                 completion_proc: ->(s) {
+          suggestions.grep(/^#{Regexp.quote(s)}/)
+        })
+      rescue Quit
+        message_misspelled
+        return
+      ensure
+        Controller.current.overriding_map = ISPELL_MODE_MAP
+      end
+      if !s.empty?
+        buffer = Buffer.current
+        pos = buffer.point
+        buffer.goto_char(ISPELL_STATUS[:beginning])
+        buffer.composite_edit do
+          buffer.delete_region(buffer.point, pos)
+          buffer.insert(s)
+        end
+      end
+      ispell_forward
+    end
+
+    define_command(:ispell_accept) do
+      ensure_ispell_active
+      ISPELL_STATUS[:ispell].add_to_session_dictionary(ISPELL_STATUS[:word])
+      ispell_forward
+    end
+
+    define_command(:ispell_insert) do
+      ensure_ispell_active
+      ISPELL_STATUS[:ispell].add_to_personal_dictionary(ISPELL_STATUS[:word])
+      ispell_forward
+    end
+
+    define_command(:ispell_skip) do
+      ensure_ispell_active
+      ispell_forward
+    end
+
+    define_command(:ispell_quit) do
+      ensure_ispell_active
+      message("Quitting spell check.")
+      ispell_done
+    end
+
+    define_command(:ispell_unknown_command) do
+      ensure_ispell_active
+      message_misspelled
+      Window.beep
+    end
+
+    def message_misspelled
+      word = ISPELL_STATUS[:word]
+      message("Misspelled: #{word}  [r]eplace, [a]ccept, [i]nsert, [SPC] to skip, [q]uit")
+    end
+
+    def ensure_ispell_active
+      if ISPELL_STATUS[:ispell].nil?
+        raise EditorError, "ispell is not active"
+      end
+    end
+  end
+end

data/lib/textbringer/commands/misc.rb

@@ -82,10 +82,9 @@ module Textbringer
 
     def update_completions(xs)
       if xs.size > 1
-        if COMPLETION[:original_buffer].nil?
+        if COMPLETION[:completions_window].nil?
+          Window.list.last.split
           COMPLETION[:completions_window] = Window.list.last
-          COMPLETION[:original_buffer] =
-            COMPLETION[:completions_window].buffer
         end
         completions = Buffer.find_or_new("*Completions*", undo_limit: 0)
         if !completions.mode.is_a?(CompletionListMode)
@@ -97,15 +96,13 @@ module Textbringer
           xs.each do |x|
             completions.insert(x + "\n")
           end
+          completions.beginning_of_buffer
           COMPLETION[:completions_window].buffer = completions
         ensure
           completions.read_only = true
         end
       else
-        if COMPLETION[:original_buffer]
-          COMPLETION[:completions_window].buffer =
-            COMPLETION[:original_buffer]
-        end
+        delete_completions_window
       end
     end
     private :update_completions

data/lib/textbringer/commands/rectangle.rb

@@ -0,0 +1,290 @@
+module Textbringer::Buffer::RectangleMethods
+  SHARED_VALUES = {}
+
+  refine Textbringer::Buffer do
+    # Returns start_line, start_col, end_line, and end_col of the rectangle region
+    # Note that start_col and end_col are 0-origin and width-based (neither 1-origin nor codepoint-based)
+    def rectangle_boundaries(s = @point, e = mark)
+      s, e = Buffer.region_boundaries(s, e)
+      save_excursion do
+        goto_char(s)
+        start_line = @current_line
+        beginning_of_line
+        start_col = display_width(substring(@point, s))
+        goto_char(e)
+        end_line = @current_line
+        beginning_of_line
+        end_col = display_width(substring(@point, e))
+
+        # Ensure start_col <= end_col
+        if start_col > end_col
+          start_col, end_col = end_col, start_col
+        end
+        [start_line, start_col, end_line, end_col]
+      end
+    end
+
+    def apply_on_rectangle(s = @point, e = mark)
+      start_line, start_col, end_line, end_col = rectangle_boundaries(s, e)
+
+      save_excursion do
+        composite_edit do
+          goto_line(start_line)
+
+          loop do
+            beginning_of_line
+            line_start = @point
+
+            # Move to start column
+            col = 0
+            while col < start_col && !end_of_line?
+              forward_char
+              col = display_width(substring(line_start, @point))
+            end
+
+            yield(start_col, end_col, col, line_start, start_line, end_line)
+
+            # Move to next line for forward iteration
+            break if @current_line >= end_line
+            forward_line
+          end
+        end
+      end
+    end
+
+    def extract_rectangle(s = @point, e = mark)
+      lines = []
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+        start_pos = @point
+        width = end_col - start_col
+
+        # If we haven't reached start_col, the line is too short
+        if col < start_col
+          # Line is shorter than start column, extract all spaces
+          lines << " " * width
+        else
+          # Move to end column
+          while col < end_col && !end_of_line?
+            forward_char
+            col = display_width(substring(line_start, @point))
+          end
+          end_pos = @point
+
+          # Extract the rectangle text for this line
+          if end_pos > start_pos
+            extracted = substring(start_pos, end_pos)
+            # Pad with spaces if the extracted text is shorter than rectangle width
+            extracted_width = display_width(extracted)
+            if extracted_width < width
+              extracted += " " * (width - extracted_width)
+            end
+            lines << extracted
+          else
+            lines << " " * width
+          end
+        end
+      end
+
+      lines
+    end
+
+    def copy_rectangle(s = @point, e = mark)
+      lines = extract_rectangle(s, e)
+      SHARED_VALUES[:killed_rectangle] = lines
+    end
+
+    def kill_rectangle(s = @point, e = mark)
+      copy_rectangle(s, e)
+      delete_rectangle(s, e)
+    end
+
+    def delete_rectangle(s = @point, e = mark)
+      check_read_only_flag
+
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+        start_pos = @point
+
+        # Only delete if we're within the line bounds
+        if col >= start_col
+          # Move to end column
+          while col < end_col && !end_of_line?
+            forward_char
+            col = display_width(substring(line_start, @point))
+          end
+          end_pos = @point
+
+          # Delete the rectangle text for this line
+          if end_pos > start_pos
+            delete_region(start_pos, end_pos)
+          end
+        end
+      end
+    end
+
+    def yank_rectangle
+      raise "No rectangle in kill ring" if SHARED_VALUES[:killed_rectangle].nil?
+      lines = SHARED_VALUES[:killed_rectangle]
+      start_line = @current_line
+      start_point = @point
+      start_col = save_excursion {
+        beginning_of_line
+        display_width(substring(@point, start_point))
+      }
+      composite_edit do
+        lines.each_with_index do |line, i|
+          goto_line(start_line + i)
+          beginning_of_line
+          line_start = @point
+
+          # Move to start column, extending line if necessary
+          col = 0
+          while col < start_col && !end_of_line?
+            forward_char
+            col = display_width(substring(line_start, @point))
+          end
+
+          # If line is shorter than start_col, extend it with spaces
+          if col < start_col
+            insert(" " * (start_col - col))
+          end
+
+          # Insert the rectangle line
+          insert(line)
+        end
+      end
+    end
+
+    def open_rectangle(s = @point, e = mark)
+      check_read_only_flag
+      s, e = Buffer.region_boundaries(s, e)
+      composite_edit do
+        apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+          # If line is shorter than start_col, extend it with spaces
+          if col < start_col
+            insert(" " * (start_col - col))
+          end
+
+          # Insert spaces to create the rectangle
+          insert(" " * (end_col - start_col))
+        end
+        goto_char(s)
+      end
+    end
+
+    def clear_rectangle(s = @point, e = mark)
+      check_read_only_flag
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+        start_pos = @point
+        if col < start_col
+          insert(" " * (end_col - start_col))
+        else
+          while col < end_col && !end_of_line?
+            forward_char
+            col = display_width(substring(line_start, @point))
+          end
+          end_pos = @point
+
+          delete_region(start_pos, end_pos) if end_pos > start_pos
+          insert(" " * (end_col - start_col))
+        end
+      end
+    end
+
+    def string_rectangle(str, s = @point, e = mark)
+      check_read_only_flag
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+        start_pos = @point
+        if col < start_col
+          insert(" " * (start_col - col))
+          insert(str)
+        else
+          while col < end_col && !end_of_line?
+            forward_char
+            col = display_width(substring(line_start, @point))
+          end
+          end_pos = @point
+
+          delete_region(start_pos, end_pos) if end_pos > start_pos
+          insert(str)
+        end
+      end
+    end
+
+    def string_insert_rectangle(str, s = @point, e = mark)
+      check_read_only_flag
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start|
+        if col < start_col
+          insert(" " * (start_col - col))
+        end
+        insert(str)
+      end
+    end
+
+    def rectangle_number_lines(s = @point, e = mark)
+      check_read_only_flag
+      n = 1
+      number_width = nil
+      apply_on_rectangle(s, e) do |start_col, end_col, col, line_start, start_line, end_line|
+        number_width ||= (1 + (end_line - start_line)).to_s.size
+        if col < start_col
+          insert(" " * (start_col - col))
+        end
+        insert(n.to_s.rjust(number_width) + " ")
+        n += 1
+      end
+    end
+  end
+end
+
+using Textbringer::Buffer::RectangleMethods
+
+module Textbringer
+  module Commands
+    define_command(:kill_rectangle,
+                   doc: "Kill the text of the region-rectangle, saving its contents as the last killed rectangle.") do
+      Buffer.current.kill_rectangle
+    end
+
+    define_command(:copy_rectangle_as_kill,
+                   doc: "Save the text of the region-rectangle as the last killed rectangle.") do
+      Buffer.current.copy_rectangle
+    end
+
+    define_command(:delete_rectangle,
+                   doc: "Delete the text of the region-rectangle.") do
+      Buffer.current.delete_rectangle
+    end
+
+    define_command(:yank_rectangle,
+                   doc: "Yank the last killed rectangle with its upper left corner at point.") do
+      Buffer.current.yank_rectangle
+    end
+
+    define_command(:open_rectangle,
+                   doc: "Insert blank space to fill the space of the region-rectangle. This pushes the previous contents of the region-rectangle to the right.") do
+      Buffer.current.open_rectangle
+    end
+
+    define_command(:clear_rectangle,
+                   doc: "Clear the region-rectangle by replacing its contents with spaces.") do
+      Buffer.current.clear_rectangle
+    end
+
+    define_command(:string_rectangle,
+                   doc: "Replace rectangle contents with the specified string on each line.") do
+      |str = read_from_minibuffer("String rectangle: ")|
+      Buffer.current.string_rectangle(str)
+    end
+
+    define_command(:string_insert_rectangle,
+                   doc: "Insert the specified string on each line of the rectangle.") do
+      |str = read_from_minibuffer("String insert rectangle: ")|
+      Buffer.current.string_insert_rectangle(str)
+    end
+
+    define_command(:rectangle_number_lines,
+                   doc: "Insert numbers in front of the region-rectangle.") do
+      Buffer.current.rectangle_number_lines
+    end
+  end
+end

data/lib/textbringer/commands/replace.rb

@@ -42,7 +42,10 @@ module Textbringer
         loop do
           re_search_forward(regexp)
           Window.current.recenter_if_needed
-          Buffer.current.set_visible_mark(match_beginning(0))
+          # Don't update visible_mark if mark is already active (transient mark mode)
+          unless Buffer.current.mark_active?
+            Buffer.current.set_visible_mark(match_beginning(0))
+          end
           begin
             Window.redisplay
             c = read_single_char("Replace?", [?y, ?n, ?!, ?q, ?.])
@@ -66,7 +69,10 @@ module Textbringer
               break
             end
           ensure
-            Buffer.current.delete_visible_mark
+            # Don't delete visible_mark if mark is active (transient mark mode)
+            unless Buffer.current.mark_active?
+              Buffer.current.delete_visible_mark
+            end
           end
         end
       rescue SearchError

data/lib/textbringer/config.rb

@@ -15,6 +15,7 @@ module Textbringer
     shell_file_name: ENV["SHELL"],
     shell_command_switch: "-c",
     grep_command: "grep -nH -e",
+    ispell_command: "aspell -a",
     fill_column: 70,
     read_file_name_completion_ignore_case: RUBY_PLATFORM.match?(/darwin/),
     default_input_method: "t_code"

data/lib/textbringer/global_minor_mode.rb

@@ -0,0 +1,58 @@
+module Textbringer
+  # Base class for global minor modes that affect all buffers.
+  # Unlike buffer-local MinorMode, global minor modes have a single on/off state.
+  class GlobalMinorMode
+    extend Commands
+    include Commands
+
+    class << self
+      attr_accessor :mode_name
+      attr_accessor :command_name
+
+      def enabled=(val)
+        @enabled = val
+      end
+
+      def enabled? = @enabled
+    end
+
+    def self.inherited(child)
+      # Initialize enabled to false immediately
+      child.instance_variable_set(:@enabled, false)
+
+      class_name = child.name
+      if class_name.nil? || class_name.empty?
+        raise ArgumentError, "GlobalMinorMode subclasses must be named classes (anonymous classes are not supported)"
+      end
+
+      base_name = class_name.slice(/[^:]*\z/)
+      child.mode_name = base_name.sub(/Mode\z/, "")
+      command_name = base_name.sub(/\A[A-Z]/) { |s| s.downcase }.
+        gsub(/(?<=[a-z])([A-Z])/) {
+          "_" + $1.downcase
+        }
+      command = command_name.intern
+      child.command_name = command
+
+      # Define the toggle command
+      define_command(command) do
+        if child.enabled?
+          child.disable
+          child.enabled = false
+        else
+          child.enable
+          child.enabled = true
+        end
+      end
+    end
+
+    # Override these in subclasses
+    def self.enable
+      raise EditorError, "Subclass must implement enable"
+    end
+
+    def self.disable
+      raise EditorError, "Subclass must implement disable"
+    end
+  end
+end

data/lib/textbringer/keymap.rb

@@ -209,6 +209,8 @@ module Textbringer
   GLOBAL_MAP.define_key("\C-xry", :yank_rectangle)
   GLOBAL_MAP.define_key("\C-xro", :open_rectangle)
   GLOBAL_MAP.define_key("\C-xrc", :clear_rectangle)
+  GLOBAL_MAP.define_key("\C-xrt", :string_rectangle)
+  GLOBAL_MAP.define_key("\C-xrN", :rectangle_number_lines)
   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)

data/lib/textbringer/modes/completion_list_mode.rb

@@ -24,10 +24,7 @@ module Textbringer
       if s.size > 0
         Window.current = Window.echo_area
         complete_minibuffer_with_string(s)
-        if COMPLETION[:original_buffer]
-          COMPLETION[:completions_window].buffer =
-            COMPLETION[:original_buffer]
-        end
+        delete_completions_window
       end
     end
   end