textbringer 0.1.6 → 0.1.7

data/lib/textbringer/config.rb

@@ -2,6 +2,7 @@
 
 module Textbringer
   CONFIG = {
+    east_asian_ambiguous_width: 1,
     default_file_encoding: Encoding::UTF_8,
     default_file_format: :unix,
     tab_width: 8,

data/lib/textbringer/controller.rb

@@ -28,13 +28,16 @@ module Textbringer
       @overriding_map = nil
       @prefix_arg = nil
       @current_prefix_arg = nil
+      @echo_immediately = false
     end
 
     def command_loop(tag)
       catch(tag) do
         loop do
           begin
+            echo_input
             c = read_char
+            break if c.nil?
             Window.echo_area.clear_message
             @last_key = c
             @key_sequence << @last_key
@@ -60,11 +63,13 @@ module Textbringer
               if cmd.nil?
                 keys = @key_sequence.map { |ch| key_name(ch) }.join(" ")
                 @key_sequence.clear
+                @prefix_arg = nil
                 message("#{keys} is undefined")
               end
             end
           rescue Exception => e
             show_exception(e)
+            @prefix_arg = nil
           end
           Window.redisplay
         end
@@ -109,6 +114,8 @@ module Textbringer
         "<#{key}>"
       when "\e"
         "ESC"
+      when "\n"
+        "RET"
       when /\A[\0-\b\v-\x1f\x7f]\z/
         "C-" + (key.ord ^ 0x40).chr.downcase
       else
@@ -123,5 +130,32 @@ module Textbringer
       Buffer.current&.keymap&.lookup(key_sequence) ||
         GLOBAL_MAP.lookup(key_sequence)
     end
+
+    def echo_input
+      if @prefix_arg || !@key_sequence.empty?
+        if !@echo_immediately
+          return if wait_input(1000)
+        end
+        @echo_immediately = true
+        s = String.new
+        if @prefix_arg
+          s << "C-u"
+          if @prefix_arg != [4]
+            s << "(#{@prefix_arg.inspect})"
+          end
+        end
+        if !@key_sequence.empty?
+          s << " " if !s.empty?
+          s << @key_sequence.map { |ch| key_name(ch) }.join(" ")
+        end
+        s << "-"
+        Window.echo_area.show(s)
+        Window.echo_area.redisplay
+        Window.current.window.noutrefresh
+        Window.update
+      else
+        @echo_immediately = false
+      end
+    end
   end
 end

data/lib/textbringer/modes/c_mode.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module Textbringer
+  CONFIG[:c_indent_level] = 4
+  CONFIG[:c_indent_tabs_mode] = true
+  CONFIG[:c_continued_statement_offset] = 4
+  CONFIG[:c_case_label_offset] = -4
+  CONFIG[:c_label_offset] = -2
+
+  class CMode < ProgrammingMode
+    self.file_name_pattern =  /\A.*\.[ch]\z/i
+
+    def initialize(buffer)
+      super(buffer)
+      @buffer[:indent_level] = CONFIG[:c_indent_level]
+      @buffer[:indent_tabs_mode] = CONFIG[:c_indent_tabs_mode]
+    end
+
+    def compile(cmd = read_from_minibuffer("Compile: ",
+                                           default: default_compile_command))
+      shell_execute(cmd, "*Compile result*")
+    end
+
+    def symbol_pattern
+      /[A-Za-z0-9\_\\]/
+    end
+
+    def default_compile_command
+      "make"
+    end
+
+    TOKEN_NAMES = [
+      :preprocessing_directive,
+      :comment,
+      :keyword,
+      :identifier,
+      :constant,
+      :string_literal,
+      :punctuator,
+      :space,
+      :partial_comment,
+      :unknown
+    ]
+    
+    TOKEN_REGEXP = /\G(?:
+(?<preprocessing_directive>
+  ^[ \t\f\v]*(?:\#|%:).*(?:\\\n.*)*[^\\]\n
+) |
+(?<comment>
+  (?<multiline_comment> \/\* (?> (?:.|\n)*? \*\/ ) ) |
+  (?<singleline_comment> \/\/ .*(?:\\\n.*)*(?<!\\)\n )
+) |
+(?<partial_comment>
+  (?<multiline_comment> \/\* (?:.|\n)* ) |
+  (?<singleline_comment> \/\/ .*? \\\n (?:.|\n)* )
+) |
+(?<keyword>
+  (?:
+    auto | break | case | char | const | continue | default | double | do |
+    else | enum | extern | float | for | goto | if | inline | int | long |
+    register | restrict | return | short | signed | sizeof | static | struct |
+    switch | typedef | union | unsigned | void | volatile | while | _Bool |
+    _Complex | _Imaginary
+  ) \b
+) |
+(?<constant>
+  (?<floating_constant>
+    (?<decimal_floating_constant>
+      (?<fractional_constant>
+        (?<digit_sequence> [0-9]+ )? \. \g<digit_sequence> |
+        \g<digit_sequence> \. )
+          (?<exponent_part> [eE] [+\-]? \g<digit_sequence> )?
+          (?<floating_suffix> [flFL] )?
+    ) |
+    (?<hexadecimal_floating_constant>
+      (?<hexadecimal_prefix> 0x | 0X )
+          (?<hexadecimal_fractional_constant>
+            (?<hexadecimal_digit_sequence> [0-9a-fA-F]+ )? \.
+                \g<hexadecimal_digit_sequence> |
+            \g<hexadecimal_digit_sequence> \. )
+          (?<binary_exponent_part> [pP] [+\-]? \g<digit_sequence> )
+          \g<floating_suffix>? |
+      \g<hexadecimal_prefix> \g<hexadecimal_digit_sequence>
+          \g<binary_exponent_part> \g<floating_suffix>?
+    )
+  ) |
+  (?<integer_constant>
+    (?<decimal_constant> [1-9][0-9]* )
+    (?<integer_suffix>
+      (?<unsigned_suffix> [uU] ) (?<long_suffix> [lL] )?
+      \g<unsigned_suffix> (?<long_long_suffix> ll | LL )?
+      \g<long_suffix> \g<unsigned_suffix>?
+      \g<long_long_suffix> \g<unsigned_suffix>?
+    )? |
+    (?<hexadecimal_constant>
+      \g<hexadecimal_prefix> \g<hexadecimal_digit_sequence> )
+          \g<integer_suffix>? |
+    (?<octal_constant> 0 (?<octal_digit> [0-7] )* )
+        \g<integer_suffix>?
+  ) |
+  (?<character_constant>
+    ' (?<c_char_sequence>
+        (?<c_char>
+          [^'\\\r\n] |
+          (?<escape_sequence>
+            (?<simple_escape_sequence> \\ ['"?\\abfnrtv] ) |
+            (?<octal_escape_sequence> \\ \g<octal_digit>{1,3} ) |
+            (?<hexadecimal_escape_sequence>
+              \\x \g<hexadecimal_digit_sequence> ) |
+            (?<universal_character_name>
+              \\u[0-9a-fA-F]{4} |
+              \\U[0-9a-fA-F]{8} )
+          )
+        )+
+      ) ' |
+    L' \g<c_char_sequence> '
+  )
+) |
+(?<string_literal>
+  " (?<s_char_sequence>
+      (?<s_char> [^"\\\r\n] | \g<escape_sequence> )+ ) " |
+  L" \g<s_char_sequence>? "
+) |
+(?<identifier>
+  (?<identifier_nondigit>
+    [_a-zA-Z] |
+    \g<universal_character_name> )
+        (?: \g<identifier_nondigit> | [0-9] )*
+) |
+(?<punctuator>
+  \[   |   \]   |   \(   |   \)   |   \{   |   \}   |
+  \.\.\.   |   \.   |
+  \+\+   |   \+=   |   \+   |
+  ->   |   --   |   -=   |   -   |
+  \*=   |   \*   |
+  \/=   |   \/   |
+  &&   |   &=   |   &   |
+  \|\|   |   \|=   |   \|   |
+  !=   |   !   |
+  ~   |
+  ==   |   =   |
+  \^=   |   \^   |
+  <:   |   <%   |   <<=   |   <<   |   <=   |   <   |
+  >>=   |   >>   |   >=   |   >   |
+  \?   |   ;   |
+  :>   |   :   |
+  ,   |
+  \#\#   |   \#   |
+  %>   |   %:%:   |   %:   |   %=   |   %
+) |
+(?<space>
+  \s+
+) |
+(?<unknown>.)
+    )/x
+
+    def lex(s)
+      tokens = []
+      pos = 0
+      line = 1
+      column = 0
+      while pos < s.size && s.index(TOKEN_REGEXP, pos)
+        text = $&
+        token_name = TOKEN_NAMES.find { |name| $~[name] }
+        if text.empty?
+          raise EditorError, "Empty token: (#{line},#{column}) #{$~.inspect}"
+        end
+        tokens.push([[line, column], token_name, text])
+        lf_count = text.count("\n")
+        if lf_count > 0
+          line += lf_count
+          column = text.slice(/[^\n]*\z/).size
+        else
+          column += text.size
+        end
+        pos += text.size
+      end
+      tokens
+    end
+
+    private
+
+    def calculate_indentation
+      if @buffer.current_line == 1
+        return 0
+      end
+      @buffer.save_excursion do
+        @buffer.beginning_of_line
+        if @buffer.looking_at?(/[ \t]*(?:#|%:)/)
+          return 0
+        end
+        bol_pos = @buffer.point
+        s = @buffer.substring(@buffer.point_min, @buffer.point).b
+        tokens = lex(s)
+        _, event, = tokens.last
+        if event == :partial_comment
+          return nil
+        end
+        line, column, event, text = find_nearest_beginning_token(tokens)
+        if event == :punctuator && text == "("
+          return column + 1
+        end
+        if line
+          @buffer.goto_line(line)
+        else
+          (ln, _), ev = tokens.reverse_each.drop_while { |(l, _), e, t|
+            l >= @buffer.current_line - 1 || e == :space
+          }.first
+          if ev == :comment
+            @buffer.goto_line(ln)
+          else
+            @buffer.backward_line
+          end
+        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]*([}\])]|:>|%>)/)
+          indentation = base_indentation
+        else
+          indentation = base_indentation + @buffer[:indent_level]
+        end
+        if @buffer.looking_at?(/[ \t]*(?:case.*|default):/)
+          indentation += @buffer[:c_case_label_offset]
+        elsif @buffer.looking_at?(/[ \t]*[_a-zA-Z0-9\\]+:/)
+          indentation += @buffer[:c_label_offset]
+        end
+        indent_continued_statement(indentation, tokens, line)
+      end
+    end
+
+    def indent_continued_statement(indentation, tokens ,line)
+      if line && !@buffer.looking_at?(/[ \t]*\{/)
+        _, last_event, last_text =
+          tokens.reverse_each.drop_while { |(l, _), e, t|
+            l == @buffer.current_line || e == :space || e == :comment
+          }.first
+        if last_event != :preprocessing_directive &&
+            /[:;{}]/ !~ last_text
+          indentation + @buffer[:c_continued_statement_offset]
+        else
+          indentation
+        end
+      else
+        indentation
+      end
+    end
+
+    CANONICAL_PUNCTUATORS = Hash.new { |h, k| k }
+    CANONICAL_PUNCTUATORS["<:"] = "["
+    CANONICAL_PUNCTUATORS[":>"] = "]"
+    CANONICAL_PUNCTUATORS["<%"] = "{"
+    CANONICAL_PUNCTUATORS["%>"] = "}"
+    BLOCK_END = {
+      "{" => "}",
+      "(" => ")",
+      "[" => "]"
+    }
+    BLOCK_BEG = BLOCK_END.invert
+
+    def find_nearest_beginning_token(tokens)
+      stack = []
+      (tokens.size - 1).downto(0) do |i|
+        (line, column), event, raw_text = tokens[i]
+        text = CANONICAL_PUNCTUATORS[raw_text]
+        case event
+        when :punctuator
+          if BLOCK_BEG.key?(text)
+            stack.push(text)
+          elsif BLOCK_END.key?(text)
+            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
+      end
+      return nil
+    end
+  end
+end

data/lib/textbringer/modes/completion_list_mode.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Textbringer
+  class CompletionListMode < Mode
+    define_generic_command :choose_completion
+
+    COMPLETION_LIST_MODE_MAP = Keymap.new
+    COMPLETION_LIST_MODE_MAP.define_key("\n", :choose_completion_command)
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = COMPLETION_LIST_MODE_MAP
+    end
+
+    def choose_completion
+      unless Window.echo_area.active?
+        raise EditorError, "Minibuffer is not active"
+      end
+      s = @buffer.save_excursion {
+        @buffer.beginning_of_line
+        @buffer.looking_at?(/.*/)
+        @buffer.match_string(0)
+      }
+      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
+      end
+    end
+  end
+end

data/lib/textbringer/modes/programming_mode.rb

@@ -25,6 +25,37 @@ module Textbringer
       buffer.keymap = PROGRAMMING_MODE_MAP
     end
 
+    # Return true if modified.
+    def indent_line
+      result = false
+      level = calculate_indentation
+      return result if level.nil?
+      @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 newline_and_reindent
       n = 1
       if indent_line
@@ -44,5 +75,11 @@ module Textbringer
       end
       @buffer.merge_undo(n) if n > 1
     end
+
+    private
+
+    def calculate_indentation
+      raise EditorError, "indent_line is not defined in the current mode"
+    end
   end
 end