ruvim 0.2.0 → 0.4.0

data/lib/ruvim/lang/ruby.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "prism"
+require "open3"
+
+module RuVim
+  module Lang
+    module Ruby
+      PRISM_KEYWORD_TYPES = %i[
+        KEYWORD_ALIAS
+        KEYWORD_AND
+        KEYWORD_BEGIN
+        KEYWORD_BEGIN_UPCASE
+        KEYWORD_BREAK
+        KEYWORD_CASE
+        KEYWORD_CLASS
+        KEYWORD_DEF
+        KEYWORD_DEFINED
+        KEYWORD_DO
+        KEYWORD_ELSE
+        KEYWORD_ELSIF
+        KEYWORD_END
+        KEYWORD_ENSURE
+        KEYWORD_FALSE
+        KEYWORD_FOR
+        KEYWORD_IF
+        KEYWORD_IF_MODIFIER
+        KEYWORD_IN
+        KEYWORD_MODULE
+        KEYWORD_NEXT
+        KEYWORD_NIL
+        KEYWORD_NOT
+        KEYWORD_OR
+        KEYWORD_REDO
+        KEYWORD_RESCUE
+        KEYWORD_RESCUE_MODIFIER
+        KEYWORD_RETRY
+        KEYWORD_RETURN
+        KEYWORD_SELF
+        KEYWORD_SUPER
+        KEYWORD_THEN
+        KEYWORD_TRUE
+        KEYWORD_UNDEF
+        KEYWORD_UNLESS
+        KEYWORD_UNLESS_MODIFIER
+        KEYWORD_UNTIL
+        KEYWORD_UNTIL_MODIFIER
+        KEYWORD_WHEN
+        KEYWORD_WHILE
+        KEYWORD_WHILE_MODIFIER
+        KEYWORD_YIELD
+        MISSING
+      ].freeze
+
+      PRISM_STRING_TYPES = %i[
+        STRING_BEGIN
+        STRING_CONTENT
+        STRING_END
+        SYMBOL_BEGIN
+        REGEXP_BEGIN
+        REGEXP_CONTENT
+        REGEXP_END
+        XSTRING_BEGIN
+        XSTRING_CONTENT
+        XSTRING_END
+        WORDS_BEGIN
+        QWORDS_BEGIN
+        WORDS_SEPARATOR
+        STRING
+        CHARACTER_LITERAL
+      ].freeze
+
+      PRISM_NUMBER_TYPES = %i[
+        INTEGER
+        FLOAT
+        RATIONAL_NUMBER
+        IMAGINARY_NUMBER
+        UINTEGER
+      ].freeze
+
+      PRISM_COMMENT_TYPES = %i[
+        COMMENT
+        EMBDOC_BEGIN
+        EMBDOC_LINE
+        EMBDOC_END
+      ].freeze
+
+      PRISM_VARIABLE_TYPES = %i[
+        INSTANCE_VARIABLE
+        CLASS_VARIABLE
+        GLOBAL_VARIABLE
+      ].freeze
+
+      PRISM_CONSTANT_TYPES = %i[
+        CONSTANT
+      ].freeze
+
+      # Keywords that open a new indentation level
+      INDENT_OPEN_RE = /\A\s*(?:def|class|module|if|unless|while|until|for|begin|case)\b/
+      # `do` at end of line (block form)
+      INDENT_DO_RE = /\bdo\s*(\|[^|]*\|)?\s*$/
+      # Opening brackets at end of line
+      INDENT_BRACKET_OPEN_RE = /[\[({]\s*$/
+      # Keywords that close an indentation level
+      INDENT_CLOSE_RE = /\A\s*(?:end|[}\])])/
+      # Keywords at same level as their opening keyword (dedent for the line itself)
+      INDENT_MID_RE = /\A\s*(?:else|elsif|when|rescue|ensure|in)\b/
+      # Modifier keywords that do NOT open indentation
+      MODIFIER_RE = /\b(?:if|unless|while|until|rescue)\b/
+
+      module_function
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row]
+          stripped = line.to_s.lstrip
+
+          # Skip blank and comment lines for indent computation
+          next if stripped.empty? || stripped.start_with?("#")
+
+          # Check if the line opens a new level
+          if stripped.match?(INDENT_OPEN_RE)
+            # Check for modifier form: something before the keyword on the same line
+            # e.g. "return if true" — if keyword is not at start, it's a modifier
+            first_word = stripped[/\A(\w+)/, 1]
+            if %w[if unless while until rescue].include?(first_word)
+              depth += 1
+            elsif %w[def class module begin case for].include?(first_word)
+              depth += 1
+            end
+          elsif stripped.match?(INDENT_DO_RE)
+            depth += 1
+          end
+
+          # Count opening brackets (not at end-of-line pattern, but individual)
+          stripped.each_char do |ch|
+            case ch
+            when "{", "[", "("
+              depth += 1
+            when "}", "]", ")"
+              depth -= 1
+            end
+          end if !stripped.match?(INDENT_OPEN_RE) && !stripped.match?(INDENT_DO_RE)
+
+          # Handle closing keywords
+          if stripped.match?(/\A\s*end\b/)
+            depth -= 1
+          end
+
+          # Handle mid keywords (else/elsif/when/rescue/ensure) — they don't change depth for following lines
+        end
+
+        # Now compute indent for target_row
+        target_line = lines[target_row].to_s.lstrip
+
+        # If target line is a closing keyword, dedent
+        if target_line.match?(INDENT_CLOSE_RE)
+          depth -= 1
+        elsif target_line.match?(INDENT_MID_RE)
+          depth -= 1
+        end
+
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      # Returns true if the line should increase indent for the next line
+      def indent_trigger?(line)
+        stripped = line.to_s.rstrip.lstrip
+        first_word = stripped[/\A(\w+)/, 1].to_s
+        return true if %w[def class module if unless while until for begin case].include?(first_word)
+        return true if stripped.match?(/\bdo\s*(\|[^|]*\|)?\s*$/)
+        false
+      end
+
+      # Dedent trigger patterns keyed by the last character typed
+      DEDENT_TRIGGERS = {
+        "d" => /\A(\s*)end\z/,
+        "e" => /\A(\s*)(?:else|rescue|ensure)\z/,
+        "f" => /\A(\s*)elsif\z/,
+        "n" => /\A(\s*)(?:when|in)\z/
+      }.freeze
+
+      # Returns the dedent pattern for the given character, or nil
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
+      def on_save(ctx, path)
+        return unless path && File.exist?(path)
+        output, status = Open3.capture2e("ruby", "-wc", path)
+        message = output.sub(/^Syntax OK\n?\z/m, "").strip
+
+        if !status.success? || !message.empty?
+          buffer_id = ctx.buffer.id
+          items = message.lines.filter_map { |line|
+            if line =~ /\A.+?:(\d+):/
+              { buffer_id: buffer_id, row: $1.to_i - 1, col: 0, text: line.strip }
+            end
+          }
+          items = [{ buffer_id: buffer_id, row: 0, col: 0, text: message }] if items.empty?
+          ctx.editor.set_quickfix_list(items)
+          first = message.lines.first.to_s.strip
+          hint = items.size > 1 ? " (Q to see all, #{items.size} total)" : ""
+          ctx.editor.echo_error("#{first}#{hint}")
+        else
+          ctx.editor.set_quickfix_list([])
+        end
+      end
+
+      def color_columns(text)
+        cols = {}
+        Prism.lex(text).value.each do |entry|
+          token = entry[0]
+          type = token.type
+          range = token.location.start_offset...token.location.end_offset
+          if PRISM_STRING_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::STRING_COLOR unless cols.key?(idx) }
+          elsif PRISM_KEYWORD_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::KEYWORD_COLOR unless cols.key?(idx) }
+          elsif PRISM_NUMBER_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::NUMBER_COLOR unless cols.key?(idx) }
+          elsif PRISM_VARIABLE_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::VARIABLE_COLOR unless cols.key?(idx) }
+          elsif PRISM_CONSTANT_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::CONSTANT_COLOR unless cols.key?(idx) }
+          elsif PRISM_COMMENT_TYPES.include?(type)
+            range.each { |idx| cols[idx] = Highlighter::COMMENT_COLOR }
+          end
+        end
+        cols
+      end
+    end
+  end
+end

