Module: Coradoc::AsciiDoc::Transformer::ListRules

Defined in:
lib/coradoc/asciidoc/transformer/list_rules.rb

Overview

Module containing list transformation rules

Class Method Summary collapse

Class Method Details

.apply(transformer_class) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
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
81
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/coradoc/asciidoc/transformer/list_rules.rb', line 8

def self.apply(transformer_class)
  transformer_class.class_eval do
    # List item
    rule(list_item: subtree(:list_item)) do
      marker = list_item[:marker]
      id = list_item[:id]
      text = list_item[:text]
      text = list_item[:text].to_s if list_item[:text].instance_of?(Parslet::Slice)
      attached = list_item[:attached]
      nested = list_item[:nested]
      line_break = list_item[:line_break]

      # Convert nested array to proper List object if needed
      if nested.is_a?(Array) && nested.any?
        first_marker = nested.first.is_a?(Model::List::Item) ? nested.first.marker : marker
        nested = if first_marker.to_s.start_with?('.', '1', 'a', 'A', 'i', 'I')
                   Model::List::Ordered.new(items: nested)
                 else
                   Model::List::Unordered.new(items: nested)
                 end
      end

      Model::List::Item.new(
        content: text, id:, marker:, attached:, nested:, line_break:
      )
    end

    # List passthrough
    rule(list: simple(:list)) do
      list
    end

    # Unordered list
    rule(unordered: sequence(:list_items)) do
      Model::List::Unordered.new(items: list_items)
    end

    rule(
      attribute_list: simple(:attribute_list),
      unordered: sequence(:list_items)
    ) do
      Model::List::Unordered.new(items: list_items, attrs: attribute_list)
    end

    # Ordered list
    rule(ordered: sequence(:list_items)) do
      Model::List::Ordered.new(items: list_items)
    end

    rule(
      attribute_list: simple(:attribute_list),
      ordered: sequence(:list_items)
    ) do
      Model::List::Ordered.new(items: list_items, attrs: attribute_list)
    end

    # Definition list term
    rule(dlist_term: simple(:term), delimiter: simple(:_delim)) do
      term.to_s
    end

    # Definition list item
    rule(
      definition_list_item: {
        terms: sequence(:terms),
        definition: simple(:contents)
      }
    ) do
      Model::List::DefinitionItem.new(terms: terms, contents: contents)
    end

    # Definition list item with hash terms (single term case)
    rule(
      definition_list_item: subtree(:item_data)
    ) do
      terms_data = item_data[:terms]
      definition = item_data[:definition]

      # Extract terms
      terms = if terms_data.is_a?(Array)
                terms_data.map do |t|
                  if t.is_a?(Hash) && t[:dlist_term]
                    t[:dlist_term].to_s
                  else
                    t.to_s
                  end
                end
              else
                [terms_data.to_s]
              end

      # Extract definition
      if definition.is_a?(Parslet::Slice)
      end
      contents = definition.to_s

      Model::List::DefinitionItem.new(terms: terms, contents: contents)
    end

    rule(definition_list: sequence(:list_items)) do
      Model::List::Definition.new(items: list_items)
    end

    # Definition list with attribute_list (e.g., [%key])
    rule(
      attribute_list: simple(:attribute_list),
      definition_list: sequence(:list_items)
    ) do
      Model::List::Definition.new(items: list_items, attrs: attribute_list)
    end

    # List containing definition_list
    rule(
      attribute_list: simple(:attribute_list),
      definition_list: sequence(:list_items)
    ) do
      Model::List::Definition.new(items: list_items, attrs: attribute_list)
    end
  end
end