coradoc-adoc 2.0.34 → 2.0.36

data/lib/coradoc/asciidoc/transform/from_core_model.rb

@@ -5,6 +5,8 @@ module Coradoc
     module Transform
       # Transforms CoreModel to AsciiDoc models
       class FromCoreModel
+        extend Transform::ListBuilding
+
         @registered = false
 
         class << self
@@ -216,24 +218,11 @@ module Coradoc
             )
           end
 
-          def transform_list(list)
-            items = Array(list.items).map do |item|
-              Coradoc::AsciiDoc::Model::List::Item.new(
-                content: item.flat_text,
-                marker: item.marker || default_marker(list.marker_type)
-              )
-            end
-
-            case list.marker_type
-            when 'ordered'
-              Coradoc::AsciiDoc::Model::List::Ordered.new(items: items)
-            when 'definition'
-              Coradoc::AsciiDoc::Model::List::Definition.new(items: items)
-            else
-              Coradoc::AsciiDoc::Model::List::Unordered.new(items: items)
-            end
-          end
-
+          # Lists nested inside list items carry depth markers so
+          # AsciiDoc reads them as nested rather than sibling lists —
+          # without this, item children other than text were dropped
+          # entirely (#68 territory). Nested lists keep their own
+          # marker type one level deeper.
           def transform_list_item(item)
             Coradoc::AsciiDoc::Model::List::Item.new(
               content: item.flat_text,
@@ -256,12 +245,95 @@ module Coradoc
             )
           end
 
-          def transform_inline(inline)
+          # Nested inline structure lives in +children+ (e.g. an
+          # ItalicElement whose single child is a BoldElement);
+          # +content+ is only the flattened display string. Build the
+          # adoc model from children so nesting survives, and default
+          # to the constrained marker — the constrained/unstrained
+          # distinction is not carried in CoreModel, and constrained
+          # is the correct rendering for span-boundary emphasis (#159).
+          def inline_model(klass, inline, unconstrained: false)
+            content = if inline.children.nil? || inline.children.empty?
+                        inline.content.to_s
+                      else
+                        create_text_elements(inline.children)
+                      end
+
+            klass.new(content: content, unconstrained: unconstrained)
+          end
+
+          # `_*text*_` parses to Italic{Bold{text}}; Metanorma renders
+          # same-span emphasis correctly only with italic innermost
+          # (`*_text_*`, #159). When an italic's entire content is one
+          # bold (or a bold's one italic), rebuild as Bold outer /
+          # Italic inner, both constrained.
+          def swap_emphasis_nesting(inline, unconstrained: false)
+            children = Array(inline.children)
+            return nil unless children.size == 1
+
+            only = children.first
+            return nil unless only.is_a?(CoreModel::InlineElement)
+
+            inner_kids = Array(only.children)
+            return nil unless inner_kids.empty? || inner_kids.all?(CoreModel::TextContent)
+
+            outer_type = inline.resolve_format_type
+            inner_type = only.resolve_format_type
+            return nil unless %w[bold italic].include?(outer_type) && outer_type != inner_type &&
+                              %w[bold italic].include?(inner_type)
+
+            classes = {
+              'bold' => Coradoc::AsciiDoc::Model::Inline::Bold,
+              'italic' => Coradoc::AsciiDoc::Model::Inline::Italic
+            }
+            inner = classes[outer_type].new(
+              content: only.children.nil? || only.children.empty? ? only.content.to_s : create_text_elements(only.children),
+              unconstrained: false
+            )
+            classes[inner_type].new(content: inner, unconstrained: unconstrained)
+          end
+
+          # AsciiDoc constrained markers only reparse as emphasis when
+          # the opening delimiter follows a boundary and the closing
+          # one precedes one. CoreModel does not carry the constraint,
+          # so derive it from the adjacent sibling text: an inline
+          # touching a word character on either side must serialize
+          # with the unconstrained form or the emphasis is lost on
+          # reparse (mid-word bolding is common in Word documents).
+          def unconstrained_flanks?(left, right)
+            left_ok = left.nil? || left.match?(/\s/)
+            right_ok = right.nil? || right.match?(/\s|[[:punct:]]/)
+            !(left_ok && right_ok)
+          end
+
+          def sibling_edge(items, index, direction)
+            item = items[index]
+            text = case item
+                   when Coradoc::CoreModel::TextContent then item.text.to_s
+                   when Coradoc::CoreModel::InlineElement then item.content.to_s
+                   when String then item
+                   else return nil
+                   end
+            return nil if text.empty?
+
+            direction == :last ? text[-1] : text[0]
+          end
+
+          def transform_inline(inline, siblings: nil, index: 0)
+            left = siblings && index.positive? ? sibling_edge(siblings, index - 1, :last) : nil
+            right = siblings ? sibling_edge(siblings, index + 1, :first) : nil
+            unconstrained = unconstrained_flanks?(left, right)
             case inline.resolve_format_type
             when 'bold'
