textbringer 0.1.0

data/lib/textbringer/controller.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Textbringer
+  TOP_LEVEL_TAG = Object.new
+  RECURSIVE_EDIT_TAG = Object.new
+
+  class Controller
+    attr_accessor :this_command, :last_command, :overriding_map
+    attr_accessor :prefix_arg, :current_prefix_arg
+    attr_reader :last_key
+
+    @@current = nil
+
+    def self.current
+      @@current
+    end
+
+    def self.current=(controller)
+      @@current = controller
+    end
+
+    def initialize
+      @key_sequence = []
+      @last_key = nil
+      @recursive_edit_level = 0
+      @this_command = nil
+      @last_command = nil
+      @overriding_map = nil
+      @prefix_arg = nil
+      @current_prefix_arg = nil
+    end
+
+    def command_loop(tag)
+      catch(tag) do
+        loop do
+          begin
+            c = Window.current.getch
+            Window.echo_area.clear_message
+            @last_key = c
+            @key_sequence << @last_key
+            cmd = key_binding(@key_sequence)
+            if cmd.is_a?(Symbol) || cmd.respond_to?(:call)
+              @key_sequence.clear
+              @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)
+                else
+                  cmd.call
+                end
+              ensure
+                run_hooks(:post_command_hook, remove_on_error: true)
+                @last_command = @this_command
+                @this_command = nil
+              end
+            else
+              if cmd.nil?
+                keys = @key_sequence.map { |c| key_name(c) }.join(" ")
+                @key_sequence.clear
+                Window.echo_area.show("#{keys} is undefined")
+              end
+            end
+          rescue Exception => e
+            handle_exception(e)
+          end
+          Window.redisplay
+        end
+      end
+    end
+
+    def wait_input(msecs)
+      Window.current.wait_input(msecs)
+    end
+
+    def read_char
+      Window.current.getch
+    end
+
+    def received_keyboard_quit?
+      while (key = Window.current.getch_nonblock) && key >= 0
+        if GLOBAL_MAP.lookup([key]) == :keyboard_quit
+          return true
+        end
+      end
+      false
+    end
+
+    def recursive_edit
+      @recursive_edit_level += 1
+      begin
+        if command_loop(RECURSIVE_EDIT_TAG)
+          raise Quit
+        end
+      ensure
+        @recursive_edit_level -= 1
+      end
+    end
+
+    private
+
+    def key_name(key)
+      case key
+      when Integer
+        if key < 0x80
+          s = Ncurses.keyname(key)
+          case s
+          when /\AKEY_(.*)/
+            "<#{$1.downcase}>"
+          else
+            s
+          end
+        else
+          key.chr(Encoding::UTF_8)
+        end
+      else
+        key.to_s
+      end
+    end
+
+    def key_binding(key_sequence)
+      @overriding_map&.lookup(key_sequence) ||
+      Buffer.current&.keymap&.lookup(key_sequence) ||
+        GLOBAL_MAP.lookup(key_sequence)
+    end
+  end
+end

data/lib/textbringer/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class EditorError < StandardError
+  end
+
+  class SearchError < EditorError
+  end
+
+  class ReadOnlyError < EditorError
+  end
+end

