ruvim 0.2.0 → 0.4.0

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

data/lib/ruvim/rich_view/table_renderer.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuVim
+  module RichView
+    module TableRenderer
+      SEPARATOR = " | "
+      SEPARATOR_WIDTH = 3
+
+      module_function
+
+      def delimiter_for(format)
+        case format.to_s
+        when "csv" then ","
+        when "tsv" then "\t"
+        else "\t"
+        end
+      end
+
+      # Compute max display width per column from visible lines.
+      # Returns an Array of column widths, or nil if single-column / empty.
+      def compute_col_widths(lines, delimiter:)
+        return nil if lines.nil? || lines.empty?
+
+        rows = lines.map { |line| split_fields(line, delimiter) }
+        max_cols = rows.map(&:length).max
+        return nil if max_cols.nil? || max_cols <= 1
+
+        col_widths = Array.new(max_cols, 0)
+        rows.each do |fields|
+          fields.each_with_index do |field, i|
+            w = RuVim::DisplayWidth.display_width(field)
+            col_widths[i] = w if w > col_widths[i]
+          end
+        end
+        col_widths
+      end
+
+      # Format a single raw line using pre-computed column widths.
+      def format_line(raw_line, delimiter:, col_widths:)
+        fields = split_fields(raw_line, delimiter)
+        padded = fields.each_with_index.map do |field, i|
+          pad_field(field, col_widths[i] || 0)
+        end
+        (fields.length...col_widths.length).each do |i|
+          padded << " " * col_widths[i]
+        end
+        padded.join(SEPARATOR)
+      end
+
+      # Map a character index in the raw line to the corresponding index
+      # in the formatted line.  Needed for correct horizontal scrolling
+      # and cursor placement in rich mode.
+      def raw_to_formatted_char_index(raw_line, raw_char_index, delimiter:, col_widths:)
+        fields = split_fields(raw_line, delimiter)
+        pos = 0
+        formatted_pos = 0
+        fields.each_with_index do |field, i|
+          field_end = pos + field.length
+          if raw_char_index <= field_end
+            offset = [raw_char_index - pos, field.length].min
+            return formatted_pos + offset
+          end
+          pos = field_end + 1 # skip delimiter
+          field_dw = RuVim::DisplayWidth.display_width(field)
+          pad_chars = [(col_widths[i] || 0) - field_dw, 0].max
+          formatted_pos += field.length + pad_chars + SEPARATOR.length
+        end
+        formatted_pos
+      end
+
+      # Map a character index in the raw line to the display column
+      # in the formatted line.  Unlike raw_to_formatted_char_index (which
+      # returns a character index), this returns the screen column directly,
+      # which is needed for display-column-based horizontal scrolling.
+      def raw_to_formatted_display_col(raw_line, raw_char_index, delimiter:, col_widths:)
+        fields = split_fields(raw_line, delimiter)
+        pos = 0
+        display_col = 0
+        fields.each_with_index do |field, i|
+          field_end = pos + field.length
+          if raw_char_index <= field_end
+            offset_chars = [raw_char_index - pos, field.length].min
+            offset_dw = RuVim::DisplayWidth.display_width(field[0...offset_chars])
+            return display_col + offset_dw
+          end
+          display_col += (col_widths[i] || 0) + SEPARATOR_WIDTH
+          pos = field_end + 1
+        end
+        display_col
+      end
+
+      # Compute the display column for the cursor position in a formatted line.
+      def cursor_display_col(raw_line, cursor_x, visible_lines:, delimiter:)
+        col_widths = compute_col_widths(visible_lines, delimiter: delimiter)
+        return RuVim::TextMetrics.screen_col_for_char_index(raw_line, cursor_x) unless col_widths
+
+        raw_to_formatted_display_col(raw_line, cursor_x, delimiter: delimiter, col_widths: col_widths)
+      end
+
+      # Render visible lines: split by delimiter, compute column widths, pad and join.
+      # Returns an array of formatted strings.
+      def render_visible(lines, delimiter:)
+        return lines if lines.nil? || lines.empty?
+
+        col_widths = compute_col_widths(lines, delimiter:)
+        return lines unless col_widths
+
+        lines.map { |line| format_line(line, delimiter:, col_widths:) }
+      end
+
+      # Split a line into fields respecting the delimiter.
+      # For CSV, handles quoted fields minimally.
+      def split_fields(line, delimiter)
+        if delimiter == ","
+          parse_csv_fields(line)
+        else
+          line.to_s.split(delimiter, -1)
+        end
+      end
+
+      # Minimal CSV field parser: handles double-quoted fields with embedded
+      # commas and escaped quotes ("").
+      def parse_csv_fields(line)
+        fields = []
+        s = line.to_s
+        pos = 0
+
+        while pos <= s.length
+          if pos < s.length && s[pos] == '"'
+            # Quoted field
+            pos += 1
+            field = +""
+            while pos < s.length
+              if s[pos] == '"'
+                if pos + 1 < s.length && s[pos + 1] == '"'
+                  field << '"'
+                  pos += 2
+                else
+                  pos += 1
+                  break
+                end
+              else
+                field << s[pos]
+                pos += 1
+              end
+            end
+            fields << field
+            # Skip comma after quoted field
+            pos += 1 if pos < s.length && s[pos] == ','
+          else
+            # Unquoted field
+            comma_idx = s.index(',', pos)
+            if comma_idx
+              fields << s[pos...comma_idx]
+              pos = comma_idx + 1
+              # Trailing comma means empty last field
+              fields << "" if pos == s.length
+            else
+              fields << s[pos..]
+              break
+            end
+          end
+        end
+
+        fields
+      end
+
+      # Pad a field to a target display width using spaces.
+      def pad_field(field, target_width)
+        current = RuVim::DisplayWidth.display_width(field)
+        gap = target_width - current
+        gap > 0 ? "#{field}#{' ' * gap}" : field
+      end
+    end
+  end
+end

