coradoc-adoc 2.0.0

data/lib/coradoc/asciidoc/serializer/serializers/inline/italic.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for Italic inline formatting
+          class Italic < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              content = Coradoc::Util::AsciiDoc.escape_characters(content, escape_chars: ['_'])
+
+              return '' if content.empty?
+
+              model.unconstrained ? "__#{content}__" : "_#{content}_"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Italic, Inline::Italic)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/link.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          class Link < Base
+            def to_adoc(model, _options = {})
+              link = model.path.dup
+              link = "link:#{link}" unless model.path&.match?(URI::DEFAULT_PARSER.make_regexp)
+
+              name_empty = model.name.nil? || model.name.empty?
+              title_empty = model.title.nil? || model.title.empty?
+              valid_empty_name_link = link.start_with?(%r{https?://})
+
+              link << if name_empty && !title_empty
+                        "[#{model.title}]"
+                      elsif !name_empty
+                        "[#{model.name}]"
+                      elsif valid_empty_name_link && !model.right_constrain
+                        ''
+                      else
+                        '[]'
+                      end
+              link
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Link, Inline::Link)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/monospace.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for Monospace inline formatting
+          class Monospace < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              content = Coradoc::Util::AsciiDoc.escape_characters(content, escape_chars: ['`'])
+
+              return '' if content.empty?
+
+              model.unconstrained ? "``#{content}``" : "`#{content}`"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Monospace, Inline::Monospace)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/quotation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          class Quotation < Base
+            def to_adoc(model, _options = {})
+              _content = serialize_content(model.content)
+              "#{_content[/^\s*/]}\"#{_content.strip}\"#{_content[/(?<!\s)\s*+$/]}"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Quotation, Inline::Quotation)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/small.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          class Small < Base
+            def to_adoc(model, _options = {})
+              "[.small]##{model.text}#"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Small, Inline::Small)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/span.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          class Span < Base
+            def to_adoc(model, _options = {})
+              if model.attributes
+                attr_string = model.attributes.to_adoc
+                if model.unconstrained
+                  "#{attr_string}###{model.text}##"
+                else
+                  "#{attr_string}##{model.text}#"
+                end
+              elsif model.role
+                if model.unconstrained
+                  "[.#{model.role}]###{model.text}##"
+                else
+                  "[.#{model.role}]##{model.text}#"
+                end
+              else
+                model.text.to_s
+              end
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Span, Inline::Span)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/stem.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for STEM inline formulas
+          class Stem < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              type = model.type || 'stem'
+              "#{type}:[#{content}]"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Stem, Inline::Stem)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/strikethrough.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for Strikethrough inline formatting
+          class Strikethrough < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content || model.text)
+
+              return '' if content.empty?
+
+              if model.unconstrained
+                "[.line-through]#[.line-through]##{content}[.line-through]#[.line-through]#"
+              else
+                "[.line-through]##{content}#"
+              end
+            end
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Strikethrough, Serializers::Inline::Strikethrough)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/subscript.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for Subscript inline formatting
+          class Subscript < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              content = Coradoc::Util::AsciiDoc.escape_characters(
+                content,
+                pass_through: %w[~]
+              )
+
+              return '' if content.empty?
+
+              "~#{content}~"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Subscript, Inline::Subscript)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/superscript.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          # Serializer for Superscript inline formatting
+          class Superscript < Base
+            def to_adoc(model, _options = {})
+              content = serialize_content(model.content)
+              # Superscript uses ^ delimiters, no need to escape
+
+              return '' if content.empty?
+
+              "^#{content}^"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Superscript, Inline::Superscript)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline/underline.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module Inline
+          class Underline < Base
+            def to_adoc(model, _options = {})
+              "[.underline]##{model.text}#"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::Inline::Underline, Inline::Underline)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/inline.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Autoload inline serializers
+        module Inline
+          autoload :Anchor, 'coradoc/asciidoc/serializer/serializers/inline/anchor'
+          autoload :AttributeReference, 'coradoc/asciidoc/serializer/serializers/inline/attribute_reference'
+          autoload :Bold, 'coradoc/asciidoc/serializer/serializers/inline/bold'
+          autoload :CrossReference, 'coradoc/asciidoc/serializer/serializers/inline/cross_reference'
+          autoload :CrossReferenceArg, 'coradoc/asciidoc/serializer/serializers/inline/cross_reference_arg'
+          autoload :Footnote, 'coradoc/asciidoc/serializer/serializers/inline/footnote'
+          autoload :HardLineBreak, 'coradoc/asciidoc/serializer/serializers/inline/hard_line_break'
+          autoload :Highlight, 'coradoc/asciidoc/serializer/serializers/inline/highlight'
+          autoload :Italic, 'coradoc/asciidoc/serializer/serializers/inline/italic'
+          autoload :Link, 'coradoc/asciidoc/serializer/serializers/inline/link'
+          autoload :Monospace, 'coradoc/asciidoc/serializer/serializers/inline/monospace'
+          autoload :Quotation, 'coradoc/asciidoc/serializer/serializers/inline/quotation'
+          autoload :Small, 'coradoc/asciidoc/serializer/serializers/inline/small'
+          autoload :Span, 'coradoc/asciidoc/serializer/serializers/inline/span'
+          autoload :Stem, 'coradoc/asciidoc/serializer/serializers/inline/stem'
+          autoload :Strikethrough, 'coradoc/asciidoc/serializer/serializers/inline/strikethrough'
+          autoload :Subscript, 'coradoc/asciidoc/serializer/serializers/inline/subscript'
+          autoload :Superscript, 'coradoc/asciidoc/serializer/serializers/inline/superscript'
+          autoload :Underline, 'coradoc/asciidoc/serializer/serializers/inline/underline'
+        end
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/line_break.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        class LineBreak < Base
+          def to_adoc(model, _options = {})
+            model.line_break
+          end
+        end
+      end
+
+      # Self-register this serializer
+      ElementRegistry.register(Coradoc::AsciiDoc::Model::LineBreak, Serializers::LineBreak)
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/core.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class Core < Base
+            def to_adoc(model, _options = {})
+              @model = model
+              _anchor = @model.anchor.nil? ? '' : serialize_child(@model.anchor).to_s
+              _attrs = @model.attrs.to_adoc(show_empty: false).to_s
+              content = +"\n"
+
+              @model.items.each do |item|
+                c = serialize_child(item)
+                next if c.empty?
+
+                # If there's a list inside a list directly, we want to
+                # skip adding an empty list item.
+                # See: https://github.com/metanorma/coradoc/issues/96
+                unless item.is_a?(Coradoc::AsciiDoc::Model::List::Core)
+                  # Use item's own marker if available, otherwise fall back to list prefix
+                  item_marker = item.marker || prefix
+                  content << item_marker.to_s
+                  content << ' ' if c[0] != ' '
+                end
+                content << c
+              end
+
+              "\n#{_anchor}#{_attrs}" + content
+            end
+
+            private
+
+            def prefix
+              @model.prefix
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::Core, List::Core)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/definition.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class Definition < Base
+            def to_adoc(model, _options = {})
+              @model = model
+              content = +"\n"
+              @model.items.each do |item|
+                # Pass delimiter to item serialization
+                serialized = serialize_child_with_options(item, delimiter: @model.delimiter)
+                content << serialized
+              end
+              content
+            end
+
+            private
+
+            def serialize_child_with_options(child, options = {})
+              serializer_class = ElementRegistry.lookup(child.class)
+              serializer = serializer_class.new
+              serializer.to_adoc(child, options)
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::Definition, List::Definition)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/definition_item.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class DefinitionItem < Base
+            def to_adoc(model, options_or_context = {})
+              context = normalize_context(options_or_context)
+              delimiter = context.option(:delimiter, '')
+              _anchor = model.anchor.nil? ? '' : serialize_child(model.anchor, context)
+              content = +''
+
+              if model.terms && model.terms.size == 1
+                t = serialize_child(model.terms.first, context)
+                content << "#{_anchor}#{t}#{delimiter} "
+              elsif model.terms && model.terms.size > 1
+                # NOTE: When multiple terms exist, anchors are rendered on each term line
+                # separately. Single term anchors are inlined with the definition.
+                model.terms.each do |term|
+                  t = serialize_child(term, context)
+                  content << "#{t}#{delimiter}\n"
+                end
+              end
+
+              d = model.contents ? serialize_children(model.contents, context) : ''
+              content << "#{d}\n"
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::DefinitionItem, List::DefinitionItem)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/item.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class Item < Base
+            HARDBREAK_MARKERS = %i[hardbreak init].freeze
+            STRIP_UNICODE_BEGIN_MARKERS = (HARDBREAK_MARKERS.dup + [false]).freeze
+            STRIP_UNICODE_END_MARKERS = [:hardbreak, :end, false].freeze
+
+            def to_adoc(model, _options = {})
+              @model = model
+              _anchor = gen_anchor(inline: true)
+              _content = Array(model.content).dup.flatten.compact
+              out = ''
+              prev_inline = :init
+
+              # Collapse meaningless <DIV>s
+              while _content.map(&:class) == [Coradoc::AsciiDoc::Model::Section] &&
+                    _content.first.safe_to_collapse?
+
+                _content = Array(_content.first.contents)
+              end
+
+              _content.each_with_index do |subitem, idx|
+                subcontent = case subitem
+                             when String
+                               subitem
+                             when Coradoc::AsciiDoc::Model::Base, Lutaml::Model::Serializable
+                               subitem.to_adoc
+                             else
+                               raise ArgumentError,
+                                     "Cannot serialize list item content of type #{subitem.class.name}. " \
+                                     'Expected String, Coradoc::AsciiDoc::Model::Base, or ' \
+                                     "Lutaml::Model::Serializable. Got: #{subitem.inspect[0..100]}"
+                             end
+
+                inline = inline?(subitem)
+                next_inline = idx + 1 == _content.length ? :end : inline?(_content[idx + 1])
+
+                # Only try to postprocess elements that are text,
+                # otherwise we could strip markup.
+                if subitem.is_a?(Coradoc::AsciiDoc::Model::TextElement)
+                  if STRIP_UNICODE_BEGIN_MARKERS.include?(prev_inline)
+                    subcontent = Coradoc.strip_unicode(subcontent,
+                                                       only: :begin)
+                  end
+                  if STRIP_UNICODE_END_MARKERS.include?(next_inline)
+                    subcontent = Coradoc.strip_unicode(subcontent,
+                                                       only: :end)
+                  end
+                end
+
+                case inline
+                when true
+                  out += if prev_inline == false
+                           "\n+\n#{subcontent}"
+                         else
+                           subcontent
+                         end
+                when false
+                  out += case prev_inline
+                         when :hardbreak
+                           subcontent.strip
+                         when :init
+                           "{empty}\n+\n#{subcontent.strip}"
+                         else
+                           "\n+\n#{subcontent.strip}"
+                         end
+                when :hardbreak
+                  if HARDBREAK_MARKERS.include?(prev_inline)
+                    # can't have two hard breaks in a row
+                    # can't start with a hard break
+                  else
+                    out += "\n+\n"
+                  end
+                end
+
+                prev_inline = inline
+              end
+              out += '{empty}' if prev_inline == :hardbreak
+              out = '{empty}' if out.empty?
+
+              attach = model.attached.map do |elem|
+                "+\n#{elem.to_adoc}"
+              end.join
+              nest = model.nested.nil? || (model.nested.is_a?(Array) && model.nested.empty?) ? '' : model.nested.to_adoc
+              out = " #{_anchor}#{out}#{model.line_break}"
+              out + attach + nest
+            end
+
+            private
+
+            def inline?(elem)
+              return true if elem.is_a?(String)
+              return false unless elem.is_a?(Coradoc::AsciiDoc::Model::Base)
+
+              elem.inline?
+            end
+
+            def gen_anchor(inline: false)
+              return '' unless @model.anchor
+
+              if inline
+                @model.anchor.to_adoc.to_s
+              else
+                "#{@model.anchor.to_adoc}\n"
+              end
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::Item, List::Item)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/ordered.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class Ordered < Core
+            private
+
+            def prefix
+              return @model.marker if @model.marker
+
+              '.' * [@model.ol_count, 1].max
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::Ordered, List::Ordered)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list/unordered.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        module List
+          class Unordered < Core
+            private
+
+            def prefix
+              # Use the marker from the first list item if available
+              return @model.items.first.marker if @model.items.first&.marker
+
+              # Otherwise use the list-level marker if set
+              return @model.marker if @model.marker
+
+              # Default to asterisk markers
+              '*' * [@model.ol_count, 1].max
+            end
+          end
+        end
+
+        # Self-register this serializer
+        ElementRegistry.register(Coradoc::AsciiDoc::Model::List::Unordered, List::Unordered)
+      end
+    end
+  end
+end

data/lib/coradoc/asciidoc/serializer/serializers/list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Coradoc
+  module AsciiDoc
+    module Serializer
+      module Serializers
+        # Autoload list serializers
+        module List
+          autoload :Core, 'coradoc/asciidoc/serializer/serializers/list/core'
+          autoload :Definition, 'coradoc/asciidoc/serializer/serializers/list/definition'
+          autoload :DefinitionItem, 'coradoc/asciidoc/serializer/serializers/list/definition_item'
+          autoload :Item, 'coradoc/asciidoc/serializer/serializers/list/item'
+          autoload :Ordered, 'coradoc/asciidoc/serializer/serializers/list/ordered'
+          autoload :Unordered, 'coradoc/asciidoc/serializer/serializers/list/unordered'
+        end
+      end
+    end
+  end
+end