ruvim 0.3.0 → 0.6.0

data/lib/ruvim/lang/rust.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Rust
+      KEYWORDS = %w[
+        as async await break const continue crate dyn else enum extern
+        false fn for if impl in let loop match mod move mut pub ref
+        return self Self static struct super trait true type unsafe use
+        where while
+        macro_rules
+      ].freeze
+
+      TYPES = %w[
+        bool char str
+        i8 i16 i32 i64 i128 isize
+        u8 u16 u32 u64 u128 usize
+        f32 f64
+        String Vec Box Rc Arc Option Result HashMap HashSet
+        Vec! vec!
+      ].freeze
+
+      ALL_KEYWORDS = (KEYWORDS + TYPES).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.map { |k| Regexp.escape(k) }.join("|")})\b/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_RAW_RE = /r#*"[^"]*"#*/
+      CHAR_RE = /'(?:\\.|[^'\\])'/
+      LIFETIME_RE = /'[a-z_]\w*/
+      NUMBER_RE = /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?(?:_?[iu](?:8|16|32|64|128|size)|_?f(?:32|64))?)\b/
+      LINE_COMMENT_RE = %r{//.*}
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      ATTRIBUTE_RE = /#!?\[[\w:(,)\s"]*\]/
+      MACRO_RE = /\b\w+!/
+      CONSTANT_RE = /\b[A-Z][A-Z0-9_]{1,}\b/
+
+      INDENT_OPEN_RE = /[{(\[]\s*(?:\/\/.*)?$/
+      INDENT_CLOSE_RE = /\A\s*[}\])]/
+
+      DEDENT_TRIGGERS = {
+        "}" => /\A(\s*)\}/,
+        "]" => /\A(\s*)\]/,
+        ")" => /\A(\s*)\)/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{", "[", "(" then depth += 1
+            when "}", "]", ")" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, CHAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_RAW_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, LIFETIME_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, MACRO_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, ATTRIBUTE_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("rust", mod: Rust,
+      extensions: %w[.rs],
+      runprg: "rustc -o /tmp/a.out % && /tmp/a.out")
+  end
+end

data/lib/ruvim/lang/scheme.rb

@@ -40,5 +40,10 @@ module RuVim
         cols
       end
     end
+
+    Registry.register("scheme", mod: Scheme,
+      extensions: %w[.scm .ss .sld],
+      shebangs: %w[gosh],
+      runprg: "gosh %")
   end
 end

data/lib/ruvim/lang/sh.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Sh
+      KEYWORDS = %w[
+        if then else elif fi case esac for while until do done
+        in function select return exit break continue
+        local export readonly declare typeset unset
+        source eval exec trap set shopt
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      STRING_SINGLE_RE = /'[^']*'/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      VARIABLE_RE = /\$\{?[A-Za-z_]\w*\}?|\$[0-9@#?!\-*$]/
+      NUMBER_RE = /\b\d+\b/
+      COMMENT_RE = /#.*/
+      SHEBANG_RE = /\A#!.*/
+      OPERATOR_RE = /(?:\|\||&&|;;|<<|>>)/
+
+      INDENT_OPEN_RE = /\b(?:then|else|do)\s*$/
+      INDENT_CLOSE_RE = /\A\s*(?:fi|done|esac|else|elif)\b/
+
+      DEDENT_TRIGGERS = {
+        "i" => /\A(\s*)fi\z/,
+        "e" => /\A(\s*)(?:done|else)\z/,
+        "c" => /\A(\s*)esac\z/,
+        "f" => /\A(\s*)elif\z/
+      }.freeze
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s.strip
+          next if line.empty? || line.start_with?("#")
+
+          depth += 1 if line.match?(/\b(?:then|else|elif|do)\s*$/) || line.match?(/\{\s*$/)
+          depth -= 1 if line.match?(/\A(?:fi|done|esac)\b/) || line.match?(/\A\}/)
+        end
+
+        target_line = lines[target_row].to_s.strip
+        depth -= 1 if target_line.match?(/\A(?:fi|done|esac|else|elif)\b/) || target_line.match?(/\A\}/)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        stripped = line.to_s.rstrip
+        stripped.match?(/\b(?:then|else|elif|do)\s*$/) || stripped.match?(/\{\s*$/)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, VARIABLE_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("sh", mod: Sh,
+      extensions: %w[.sh .bash .zsh],
+      shebangs: %w[bash sh zsh ksh dash],
+      runprg: "bash %")
+  end
+end

data/lib/ruvim/lang/sql.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Sql
+      KEYWORDS = %w[
+        SELECT FROM WHERE AND OR NOT IN IS NULL LIKE BETWEEN EXISTS
+        INSERT INTO VALUES UPDATE SET DELETE CREATE TABLE ALTER DROP
+        INDEX VIEW TRIGGER FUNCTION PROCEDURE
+        JOIN INNER LEFT RIGHT OUTER FULL CROSS ON USING
+        GROUP BY ORDER ASC DESC HAVING LIMIT OFFSET DISTINCT
+        UNION ALL INTERSECT EXCEPT AS CASE WHEN THEN ELSE END
+        BEGIN COMMIT ROLLBACK TRANSACTION SAVEPOINT
+        PRIMARY KEY FOREIGN REFERENCES UNIQUE CHECK DEFAULT CONSTRAINT
+        IF ELSE ELSEIF WHILE LOOP FOR RETURN DECLARE
+        INT INTEGER BIGINT SMALLINT TINYINT
+        FLOAT DOUBLE DECIMAL NUMERIC REAL
+        CHAR VARCHAR TEXT BLOB CLOB BOOLEAN DATE TIME TIMESTAMP
+        SERIAL AUTO_INCREMENT IDENTITY
+        CASCADE RESTRICT SET GRANT REVOKE WITH RECURSIVE
+        COUNT SUM AVG MIN MAX COALESCE NULLIF CAST CONVERT
+        EXPLAIN ANALYZE VACUUM REINDEX CLUSTER TRUNCATE
+        TRUE FALSE
+      ].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/i
+      STRING_SINGLE_RE = /'(?:''|[^'])*'/
+      STRING_DOUBLE_RE = /"(?:""|[^"])*"/
+      NUMBER_RE = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b/
+      LINE_COMMENT_RE = /--.*/
+      BLOCK_COMMENT_RE = %r{/\*.*?\*/}
+      PARAMETER_RE = /[:@$]\w+/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, PARAMETER_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("sql", mod: Sql,
+      extensions: %w[.sql])
+  end
+end

