textbringer 0.1.4 → 0.1.5

data/lib/textbringer/commands/buffers.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    [
+      :forward_char,
+      :backward_char,
+      :forward_word,
+      :backward_word,
+      :next_line,
+      :previous_line,
+      :delete_char,
+      :backward_delete_char,
+    ].each do |name|
+      define_command(name) do |n = number_prefix_arg|
+        Buffer.current.send(name, n)
+      end
+    end
+
+    [
+      :beginning_of_line,
+      :end_of_line,
+      :beginning_of_buffer,
+      :end_of_buffer,
+      :exchange_point_and_mark,
+      :copy_region,
+      :kill_region,
+      :yank,
+      :newline,
+      :delete_region,
+      :transpose_chars
+    ].each do |name|
+      define_command(name) do
+        Buffer.current.send(name)
+      end
+    end
+
+    define_command(:set_mark_command) do
+      Buffer.current.set_mark
+      message("Mark set")
+    end
+
+    define_command(:goto_char) do
+      |n = read_from_minibuffer("Go to char: ")|
+      Buffer.current.goto_char(n.to_i)
+      Window.current.recenter_if_needed
+    end
+
+    define_command(:goto_line) do
+      |n = read_from_minibuffer("Go to line: ")|
+      Buffer.current.goto_line(n.to_i)
+      Window.current.recenter_if_needed
+    end
+
+    define_command(:self_insert) do |n = number_prefix_arg|
+      c = Controller.current.last_key
+      merge_undo = Controller.current.last_command == :self_insert
+      n.times do
+        Buffer.current.insert(c, merge_undo)
+      end
+    end
+
+    define_command(:quoted_insert) do |n = number_prefix_arg|
+      c = Controller.current.read_char
+      if !c.is_a?(String)
+        raise EditorError, "Invalid key"
+      end
+      n.times do
+        Buffer.current.insert(c)
+      end
+    end
+
+    define_command(:kill_line) do
+      Buffer.current.kill_line(Controller.current.last_command == :kill_region)
+      Controller.current.this_command = :kill_region
+    end
+
+    define_command(:kill_word) do
+      Buffer.current.kill_word(Controller.current.last_command == :kill_region)
+      Controller.current.this_command = :kill_region
+    end
+
+    define_command(:yank_pop) do
+      if Controller.current.last_command != :yank
+        raise EditorError, "Previous command was not a yank"
+      end
+      Buffer.current.yank_pop
+      Controller.current.this_command = :yank
+    end
+
+    define_command(:undo) do
+      Buffer.current.undo
+      message("Undo!")
+    end
+
+    define_command(:redo) do
+      Buffer.current.redo
+      message("Redo!")
+    end
+  end
+end

data/lib/textbringer/commands/clipboard.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "clipboard"
+
+module Textbringer
+  module Commands
+    CLIPBOARD_AVAILABLE =
+      Clipboard.implementation.name != :Linux || ENV["DISPLAY"]
+
+    if CLIPBOARD_AVAILABLE
+      GLOBAL_MAP.define_key("\ew", :clipboard_copy_region)
+      GLOBAL_MAP.define_key("\C-w", :clipboard_kill_region)
+      GLOBAL_MAP.define_key("\C-y", :clipboard_yank)
+    end
+
+    define_command(:clipboard_copy_region) do
+      copy_region
+      Clipboard.copy(KILL_RING.current)
+    end
+
+    define_command(:clipboard_kill_region) do
+      kill_region
+      Clipboard.copy(KILL_RING.current)
+    end
+
+    define_command(:clipboard_yank) do
+      s = Clipboard.paste.encode(Encoding::UTF_8)
+      if KILL_RING.empty? || KILL_RING.current != s
+        KILL_RING.push(s)
+      end
+      yank
+      Controller.current.this_command = :yank
+    end
+  end
+end

data/lib/textbringer/commands/ctags.rb

@@ -50,24 +50,20 @@ module Textbringer
         CTAGS[:candidates] = candidates
         index = 0
       end
-      tag_mark_stack = CTAGS[:tag_mark_stack]
-      if tag_mark_stack.size == TAG_MARK_LIMIT
-        mark = tag_mark_stack.shift
-        mark.delete
-      end
-      tag_mark_stack.push(Buffer.current.new_mark)
       file, addr, n = candidates[index]
-      find_file(file)
       case addr
       when /\A\d+\z/
+        push_tag_mark_and_find_file(file)
         goto_line(addr.to_i)
       when %r'\A/\^(.*)\$/\z'
+        push_tag_mark_and_find_file(file)
         beginning_of_buffer
         n.times do
           re_search_forward("^" + Regexp.quote($1) + "$")
         end
         beginning_of_line
       when %r'\A\?\^(.*)\$\?\z'
+        push_tag_mark_and_find_file(file)
         end_of_buffer
         n.times do
           re_search_backward("^" + Regexp.quote($1) + "$")
@@ -110,5 +106,16 @@ module Textbringer
         mark.delete
       end
     end
