textbringer 14 → 15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b974ebb2c6338de9890aee4aa219529d5d81f9b838b21bb6e738ddf205015d5
-  data.tar.gz: fe3ed3ec2825a26e9e0c6eaa777a6e5c53549ac604ffe38eceb653ca2e6ef6b2
+  metadata.gz: 5ad5b7d9a5cc2022075f802db23f24781dcb3be366a4ba3ee27015a66ada834d
+  data.tar.gz: 1933c54c72c4e189b4f0a6ba81d6186d7618c9eaaa3eccbe5b61925d8959c108
 SHA512:
-  metadata.gz: ddcdd02dc9fd8d7397ef7994d000d470268aff0052dcab907a2a6cb073a9f39847180c1dfc40984e36d19e4bd64459cdeed8ab6ba493cdf4d1df542d9f4ac3cb
-  data.tar.gz: cf0095973d9e53072a6243568ffe70aaf3a33b5091767c00ff0064ed9dcfc7f0f9c053b7d146abf69ec0cacb88f4495f16a283e05383246a4a84a001413b8cfd
+  metadata.gz: 44736e20de4174e865ad160107e48461e26d46cd495e74000138c724753dafaae65b5e530902e8f1ad1f38659e301cfe2fbec71208913f85d01af5e23b124bc5
+  data.tar.gz: b07e7c3533f540b88157c268d498f7ec6bd077db6fce0e3adb154acc02fb9d960cee0bfb23cd91342a6dce12f0c8af1083dac1434fc67c9fddc361bd03623ded

data/CLAUDE.md

