ruvim 0.1.0 → 0.3.0

data/lib/ruvim/highlighter.rb

@@ -1,5 +1,14 @@
+# frozen_string_literal: true
+
 module RuVim
   module Highlighter
+    KEYWORD_COLOR = "\e[36m"
+    STRING_COLOR = "\e[32m"
+    NUMBER_COLOR = "\e[33m"
+    COMMENT_COLOR = "\e[90m"
+    VARIABLE_COLOR = "\e[93m"
+    CONSTANT_COLOR = "\e[96m"
+
     module_function
 
     def color_columns(filetype, line)
@@ -9,32 +18,18 @@ module RuVim
 
       case ft
       when "ruby"
-        ruby_color_columns(text)
+        Lang::Ruby.color_columns(text)
       when "json"
-        json_color_columns(text)
+        Lang::Json.color_columns(text)
+      when "markdown"
+        Lang::Markdown.color_columns(text)
+      when "scheme"
+        Lang::Scheme.color_columns(text)
       else
         {}
       end
     end
 
-    def ruby_color_columns(text)
-      cols = {}
-      apply_regex(cols, text, /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/, "\e[32m")
-      apply_regex(cols, text, /\b(?:def|class|module|end|if|elsif|else|unless|case|when|do|while|until|begin|rescue|ensure|return|yield)\b/, "\e[36m")
-      apply_regex(cols, text, /\b\d+(?:\.\d+)?\b/, "\e[33m")
-      apply_regex(cols, text, /#.*\z/, "\e[90m", override: true)
-      cols
-    end
-
-    def json_color_columns(text)
-      cols = {}
-      apply_regex(cols, text, /"(?:\\.|[^"\\])*"\s*(?=:)/, "\e[36m")
-      apply_regex(cols, text, /"(?:\\.|[^"\\])*"/, "\e[32m")
-      apply_regex(cols, text, /\b(?:true|false|null)\b/, "\e[35m")
-      apply_regex(cols, text, /-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b/, "\e[33m")
-      cols
-    end
-
     def apply_regex(cols, text, regex, color, override: false)
       text.to_enum(:scan, regex).each do
         m = Regexp.last_match
@@ -47,6 +42,6 @@ module RuVim
       end
     end
 
-    module_function :ruby_color_columns, :json_color_columns, :apply_regex
+    module_function :apply_regex
   end
 end

data/lib/ruvim/input.rb

@@ -1,34 +1,48 @@
+# frozen_string_literal: true
+
 module RuVim
   class Input
-    def initialize(stdin: STDIN)
-      @stdin = stdin
+    def initialize(input)
+      @input = input
     end
 
-    def read_key(timeout: nil, wakeup_ios: [])
-      ios = [@stdin, *wakeup_ios].compact
+    def read_key(timeout: nil, wakeup_ios: [], esc_timeout: nil)
+      ios = [@input, *wakeup_ios].compact
       readable = IO.select(ios, nil, nil, timeout)
       return nil unless readable
 
       ready = readable[0]
-      wakeups = ready - [@stdin]
+      wakeups = ready - [@input]
       wakeups.each { |io| drain_io(io) }
-      return nil unless ready.include?(@stdin)
-
-      ch = @stdin.getch
-      return :ctrl_c if ch == "\u0003"
-      return :ctrl_i if ch == "\u0009"
-      return :ctrl_n if ch == "\u000e"
-      return :ctrl_o if ch == "\u000f"
-      return :ctrl_p if ch == "\u0010"
-      return :ctrl_r if ch == "\u0012"
-      return :ctrl_v if ch == "\u0016"
-      return :ctrl_w if ch == "\u0017"
-      return :enter if ch == "\r" || ch == "\n"
-      return :backspace if ch == "\u007f" || ch == "\b"
+      return nil unless ready.include?(@input)
 
-      return read_escape_sequence if ch == "\e"
+      ch = @input.getch
+      case ch
+      when "\u0002" then :ctrl_b
+      when "\u0003" then :ctrl_c
+      when "\u0004" then :ctrl_d
+      when "\u0005" then :ctrl_e
+      when "\u0006" then :ctrl_f
+      when "\u0009" then :ctrl_i
+      when "\u000c" then :ctrl_l
+      when "\u000e" then :ctrl_n
+      when "\u000f" then :ctrl_o
+      when "\u0010" then :ctrl_p
+      when "\u0012" then :ctrl_r
+      when "\u0015" then :ctrl_u
+      when "\u0016" then :ctrl_v
+      when "\u0017" then :ctrl_w
+      when "\u0019" then :ctrl_y
+      when "\u001a" then :ctrl_z
+      when "\r", "\n" then :enter
+      when "\u007f", "\b" then :backspace
+      when "\e" then read_escape_sequence(timeout: esc_timeout)
+      else ch
+      end
+    end
 
-      ch
+    def has_pending_input?
+      IO.select([@input], nil, nil, 0) != nil
     end
 
     private
@@ -41,23 +55,32 @@ module RuVim
       nil
     end
 
-    def read_escape_sequence
+    def read_escape_sequence(timeout: nil)
       extra = +""
+      recognized = {
+        "[A" => :up,
+        "[B" => :down,
+        "[C" => :right,
+        "[D" => :left,
+        "[1;2A" => :shift_up,
+        "[1;2B" => :shift_down,
+        "[1;2C" => :shift_right,
+        "[1;2D" => :shift_left,
+        "[5~" => :pageup,
+        "[6~" => :pagedown
+      }
+      wait = timeout.nil? ? 0.005 : [timeout.to_f, 0.0].max
       begin
-        while IO.select([@stdin], nil, nil, 0.005)
-          extra << @stdin.read_nonblock(1)
+        while IO.select([@input], nil, nil, wait)
+          extra << @input.read_nonblock(1)
+          key = recognized[extra]
+          return key if key
         end
       rescue IO::WaitReadable, EOFError
       end
 
       case extra
       when "" then :escape
-      when "[A" then :up
-      when "[B" then :down
-      when "[C" then :right
-      when "[D" then :left
-      when "[5~" then :pageup
-      when "[6~" then :pagedown
       else
         [:escape_sequence, extra]
       end

data/lib/ruvim/keymap_manager.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module RuVim
   class KeymapManager
     Match = Struct.new(:status, :invocation, keyword_init: true)
+    BindingEntry = Struct.new(:layer, :mode, :tokens, :id, :argv, :kwargs, :bang, :scope, keyword_init: true)
 
     def initialize
       @mode_maps = Hash.new { |h, k| h[k] = {} }
@@ -44,6 +47,25 @@ module RuVim
       resolve_layers(layers, pending_tokens)
     end
 
+    def binding_entries_for_context(editor, mode: nil)
+      buffer = editor.current_buffer
+      filetype = detect_filetype(buffer)
+      modes = normalized_mode_filter(mode)
+      entries = []
+
+      entries.concat(snapshot_plain_layer(@buffer_maps[buffer.id], layer: :buffer))
+
+      if filetype && @filetype_maps.key?(filetype)
+        ft_modes = @filetype_maps[filetype]
+        entries.concat(snapshot_mode_layers(ft_modes, layer: :filetype, modes:))
+      end
+
+      entries.concat(snapshot_mode_layers(@mode_maps, layer: :app, modes:, scope: :mode))
+      entries.concat(snapshot_plain_layer(@global_map, layer: :app, scope: :global))
+
+      entries
+    end
+
     private
 
     def build_invocation(id, argv:, kwargs:, bang:, tokens:)
@@ -73,6 +95,67 @@ module RuVim
       Match.new(status: has_prefix ? :pending : :none)
     end
 
+    def snapshot_plain_layer(layer_map, layer:, scope: nil)
+      return [] unless layer_map && !layer_map.empty?
+
+      layer_map.map do |tokens, inv|
+        snapshot_entry(tokens, inv, layer:, scope:)
+      end.sort_by { |e| [token_sort_key(e.tokens), e.id.to_s] }
+    end
+
+    def snapshot_mode_layers(mode_maps, layer:, modes: nil, scope: nil)
+      return [] unless mode_maps
+
+      selected = mode_maps.keys.map(&:to_sym)
+      selected &= modes if modes
+      selected.sort_by! { |m| mode_sort_key(m) }
+
+      selected.flat_map do |m|
+        next [] if mode_maps[m].nil? || mode_maps[m].empty?
+
+        mode_maps[m].map do |tokens, inv|
+          snapshot_entry(tokens, inv, layer:, mode: m, scope:)
+        end.sort_by { |e| [token_sort_key(e.tokens), e.id.to_s] }
+      end
+    end
+
+    def snapshot_entry(tokens, inv, layer:, mode: nil, scope: nil)
+      BindingEntry.new(
+        layer: layer,
+        mode: mode,
+        tokens: Array(tokens).map(&:dup),
+        id: inv.id.to_s,
+        argv: Array(inv.argv).map { |v| v.is_a?(String) ? v.dup : v },
+        kwargs: (inv.kwargs || {}).dup,
+        bang: !!inv.bang,
+        scope: scope
+      )
+    end
+
+    def normalized_mode_filter(mode)
+      return nil if mode.nil?
+
+      ary = Array(mode).compact.map { |m| m.to_sym }
+      ary.empty? ? nil : ary
+    end
+
+    def token_sort_key(tokens)
+      Array(tokens).join("\0")
+    end
+
+    def mode_sort_key(mode)
+      order = {
+        normal: 0,
+        insert: 1,
+        visual_char: 2,
+        visual_line: 3,
+        visual_block: 4,
+        operator_pending: 5,
+        command_line: 6
+      }
+      [order.fetch(mode.to_sym, 99), mode.to_s]
+    end
+
     def detect_filetype(buffer)
       ft = buffer.options["filetype"] if buffer.respond_to?(:options)
       return ft if ft && !ft.empty?

data/lib/ruvim/keyword_chars.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuVim
+  module KeywordChars
+    module_function
+
+    DEFAULT_CHAR_CLASS = "[:alnum:]_".freeze
+    DEFAULT_REGEX = /[[:alnum:]_]/.freeze
+
+    def char_class(raw)
+      spec = raw.to_s
+      return DEFAULT_CHAR_CLASS if spec.empty?
+
+      @char_class_cache ||= {}
+      return @char_class_cache[spec] if @char_class_cache.key?(spec)
+
+      extra = []
+      spec.split(",").each do |tok|
+        t = tok.strip
+        next if t.empty? || t == "@"
+
+        if t.length == 1
+          extra << Regexp.escape(t)
+        elsif t.match?(/\A\d+-\d+\z/)
+          a, b = t.split("-", 2).map(&:to_i)
+          lo, hi = [a, b].minmax
+          next if lo < 0 || hi > 255
+          extra << "#{Regexp.escape(lo.chr)}-#{Regexp.escape(hi.chr)}"
+        end
+      end
+
+      @char_class_cache[spec] = "#{DEFAULT_CHAR_CLASS}#{extra.join}".freeze
+    end
+
+    def regex(raw)
+      spec = raw.to_s
+      return DEFAULT_REGEX if spec.empty?
+
+      @regex_cache ||= {}
+      return @regex_cache[spec] if @regex_cache.key?(spec)
+
+      klass = char_class(spec)
+      @regex_cache[spec] = /[#{klass}]/
+    rescue RegexpError
+      DEFAULT_REGEX
+    end
+  end
+end

data/lib/ruvim/lang/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Base
+      module_function
+
+      def indent_trigger?(_line)
+        false
+      end
+
+      def dedent_trigger(_char)
+        nil
+      end
+
+      def calculate_indent(_lines, _target_row, _shiftwidth)
+        nil
+      end
+
+      def on_save(_ctx, _path)
+        # no-op
+      end
+    end
+  end
+end

data/lib/ruvim/lang/csv.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Csv
+      module_function
+
+      # Detect CSV from buffer content: commas > 0 (and not TSV)
+      def detect?(buffer)
+        sample = (0...[buffer.line_count, 20].min).map { |i| buffer.line_at(i) }
+        commas = sample.sum { |l| l.count(",") }
+        commas > 0
+      end
+    end
+  end
+
+  RichView.register("csv", RichView::TableRenderer, detector: Lang::Csv.method(:detect?))
+end

data/lib/ruvim/lang/json.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Json
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, /"(?:\\.|[^"\\])*"\s*(?=:)/, "\e[36m")
+        Highlighter.apply_regex(cols, text, /"(?:\\.|[^"\\])*"/, "\e[32m")
+        Highlighter.apply_regex(cols, text, /\b(?:true|false|null)\b/, "\e[35m")
+        Highlighter.apply_regex(cols, text, /-?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b/, "\e[33m")
+        cols
+      end
+    end
+  end
+end

data/lib/ruvim/lang/markdown.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Markdown
+      # --- Regex patterns ---
+
+      HEADING_RE        = /\A(\s*)(\#{1,6})\s/
+      FENCE_RE          = /\A(`{3,}|~{3,})/
+      HR_RE             = /\A(\-{3,}|\*{3,}|_{3,})\s*\z/
+      BLOCK_QUOTE_RE    = /\A\s*> /
+      TABLE_LINE_RE     = /\A\s*\|.*\|\s*\z/
+      TABLE_SEPARATOR_RE = /\A\|[\s\-:|]+\|\z/
+
+      BOLD_RE           = /\*\*([^*]+)\*\*/
+      ITALIC_RE         = /(?<!\*)\*([^*]+)\*(?!\*)/
+      INLINE_CODE_RE    = /`([^`]+)`/
+      LINK_RE           = /\[([^\]]+)\]\(([^)]+)\)/
+      CHECKBOX_CHECKED_RE   = /^(\s*-\s*)\[x\]/
+      CHECKBOX_UNCHECKED_RE = /^(\s*-\s*)\[ \]/
+
+      # --- Heading styles (for color_columns) ---
+
+      HEADING_COLORS = {
+        1 => "\e[1;33m",   # bold yellow
+        2 => "\e[1;36m",   # bold cyan
+        3 => "\e[1;32m",   # bold green
+        4 => "\e[1;35m",   # bold magenta
+        5 => "\e[1;34m",   # bold blue
+        6 => "\e[1;90m"    # bold dim
+      }.freeze
+
+      # --- FenceState: tracks code fence open/close across lines ---
+
+      class FenceState
+        attr_reader :in_code_block, :fence_marker
+
+        def initialize
+          @in_code_block = false
+          @fence_marker = nil
+        end
+
+        def scan_line(line)
+          stripped = line.to_s.strip
+          if @in_code_block
+            if fence_close?(stripped)
+              @in_code_block = false
+              @fence_marker = nil
+            end
+          else
+            marker = fence_open(stripped)
+            if marker
+              @in_code_block = true
+              @fence_marker = marker
+            end
+          end
+        end
+
+        private
+
+        def fence_open(stripped)
+          if (m = stripped.match(/\A(`{3,})(.*)\z/))
+            m[1]
+          elsif (m = stripped.match(/\A(~{3,})(.*)\z/))
+            m[1]
+          end
+        end
+
+        def fence_close?(stripped)
+          return false unless @fence_marker
+          if @fence_marker.start_with?("`")
+            stripped.match?(/\A`{#{@fence_marker.length},}\s*\z/)
+          else
+            stripped.match?(/\A~{#{@fence_marker.length},}\s*\z/)
+          end
+        end
+      end
+
+      # --- Detection helpers ---
+
+      module_function
+
+      def heading?(line)
+        line.to_s.match?(HEADING_RE)
+      end
+
+      def heading_level(line)
+        m = line.to_s.match(HEADING_RE)
+        m ? m[2].length : 0
+      end
+
+      def fence_line?(stripped)
+        stripped.to_s.match?(FENCE_RE)
+      end
+
+      def horizontal_rule?(stripped)
+        stripped.to_s.match?(HR_RE)
+      end
+
+      def block_quote?(line)
+        line.to_s.match?(BLOCK_QUOTE_RE)
+      end
+
+      def table_line?(line)
+        stripped = line.to_s.strip
+        stripped.start_with?("|") && stripped.end_with?("|") && stripped.length > 1
+      end
+
+      def table_separator?(stripped)
+        stripped.to_s.match?(TABLE_SEPARATOR_RE)
+      end
+
+      def parse_table_cells(line)
+        stripped = line.to_s.strip
+        inner = stripped[1...-1] || ""
+        inner.split("|", -1).map(&:strip)
+      end
+
+      # --- Syntax highlight: color_columns ---
+
+      def color_columns(text)
+        cols = {}
+        return cols if text.nil? || text.empty?
+
+        stripped = text.strip
+
+        # Fence line: entire line dim
+        if fence_line?(stripped)
+          fill_line(cols, text, "\e[90m")
+          return cols
+        end
+
+        # HR: entire line dim
+        if horizontal_rule?(stripped)
+          fill_line(cols, text, "\e[90m")
+          return cols
+        end
+
+        # Heading: entire line colored by level
+        if (m = text.match(HEADING_RE))
+          level = m[2].length
+          color = HEADING_COLORS[level] || HEADING_COLORS[6]
+          fill_line(cols, text, color)
+          return cols
+        end
+
+        # Block quote marker
+        if (m = text.match(/\A(\s*>)/))
+          Highlighter.apply_regex(cols, text, /\A\s*>/, "\e[36m")
+        end
+
+        # Inline elements
+        Highlighter.apply_regex(cols, text, CHECKBOX_CHECKED_RE, "\e[32m")
+        Highlighter.apply_regex(cols, text, CHECKBOX_UNCHECKED_RE, "\e[90m")
+        Highlighter.apply_regex(cols, text, BOLD_RE, "\e[1m")
+        Highlighter.apply_regex(cols, text, ITALIC_RE, "\e[3m")
+        Highlighter.apply_regex(cols, text, INLINE_CODE_RE, "\e[33m")
+        Highlighter.apply_regex(cols, text, LINK_RE, "\e[4m")
+
+        cols
+      end
+
+      private
+
+      def self.fill_line(cols, text, color)
+        text.length.times { |i| cols[i] = color }
+      end
+    end
+  end
+end