metanorma-document 0.5.0 → 0.5.2.pre.alpha.1

data/lib/metanorma/mirror/handlers/paragraph.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Paragraph
-        EXTRA = { alignment: nil, keep_with_next: nil,
-                  keep_with_previous: nil }.freeze
-
-        def self.call(element, context:)
-          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
-          content = Inline.extract_inline(element, context:)
-
-          Handlers.build_node("paragraph", attrs: attrs, content: content)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/quote.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Quote
-        def self.call(element, context:)
-          attrs = Handlers.extract_attrs(element)
-          content = context.extract_blocks(element)
-
-          Handlers.build_node("quote", attrs: attrs, content: content)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/review.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Review
-        EXTRA = { date: nil, from: nil, to: nil, reviewer: nil,
-                  display: nil }.freeze
-
-        def self.call(element, context:)
-          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
-          content = context.extract_blocks(element)
-
-          Handlers.build_node("review", attrs: attrs, content: content)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/section.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Section
-        def self.clause(element, context:)
-          attrs = section_attrs(element, context:)
-          content = context.extract_blocks(element)
-
-          Handlers.build_node("clause", attrs: attrs, content: content)
-        end
-
-        def self.annex(element, context:)
-          attrs = section_attrs(element, context:)
-          attrs[:commentary] = SafeAttr.read(element, :commentary)
-          attrs[:language] = SafeAttr.read(element, :language)
-          attrs[:script] = SafeAttr.read(element, :script)
-
-          content = context.extract_blocks(element)
-
-          Handlers.build_node("annex", attrs: attrs.compact, content: content)
-        end
-
-        def self.content_section(element, context:)
-          attrs = section_attrs(element, context:)
-          content = context.extract_blocks(element)
-
-          subsection = SafeAttr.read(element, :subsection)
-          subsection&.each do |sub|
-            result = context.registry.handle(sub, context: context)
-            result.append_to(content)
-          end
-
-          Handlers.build_node("content_section", attrs: attrs, content: content)
-        end
-
-        def self.terms(element, context:)
-          attrs = section_attrs(element, context:)
-          content = context.extract_named_collections(element,
-                                                      %i[p term dl example
-                                                         admonition])
-          children = context.extract_section_children(element)
-
-          Handlers.build_node("terms", attrs: attrs,
-                                       content: content + children)
-        end
-
-        def self.definitions(element, context:)
-          attrs = section_attrs(element, context:)
-          content = context.extract_blocks(element)
-
-          Handlers.build_node("definitions", attrs: attrs, content: content)
-        end
-
-        def self.references(element, context:)
-          attrs = section_attrs(element, context:)
-          attrs[:normative] = SafeAttr.read(element, :normative)
-          attrs[:hidden] = SafeAttr.read(element, :hidden)
-
-          # Prefatory paragraphs (e.g. "The following documents are referred to...")
-          content = context.extract_named_collections(element,
-                                                      %i[p])
-
-          # Bibliographic items
-          refs = SafeAttr.read(element, :references)
-          refs&.each do |ref|
-            text = extract_biblio_text(ref)
-            next if text.strip.empty?
-
-            content << Handlers.build_node("paragraph",
-                                           attrs: { id: SafeAttr.read(ref,
-                                                                      :id) }.compact,
-                                           content: [context.text_node(text)])
-          end
-
-          Handlers.build_node("references", attrs: attrs, content: content)
-        end
-
-        def self.extract_biblio_text(ref)
-          parts = []
-
-          tag = SafeAttr.read(ref, :biblio_tag)
-          if tag
-            tag_text = Inline.extract_formatted_text(tag).strip
-            parts << tag_text unless tag_text.empty?
-          end
-
-          formatted = SafeAttr.read(ref, :formatted_ref)
-          if formatted
-            fmt_text = Inline.extract_formatted_text(formatted).strip
-            parts << fmt_text unless fmt_text.empty?
-          end
-
-          return parts.join(" ") unless parts.empty?
-
-          docid = SafeAttr.read(ref, :docidentifier)
-          if docid
-            text = Inline.extract_formatted_text(docid)
-            return text unless text.strip.empty?
-          end
-
-          ""
-        end
-
-        def self.floating_title(element, context:)
-          attrs = {}
-          attrs[:id] = context.id_strategy.assign_id(element)
-          attrs[:depth] = SafeAttr.read(element, :depth)
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-
-          title = extract_title(element)
-          attrs[:title] = title if title
-
-          Handlers.build_node("floating_title", attrs: attrs.compact)
-        end
-
-        def self.section_attrs(element, context:)
-          attrs = {}
-          attrs[:id] = context.id_strategy.assign_id(element)
-          attrs[:number] = SafeAttr.read(element, :number)
-          attrs[:obligation] = SafeAttr.read(element, :obligation)
-          attrs[:unnumbered] = SafeAttr.read(element, :unnumbered)
-          attrs[:toc] = SafeAttr.read(element, :toc)
-          attrs[:type] = SafeAttr.read(element, :type)
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-          attrs[:autonum] = SafeAttr.read(element, :autonum)
-          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
-
-          title = extract_title(element)
-          attrs[:title] = title if title
-          attrs.compact
-        end
-
-        def self.extract_title(element)
-          title = SafeAttr.read(element, :title)
-          return nil unless title
-
-          case title
-          when String then title
-          else
-            rich = Inline.extract_rich_html(title)
-            rich.empty? ? Inline.extract_element_text(title) : rich
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/sourcecode.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Sourcecode
-        EXTRA = { language: :lang, filename: nil, linenums: nil }.freeze
-
-        def self.call(element, context:)
-          attrs = Handlers.extract_attrs(element, extra_attrs: EXTRA)
-
-          body = SafeAttr.read(element, :body)
-          text = if body
-                   body.decoded_content
-                 elsif SafeAttr.read(element, :content).is_a?(String)
-                   SafeAttr.read(element, :content)
-                 else
-                   ""
-                 end
-          attrs[:text] = text
-
-          Handlers.build_node("sourcecode", attrs: attrs.compact)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/structural.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Structural
-        def self.preface(element, context:)
-          attrs = {}
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
-
-          content = []
-          %i[abstract foreword introduction acknowledgements
-             executivesummary].each do |attr|
-            child = SafeAttr.read(element, attr)
-            next unless child
-
-            result = context.registry.handle(child, context: context)
-            result.append_to(content)
-          end
-
-          element_content = SafeAttr.read(element, :content)
-          Array(element_content).each do |child|
-            result = context.registry.handle(child, context: context)
-            result.append_to(content)
-          end
-
-          Handlers.build_node("preface", attrs: attrs.compact, content: content)
-        end
-
-        def self.sections(element, context:)
-          attrs = {}
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-          attrs[:displayorder] = SafeAttr.read(element, :displayorder)
-
-          content = []
-          %i[clause terms definitions references floating_title].each do |attr|
-            collection = SafeAttr.read(element, attr)
-            next unless collection
-
-            Array(collection).each do |child|
-              result = context.registry.handle(child, context: context)
-              result.append_to(content)
-            end
-          end
-
-          Handlers.build_node("sections", attrs: attrs.compact,
-                                          content: content)
-        end
-
-        def self.bibliography(element, context:)
-          attrs = {}
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-
-          content = []
-          refs = SafeAttr.read(element, :references)
-          Array(refs).each do |ref|
-            result = context.registry.handle(ref, context: context)
-            result.append_to(content)
-          end
-
-          Handlers.build_node("bibliography", attrs: attrs.compact,
-                                              content: content)
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/table.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Table
-        def self.call(element, context:)
-          attrs = table_attrs(element)
-          content = []
-
-          thead = SafeAttr.read(element, :thead)
-          if thead
-            rows = extract_rows(thead, context:)
-            unless rows.empty?
-              content << Handlers.build_node("table_head",
-                                             content: rows)
-            end
-          end
-
-          tbody = SafeAttr.read(element, :tbody)
-          if tbody
-            rows = extract_rows(tbody, context:)
-            unless rows.empty?
-              content << Handlers.build_node("table_body",
-                                             content: rows)
-            end
-          end
-
-          tfoot = SafeAttr.read(element, :tfoot)
-          if tfoot
-            rows = extract_rows(tfoot, context:)
-            unless rows.empty?
-              content << Handlers.build_node("table_foot",
-                                             content: rows)
-            end
-          end
-
-          Handlers.build_node("table", attrs: attrs, content: content)
-        end
-
-        def self.extract_rows(table_section, context:)
-          Array(table_section.tr).map do |tr|
-            cells = Array(tr.td).map { |td| build_cell(td, context:) }
-            Array(tr.th).each { |th| cells << build_cell(th, context:) }
-
-            row_attrs = {}
-            row_attrs[:id] = SafeAttr.read(tr, :id)
-            Handlers.build_node("table_row", attrs: row_attrs.compact,
-                                             content: cells)
-          end
-        end
-
-        def self.build_cell(cell, context:)
-          attrs = {}
-          attrs[:colspan] = SafeAttr.read(cell, :colspan)
-          attrs[:rowspan] = SafeAttr.read(cell, :rowspan)
-          attrs[:align] = SafeAttr.read(cell, :align)
-          attrs[:valign] = SafeAttr.read(cell, :valign)
-
-          content = Inline.extract_inline(cell, context:)
-
-          Handlers.build_node("table_cell", attrs: attrs.compact,
-                                            content: content)
-        end
-
-        def self.table_attrs(element)
-          attrs = {}
-          attrs[:id] = SafeAttr.read(element, :id)
-          attrs[:width] = SafeAttr.read(element, :width)
-          attrs[:align] = SafeAttr.read(element, :align)
-          attrs[:unnumbered] = SafeAttr.read(element, :unnumbered)
-          attrs[:semx_id] = SafeAttr.read(element, :semx_id)
-
-          name = SafeAttr.read(element, :name)
-          attrs[:title] = Handlers.extract_name_text(name) if name
-          attrs.compact
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers/term.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      module Term
-        def self.call(element, context:)
-          attrs = {}
-          attrs[:id] = SafeAttr.read(element, :id)
-          attrs[:anchor] = SafeAttr.read(element, :anchor)
-
-          fmt_name = SafeAttr.read(element, :fmt_name)
-          if fmt_name
-            number = Inline.extract_formatted_text(fmt_name)
-            attrs[:number] = number unless number.empty?
-          end
-
-          content = []
-
-          # Term name from fmt_preferred paragraphs
-          extract_fmt_paragraphs(element, :fmt_preferred, content, context)
-
-          # Definition from fmt_definition → semx → p
-          fmt_def = SafeAttr.read(element, :fmt_definition)
-          if fmt_def
-            extract_semx_paragraphs(fmt_def, content, context)
-          end
-
-          # Source from fmt_termsource
-          fmt_ts_list = SafeAttr.read(element, :fmt_termsource)
-          if fmt_ts_list && !fmt_ts_list.empty?
-            source_text = Inline.extract_formatted_text(fmt_ts_list.first)
-            unless source_text.empty?
-              content << Handlers.build_node("paragraph",
-                                             attrs: { class: "source" },
-                                             content: [context.text_node(source_text)])
-            end
-          end
-
-          # Term notes
-          SafeAttr.read(element, :termnote)&.each do |tn|
-            note_attrs = { id: SafeAttr.read(tn, :id) }
-            fn = SafeAttr.read(tn, :fmt_name)
-            if fn
-              num = Inline.extract_formatted_text(fn)
-              note_attrs[:number] = num unless num.empty?
-            end
-            note_content = context.extract_named_collections(tn, %i[p ul ol dl])
-            content << Handlers.build_node("note", attrs: note_attrs.compact,
-                                                   content: note_content)
-          end
-
-          # Term examples
-          SafeAttr.read(element, :termexample)&.each do |te|
-            ex_attrs = { id: SafeAttr.read(te, :id) }
-            ex_content = context.extract_named_collections(te, %i[p ul ol dl])
-            content << Handlers.build_node("example", attrs: ex_attrs.compact,
-                                                      content: ex_content)
-          end
-
-          # Nested terms
-          SafeAttr.read(element, :term)&.each do |t|
-            result = context.registry.handle(t, context: context)
-            result.append_to(content)
-          end
-
-          Handlers.build_node("term", attrs: attrs.compact, content: content)
-        end
-
-        def self.extract_fmt_paragraphs(element, attr_name, content, context)
-          fmt_list = SafeAttr.read(element, attr_name)
-          return unless fmt_list
-
-          fmt_list.each do |fmt_el|
-            ps = SafeAttr.read(fmt_el, :p)
-            next unless ps
-
-            ps.each do |p|
-              result = context.registry.handle(p, context: context)
-              result.append_to(content)
-            end
-          end
-        end
-
-        # fmt_definition wraps content in semx elements → extract p from semx
-        def self.extract_semx_paragraphs(fmt_def, content, context)
-          semx_list = SafeAttr.read(fmt_def, :semx)
-          return unless semx_list
-
-          Array(semx_list).each do |s|
-            SafeAttr.read(s, :p)&.each do |p|
-              result = context.registry.handle(p, context: context)
-              result.append_to(content)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/mirror/handlers.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Mirror
-    module Handlers
-      autoload :Paragraph, "#{__dir__}/handlers/paragraph"
-      autoload :Section, "#{__dir__}/handlers/section"
-      autoload :List, "#{__dir__}/handlers/list"
-      autoload :Table, "#{__dir__}/handlers/table"
-      autoload :Figure, "#{__dir__}/handlers/figure"
-      autoload :Sourcecode, "#{__dir__}/handlers/sourcecode"
-      autoload :Admonition, "#{__dir__}/handlers/admonition"
-      autoload :Formula, "#{__dir__}/handlers/formula"
-      autoload :Example, "#{__dir__}/handlers/example"
-      autoload :Note, "#{__dir__}/handlers/note"
-      autoload :Quote, "#{__dir__}/handlers/quote"
-      autoload :Review, "#{__dir__}/handlers/review"
-      autoload :Inline, "#{__dir__}/handlers/inline"
-      autoload :Structural, "#{__dir__}/handlers/structural"
-      autoload :Term, "#{__dir__}/handlers/term"
-
-      COMMON_ATTRS = %i[id semx_id].freeze
-
-      def self.build_node(type, attrs: {}, content: [])
-        if content.nil? || content.empty?
-          Model::Leaf.new(type: type, attrs: attrs)
-        else
-          Model::Container.new(type: type, attrs: attrs, content: content)
-        end
-      end
-
-      def self.build_text(text, marks: [])
-        Model::Text.new(text: text, marks: marks)
-      end
-
-      def self.build_mark(type, attrs: {})
-        Model::Mark.new(type: type, attrs: attrs)
-      end
-
-      def self.extract_attrs(element, extra_attrs: {})
-        attrs = {}
-        COMMON_ATTRS.each do |attr|
-          attrs[attr] = SafeAttr.read(element, attr)
-        end
-        extra_attrs.each do |attr, source_attr|
-          attrs[attr] = SafeAttr.read(element, source_attr || attr)
-        end
-        attrs.compact
-      end
-
-      def self.extract_name_text(name)
-        Inline::TextExtractor.extract_name_text(name)
-      end
-
-      def self.extract_bibdata_title(bibdata)
-        Metadata.title_from_bibdata(bibdata)
-      end
-    end
-  end
-end