+
+    private
+
+    def push_tag_mark_and_find_file(file)
+      tag_mark_stack = CTAGS[:tag_mark_stack]
+      if tag_mark_stack.size == TAG_MARK_LIMIT
+        tag_mark_stack.shift.delete
+      end
+      tag_mark_stack.push(Buffer.current.new_mark)
+      find_file(file)
+    end
   end
 end

data/lib/textbringer/commands/dabbrev.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module Textbringer
-  using Module.new {
+  module DabbrevExtension
     refine Buffer do
-      def dabbrev_expand(contd)
+      def dabbrev_expand(contd = false)
         if contd && self[:dabbrev_stem]
           buffers = self[:dabbrev_buffers]
           buffer = self[:dabbrev_buffer]
@@ -13,43 +13,26 @@ module Textbringer
           candidates = self[:dabbrev_candidates]
         else
           buffers = Buffer.to_a
-          buffer = buffers.pop
-          stem = save_excursion {
-            pos = point
-            backward_word(regexp: /[\p{Letter}\p{Number}_\-]/)
-            substring(point, pos)
-          }
-          if stem.empty?
-            raise "No possible abbreviation"
-          end
+          buffers.delete(self)
+          buffer = self
+          stem = get_stem_at_point
           pos = point
           direction = :backward
           candidates = []
         end
-        candidates_exclusion = candidates.empty? ? "" :
-          "(?!(?:" + candidates.map { |s|
-            Regexp.quote(s)
-          }.join("|") + ")\\b)"
-        re = /\b#{Regexp.quote(stem)}#{candidates_exclusion}
-              ([\p{Letter}\p{Number}_\-]+)/x
+        re = dabbrev_regexp(stem, candidates)
         candidate = nil
         loop do
           pos, candidate = buffer.dabbrev_search(re, pos, direction)
-          if pos
-            break
+          break if pos
+          if direction == :backward
+            pos = buffer.point
+            direction = :forward
           else
-            if direction == :backward
-              pos = buffer.point
-              direction = :forward
-            else
-              buffer = buffers.pop
-              if buffer
-                pos = buffer.point
-                direction = :backward
-              else
-                break
-              end
-            end
+            buffer = buffers.pop
+            break if buffer.nil?
+            pos = buffer.point
+            direction = :backward
           end
         end
         if !candidates.empty?
@@ -82,8 +65,32 @@ module Textbringer
           end
         end
       end
+
+      private
+
+      def get_stem_at_point
+        save_excursion {
+          pos = point
+          backward_word(regexp: /[\p{Letter}\p{Number}_\-]/)
+          if point == pos
+            raise EditorError, "No possible abbreviation"
+          end
+          substring(point, pos)
+        }
+      end
+
+      def dabbrev_regexp(stem, candidates)
+        candidates_exclusion = candidates.empty? ? "" :
+          "(?!(?:" + candidates.map { |s|
+            Regexp.quote(s)
+          }.join("|") + ")\\b)"
+        /\b#{Regexp.quote(stem)}#{candidates_exclusion}
+        ([\p{Letter}\p{Number}_\-]+)/x
+      end
     end
-  }
+  end
+
+  using DabbrevExtension
 
   module Commands
     GLOBAL_MAP.define_key("\e/", :dabbrev_expand_command)