-              Coradoc::AsciiDoc::Model::Inline::Bold.new(content: inline.content)
+              inline_model(Coradoc::AsciiDoc::Model::Inline::Bold, inline,
+                           unconstrained: unconstrained)
             when 'italic'
-              Coradoc::AsciiDoc::Model::Inline::Italic.new(content: inline.content)
+              # #159: italic directly wrapping only bold (`_*text*_`)
+              # re-serializes as Bold outer / Italic inner (`*_text_*`)
+              # for correct Metanorma rendering.
+              swap_emphasis_nesting(inline, unconstrained: unconstrained) ||
+                inline_model(Coradoc::AsciiDoc::Model::Inline::Italic, inline,
+                             unconstrained: unconstrained)
             when 'monospace'
               Coradoc::AsciiDoc::Model::Inline::Monospace.new(content: inline.content)
             when 'highlight'
@@ -546,7 +618,13 @@ module Coradoc
           def create_text_elements(content)
             case content
             when Array
-              content.map { |item| create_text_elements(item) }
+              content.each_with_index.map do |item, i|
+                if item.is_a?(Coradoc::CoreModel::InlineElement)
+                  transform_inline(item, siblings: content, index: i)
+                else
+                  create_text_elements(item)
+                end
+              end
             when Coradoc::CoreModel::InlineElement
               transform_inline(content)
             when Coradoc::CoreModel::TextContent
@@ -577,13 +655,6 @@ module Coradoc
             attrs['language'] = block.language if block.language
             attrs
           end
-
-          def default_marker(marker_type)
-            case marker_type
-            when 'ordered' then '.'
-            else '*'
-            end
-          end
         end
 
         def transform(model) = self.class.transform(model)

data/lib/coradoc/asciidoc/transform/frontmatter_attribute_map.rb

@@ -59,10 +59,11 @@ module Coradoc
           # @return [Hash{String=>String}]
           def attributes_from_block(block)
             result = {}
-            return result unless block&.data
+            data = CoreModel::FrontmatterBlock::Codec.to_hash(block)
+            return result if data.empty?
 
             MAPPINGS.each do |(_, front_key, _)|
-              value = block.data[front_key]
+              value = data[front_key]
               next if value.nil?
 
               attr_name = front_key_to_attribute(front_key)

data/lib/coradoc/asciidoc/transform/text_extract_visitor.rb

@@ -109,15 +109,18 @@ module Coradoc
 
         # Collections
         def visit_array(models)
+          # Fragments of one source line concatenate (an escape splits
+          # `foo\_bar` into three pieces); a soft line break joins
+          # with a space (soft-wrapped paragraph lines).
           result = []
           models.each_with_index do |item, idx|
             text = visit(item)
             next if text.empty?
 
             result << text
-            next unless idx < models.length - 1 && !text.empty?
+            next if idx == models.length - 1
 
-            result << ' ' if item.is_a?(Model::TextElement) && item.line_break != '+'
+            result << ' ' if item.is_a?(Model::TextElement) && item.line_break == "\n"
           end
           result.join
         end

data/lib/coradoc/asciidoc/transform/to_core_model.rb

@@ -108,12 +108,22 @@ module Coradoc
             DelimiterMapping::CHAR_TO_SEMANTIC[char] || :open
           end
 