@@ -0,0 +1,197 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Textbringer is an Emacs-like text editor written in Ruby. It is extensible by Ruby instead of Lisp and runs in the terminal using ncurses.
+
+**Ruby Version**: Requires Ruby >= 3.2
+
+## Development Commands
+
+### Setup
+```bash
+bundle install
+```
+
+For ncursesw support (required for multibyte characters):
+```bash
+sudo apt-get install libncursesw5-dev
+gem install curses
+```
+
+### Running the Editor
+```bash
+# Run the main executable
+./exe/txtb
+
+# Or after installation
+txtb
+```
+
+### Testing
+```bash
+# Run all tests
+bundle exec rake test
+
+# Or simply (default task)
+bundle exec rake
+
+# On Ubuntu/Linux (for CI)
+xvfb-run bundle exec rake test
+
+# Run a single test file
+ruby -Ilib:test test/textbringer/test_buffer.rb
+```
+
+### Build and Release
+```bash
+# Install gem locally
+bundle exec rake install
+
+# Bump version and create release
+bundle exec rake bump
+```
+
+## Architecture
+
+### Core Components
+
+**Buffer** (`lib/textbringer/buffer.rb`)
+- The fundamental text container, similar to Emacs buffers
+- Uses a gap buffer implementation (GAP_SIZE = 256) for efficient text editing
+- Supports undo/redo with UNDO_LIMIT = 1000
+- Handles encoding detection (UTF-8, EUC-JP, Windows-31J) and file format conversion
+- Manages marks, point (cursor position), and the kill ring
+- Class methods maintain global buffer list (@@list, @@current, @@minibuffer)
+
+**Window** (`lib/textbringer/window.rb`)
+- Display abstraction using curses for terminal UI
+- Multiple windows can display different buffers or the same buffer
+- Window.current tracks the active window
+- Echo area (@@echo_area) for messages and minibuffer input
+- Manages cursor position and window splitting/deletion
+
+**Controller** (`lib/textbringer/controller.rb`)
+- The main event loop and command dispatcher
+- Reads key sequences and dispatches to commands
+- Handles prefix arguments, keyboard macros, and recursive editing
+- Maintains command execution state (this_command, last_command)
+- Pre/post command hooks for extensibility
+
+**Mode** (`lib/textbringer/mode.rb`)
+- Buffer modes define context-specific behavior and syntax highlighting
+- Modes inherit from Mode class (FundamentalMode, ProgrammingMode, RubyMode, CMode, etc.)
+- Each mode has its own keymap and syntax table
+- `define_local_command` creates mode-specific commands
+- Modes are automatically selected based on file_name_pattern or interpreter_name_pattern
+
+**Keymap** (`lib/textbringer/keymap.rb`)
+- Tree structure for key bindings (supports multi-stroke sequences)
+- Uses `kbd()` function to parse Emacs-style key notation
+- Key sequences can bind to commands (symbols) or nested keymaps
+
+**Commands** (`lib/textbringer/commands.rb` and `lib/textbringer/commands/*.rb`)
+- Commands are defined using `define_command(name, doc:)`
+- Available as module functions in the Commands module
+- Command groups: buffers, windows, files, isearch, replace, rectangle, etc.
+- All commands accessible via Alt+x or key bindings
+
+### Plugin System
+
+Plugins are loaded from `~/.textbringer/plugins/` via `Plugin.load_plugins`. Examples:
+- Mournmail (mail client)
+- MedicineShield (Mastodon client)
+- textbringer-presentation
+- textbringer-ghost_text
+
+### Configuration
+
+User configuration is loaded from:
+1. `~/.textbringer/init.rb` (loaded first)
+2. `~/.textbringer.rb` (loaded after plugins)
+
+Global configuration hash: `CONFIG` in `lib/textbringer/config.rb`
+
+Key settings:
+- `east_asian_ambiguous_width`: Character width (1 or 2)
+- `tab_width`, `indent_tabs_mode`: Indentation
+- `syntax_highlight`, `highlight_buffer_size_limit`: Syntax highlighting
+- `default_input_method`: Input method for non-ASCII text
+
+### Input Methods
+
+Support for non-ASCII input:
+- T-Code (`lib/textbringer/input_methods/t_code_input_method.rb`)
+- Hiragana (`lib/textbringer/input_methods/hiragana_input_method.rb`)
+- Hangul (`lib/textbringer/input_methods/hangul_input_method.rb`)
+
+### Testing Infrastructure
+
+Tests use `Test::Unit` with custom `Textbringer::TestCase` base class in `test/test_helper.rb`.
+
+Key test helpers:
+- `FakeController`: Test controller with `test_key_buffer` for simulating input
+- `FakeCursesWindow`: Mock curses window for headless testing
+- `push_keys(keys)`: Simulate keyboard input
+- `mkcdtmpdir`: Create temporary directory for file tests
+- `Window.setup_for_test`: Initialize test environment
+
+Tests are organized mirroring lib structure: `test/textbringer/**/*`.
+
+## Code Patterns
+
+### Defining Commands
+```ruby
+define_command(:command_name, doc: "Description") do
+  # Command implementation
+  # Access current buffer: Buffer.current
+  # Get prefix arg: current_prefix_arg
+end
+```
+
+### Mode-Specific Commands
+```ruby
+class MyMode < Mode
+  define_local_command(:my_command) do
+    # Mode-specific implementation
+  end
+end
+```
+
+### Key Bindings
+```ruby
+GLOBAL_MAP.define_key("\C-x\C-f", :find_file)
+MODE_MAP.define_key("C-c C-c", :compile)
+```
+
+### Buffer Operations
+- Always use `Buffer.current` to get the active buffer
+- `@buffer.point` is the cursor position
+- `@buffer.mark` for region operations
+- `@buffer.insert(text)`, `@buffer.delete_char(n)` for modifications
+- `@buffer.save_point` and `@buffer.goto_char(pos)` for navigation
+
+### Window Management
+- `Window.current` is the active window
+- `Window.redisplay` updates the display
+- `Window.echo_area` for messages
+- `message(text)` to display in echo area
+
+## File Organization
+
+- `lib/textbringer.rb`: Main entry point, requires all components
+- `lib/textbringer/commands/*.rb`: Command implementations by category
+- `lib/textbringer/modes/*.rb`: Major and minor modes
+- `lib/textbringer/faces/*.rb`: Syntax highlighting face definitions
+- `exe/txtb`: Main executable
+- `exe/tbclient`: Client for server mode
+- `exe/tbtags`: Tag file generator
+
+## Notes
+
+- The editor is designed to mimic Emacs conventions and terminology
+- Key sequences use Emacs notation: C- (Control), M- (Meta/Alt), S- (Shift)
+- The codebase uses extensive metaprogramming for command registration and mode definition
+- All user-facing text editing operations should go through Buffer methods to maintain undo/redo support