data/lib/textbringer/keymap.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "ncursesw"
+
+module Textbringer
+  class Keymap
+    def initialize
+      @map = {}
+    end
+
+    def define_key(key, command)
+      key_sequence = kbd(key)
+
+      case key_sequence.size
+      when 0
+        raise ArgumentError, "Empty key"
+      when 1
+        @map[key_sequence.first] = command
+      else
+        k, *ks = key_sequence
+        (@map[k] ||= Keymap.new).define_key(ks, command)
+      end
+    end
+    alias [] define_key
+
+    def lookup(key_sequence)
+      case key_sequence.size
+      when 0
+        raise ArgumentError, "Empty key"
+      when 1
+        @map[key_sequence.first]
+      else
+        k, *ks = key_sequence
+        @map[k]&.lookup(ks)
+      end
+    end
+
+    def handle_undefined_key
+      @map.default_proc = Proc.new { |h, k| yield(k) }
+    end
+
+    private
+
+    def kbd(key)
+      case key
+      when Integer, Symbol
+        [key]
+      when String
+        key.unpack("C*")
+      when Array
+        key
+      else
+        raise TypeError, "invalid key type #{key.class}"
+      end
+    end
+  end
+
+  GLOBAL_MAP = Keymap.new
+  GLOBAL_MAP.define_key(:resize, :resize_window)
+  GLOBAL_MAP.define_key(:right, :forward_char)
+  GLOBAL_MAP.define_key(?\C-f, :forward_char)
+  GLOBAL_MAP.define_key(:left, :backward_char)
+  GLOBAL_MAP.define_key(?\C-b, :backward_char)
+  GLOBAL_MAP.define_key("\ef", :forward_word)
+  GLOBAL_MAP.define_key("\eb", :backward_word)
+  GLOBAL_MAP.define_key("\egc", :goto_char)
+  GLOBAL_MAP.define_key("\egg", :goto_line)
+  GLOBAL_MAP.define_key("\eg\eg", :goto_line)
+  GLOBAL_MAP.define_key(:down, :next_line)
+  GLOBAL_MAP.define_key(?\C-n, :next_line)
+  GLOBAL_MAP.define_key(:up, :previous_line)
+  GLOBAL_MAP.define_key(?\C-p, :previous_line)
+  GLOBAL_MAP.define_key(:dc, :delete_char)
+  GLOBAL_MAP.define_key(?\C-d, :delete_char)
+  GLOBAL_MAP.define_key(:backspace, :backward_delete_char)
+  GLOBAL_MAP.define_key(?\C-h, :backward_delete_char)
+  GLOBAL_MAP.define_key(?\C-a, :beginning_of_line)
+  GLOBAL_MAP.define_key(:home, :beginning_of_line)
+  GLOBAL_MAP.define_key(?\C-e, :end_of_line)
+  GLOBAL_MAP.define_key(:end, :end_of_line)
+  GLOBAL_MAP.define_key("\e<", :beginning_of_buffer)
+  GLOBAL_MAP.define_key("\e>", :end_of_buffer)
+  (0x20..0x7e).each do |c|
+    GLOBAL_MAP.define_key(c, :self_insert)
+  end
+  GLOBAL_MAP.define_key(?\t, :self_insert)
+  GLOBAL_MAP.define_key(?\C-q, :quoted_insert)
+  GLOBAL_MAP.define_key("\C- ", :set_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)
+  GLOBAL_MAP.define_key(?\C-k, :kill_line)
+  GLOBAL_MAP.define_key("\ed", :kill_word)
+  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-t", :transpose_chars)
+  GLOBAL_MAP.define_key(?\n, :newline)
+  GLOBAL_MAP.define_key("\C-l", :recenter)
+  GLOBAL_MAP.define_key("\C-v", :scroll_up)
+  GLOBAL_MAP.define_key(:npage, :scroll_up)
+  GLOBAL_MAP.define_key("\ev", :scroll_down)
+  GLOBAL_MAP.define_key(:ppage, :scroll_down)
+  GLOBAL_MAP.define_key("\C-x0", :delete_window)
+  GLOBAL_MAP.define_key("\C-x1", :delete_other_windows)
+  GLOBAL_MAP.define_key("\C-x2", :split_window)
+  GLOBAL_MAP.define_key("\C-xo", :other_window)
+  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)
+  GLOBAL_MAP.define_key("\C-xb", :switch_to_buffer)
+  GLOBAL_MAP.define_key("\C-x\C-s", :save_buffer)
+  GLOBAL_MAP.define_key("\C-x\C-w", :write_file)
+  GLOBAL_MAP.define_key("\C-xk", :kill_buffer)
+  GLOBAL_MAP.define_key("\C-x\nf", :set_buffer_file_encoding)
+  GLOBAL_MAP.define_key("\C-x\nn", :set_buffer_file_format)
+  GLOBAL_MAP.define_key("\ex", :execute_command)
+  GLOBAL_MAP.define_key("\e:", :eval_expression)
+  GLOBAL_MAP.define_key(?\C-u, :universal_argument)
+  GLOBAL_MAP.define_key(?\C-g, :keyboard_quit)
+  GLOBAL_MAP.define_key(?\C-s, :isearch_forward)
+  GLOBAL_MAP.define_key(?\C-r, :isearch_backward)
+  GLOBAL_MAP.handle_undefined_key do |key|
+    if key.is_a?(Integer) && key > 0x80
+      begin
+        key.chr(Encoding::UTF_8)
+        :self_insert
+      rescue RangeError
+        nil
+      end
+    else
+      nil
+    end
+  end
+
+  MINIBUFFER_LOCAL_MAP = Keymap.new
+  MINIBUFFER_LOCAL_MAP.define_key(?\n, :exit_recursive_edit)
+  MINIBUFFER_LOCAL_MAP.define_key(?\t, :complete_minibuffer)
+  MINIBUFFER_LOCAL_MAP.define_key(?\C-g, :abort_recursive_edit)
+end