+          # Reused parser/transformer for inline re-parsing: Parsanol's
+          # VM program cache is keyed by atom identity, so a fresh parser
+          # per call recompiled the grammar every time (see also
+          # Transformer::TableCellBuilder).
+          def inline_reparse
+            @inline_reparse ||= [
+              Coradoc::AsciiDoc::Parser::Base.new,
+              Coradoc::AsciiDoc::Transformer.new
+            ]
+          end
+
           def parse_inline_text(raw_text)
             return [] if raw_text.nil? || raw_text.to_s.strip.empty?
 
             text = raw_text.to_s
-            parser = Coradoc::AsciiDoc::Parser::Base.new
-            transformer = Coradoc::AsciiDoc::Transformer.new
+            parser, transformer = inline_reparse
 
             parsed = parser.text_any.parse(text)
             result = transformer.apply({ text: parsed })

data/lib/coradoc/asciidoc/transform.rb

@@ -8,6 +8,7 @@ module Coradoc
       autoload :ToCoreModel, "#{__dir__}/transform/to_core_model"
       autoload :ToCoreModelRegistrations, "#{__dir__}/transform/to_core_model_registrations"
       autoload :FromCoreModel, "#{__dir__}/transform/from_core_model"
+      autoload :ListBuilding, "#{__dir__}/transform/from_core_model/list_building"
       autoload :FromCoreModelRegistrations, "#{__dir__}/transform/from_core_model_registrations"
       autoload :TextExtractVisitor, "#{__dir__}/transform/text_extract_visitor"
       autoload :InlineTransformVisitor, "#{__dir__}/transform/inline_transform_visitor"

data/lib/coradoc/asciidoc/transformer/source_line_extractor.rb

@@ -33,7 +33,7 @@ module Coradoc
 
         def extract(node)
           case node
-          when Parsanol::Slice then line_of(node)
+          when Parsanol::Slice, Coradoc::AsciiDoc::Parser::PositionedString then line_of(node)
           when Coradoc::AsciiDoc::Model::Base then node.source_line
           when Hash then extract_from_hash(node)
           when Array then extract_from_array(node)

data/lib/coradoc/asciidoc/transformer/table_cell_builder.rb

@@ -13,6 +13,16 @@ module Coradoc
       module TableCellBuilder
         module_function
 
+        # Reused parser for cell-content re-parsing. Atoms are memoized
+        # per parser instance and Parsanol's VM program cache is keyed by
+        # atom identity — a fresh parser per cell recompiled the whole
+        # grammar for every cell (tables transformed ~50× slower than
+        # they parsed). Sequential reuse only; parse state lives in the
+        # per-call context, not the parser.
+        def inline_parser
+          @inline_parser ||= Coradoc::AsciiDoc::Parser::Base.new
+        end
+
         # @param format [Hash, String, Object, nil] Cell format from parser
         # @param content [Object] Cell content
         # @return [Model::TableCell]
@@ -59,14 +69,15 @@ module Coradoc
         # @param style [String, nil] 'a' (AsciiDoc), 'l' (literal), or nil
         # @return [Array<Model::TextElement>]
         def parse_inline_content(text, style = nil)