data/lib/textbringer/buffer.rb

@@ -10,7 +10,8 @@ module Textbringer
 
     attr_accessor :mode, :keymap
     attr_reader :name, :file_name, :file_encoding, :file_format, :point, :marks
-    attr_reader :current_line, :current_column, :visible_mark
+    attr_reader :current_line, :current_column, :visible_mark, :mark_active
+    attr_reader :last_match
     attr_reader :input_method
 
     GAP_SIZE = 256
@@ -253,8 +254,10 @@ module Textbringer
       @save_point_level = 0
       @match_offsets = []
       @visible_mark = nil
+      @mark_active = false
       @read_only = read_only
       @callbacks = {}
+      @last_match = nil
       @input_method = nil
     end
 
@@ -945,6 +948,20 @@ module Textbringer
       end
     end
 
+    def activate_mark
+      @mark_active = true
+      set_visible_mark(@mark.location) if @mark
+    end
+
+    def deactivate_mark
+      @mark_active = false
+      delete_visible_mark
+    end
+
+    def mark_active?
+      @mark_active
+    end
+
     def self.region_boundaries(s, e)
       if s > e
         [e, s]
@@ -1159,6 +1176,7 @@ module Textbringer
 
     def byteindex(forward, re, pos)
       @match_offsets = []
+      @last_match = nil
       method = forward ? :byteindex : :byterindex
       adjust_gap(0, 0)
       s = @contents.byteslice(@gap_end..-1)
@@ -1167,9 +1185,9 @@ module Textbringer
       end
       i = s.send(method, re, pos)
       if i
-        m = Regexp.last_match
-        (0 .. m.size - 1).each do |j|
-          @match_offsets.push(m.byteoffset(j))
+        @last_match = Regexp.last_match
+        (0 .. @last_match.size - 1).each do |j|
+          @match_offsets.push(@last_match.byteoffset(j))
         end
         i
       else
@@ -1294,6 +1312,10 @@ module Textbringer
       end
     end
 
+    def minor_mode_active?(mode_class)
+      @minor_modes.any? { |mode| mode.instance_of?(mode_class) }
+    end
+
     def mode_names
       names = []
       names.push(mode&.name || 'None')

data/lib/textbringer/commands/buffers.rb

@@ -93,7 +93,12 @@ module Textbringer
 
     define_command(:exchange_point_and_mark,
                    doc: "Exchange the positions of point and mark.") do