data/lib/textbringer/mode.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class Mode
+    extend Commands
+    include Commands
+    
+    @@mode_list = []
+    
+    def self.list
+      @@mode_list
+    end
+
+    class << self
+      attr_accessor :mode_name
+      attr_accessor :command_name
+      attr_accessor :hook_name
+      attr_accessor :file_name_pattern
+    end
+
+    def self.define_generic_command(name)
+      command_name = (name.to_s + "_command").intern
+      define_command(command_name) do |*args|
+        begin
+          Buffer.current.mode.send(name, *args)
+        rescue NoMethodError => e
+          if e.receiver == Buffer.current.mode && e.name == name
+            raise EditorError,
+              "#{command_name} is not supported in the current mode"
+          else
+            raise
+          end
+        end
+      end
+    end
+
+    def self.inherited(child)
+      base_name = child.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
+      hook = (command_name + "_hook").intern
+      child.command_name = command
+      child.hook_name = hook
+      define_command(command) do
+        Buffer.current.apply_mode(child)
+      end
+      @@mode_list.push(child)
+    end
+
+    attr_reader :buffer
+
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def name
+      self.class.mode_name
+    end
+  end
+end

data/lib/textbringer/modes/backtrace_mode.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class BacktraceMode < Mode
+    define_generic_command :jump_to_source_location
+
+    BACKTRACE_MODE_MAP = Keymap.new
+    BACKTRACE_MODE_MAP.define_key("\n", :jump_to_source_location_command)
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = BACKTRACE_MODE_MAP
+    end
+
+    def jump_to_source_location
+      file_name, line_number = get_source_location
+      if file_name
+        find_file(file_name)
+        goto_line(line_number)
+      end
+    end
+
+    private
+
+    def get_source_location
+      @buffer.save_excursion do
+        @buffer.beginning_of_line
+        if @buffer.looking_at?(/^(\S*?):(\d+):/)
+          file_name = @buffer.match_string(1)
+          line_number = @buffer.match_string(2).to_i
+          [file_name, line_number]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/textbringer/modes/fundamental_mode.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class FundamentalMode < Mode
+  end
+end

data/lib/textbringer/modes/programming_mode.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class ProgrammingMode < Mode
+    # abstract mode
+    undefine_command(:programming_mode)
+
+    define_generic_command :indent_line
+    define_generic_command :newline_and_reindent
+    define_generic_command :forward_definition
+    define_generic_command :backward_definition
+    define_generic_command :compile
+
+    PROGRAMMING_MODE_MAP = Keymap.new
+    PROGRAMMING_MODE_MAP.define_key("\t", :indent_line_command)
+    PROGRAMMING_MODE_MAP.define_key("\n", :newline_and_reindent_command)
+    PROGRAMMING_MODE_MAP.define_key("\C-c\C-n", :forward_definition_command)
+    PROGRAMMING_MODE_MAP.define_key("\C-c\C-p", :backward_definition_command)
+    PROGRAMMING_MODE_MAP.define_key("\C-c\C-c", :compile_command)
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = PROGRAMMING_MODE_MAP
+    end
+
+    def newline_and_reindent
+      n = 1
+      @buffer.save_excursion do
+        pos = @buffer.point
+        @buffer.beginning_of_line
+        if /\A\s+\z/ =~ @buffer.substring(@buffer.point, pos)
+          @buffer.delete_region(@buffer.point, pos)
+          n += 1
+        end
+      end
+      @buffer.insert("\n")
+      if indent_line
+        n += 1
+      end
+      @buffer.merge_undo(n) if n > 1
+    end
+  end
+end