data/lib/ruvim/lang/toml.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Toml
+      KEYWORD_RE = /\b(?:true|false)\b/
+      TABLE_RE = /\A\s*\[[\w.\-"]+\]/
+      ARRAY_TABLE_RE = /\A\s*\[\[[\w.\-"]+\]\]/
+      KEY_RE = /\A\s*[\w.\-]+\s*(?==)/
+      STRING_DOUBLE_RE = /"(?:\\.|[^"\\])*"/
+      STRING_SINGLE_RE = /'[^']*'/
+      NUMBER_RE = /(?<=[= ])[+-]?(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?)\b/
+      DATETIME_RE = /\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?/
+      COMMENT_RE = /#.*/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, ARRAY_TABLE_RE, "\e[1;36m")
+        Highlighter.apply_regex(cols, text, TABLE_RE, "\e[1;36m")
+        Highlighter.apply_regex(cols, text, KEY_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, DATETIME_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("toml", mod: Toml,
+      extensions: %w[.toml])
+  end
+end

data/lib/ruvim/lang/tsv.rb

@@ -2,6 +2,9 @@
 
 module RuVim
   module Lang
+    Registry.register("tsv", mod: Base,
+      extensions: %w[.tsv])
+
     module Tsv
       module_function
 
@@ -15,5 +18,5 @@ module RuVim
     end
   end
 
-  RichView.register("tsv", RichView::TableRenderer, detector: Lang::Tsv.method(:detect?))
+  RichView.register(:tsv, RichView::TableRenderer, detector: Lang::Tsv.method(:detect?))
 end

data/lib/ruvim/lang/typescript.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Typescript
+      TS_KEYWORDS = %w[
+        abstract as declare enum implements interface
+        module namespace private protected public readonly
+        type keyof infer extends
+        never unknown any
+        override satisfies
+      ].freeze
+
+      ALL_KEYWORDS = (Javascript::KEYWORDS + TS_KEYWORDS).uniq.freeze
+
+      KEYWORD_RE = /\b(?:#{ALL_KEYWORDS.join("|")})\b/
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        Javascript.calculate_indent(lines, target_row, shiftwidth)
+      end
+
+      def indent_trigger?(line)
+        Javascript.indent_trigger?(line)
+      end
+
+      def dedent_trigger(char)
+        Javascript.dedent_trigger(char)
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, Javascript::STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, Javascript::STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, Javascript::TEMPLATE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, Javascript::NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, Javascript::CONSTANT_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, Javascript::BLOCK_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        Highlighter.apply_regex(cols, text, Javascript::LINE_COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("typescript", mod: Typescript,
+      extensions: %w[.ts],
+      aliases: %w[typescriptreact],
+      runprg: "npx tsx %")
+    Registry.register("typescriptreact", mod: Typescript,
+      extensions: %w[.tsx])
+  end
+end

data/lib/ruvim/lang/yaml.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Yaml
+      KEYWORDS = %w[true false null yes no on off].freeze
+
+      KEYWORD_RE = /\b(?:#{KEYWORDS.join("|")})\b/
+      KEY_RE = /\A\s*[\w.\-\/]+\s*(?=:)/
+      TAG_RE = /![\w!.\/\-]*/
+      ANCHOR_RE = /[&*]\w+/
+      COMMENT_RE = /#.*/
+      STRING_SINGLE_RE = /'(?:[^'\\]|\\.)*'/
+      STRING_DOUBLE_RE = /"(?:[^"\\]|\\.)*"/
+      NUMBER_RE = /(?<=[\s:\-\[,]|^)-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?\s*$/
+      BLOCK_SCALAR_RE = /\A\s*[|>][+-]?\s*$/
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        return 0 if target_row == 0
+
+        prev_row = target_row - 1
+        prev_row -= 1 while prev_row > 0 && lines[prev_row].to_s.strip.empty?
+        prev = lines[prev_row].to_s
+        prev_indent = prev[/\A */].size
+
+        # Increase indent after mapping key or list with sub-items
+        if prev.match?(/:\s*$/) || prev.match?(/[|>][+-]?\s*$/)
+          return prev_indent + shiftwidth
+        end
+
+        prev_indent
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(/:\s*$/) || line.to_s.rstrip.match?(/[|>][+-]?\s*$/)
+      end
+
+      def dedent_trigger(_char)
+        nil
+      end
+
+      def color_columns(text)
+        cols = {}
+        Highlighter.apply_regex(cols, text, STRING_SINGLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_DOUBLE_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEY_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, "\e[35m")
+        Highlighter.apply_regex(cols, text, TAG_RE, Highlighter::CONSTANT_COLOR)
+        Highlighter.apply_regex(cols, text, ANCHOR_RE, Highlighter::VARIABLE_COLOR)
+        Highlighter.apply_regex(cols, text, NUMBER_RE, Highlighter::NUMBER_COLOR)
+        Highlighter.apply_regex(cols, text, BLOCK_SCALAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, COMMENT_RE, Highlighter::COMMENT_COLOR, override: true)
+        cols
+      end
+    end
+
+    Registry.register("yaml", mod: Yaml,
+      extensions: %w[.yml .yaml])
+  end
+end

data/lib/ruvim/rich_view/json_renderer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RuVim
+  module RichView
+    module JsonRenderer
+      module_function
+
+      # Signal that this renderer creates a virtual buffer
+      # instead of entering rich mode on the same buffer.
+      def open_view!(editor)
+        buffer = editor.current_buffer
+        window = editor.current_window
+        text = buffer.lines.join("\n")
+
+        begin
+          parsed = JSON.parse(text)
+        rescue JSON::ParserError => e
+          editor.echo_error("JSON parse error: #{e.message}")
+          return
+        end
+
+        # Compute cursor's significant char offset before formatting
+        cursor_offset = char_offset_for(buffer.lines, window.cursor_y, window.cursor_x)
+        sig_count = significant_char_count(text, cursor_offset + 1)
+
+        formatted = JSON.pretty_generate(parsed)
+        lines = formatted.lines(chomp: true)
+
+        target_line = line_for_significant_count(formatted, sig_count)
+
+        buf = editor.add_virtual_buffer(
+          kind: :json_formatted,
+          name: "[JSON Formatted]",
+          lines: lines,
+          filetype: "json",
+          readonly: true,
+          modifiable: false
+        )
+        editor.switch_to_buffer(buf.id)
+        RichView.bind_close_keys(editor, buf.id)
+        window.cursor_y = [target_line, lines.length - 1].min
+        window.cursor_x = 0
+        editor.echo("[JSON Formatted] #{lines.length} lines")
+      end
+
+      # Count significant (non-whitespace-outside-strings) characters
+      # in text[0...byte_offset].
+      def significant_char_count(text, byte_offset)
+        in_string = false
+        escape = false
+        count = 0
+        text.each_char.with_index do |ch, i|
+          break if i >= byte_offset
+          if in_string
+            if escape
+              escape = false
+            elsif ch == "\\"
+              escape = true
+            elsif ch == '"'
+              in_string = false
+            end
+            count += 1
+          else
+            case ch
+            when '"'
+              in_string = true
+              count += 1
+            when " ", "\n", "\r", "\t"
+              # skip whitespace outside strings
+            else
+              count += 1
+            end
+          end
+        end
+        count
+      end
+
+      # Find the line number in text where the N-th significant character falls.
+      def line_for_significant_count(text, target_count)
+        return 0 if target_count <= 0
+
+        in_string = false
+        escape = false
+        count = 0
+        line = 0
+        text.each_char do |ch|
+          if ch == "\n" && !in_string
+            line += 1
+            next
+          end
+          if in_string
+            if escape
+              escape = false
+            elsif ch == "\\"
+              escape = true
+            elsif ch == '"'
+              in_string = false
+            end
+            count += 1
+          else
+            case ch
+            when '"'
+              in_string = true
+              count += 1
+            when " ", "\r", "\t"
+              # skip
+            else
+              count += 1
+            end
+          end
+          return line if count >= target_count
+        end
+        line
+      end
+
+      # Compute character offset in joined text from cursor row/col.
+      def char_offset_for(lines, row, col)
+        offset = 0
+        lines.each_with_index do |line, i|
+          if i == row
+            return offset + [col, line.length].min
+          end
+          offset += line.length + 1 # +1 for "\n"
+        end
+        offset
+      end
+    end
+  end
+end

data/lib/ruvim/rich_view/jsonl_renderer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RuVim
+  module RichView
+    module JsonlRenderer
+      module_function
+
+      SEPARATOR = "---"
+
+      def open_view!(editor)
+        buffer = editor.current_buffer
+        window = editor.current_window
+        cursor_row = window.cursor_y
+
+        output_lines = []
+        # Map from source line index to starting line in output
+        line_map = {}
+
+        buffer.lines.each_with_index do |raw_line, idx|
+          line = raw_line.to_s.strip
+          next if line.empty?
+
+          output_lines << SEPARATOR unless output_lines.empty?
+          line_map[idx] = output_lines.length
+
+          begin
+            parsed = JSON.parse(line)
+            formatted = JSON.pretty_generate(parsed)
+            formatted.each_line(chomp: true) { |l| output_lines << l }
+          rescue JSON::ParserError
+            output_lines << "// PARSE ERROR: #{raw_line}"
+          end
+        end
+
+        output_lines << "" if output_lines.empty?
+
+        target_line = line_map[cursor_row] || 0
+
+        buf = editor.add_virtual_buffer(
+          kind: :jsonl_formatted,
+          name: "[JSONL Formatted]",
+          lines: output_lines,
+          filetype: "json",
+          readonly: true,
+          modifiable: false
+        )
+        editor.switch_to_buffer(buf.id)
+        RichView.bind_close_keys(editor, buf.id)
+        window.cursor_y = [target_line, output_lines.length - 1].min
+        window.cursor_x = 0
+        editor.echo("[JSONL Formatted] #{output_lines.length} lines")
+      end
+    end
+  end
+end

data/lib/ruvim/rich_view/table_renderer.rb

@@ -9,9 +9,9 @@ module RuVim
       module_function
 
       def delimiter_for(format)
-        case format.to_s
-        when "csv" then ","
-        when "tsv" then "\t"
+        case format
+        when :csv then ","
+        when :tsv then "\t"
         else "\t"
         end
       end

data/lib/ruvim/rich_view.rb

@@ -2,6 +2,8 @@
 
 require_relative "rich_view/table_renderer"
 require_relative "rich_view/markdown_renderer"
+require_relative "rich_view/json_renderer"
+require_relative "rich_view/jsonl_renderer"
 
 module RuVim
   module RichView
@@ -11,12 +13,12 @@ module RuVim
     module_function
 
     def register(filetype, renderer, detector: nil)
-      @renderers[filetype.to_s] = renderer
-      @detectors << { filetype: filetype.to_s, detector: detector } if detector
+      @renderers[filetype.to_sym] = renderer
+      @detectors << { filetype: filetype.to_sym, detector: detector } if detector
     end
 
     def renderer_for(filetype)
-      @renderers[filetype.to_s]
+      @renderers[filetype.to_sym]
     end
 
     def registered_filetypes
@@ -24,10 +26,13 @@ module RuVim
     end
 
     # Detect format from filetype or buffer content.
-    # Returns a filetype string ("tsv", "csv", "markdown") or nil.
+    # Returns a filetype symbol (:tsv, :csv, :markdown) or nil.
     def detect_format(buffer)
-      ft = buffer.options["filetype"].to_s
-      return ft if @renderers.key?(ft)
+      raw = buffer.options["filetype"]
+      if raw && !raw.to_s.empty?
+        ft = raw.to_sym
+        return ft if @renderers.key?(ft)
+      end
 
       # Ask registered detectors
       @detectors.each do |entry|
@@ -40,12 +45,17 @@ module RuVim
     # Enter rich mode on the current buffer (same buffer, no virtual buffer).
     def open!(editor, format: nil)
       buffer = editor.current_buffer
-      format ||= detect_format(buffer)
+      format = format ? format.to_sym : detect_format(buffer)
       raise RuVim::CommandError, "Cannot detect format for rich view" unless format
 
       renderer = @renderers[format]
       raise RuVim::CommandError, "No renderer for format: #{format}" unless renderer
 
+      if renderer.respond_to?(:open_view!)
+        renderer.open_view!(editor)
+        return
+      end
+
       delimiter = renderer.delimiter_for(format)
       editor.enter_rich_mode(format: format, delimiter: delimiter)
       editor.echo("[Rich: #{format}]")
@@ -89,5 +99,18 @@ module RuVim
 
       editor.exit_rich_mode
     end
+
+    # Bind Esc and C-c to close a virtual buffer created by a renderer.
+    def bind_close_keys(editor, buffer_id)
+      km = editor.keymap_manager
+      return unless km
+
+      km.bind_buffer(buffer_id, "\e", "rich.close_buffer")
+      km.bind_buffer(buffer_id, "<C-c>", "rich.close_buffer")
+    end
+
+    register(:markdown, MarkdownRenderer)
+    register(:json, JsonRenderer)
+    register(:jsonl, JsonlRenderer)
   end
 end