data/lib/textbringer/commands/files.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    define_command(:find_file) do
+      |file_name = read_file_name("Find file: ")|
+      buffer = Buffer.find_file(file_name)
+      if buffer.new_file?
+        message("New file")
+      end
+      switch_to_buffer(buffer)
+      shebang = buffer.save_excursion {
+        buffer.beginning_of_buffer
+        buffer.looking_at?(/#!.*$/) ? buffer.match_string(0) : nil
+      }
+      mode = Mode.list.find { |m|
+        (m.file_name_pattern &&
+         m.file_name_pattern =~ File.basename(buffer.file_name)) ||
+          (m.interpreter_name_pattern &&
+           m.interpreter_name_pattern =~ shebang)
+      } || FundamentalMode
+      send(mode.command_name)
+    end
+
+    define_command(:save_buffer) do
+      if Buffer.current.file_name.nil?
+        Buffer.current.file_name = read_file_name("File to save in: ")
+        next if Buffer.current.file_name.nil?
+      end
+      if Buffer.current.file_modified?
+        unless yes_or_no?("File changed on disk.  Save anyway?")
+          message("Cancelled")
+          next
+        end
+      end
+      Buffer.current.save
+      message("Wrote #{Buffer.current.file_name}")
+    end
+
+    define_command(:write_file) do
+      |file_name = read_file_name("Write file: ")|
+      if File.directory?(file_name)
+        file_name = File.expand_path(Buffer.current.name, file_name)
+      end
+      if File.exist?(file_name)
+        unless y_or_n?("File `#{file_name}' exists; overwrite?")
+          message("Cancelled")
+          next
+        end
+      end
+      Buffer.current.save(file_name)
+      message("Wrote #{Buffer.current.file_name}")
+    end
+
+    define_command(:set_buffer_file_encoding) do
+      |enc = read_from_minibuffer("File encoding: ",
+                                  default: Buffer.current.file_encoding.name)|
+      Buffer.current.file_encoding = enc
+    end
+
+    define_command(:set_buffer_file_format) do
+      |format = read_from_minibuffer("File format: ",
+                                     default: Buffer.current.file_format.to_s)|
+      Buffer.current.file_format = format
+    end
+
+    define_command(:pwd) do
+      message(Dir.pwd)
+    end
+
+    define_command(:chdir) do
+      |dir_name = read_file_name("Change directory: ")|
+      Dir.chdir(dir_name)
+    end
+  end
+end

data/lib/textbringer/commands/isearch.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    ISEARCH_MODE_MAP = Keymap.new
+    (?\x20..?\x7e).each do |c|
+      ISEARCH_MODE_MAP.define_key(c, :isearch_printing_char)
+    end
+    ISEARCH_MODE_MAP.define_key(?\t, :isearch_printing_char)
+    ISEARCH_MODE_MAP.handle_undefined_key do |key|
+      if key.is_a?(String) && /[\0-\x7f]/ !~ key 
+        :isearch_printing_char
+      else
+        nil
+      end
+    end
+    ISEARCH_MODE_MAP.define_key(:backspace, :isearch_delete_char)
+    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-g, :isearch_abort)
+    
+    ISEARCH_STATUS = {
+      forward: true,
+      string: "",
+      last_string: "",
+      start: 0,
+      last_pos: 0,
+      recursive_edit: false
+    }
+
+    define_command(:isearch_forward) do |**options|
+      isearch_mode(true, **options)
+    end
+
+    define_command(:isearch_backward) do |**options|
+      isearch_mode(false, **options)
+    end
+
+    def isearch_mode(forward, recursive_edit: false)
+      ISEARCH_STATUS[:forward] = forward
+      ISEARCH_STATUS[:string] = String.new
+      ISEARCH_STATUS[:recursive_edit] = recursive_edit
+      Controller.current.overriding_map = ISEARCH_MODE_MAP
+      run_hooks(:isearch_mode_hook)
+      add_hook(:pre_command_hook, :isearch_pre_command_hook)
+      ISEARCH_STATUS[:start] = ISEARCH_STATUS[:last_pos] = Buffer.current.point
+      if Buffer.current != Buffer.minibuffer
+        message(isearch_prompt, log: false)
+      end
+      if recursive_edit
+        recursive_edit()
+      end
+    end
+
+    def isearch_prompt
+      if ISEARCH_STATUS[:forward]
+        "I-search: "
+      else
+        "I-search backward: "
+      end
+    end
+
+    def isearch_pre_command_hook
+      if /\Aisearch_/ !~ Controller.current.this_command
+        isearch_done
+      end
+    end
+
+    def isearch_done
+      Buffer.current.delete_visible_mark
+      Controller.current.overriding_map = nil
+      remove_hook(:pre_command_hook, :isearch_pre_command_hook)
+      ISEARCH_STATUS[:last_string] = ISEARCH_STATUS[:string]
+      if ISEARCH_STATUS[:recursive_edit]
+        exit_recursive_edit
+      end
+    end
+
+    define_command(:isearch_exit) do
+      isearch_done
+    end
+
+    define_command(:isearch_abort) do
+      goto_char(Buffer.current[:isearch_start])
+      isearch_done
+      raise Quit
+    end
+
+    define_command(:isearch_printing_char) do
+      c = Controller.current.last_key
+      ISEARCH_STATUS[:string].concat(c)
+      isearch_search
+    end
+
+    define_command(:isearch_delete_char) do
+      ISEARCH_STATUS[:string].chop!
+      isearch_search
+    end
+
+    def isearch_search
+      forward = ISEARCH_STATUS[:forward]
+      options = if /\A[A-Z]/ =~ ISEARCH_STATUS[:string]
+                  nil
+                else
+                  Regexp::IGNORECASE
+                end
+      re = Regexp.new(Regexp.quote(ISEARCH_STATUS[:string]), options)
+      last_pos = ISEARCH_STATUS[:last_pos]
+      offset = forward ? last_pos : last_pos - ISEARCH_STATUS[:string].bytesize
+      if Buffer.current.byteindex(forward, re, offset)
+        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))
+        goto_char(forward ? match_end(0) : match_beginning(0))
+      else
+        if Buffer.current != Buffer.minibuffer
+          message("Failing " + isearch_prompt + ISEARCH_STATUS[:string],
+                  log: false)
+        end
+      end
+    end
+
+    def isearch_repeat_forward
+      isearch_repeat(true)
+    end
+
+    def isearch_repeat_backward
+      isearch_repeat(false)
+    end
+
+    def isearch_repeat(forward)
+      ISEARCH_STATUS[:forward] = forward
+      ISEARCH_STATUS[:last_pos] = Buffer.current.point
+      if ISEARCH_STATUS[:string].empty?
+        ISEARCH_STATUS[:string] = ISEARCH_STATUS[:last_string]
+      end
+      isearch_search
+    end
+  end
+end