ruvim 0.2.0 → 0.3.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/markdown_renderer.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module RuVim
+  module RichView
+    module MarkdownRenderer
+      module_function
+
+      def delimiter_for(_format)
+        nil
+      end
+
+      def needs_pre_context?
+        true
+      end
+
+      def render_visible(lines, delimiter:, context: {})
+        return lines if lines.nil? || lines.empty?
+
+        state = Lang::Markdown::FenceState.new
+        pre = context[:pre_context_lines]
+        if pre
+          pre.each { |l| state.scan_line(l) }
+        end
+
+        # Identify table groups for column-width alignment
+        table_groups = identify_table_groups(lines)
+
+        lines.each_with_index.map do |line, idx|
+          rendered = render_line(line, state, table_groups[idx])
+          state.scan_line(line)
+          rendered
+        end
+      end
+
+      def cursor_display_col(raw_line, cursor_x, visible_lines:, delimiter:)
+        if Lang::Markdown.table_line?(raw_line)
+          table_lines = visible_lines.select { |l| Lang::Markdown.table_line?(l) }
+          group = build_table_group(table_lines)
+          if group
+            return table_cursor_display_col(raw_line, cursor_x, group)
+          end
+        end
+        RuVim::TextMetrics.screen_col_for_char_index(raw_line, cursor_x)
+      end
+
+      # --- Line rendering ---
+
+      def render_line(line, state, table_group)
+        stripped = line.to_s.strip
+
+        # Code fence open/close
+        if !state.in_code_block && Lang::Markdown.fence_line?(stripped)
+          return "\e[90m#{line}\e[m"
+        end
+
+        if state.in_code_block
+          if Lang::Markdown.fence_line?(stripped)
+            return "\e[90m#{line}\e[m"
+          end
+          return "\e[38;5;223m#{line}\e[m"
+        end
+
+        # HR
+        if Lang::Markdown.horizontal_rule?(stripped)
+          return render_hr(line)
+        end
+
+        # Heading
+        level = Lang::Markdown.heading_level(line)
+        if level > 0
+          return render_heading(line, level)
+        end
+
+        # Block quote
+        if Lang::Markdown.block_quote?(line)
+          return "\e[36m#{apply_inline(line)}\e[m"
+        end
+
+        # Table
+        if table_group
+          return render_table_line(line, stripped, table_group)
+        end
+
+        # Default: inline decoration only
+        apply_inline(line)
+      end
+
+      # --- Heading rendering ---
+
+      HEADING_STYLES = Lang::Markdown::HEADING_COLORS
+
+      def render_heading(line, level)
+        style = HEADING_STYLES[level] || HEADING_STYLES[6]
+        "#{style}#{line}\e[m"
+      end
+
+      # --- HR rendering ---
+
+      def render_hr(line)
+        # Replace the HR marker with box-drawing horizontal line
+        width = [line.length, 3].max
+        "\e[90m#{"─" * width}\e[m"
+      end
+
+      # --- Inline decoration ---
+
+      def apply_inline(line)
+        result = line.to_s.dup
+
+        # Checkbox (must come before bold/italic to avoid interference)
+        result = result.gsub(Lang::Markdown::CHECKBOX_CHECKED_RE) { "#{$1}\e[32m[x]\e[m" }
+        result = result.gsub(Lang::Markdown::CHECKBOX_UNCHECKED_RE) { "#{$1}\e[90m[ ]\e[m" }
+
+        # Bold **text**
+        result = result.gsub(Lang::Markdown::BOLD_RE) { "\e[1m**#{$1}**\e[22m" }
+
+        # Italic *text* (but not ** which is bold)
+        result = result.gsub(Lang::Markdown::ITALIC_RE) { "\e[3m*#{$1}*\e[23m" }
+
+        # Inline code `text`
+        result = result.gsub(Lang::Markdown::INLINE_CODE_RE) { "\e[33m`#{$1}`\e[m" }
+
+        # Links [text](url)
+        result = result.gsub(Lang::Markdown::LINK_RE) { "\e[4m#{$1}\e[24m(\e[2m#{$2}\e[22m)" }
+
+        result
+      end
+
+      # --- Table rendering ---
+
+      def identify_table_groups(lines)
+        groups = {}
+        i = 0
+        while i < lines.length
+          if Lang::Markdown.table_line?(lines[i])
+            start = i
+            table_lines = []
+            while i < lines.length && Lang::Markdown.table_line?(lines[i])
+              table_lines << lines[i]
+              i += 1
+            end
+            group = build_table_group(table_lines)
+            (start...(start + table_lines.length)).each { |j| groups[j] = group }
+          else
+            i += 1
+          end
+        end
+        groups
+      end
+
+      def build_table_group(table_lines)
+        return nil if table_lines.nil? || table_lines.empty?
+
+        cells = table_lines.map { |l| Lang::Markdown.parse_table_cells(l) }
+        max_cols = cells.map(&:length).max
+        return nil if max_cols.nil? || max_cols.zero?
+
+        col_widths = Array.new(max_cols, 0)
+        cells.each do |row|
+          row.each_with_index do |cell, ci|
+            w = RuVim::DisplayWidth.display_width(cell)
+            col_widths[ci] = w if w > col_widths[ci]
+          end
+        end
+
+        { col_widths: col_widths, max_cols: max_cols }
+      end
+
+      def render_table_line(line, stripped, group)
+        if Lang::Markdown.table_separator?(stripped)
+          render_table_separator(group)
+        else
+          render_table_data_row(line, group)
+        end
+      end
+
+      def render_table_separator(group)
+        col_widths = group[:col_widths]
+        cells = col_widths.map { |w| "─" * (w + 2) }
+        "├#{cells.join("┼")}┤"
+      end
+
+      def render_table_data_row(line, group)
+        col_widths = group[:col_widths]
+        cells = Lang::Markdown.parse_table_cells(line)
+        padded = cells.each_with_index.map do |cell, i|
+          target = col_widths[i] || 0
+          pad_cell(cell, target)
+        end
+        # Fill missing columns
+        (cells.length...group[:max_cols]).each do |i|
+          padded << " " * (col_widths[i] || 0)
+        end
+        "│ #{padded.join(" │ ")} │"
+      end
+
+      def pad_cell(cell, target_width)
+        current = RuVim::DisplayWidth.display_width(cell)
+        gap = target_width - current
+        gap > 0 ? "#{cell}#{" " * gap}" : cell
+      end
+
+      # --- Table cursor mapping ---
+
+      def table_cursor_display_col(raw_line, cursor_x, group)
+        col_widths = group[:col_widths]
+        cells = Lang::Markdown.parse_table_cells(raw_line)
+
+        # Map cursor_x (in raw line) to display col in formatted line
+        # Raw line: "| cell1 | cell2 |"
+        # Formatted: "│ cell1  │ cell2  │"
+
+        # Walk through the raw line to find which cell cursor_x is in
+        pos = 0
+        raw = raw_line.to_s
+        # Skip leading whitespace
+        pos += 1 while pos < raw.length && raw[pos] == " "
+        # Skip leading |
+        pos += 1 if pos < raw.length && raw[pos] == "|"
+
+        display_col = 2  # "│ " prefix
+        cells.each_with_index do |cell, ci|
+          # Skip whitespace before cell content
+          pos += 1 while pos < raw.length && raw[pos] == " "
+
+          cell_start = pos
+          cell_end = cell_start + cell.length
+
+          if cursor_x < cell_end || ci == cells.length - 1
+            # Cursor is in this cell
+            offset_in_cell = [cursor_x - cell_start, 0].max
+            offset_in_cell = [offset_in_cell, cell.length].min
+            return display_col + RuVim::DisplayWidth.display_width(cell[0...offset_in_cell])
+          end
+
+          display_col += (col_widths[ci] || 0) + 3  # " │ "
+          pos = cell_end
+          # Skip whitespace after cell
+          pos += 1 while pos < raw.length && raw[pos] == " "
+          # Skip |
+          pos += 1 if pos < raw.length && raw[pos] == "|"
+        end
+
+        display_col
+      end
+    end
+  end
+end