data/lib/ruvim/lang/scheme.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Scheme
+      KEYWORDS = %w[
+        define define-syntax define-record-type define-values define-library
+        lambda let let* letrec letrec* let-values let-syntax letrec-syntax
+        if cond case when unless and or not
+        begin do set! quote quasiquote unquote unquote-splicing
+        syntax-rules syntax-case
+        import export library
+        else =>
+        call-with-current-continuation call/cc
+        call-with-values values
+        dynamic-wind
+        guard raise raise-continuable with-exception-handler
+        parameterize make-parameter
+        include include-ci
+      ].freeze
+
+      KEYWORD_RE = /(?<=[\s(])(#{KEYWORDS.map { |k| Regexp.escape(k) }.join("|")})(?=[\s()\]]|$)/
+      COMMENT_RE = /;.*/
+      STRING_RE = /"(?:\\.|[^"\\])*"/
+      CHAR_RE = /#\\(?:space|newline|tab|alarm|backspace|delete|escape|null|return|[^\s()])/
+      BOOLEAN_RE = /#[tf]\b/
+      NUMBER_RE = /(?<=[\s(])[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?(?=[\s()\]]|$)/
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        # Order matters: comment overrides all, then strings, then others
+        Highlighter.apply_regex(cols, text, CHAR_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, STRING_RE, Highlighter::STRING_COLOR)
+        Highlighter.apply_regex(cols, text, KEYWORD_RE, Highlighter::KEYWORD_COLOR)
+        Highlighter.apply_regex(cols, text, BOOLEAN_RE, "\e[35m")
+        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
+  end
+end

data/lib/ruvim/lang/tsv.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Tsv
+      module_function
+
+      # Detect TSV from buffer content: tabs >= commas and tabs > 0
+      def detect?(buffer)
+        sample = (0...[buffer.line_count, 20].min).map { |i| buffer.line_at(i) }
+        tabs = sample.sum { |l| l.count("\t") }
+        commas = sample.sum { |l| l.count(",") }
+        tabs > 0 && tabs >= commas
+      end
+    end
+  end
+
+  RichView.register("tsv", RichView::TableRenderer, detector: Lang::Tsv.method(:detect?))
+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