data/lib/ruvim/rich_view.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+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
+    @renderers = {}
+    @detectors = []
+
+    module_function
+
+    def register(filetype, renderer, detector: nil)
+      @renderers[filetype.to_s] = renderer
+      @detectors << { filetype: filetype.to_s, detector: detector } if detector
+    end
+
+    def renderer_for(filetype)
+      @renderers[filetype.to_s]
+    end
+
+    def registered_filetypes
+      @renderers.keys
+    end
+
+    # Detect format from filetype or buffer content.
+    # Returns a filetype string ("tsv", "csv", "markdown") or nil.
+    def detect_format(buffer)
+      ft = buffer.options["filetype"].to_s
+      return ft if @renderers.key?(ft)
+
+      # Ask registered detectors
+      @detectors.each do |entry|
+        return entry[:filetype] if entry[:detector].call(buffer)
+      end
+
+      nil
+    end
+
+    # 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)
+      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}]")
+    end
+
+    # Check if rich view rendering is active (persists during command-line mode).
+    def active?(editor)
+      !!editor.rich_state
+    end
+
+    # Render visible lines through the appropriate renderer.
+    # Takes raw lines from buffer, returns formatted lines for display.
+    def render_visible_lines(editor, lines, context: {})
+      state = editor.rich_state
+      return lines unless state
+
+      format = state[:format]
+      renderer = @renderers[format]
+      return lines unless renderer
+
+      delimiter = state[:delimiter]
+      if renderer.respond_to?(:needs_pre_context?) && renderer.needs_pre_context?
+        renderer.render_visible(lines, delimiter: delimiter, context: context)
+      else
+        renderer.render_visible(lines, delimiter: delimiter)
+      end
+    end
+
+    # Toggle: if in rich mode, exit; otherwise enter.
+    def toggle!(editor, format: nil)
+      if active?(editor)
+        close!(editor)
+      else
+        open!(editor, format: format)
+      end
+    end
+
+    # Exit rich mode and return to normal mode.
+    def close!(editor)
+      return unless active?(editor)
+
+      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
+  end
+end