data/lib/textbringer/modes/ruby_mode.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module Textbringer
+  CONFIG[:ruby_indent_level] = 2
+  CONFIG[:ruby_indent_tabs_mode] = false
+
+  class RubyMode < ProgrammingMode
+    self.file_name_pattern = /\A(?:.*\.(?:rb|ru|rake|thor)|
+                              (?:Gem|Rake|Cap|Thor|Vagrant|Guard|Pod)file)\z/x
+
+    def initialize(buffer)
+      super(buffer)
+      @buffer[:indent_tabs_mode] = CONFIG[:ruby_indent_tabs_mode]
+    end
+
+    # Return true if modified.
+    def indent_line
+      result = false
+      level = calculate_indentation
+      @buffer.save_excursion do
+        @buffer.beginning_of_line
+        has_space = @buffer.looking_at?(/[ \t]+/)
+        if has_space
+          s = @buffer.match_string(0)
+          break if /\t/ !~ s && s.size == level
+          @buffer.delete_region(@buffer.match_beginning(0),
+                                @buffer.match_end(0))
+        else
+          break if level == 0
+        end
+        @buffer.indent_to(level)
+        if has_space
+          @buffer.merge_undo(2)
+        end
+        result = true
+      end
+      pos = @buffer.point
+      @buffer.beginning_of_line
+      @buffer.forward_char while /[ \t]/ =~ @buffer.char_after
+      if @buffer.point < pos
+        @buffer.goto_char(pos)
+      end
+      result
+    end
+
+    def forward_definition(n = number_prefix_arg || 1)
+      tokens = Ripper.lex(@buffer.to_s)
+      @buffer.forward_line
+      n.times do |i|
+        tokens = tokens.drop_while { |(l, c), e, t|
+          l < @buffer.current_line ||
+            e != :on_kw || /\A(?:class|module|def)\z/ !~ t
+        }
+        (line, column), event, text = tokens.first
+        if line.nil?
+          @buffer.end_of_buffer
+          break
+        end
+        @buffer.goto_line(line)
+        tokens = tokens.drop(1)
+      end
+      while /\s/ =~ @buffer.char_after
+        @buffer.forward_char
+      end
+    end
+
+    def backward_definition(n = number_prefix_arg || 1)
+      tokens = Ripper.lex(@buffer.to_s).reverse
+      @buffer.beginning_of_line
+      n.times do |i|
+        tokens = tokens.drop_while { |(l, c), e, t|
+          l >= @buffer.current_line ||
+            e != :on_kw || /\A(?:class|module|def)\z/ !~ t
+        }
+        (line, column), event, text = tokens.first
+        if line.nil?
+          @buffer.beginning_of_buffer
+          break
+        end
+        @buffer.goto_line(line)
+        tokens = tokens.drop(1)
+      end
+      while /\s/ =~ @buffer.char_after
+        @buffer.forward_char
+      end
+    end
+
+    def compile
+      cmd = read_from_minibuffer("Compile: ", default: default_compile_command)
+      shell_execute(cmd, "*Ruby compile result*")
+      backtrace_mode
+    end
+
+    private
+
+    def calculate_indentation
+      if @buffer.current_line == 1
+        return 0
+      end
+      @buffer.save_excursion do
+        @buffer.beginning_of_line
+        bol_pos = @buffer.point
+        tokens = Ripper.lex(@buffer.substring(@buffer.point_min,
+                                              @buffer.point))
+        line, column, event, text = find_nearest_beginning_token(tokens)
+        if event == :on_lparen
+          return column + 1
+        end
+        if line
+          @buffer.goto_line(line)
+        else
+          @buffer.backward_line
+        end
+        @buffer.looking_at?(/[ \t]*/)
+        base_indentation = @buffer.match_string(0).
+          gsub(/\t/, " " * @buffer[:tab_width]).size
+        @buffer.goto_char(bol_pos)
+        if line.nil? ||
+          @buffer.looking_at?(/[ \t]*([}\])]|(end|else|elsif|when|rescue|ensure)\b)/)
+          indentation = base_indentation
+        else
+          indentation = base_indentation + @buffer[:ruby_indent_level]
+        end
+        _, last_event, last_text = tokens.reverse_each.find { |_, e, _|
+          e != :on_sp && e != :on_nl && e != :on_ignored_nl
+        }
+        if (last_event == :on_op && last_text != "|") ||
+            last_event == :on_period
+          indentation += @buffer[:ruby_indent_level]
+        end
+        indentation
+      end
+    end
+    
+    BLOCK_END = {
+      "{" => "}",
+      "(" => ")",
+      "[" => "]"
+    }
+
+    def find_nearest_beginning_token(tokens)
+      stack = []
+      (tokens.size - 1).downto(0) do |i|
+        (line, column), event, text = tokens[i]
+        case event
+        when :on_kw
+          case text
+          when "class", "module", "def", "if", "unless", "case",
+            "do", "for", "while", "until", "begin"
+            if /\A(if|unless|while|until)\z/ =~ text
+              ts = tokens[0...i].reverse_each.take_while { |(l,_),| l == line }
+              t = ts.find { |_, e| e != :on_sp }
+              next if t && !(t[1] == :on_op && t[2] == "=")
+            end
+            if stack.empty?
+              return line, column, event, text
+            end
+            if stack.last != "end"
+              raise EditorError, "#{@buffer.name}:#{line}: Unmatched #{text}"
+            end
+            stack.pop
+          when "end"
+            stack.push(text)
+          end
+        when :on_rbrace, :on_rparen, :on_rbracket
+          stack.push(text)
+        when :on_lbrace, :on_lparen, :on_lbracket, :on_tlambeg
+          if stack.empty?
+            return line, column, event, text
+          end
+          if stack.last != BLOCK_END[text]
+            raise EditorError, "#{@buffer.name}:#{line}: Unmatched #{text}"
+          end
+          stack.pop
+        end
+      end
+      return nil
+    end
+
+    def default_compile_command
+      @buffer[:ruby_compile_command] ||
+        if File.exist?("Rakefile")
+          prefix = File.exist?("Gemfile") ? "bundle exec " : ""
+          prefix + "rake"
+        else
+          "ruby " + @buffer.file_name
+        end
+    end
+  end
+end

data/lib/textbringer/modes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "mode"
+require_relative "modes/fundamental_mode"
+require_relative "modes/programming_mode"
+require_relative "modes/ruby_mode"
+require_relative "modes/backtrace_mode"