-      Buffer.current.exchange_point_and_mark
+      buffer = Buffer.current
+      buffer.exchange_point_and_mark
+      # Activate mark if transient mark mode is enabled
+      if TransientMarkMode.enabled?
+        buffer.activate_mark
+      end
     end
 
     define_command(:copy_region,
@@ -147,6 +152,10 @@ module Textbringer
         buffer.pop_to_mark
       else
         buffer.push_mark
+        # Activate mark if transient mark mode is enabled
+        if TransientMarkMode.enabled?
+          buffer.activate_mark
+        end
         message("Mark set")
       end
     end

data/lib/textbringer/commands/isearch.rb

@@ -77,7 +77,10 @@ module Textbringer
     end
 
     def isearch_done
-      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
       Controller.current.overriding_map = nil
       remove_hook(:pre_command_hook, :isearch_pre_command_hook)
       ISEARCH_STATUS[:last_string] = ISEARCH_STATUS[:string]
@@ -154,8 +157,11 @@ module Textbringer
         if Buffer.current != Buffer.minibuffer
           message(isearch_prompt + ISEARCH_STATUS[:string], log: false)
         end
-        Buffer.current.set_visible_mark(forward ? match_beginning(0) :
-                                        match_end(0))
+        # Don't update visible_mark if mark is already active (transient mark mode)
+        unless Buffer.current.mark_active?
+          Buffer.current.set_visible_mark(forward ? match_beginning(0) :
+                                          match_end(0))
+        end
         goto_char(forward ? match_end(0) : match_beginning(0))
       else
         if Buffer.current != Buffer.minibuffer

data/lib/textbringer/commands/ispell.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "open3"
+require "uri"
 
 module Textbringer
   module Commands
@@ -8,13 +9,17 @@ module Textbringer
       def initialize
         @personal_dictionary_modified = false
         @stdin, @stdout, @stderr, @wait_thr =
-          Open3.popen3("aspell -a")
+          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+(.*)/
@@ -70,66 +75,54 @@ module Textbringer
     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 = {}
 
-    ISPELL_WORD_REGEXP = /[A-Za-z]+/
-
-    define_command(:ispell_word) do
-      buffer = Buffer.current
-      word = buffer.save_excursion {
-        while !buffer.beginning_of_buffer? && buffer.char_after =~ /[A-Za-z]/
-          buffer.backward_char
-        end
-        buffer.re_search_forward(/[A-Za-z]+/, raise_error: false) &&
-          buffer.match_string(0)
-      }
-      if word.nil?
-        message("No word at point.")
-        return
-      end
-      start_pos = buffer.match_beginning(0)
-      end_pos = buffer.match_end(0)
-      ispell = Ispell.new
-      begin
-        _original, suggestions = ispell.check_word(word)
-        if suggestions.nil? || suggestions.empty?
-          message("#{word.inspect} is spelled correctly.")
-        else
-          s = read_from_minibuffer("Correct #{word} with: ",
-                                   completion_proc: ->(s) {
-                                     suggestions.grep(/^#{Regexp.quote(s)}/)
-                                   })
-          if s
-            buffer.composite_edit do
-              buffer.delete_region(start_pos, end_pos)
-              buffer.insert(s)
-            end
-          end
-        end
-      ensure
-        ispell.close
-      end
-    end
+    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
-      ispell_forward
-      ISPELL_STATUS[:recursive_edit] = recursive_edit
-      if recursive_edit
-        recursive_edit()
+      if !ispell_forward
+        ISPELL_STATUS[:recursive_edit] = recursive_edit
+        if recursive_edit
+          recursive_edit()
+        end
       end
     end
 
     def ispell_done
-      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
       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
@@ -141,8 +134,15 @@ module Textbringer
       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
-        buffer.set_visible_mark
+        # 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)
@@ -150,9 +150,9 @@ module Textbringer
           ISPELL_STATUS[:beginning] = ispell_beginning
           ISPELL_STATUS[:word] = word
           ISPELL_STATUS[:suggestions] = suggestions
-          message("Mispelled: #{word}  [r]eplace, [a]ccept, [i]nsert, [SPC] to skip, [q]uit")
+          message_misspelled
           recenter
-          return
+          return false
         end
       end
       Controller.current.overriding_map = nil
@@ -162,17 +162,25 @@ module Textbringer
       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
-      s = read_from_minibuffer("Correct #{word} with: ",
-                               completion_proc: ->(s) {
-        suggestions.grep(/^#{Regexp.quote(s)}/)
-      })
-      Controller.current.overriding_map = ISPELL_MODE_MAP
+      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
@@ -186,28 +194,43 @@ module Textbringer
     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
-      word = ISPELL_STATUS[:word]
-      message("Mispelled: #{word}  [r]eplace, [a]ccept, [i]nsert, [SPC] to skip, [q]uit")
+      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/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/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

data/lib/textbringer/modes/transient_mark_mode.rb

@@ -0,0 +1,101 @@
+require "set"
+
+module Textbringer
+  # Transient Mark Mode is a global minor mode that highlights
+  # the region between mark and point when the mark is active.
+  class TransientMarkMode < GlobalMinorMode
+    # Commands that should NOT deactivate the mark
+    MARK_PRESERVING_COMMANDS = [
+      :set_mark_command,
+      :exchange_point_and_mark,
+      :transient_mark_mode,
+      # Navigation commands that should preserve mark
+      :beginning_of_line,
+      :end_of_line,
+      :next_line,
+      :previous_line,
+      :forward_char,
+      :backward_char,
+      :forward_word,
+      :backward_word,
+      :scroll_up_command,
+      :scroll_down_command,
+      :beginning_of_buffer,
+      :end_of_buffer,
+      # Search commands
+      :isearch_forward,
+      :isearch_backward,
+      :isearch_repeat_forward,
+      :isearch_repeat_backward,
+      :isearch_printing_char,
+      # Undo/redo
+      :undo,
+      :redo_command,
+      # Other navigation
+      :goto_line,
+      :goto_char,
+      :recenter,
+      :move_to_beginning_of_line,
+      :move_to_end_of_line
+    ].to_set.freeze
+
+    # Hook to deactivate mark before most commands
+    PRE_COMMAND_HOOK = -> {
+      buffer = Buffer.current
+      controller = Controller.current
+
+      return unless buffer.mark_active?
+
+      # Check if this command preserves the mark
+      command = controller.this_command
+      unless MARK_PRESERVING_COMMANDS.include?(command)
+        buffer.deactivate_mark
+      end
+    }
+
+    # Hook to update visible mark after commands
+    POST_COMMAND_HOOK = -> {
+      buffer = Buffer.current
+
+      # Skip if in isearch or ispell mode (they manage their own highlighting)
+      controller = Controller.current
+      if controller.overriding_map
+        return if Commands.const_defined?(:ISEARCH_MODE_MAP) &&
+                  controller.overriding_map == Commands::ISEARCH_MODE_MAP
+        return if Commands.const_defined?(:ISPELL_MODE_MAP) &&
+                  controller.overriding_map == Commands::ISPELL_MODE_MAP
+      end
+
+      # Update visible_mark to reflect mark_active state
+      if buffer.mark_active?
+        begin
+          mark = buffer.mark
+          buffer.set_visible_mark(mark.location) if mark
+        rescue EditorError
+          # Mark is not set, do nothing
+        end
+      elsif !buffer.mark_active? && buffer.visible_mark
+        buffer.delete_visible_mark
+      end
+    }
+
+    def self.enable
+      # Add global hooks (not buffer-local)
+      add_hook(:pre_command_hook, PRE_COMMAND_HOOK, local: false)
+      add_hook(:post_command_hook, POST_COMMAND_HOOK, local: false)
+      message("Transient Mark mode enabled")
+    end
+
+    def self.disable
+      # Remove global hooks
+      remove_hook(:pre_command_hook, PRE_COMMAND_HOOK, local: false)
+      remove_hook(:post_command_hook, POST_COMMAND_HOOK, local: false)
+
+      # Deactivate mark in all buffers
+      Buffer.list.each do |buffer|
+        buffer.deactivate_mark
+      end
+      message("Transient Mark mode disabled")
+    end
+  end
+end

data/lib/textbringer/utils.rb

@@ -134,7 +134,6 @@ module Textbringer
     end
 
     COMPLETION = {
-      original_buffer: nil,
       completions_window: nil
     }
 
@@ -186,11 +185,14 @@ module Textbringer
         Buffer.minibuffer.keymap = old_minibuffer_map
         Buffer.minibuffer.disable_input_method
         Controller.current.current_prefix_arg = old_current_prefix_arg
-        if COMPLETION[:original_buffer]
-          COMPLETION[:completions_window].buffer = COMPLETION[:original_buffer]
-          COMPLETION[:completions_window] = nil
-          COMPLETION[:original_buffer] = nil
-        end
+        delete_completions_window
+      end
+    end
+
+    def delete_completions_window
+      if COMPLETION[:completions_window]
+        Window.delete_window(COMPLETION[:completions_window])
+        COMPLETION[:completions_window] = nil
       end
     end
 

data/lib/textbringer/version.rb

@@ -1,3 +1,3 @@
 module Textbringer
-  VERSION = "14"
+  VERSION = "15"
 end

data/lib/textbringer/window.rb

@@ -405,7 +405,7 @@ module Textbringer
         @window.erase
         @window.setpos(0, 0)
         @window.attrset(0)
-        if @buffer.visible_mark &&
+        if current? && @buffer.visible_mark &&
            @buffer.point_after_mark?(@buffer.visible_mark)
           @window.attron(Curses::A_REVERSE)
         end
@@ -450,7 +450,7 @@ module Textbringer
           break if newx == columns && cury == lines - 2
           @buffer.forward_char
         end
-        if @buffer.visible_mark
+        if current? && @buffer.visible_mark
           @window.attroff(Curses::A_REVERSE)
         end
         @buffer.mark_to_point(@bottom_of_window)
@@ -679,7 +679,7 @@ module Textbringer
       if @buffer.point_at_mark?(point)
         @cursor.y = cury
         @cursor.x = curx
-        if @buffer.visible_mark
+        if current? && @buffer.visible_mark
           if @buffer.point_after_mark?(@buffer.visible_mark)
             @window.attroff(Curses::A_REVERSE)
           elsif @buffer.point_before_mark?(@buffer.visible_mark)
@@ -687,7 +687,7 @@ module Textbringer
           end
         end
       end
-      if @buffer.visible_mark &&
+      if current? && @buffer.visible_mark &&
          @buffer.point_at_mark?(@buffer.visible_mark)
         if @buffer.point_after_mark?(point)
           @window.attroff(Curses::A_REVERSE)

data/lib/textbringer.rb

@@ -37,7 +37,9 @@ require_relative "textbringer/modes/completion_list_mode"
 require_relative "textbringer/modes/buffer_list_mode"
 require_relative "textbringer/modes/help_mode"
 require_relative "textbringer/minor_mode"
+require_relative "textbringer/global_minor_mode"
 require_relative "textbringer/modes/overwrite_mode"
+require_relative "textbringer/modes/transient_mark_mode"
 require_relative "textbringer/input_method"
 require_relative "textbringer/input_methods/t_code_input_method"
 require_relative "textbringer/input_methods/hiragana_input_method"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textbringer
 version: !ruby/object:Gem::Version
-  version: '14'
+  version: '15'
 platform: ruby
 authors:
 - Shugo Maeda
@@ -329,6 +329,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGES.md
+- CLAUDE.md
 - Gemfile
 - LICENSE.txt
 - README.ja.md
@@ -368,6 +369,7 @@ files:
 - lib/textbringer/face.rb
 - lib/textbringer/faces/basic.rb
 - lib/textbringer/faces/programming.rb
+- lib/textbringer/global_minor_mode.rb
 - lib/textbringer/input_method.rb
 - lib/textbringer/input_methods/hangul_input_method.rb
 - lib/textbringer/input_methods/hiragana_input_method.rb
@@ -385,6 +387,7 @@ files:
 - lib/textbringer/modes/overwrite_mode.rb
 - lib/textbringer/modes/programming_mode.rb
 - lib/textbringer/modes/ruby_mode.rb
+- lib/textbringer/modes/transient_mark_mode.rb
 - lib/textbringer/plugin.rb
 - lib/textbringer/ring.rb
 - lib/textbringer/utils.rb