Module: Markdown::Merge::BackendSupport

Defined in:
lib/markdown/merge/backend_support.rb

Overview

Shared boilerplate for backend-specific Markdown wrapper backends.

Constant Summary collapse

DEFAULT_CAPABILITIES = 
{
  query: false,
  bytes_field: false,
  incremental: false,
  pure_ruby: false,
  markdown_only: true,
  error_tolerant: true
}.freeze

Class Method Summary collapse

Class Method Details

.configure_markdown_only_language_class!(klass, backend_label:, factory_method: :markdown, unsupported_language_message: nil) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/markdown/merge/backend_support.rb', line 34

def configure_markdown_only_language_class!(klass, backend_label:, factory_method: :markdown,
                                            unsupported_language_message: nil)
  klass.singleton_class.class_eval do
    define_method(:from_library) do |_path = nil, symbol: nil, name: nil|
      lang_name = name || symbol&.to_s&.sub(/^tree_sitter_/, '')&.to_sym || :markdown

      unless lang_name == :markdown
        message = if unsupported_language_message.respond_to?(:call)
                    unsupported_language_message.call(lang_name)
                  else
                    unsupported_language_message || "#{backend_label} backend only supports Markdown, not #{lang_name}."
                  end
        raise TreeHaver::NotAvailable, message
      end

      public_send(factory_method)
    end
  end
end

.configure_node_heading_and_code_block_helpers!(klass, heading_matcher:, code_block_matcher:, heading_level_extractor: nil, code_block_info_extractor: nil) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/markdown/merge/backend_support.rb', line 82

def configure_node_heading_and_code_block_helpers!(klass, heading_matcher:, code_block_matcher:,
                                                   heading_level_extractor: nil,
                                                   code_block_info_extractor: nil)
  klass.class_eval do
    define_method(:header_level) do
      return unless Markdown::Merge::BackendSupport.send(:node_helper_match?, self, heading_matcher)

      if heading_level_extractor.respond_to?(:call)
        heading_level_extractor.call(inner_node)
      else
        Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :header_level)
      end
    end

    define_method(:fence_info) do
      return unless Markdown::Merge::BackendSupport.send(:node_helper_match?, self, code_block_matcher)

      if code_block_info_extractor.respond_to?(:call)
        code_block_info_extractor.call(inner_node)
      else
        Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :fence_info)
      end
    end
  end
end

.configure_node_link_and_navigation!(klass, next_sibling_selector:, prev_sibling_selector:, parent_selector: :parent) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/markdown/merge/backend_support.rb', line 54

def configure_node_link_and_navigation!(klass, next_sibling_selector:, prev_sibling_selector:,
                                        parent_selector: :parent)
  klass.class_eval do
    define_method(:url) do
      Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :url)
    end

    define_method(:title) do
      Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, :title)
    end

    define_method(:next_sibling) do
      sibling = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, next_sibling_selector)
      sibling ? self.class.new(sibling, source: source, lines: lines) : nil
    end

    define_method(:prev_sibling) do
      sibling = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, prev_sibling_selector)
      sibling ? self.class.new(sibling, source: source, lines: lines) : nil
    end

    define_method(:parent) do
      parent_node = Markdown::Merge::BackendSupport.send(:safe_inner_node_call, inner_node, parent_selector)
      parent_node ? self.class.new(parent_node, source: source, lines: lines) : nil
    end
  end
end

.install!(backend_module:, backend_name:, gem_name:, require_path:, capabilities: {}) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/markdown/merge/backend_support.rb', line 18

def install!(backend_module:, backend_name:, gem_name:, require_path:, capabilities: {})
  install_availability_methods!(
    backend_module: backend_module,
    backend_name: backend_name,
    gem_name: gem_name,
    capabilities: capabilities
  )
  install_tree_wrapper!(backend_module)
  register_backend!(
    backend_module: backend_module,
    backend_name: backend_name,
    gem_name: gem_name,
    require_path: require_path
  )
end