Module: RuVim::RichView

Defined in:
lib/ruvim/rich_view.rb,
lib/ruvim/rich_view/json_renderer.rb,
lib/ruvim/rich_view/jsonl_renderer.rb,
lib/ruvim/rich_view/table_renderer.rb,
lib/ruvim/rich_view/markdown_renderer.rb

Defined Under Namespace

Modules: JsonRenderer, JsonlRenderer, MarkdownRenderer, TableRenderer

Class Method Summary collapse

Class Method Details

.active?(editor) ⇒ Boolean

Check if rich view rendering is active (persists during command-line mode).

Returns:

  • (Boolean) 


65
66
67
 
# File 'lib/ruvim/rich_view.rb', line 65

def active?(editor)
  !!editor.rich_state
end

.bind_close_keys(editor, buffer_id) ⇒ Object

Bind Esc and C-c to close a virtual buffer created by a renderer.



104
105
106
107
108
109
110
 
# File 'lib/ruvim/rich_view.rb', line 104

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

.close!(editor) ⇒ Object

Exit rich mode and return to normal mode.



97
98
99
100
101
 
# File 'lib/ruvim/rich_view.rb', line 97

def close!(editor)
  return unless active?(editor)

  editor.exit_rich_mode
end

.detect_format(buffer) ⇒ Object

Detect format from filetype or buffer content. Returns a filetype symbol (:tsv, :csv, :markdown) or nil.



30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/ruvim/rich_view.rb', line 30

def detect_format(buffer)
  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|
    return entry[:filetype] if entry[:detector].call(buffer)
  end

  nil
end

.open!(editor, format: nil) ⇒ Object

Enter rich mode on the current buffer (same buffer, no virtual buffer).

Raises:



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/ruvim/rich_view.rb', line 46

def open!(editor, format: nil)
  buffer = editor.current_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}]")
end

.register(filetype, renderer, detector: nil) ⇒ Object 



15
16
17
18
 
# File 'lib/ruvim/rich_view.rb', line 15

def register(filetype, renderer, detector: nil)
  @renderers[filetype.to_sym] = renderer
  @detectors << { filetype: filetype.to_sym, detector: detector } if detector
end

.registered_filetypes ⇒ Object 



24
25
26
 
# File 'lib/ruvim/rich_view.rb', line 24

def registered_filetypes
  @renderers.keys
end

.render_visible_lines(editor, lines, context: {}) ⇒ Object

Render visible lines through the appropriate renderer. Takes raw lines from buffer, returns formatted lines for display.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/ruvim/rich_view.rb', line 71

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

.renderer_for(filetype) ⇒ Object 



20
21
22
 
# File 'lib/ruvim/rich_view.rb', line 20

def renderer_for(filetype)
  @renderers[filetype.to_sym]
end

.toggle!(editor, format: nil) ⇒ Object

Toggle: if in rich mode, exit; otherwise enter.



88
89
90
91
92
93
94
 
# File 'lib/ruvim/rich_view.rb', line 88

def toggle!(editor, format: nil)
  if active?(editor)
    close!(editor)
  else
    open!(editor, format: format)
  end
end