-          return [Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
+          text = text.to_s.strip unless style == 'l'
+          return [Model::TextElement.new(content: '')] if text.empty?
 
           return parse_block_content(text) if style == 'a'
           return [Model::TextElement.new(content: text.to_s)] if style == 'l'
 
-          parser = Coradoc::AsciiDoc::Parser::Base.new
+          parser = inline_parser
           begin
-            ast = parser.text_any.parse(text.to_s)
+            ast = Parser::TreeMaterializer.convert(parser.text_any.parse(text.to_s))
             transformed = Transformer.new.apply(ast)
             content_array = transformed.is_a?(Array) ? transformed : [transformed]
             [Model::TextElement.new(content: content_array)]
@@ -81,7 +92,7 @@ module Coradoc
         def parse_block_content(text)
           return [Model::TextElement.new(content: '')] if text.nil? || text.to_s.strip.empty?
 
-          parser = Coradoc::AsciiDoc::Parser::Base.new
+          parser = inline_parser
           text_str = text.to_s
 
           if /^(\*+|-+|\d+\.)/m.match?(text_str)
@@ -89,14 +100,14 @@ module Coradoc
             if list_match
               list_text = list_match[1] + list_match[2]
               begin
-                ast = parser.list.parse(list_text)
+                ast = Parser::TreeMaterializer.convert(parser.list.parse(list_text))
                 transformed = Transformer.new.apply(ast)
 
                 before_list = text_str[0, list_match.begin(1) - 1].strip
                 before_elements = []
                 unless before_list.empty?
                   begin
-                    before_ast = parser.text_any.parse(before_list)
+                    before_ast = Parser::TreeMaterializer.convert(parser.text_any.parse(before_list))
                     before_transformed = Transformer.new.apply(before_ast)
                     before_array = before_transformed.is_a?(Array) ? before_transformed : [before_transformed]
                     before_elements = [Model::TextElement.new(content: before_array)]
@@ -113,7 +124,7 @@ module Coradoc
           end
 
           begin
-            ast = parser.text_any.parse(text_str)
+            ast = Parser::TreeMaterializer.convert(parser.text_any.parse(text_str))
             transformed = Transformer.new.apply(ast)
             content_array = transformed.is_a?(Array) ? transformed : [transformed]
             [Model::TextElement.new(content: content_array)]

data/lib/coradoc/asciidoc/version.rb

@@ -2,6 +2,6 @@
 
 module Coradoc
   module AsciiDoc
-    VERSION = '2.0.34'
+    VERSION = '2.0.36'
   end
 end

data/lib/coradoc/asciidoc.rb

@@ -32,6 +32,9 @@ module Coradoc
     autoload :Model, "#{__dir__}/asciidoc/model"
     autoload :Parser, "#{__dir__}/asciidoc/parser"
     autoload :Transformer, "#{__dir__}/asciidoc/transformer"
+    # Registration side effect: loading registers rules into Coradoc::Lint.registry.
+    autoload :Lint, "#{__dir__}/asciidoc/lint"
+    autoload :Formatter, "#{__dir__}/asciidoc/formatter"
     autoload :Serializer, "#{__dir__}/asciidoc/serializer"
     autoload :Transform, "#{__dir__}/asciidoc/transform"
     autoload :Builder, "#{__dir__}/asciidoc/builder"
@@ -79,6 +82,15 @@ module Coradoc
         Transform::ToCoreModel.transform(document)
       end
 
+      # Canonical-format AsciiDoc text (#110): parse to the model
+      # tree, serialize, and normalize inter-block whitespace.
+      #
+      # @param text [String] AsciiDoc content
+      # @return [String] canonically formatted AsciiDoc
+      def format(text)
+        Formatter.call(text)
+      end
+
       # Serialize a document model to AsciiDoc string
       #
       # @param document [Coradoc::AsciiDoc::Model::Document, Coradoc::CoreModel::Base]

data/lib/coradoc/util/asciidoc.rb

@@ -50,6 +50,62 @@ module Coradoc
         result
       end
 
+      # Escape delimiter characters in plain-text content so the text
+      # survives a reparse (#92): `__x__`, `**x**`, `x~2~` and `` `x` ``
+      # would otherwise re-enter as formatting. Runs of two or more
+      # delimiters (`__`, `**`, `~~`) are dangerous anywhere; a single
+      # `*`, `_` or `~` only forms a constrained pair at a
+      # boundary/word transition; `^` and `` ` `` attach to words.
+      def self.escape_text_delimiters(text)
+        return '' if text.nil?
+
+        text.to_s.gsub(/(?<!\\)[`*_~^]+/) do |run|
+          match = Regexp.last_match
+          dangerous =
+            case run[0]
+            when '`'
+              true
+            when '^'
+              word_transition?(text, match)
+            else
+              run.length >= 2 || word_transition?(text, match)
+            end
+          dangerous ? run.chars.map { |c| "\\#{c}" }.join : run
+        end
+      end
+
+      WHITESPACE = /\s/
+      WORD_CHAR = /[[:word:]]/
+      PUNCT_CHAR = /[[:punct:]]/
+      private_constant :WHITESPACE, :WORD_CHAR, :PUNCT_CHAR
+
+      # A delimiter run at [start, stop) is dangerous when it can open
+      # a pair (boundary on its left, word char on its right) or close
+      # one (word char on its left, boundary-or-punctuation on its
+      # right — AsciiDoc lets a closing delimiter precede punctuation).
+      def self.word_transition?(text, match)
+        start = match.begin(0)
+        stop = match.end(0)
+        before = start.zero? ? nil : text[start - 1]
+        after = stop >= text.length ? nil : text[stop]
+
+        opens = boundary?(before) && word?(after)
+        closes = word?(before) && (boundary?(after) || punctuation?(after))
+        opens || closes
+      end
+
+      def self.boundary?(char)
+        char.nil? || char.match?(WHITESPACE)
+      end
+
+      def self.word?(char)
+        !char.nil? && char.match?(WORD_CHAR)
+      end
+
+      def self.punctuation?(char)
+        !char.nil? && char.match?(PUNCT_CHAR)
+      end
+
       # Unescape AsciiDoc characters in content
       #
       # @param content [String] The content to unescape

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coradoc-adoc
 version: !ruby/object:Gem::Version
-  version: 2.0.34
+  version: 2.0.36
 platform: ruby
 authors:
 - Ribose Inc.
@@ -41,16 +41,16 @@ dependencies:
   name: parsanol
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.123
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.123
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +104,8 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - Rakefile
+- grammar/coradoc-adoc.artifact.json
+- grammar/coradoc-adoc.parg
 - lib/coradoc/asciidoc.rb
 - lib/coradoc/asciidoc/builder.rb
 - lib/coradoc/asciidoc/builder/block_builder.rb
@@ -112,6 +114,12 @@ files:
 - lib/coradoc/asciidoc/builder/list_builder.rb
 - lib/coradoc/asciidoc/builder/text_builder.rb
 - lib/coradoc/asciidoc/delimiter_mapping.rb
+- lib/coradoc/asciidoc/formatter.rb
+- lib/coradoc/asciidoc/lint.rb
+- lib/coradoc/asciidoc/lint/document_title.rb
+- lib/coradoc/asciidoc/lint/duplicate_ids.rb
+- lib/coradoc/asciidoc/lint/empty_section.rb
+- lib/coradoc/asciidoc/lint/heading_levels.rb
 - lib/coradoc/asciidoc/model.rb
 - lib/coradoc/asciidoc/model/admonition.rb
 - lib/coradoc/asciidoc/model/anchorable.rb
@@ -229,12 +237,14 @@ files:
 - lib/coradoc/asciidoc/parser/list.rb
 - lib/coradoc/asciidoc/parser/metadata_detector.rb
 - lib/coradoc/asciidoc/parser/paragraph.rb
+- lib/coradoc/asciidoc/parser/positioned_string.rb
 - lib/coradoc/asciidoc/parser/rule_dispatcher.rb
 - lib/coradoc/asciidoc/parser/section.rb
 - lib/coradoc/asciidoc/parser/stem.rb
 - lib/coradoc/asciidoc/parser/table.rb
 - lib/coradoc/asciidoc/parser/term.rb
 - lib/coradoc/asciidoc/parser/text.rb
+- lib/coradoc/asciidoc/parser/tree_materializer.rb
 - lib/coradoc/asciidoc/reference_materializers.rb
 - lib/coradoc/asciidoc/reference_materializers/navigation.rb
 - lib/coradoc/asciidoc/serializer.rb
@@ -330,6 +340,7 @@ files:
 - lib/coradoc/asciidoc/transform/element_transformers/other_transformer.rb
 - lib/coradoc/asciidoc/transform/element_transformers/table_transformer.rb
 - lib/coradoc/asciidoc/transform/from_core_model.rb
+- lib/coradoc/asciidoc/transform/from_core_model/list_building.rb
 - lib/coradoc/asciidoc/transform/from_core_model_registrations.rb
 - lib/coradoc/asciidoc/transform/frontmatter_attribute_map.rb
 - lib/coradoc/asciidoc/transform/inline_transform_visitor.rb