coradoc-adoc 2.0.0 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c26d9ebfcf6853d33150a149234dbb84d35fa07afe3cba77894fa6bcc96dc0cd
-  data.tar.gz: d9208da701b03723fedcbe52bc40dad2c7c880fbc48d2817e309a7fdfd439d35
+  metadata.gz: bfa6580ceec41f023bc49501abcd731a8ce2bbe25fb381a083b6595a4ccd7c1e
+  data.tar.gz: 0fa0c15adc1ed488f4fc0913cc8342551896025065cf543ef2307de95947fa1a
 SHA512:
-  metadata.gz: 0c10a653ea35637819bd299247cfa100793dc16ec9a02e4c9d96e4e54dbf8f6d38fd053feab58e8849a5b06d4cf24c2b9a97fd29048e584e76ca1a732cbb0628
-  data.tar.gz: 76fb17f26249012cc48d581cb4dce02ffee066260d41cd010b7bcf8f2c7bfa46ac4ef83330d5d14d568099b059abf2cb910d19b397d4b12401833bb4867a0282
+  metadata.gz: e9276729c16a8084735f487d8faaadc9d64ac81781214c41ff8808bd771eeddfc5d22e726b1fc09add738b3771fcf1902249879fbc91f203d6918f2a42b5509e
+  data.tar.gz: 07735c28d0a67001c6791420c22558e4a711a08857fe20fe33eade7c3d6f5284a67c6bbc3d3473614e401324dd150abe76aa618150837b0df81967134535ec94

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/coradoc/asciidoc/builder/block_builder.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      module BlockBuilder
+        def build_annotation_block(ast)
+          Coradoc::CoreModel::AnnotationBlock.new(
+            annotation_type: extract_annotation_type(ast),
+            annotation_label: extract_annotation_label(ast),
+            content: extract_block_content(ast),
+            lines: extract_block_lines(ast),
+            title: ast[:title],
+            id: ast[:id],
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def build_generic_block(ast)
+          Coradoc::CoreModel::Block.new(
+            delimiter_type: ast[:delimiter]&.to_s,
+            content: extract_block_content(ast),
+            lines: extract_block_lines(ast),
+            title: ast[:title],
+            id: ast[:id],
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def extract_block_content(ast)
+          return ast[:content] if ast[:content]
+
+          if ast[:lines]
+            lines = Array(ast[:lines])
+            return lines.map { |line| extract_text_content(line) }.join("\n")
+          end
+
+          ''
+        end
+
+        def extract_block_lines(ast)
+          return [] unless ast[:lines]
+
+          Array(ast[:lines]).map { |line| extract_text_content(line) }
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/builder/detection.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      module Detection
+        def detect_element_type(ast)
+          return :header if ast.key?(:header) || has_header_structure?(ast)
+          return :section if ast.key?(:section) || has_section_structure?(ast)
+          return :block if ast.key?(:block) || has_block_structure?(ast)
+          return :list if ast.key?(:list) || ast.key?(:unordered) ||
+                          ast.key?(:ordered) || ast.key?(:definition_list)
+          return :paragraph if ast.key?(:paragraph)
+          return :text if ast.key?(:text)
+          return :attribute if ast.key?(:key) && ast.key?(:value)
+          return :document_attributes if ast.key?(:document_attributes)
+          return :inline if has_inline_structure?(ast)
+          return :line_break if ast.key?(:line_break) && ast.keys.length == 1
+          return :comment_line if ast.key?(:comment_line)
+          return :comment_block if ast.key?(:comment_block)
+          return :include if ast.key?(:include)
+          return :table if ast.key?(:table)
+          return :unparsed if ast.key?(:unparsed)
+          return :tag if ast.key?(:tag)
+          return :bibliography_entry if ast.key?(:bibliography_entry)
+
+          nil
+        end
+
+        def detect_block_type(ast)
+          return :annotation if extract_annotation_type(ast)
+          return :list if ast[:marker] && list_markers.include?(ast[:marker].to_s)
+
+          :generic
+        end
+
+        def has_header_structure?(ast)
+          ast.key?(:title) && (ast.key?(:author) || ast.key?(:revision))
+        end
+
+        def has_section_structure?(ast)
+          ast.key?(:title) && ast.key?(:level)
+        end
+
+        def has_block_structure?(ast)
+          ast.key?(:delimiter) || ast.key?(:lines)
+        end
+
+        def has_inline_structure?(ast)
+          inline_format_types.any? { |type| ast.key?(type) }
+        end
+
+        def detect_inline_format(ast)
+          ast.each_key do |key|
+            key_str = key.to_s
+            return key_str if key_str.end_with?('_constrained', '_unconstrained')
+          end
+
+          inline_format_types.each do |format|
+            return format.to_s if ast.key?(format)
+          end
+
+          'text'
+        end
+
+        def detect_constrained(ast, format_type)
+          if format_type.end_with?('_constrained')
+            return true
+          elsif format_type.end_with?('_unconstrained')
+            return false
+          end
+
+          key = "#{format_type}_constrained".to_sym
+          return true if ast.key?(key)
+
+          unconstrained_key = "#{format_type}_unconstrained".to_sym
+          return false if ast.key?(unconstrained_key)
+
+          true
+        end
+
+        def extract_level(ast)
+          if ast[:level]
+            level_str = ast[:level].to_s
+            return level_str.length - 1 if level_str.start_with?('=')
+            return level_str.to_i if level_str.match?(/^\d+$/)
+          end
+
+          1
+        end
+
+        def extract_annotation_type(ast)
+          attr_list = ast[:attribute_list]
+          if attr_list.is_a?(Hash) && attr_list[:positional]
+            positional = Array(attr_list[:positional])
+            annotation = positional.find do |p|
+              annotation_types.include?(p.to_s.downcase)
+            end
+            return annotation.to_s.downcase if annotation
+          end
+
+          return ast[:admonition_type]&.to_s&.downcase if ast[:admonition_type]
+
+          nil
+        end
+
+        def extract_annotation_label(ast)
+          attr_list = ast[:attribute_list]
+          return nil unless attr_list.is_a?(Hash)
+
+          if attr_list[:named]
+            named = Array(attr_list[:named])
+            reviewer_attr = named.find do |n|
+              n.is_a?(Hash) && n[:key] == 'reviewer'
+            end
+            return reviewer_attr[:value] if reviewer_attr
+          end
+
+          nil
+        end
+
+        def detect_marker_type(ast)
+          marker = ast[:marker]&.to_s
+          return 'unordered' if marker&.start_with?('*')
+          return 'unordered' if marker&.start_with?('-')
+          return 'ordered' if marker&.match?(/^\d+\./) || marker&.start_with?('.')
+          return 'definition' if marker&.end_with?('::')
+
+          'unordered'
+        end
+
+        def detect_marker_level(ast)
+          marker = ast[:marker]&.to_s
+          return marker.length if marker&.match?(/^[*.]+$/)
+
+          1
+        end
+
+        def extract_text_content(content)
+          case content
+          when String
+            content
+          when Array
+            content.map { |c| extract_text_content(c) }.join
+          when Hash
+            if content[:text]
+              extract_text_content(content[:text])
+            elsif content[:paragraph_text]
+              extract_text_content(content[:paragraph_text])
+            else
+              content.values.map { |v| extract_text_content(v) }.join
+            end
+          else
+            content.to_s
+          end
+        end
+
+        def extract_inline_content(ast, format_type)
+          content_key = format_type.to_sym
+          content = ast[content_key] ||
+                    ast["#{format_type}_constrained".to_sym] ||
+                    ast["#{format_type}_unconstrained".to_sym]
+
+          extract_text_content(content)
+        end
+
+        def annotation_types
+          %w[note warning caution important tip reviewer sidebar]
+        end
+
+        def list_markers
+          %w[* - . ::]
+        end
+
+        def inline_format_types
+          %i[bold italic monospace superscript subscript highlight span link
+             cross_reference bold_constrained bold_unconstrained
+             italic_constrained italic_unconstrained monospace_constrained
+             monospace_unconstrained]
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/builder/element_builder.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      module ElementBuilder
+        def build_header(ast)
+          header_ast = ast[:header] || ast
+
+          Coradoc::CoreModel::HeaderElement.new(
+            title: extract_text_content(header_ast[:title]),
+            id: header_ast[:id]
+          )
+        end
+
+        def build_section(ast)
+          section_ast = ast[:section] || ast
+
+          Coradoc::CoreModel::SectionElement.new(
+            title: extract_text_content(section_ast[:title]),
+            id: section_ast[:id],
+            level: extract_level(section_ast),
+            children: build_section_contents(section_ast[:contents]) +
+                      build_subsections(section_ast[:sections])
+          )
+        end
+
+        def build_section_contents(contents_ast)
+          return [] unless contents_ast
+
+          Array(contents_ast).map { |content| build_element(content) }.compact
+        end
+
+        def build_subsections(sections_ast)
+          return [] unless sections_ast
+
+          Array(sections_ast).map { |section| build_element(section) }.compact
+        end
+
+        def build_line_break(ast)
+          Coradoc::CoreModel::Block.new(
+            block_semantic_type: 'line_break',
+            content: ast[:line_break] || ast['line_break']
+          )
+        end
+
+        def build_comment_line(ast)
+          comment_ast = ast[:comment_line] || ast['comment_line'] || ast
+
+          Coradoc::CoreModel::CommentBlock.new(
+            content: comment_ast[:comment_text] || comment_ast['comment_text']
+          )
+        end
+
+        def build_comment_block(ast)
+          comment_ast = ast[:comment_block] || ast['comment_block'] || ast
+
+          Coradoc::CoreModel::CommentBlock.new(
+            content: comment_ast[:comment_text] || comment_ast['comment_text']
+          )
+        end
+
+        def build_include(ast)
+          include_ast = ast[:include] || ast['include'] || ast
+
+          Coradoc::CoreModel::Block.new(
+            block_semantic_type: 'include',
+            content: include_ast[:path] || include_ast['path']
+          )
+        end
+
+        def build_table(ast)
+          table_ast = ast[:table] || ast['table'] || ast
+
+          Coradoc::CoreModel::Table.new(
+            title: table_ast[:title] || table_ast['title'],
+            id: table_ast[:id] || table_ast['id'],
+            rows: table_ast[:rows] || table_ast['rows'] || []
+          )
+        end
+
+        def build_unparsed(ast)
+          Coradoc::CoreModel::Block.new(
+            block_semantic_type: 'unparsed',
+            content: (ast[:unparsed] || ast['unparsed']).to_s
+          )
+        end
+
+        def build_tag(ast)
+          tag_ast = ast[:tag] || ast['tag'] || ast
+
+          Coradoc::CoreModel::Block.new(
+            block_semantic_type: 'tag',
+            content: tag_ast[:name] || tag_ast['name']
+          )
+        end
+
+        def build_bibliography_entry(ast)
+          bib_ast = ast[:bibliography_entry] || ast['bibliography_entry'] || ast
+
+          Coradoc::CoreModel::BibliographyEntry.new(
+            anchor_name: bib_ast[:anchor_name] || bib_ast['anchor_name'],
+            document_id: bib_ast[:document_id] || bib_ast['document_id'],
+            ref_text: bib_ast[:ref_text] || bib_ast['ref_text']
+          )
+        end
+
+        def build_generic_element(ast)
+          Coradoc::CoreModel::Block.new(
+            block_semantic_type: 'unknown',
+            content: ast.to_s
+          )
+        end
+
+        def build_attribute(ast)
+          Coradoc::CoreModel::ElementAttribute.new(
+            name: ast[:key],
+            value: ast[:value]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/builder/list_builder.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      module ListBuilder
+        def build_list_block(ast)
+          Coradoc::CoreModel::ListBlock.new(
+            marker_type: detect_marker_type(ast),
+            marker_level: detect_marker_level(ast),
+            items: build_list_items(ast[:items] || ast[:list_items]),
+            title: ast[:title],
+            id: ast[:id],
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def build_unordered_list(ast)
+          items = Array(ast[:unordered]).map { |item| build_list_item(item) }
+
+          Coradoc::CoreModel::ListBlock.new(
+            marker_type: 'unordered',
+            marker_level: 1,
+            items: items,
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def build_ordered_list(ast)
+          items = Array(ast[:ordered]).map { |item| build_list_item(item) }
+
+          Coradoc::CoreModel::ListBlock.new(
+            marker_type: 'ordered',
+            marker_level: 1,
+            items: items,
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def build_definition_list(ast)
+          items = Array(ast[:definition_list]).map do |item|
+            build_definition_item(item)
+          end
+
+          Coradoc::CoreModel::ListBlock.new(
+            marker_type: 'definition',
+            marker_level: 1,
+            items: items,
+            attributes: build_attributes_private(ast[:attribute_list])
+          )
+        end
+
+        def build_list_items(items_ast)
+          return [] unless items_ast
+
+          Array(items_ast).map { |item| build_list_item(item) }
+        end
+
+        def build_list_item(ast)
+          item_ast = ast[:list_item] || ast
+
+          Coradoc::CoreModel::ListItem.new(
+            marker: item_ast[:marker]&.to_s,
+            content: extract_item_content(item_ast),
+            nested_list: build_nested_list(item_ast[:nested]),
+            children: build_item_children(item_ast[:attached])
+          )
+        end
+
+        def build_definition_item(ast)
+          item_ast = ast[:definition_list_item] || ast
+
+          Coradoc::CoreModel::ListItem.new(
+            marker: '::',
+            content: build_definition_content(item_ast),
+            children: []
+          )
+        end
+
+        def build_definition_content(ast)
+          terms = Array(ast[:terms]).join(', ')
+          definition = ast[:definition] || ast[:contents]
+
+          "#{terms}: #{definition}"
+        end
+
+        def build_nested_list(nested_ast)
+          return nil unless nested_ast
+
+          if nested_ast.is_a?(Array)
+            Coradoc::CoreModel::ListBlock.new(
+              marker_type: 'unordered',
+              marker_level: 2,
+              items: nested_ast.map { |item| build_list_item(item) }
+            )
+          else
+            build_element(nested_ast)
+          end
+        end
+
+        def build_item_children(attached_ast)
+          return [] unless attached_ast
+
+          Array(attached_ast).map { |child| build_element(child) }.compact
+        end
+
+        def extract_item_content(ast)
+          if ast[:text]
+            case ast[:text]
+            when String
+              ast[:text]
+            when Array
+              ast[:text].map(&:to_s).join
+            else
+              ast[:text].to_s
+            end
+          elsif ast[:content]
+            ast[:content].to_s
+          else
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/builder/text_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    class Builder
+      module TextBuilder
+        def build_nested_inlines(ast)
+          nested = []
+
+          ast.each_value do |value|
+            next unless value.is_a?(Array)
+
+            value.each do |item|
+              nested << build_inline(item) if item.is_a?(Hash) && has_inline_structure?(item)
+            end
+          end
+
+          nested
+        end
+      end
+    end
+  end
+end