coradoc 1.1.5 → 1.1.7

data/lib/coradoc/input/html/postprocessor.rb

@@ -1,214 +1,220 @@
-module Coradoc::Input::HTML
-  # Postprocessor's aim is to convert a Coradoc tree from
-  # a mess that has been created from HTML into a tree that
-  # is compatible with what we would get out of Coradoc, if
-  # it parsed it directly.
-  class Postprocessor
-    Element = Coradoc::Element
-
-    def self.process(coradoc)
-      new(coradoc).process
-    end
-
-    def initialize(coradoc)
-      @tree = coradoc
-    end
+module Coradoc
+  module Input
+    module Html
+      # Postprocessor's aim is to convert a Coradoc tree from
+      # a mess that has been created from HTML into a tree that
+      # is compatible with what we would get out of Coradoc, if
+      # it parsed it directly.
+      class Postprocessor
+        Element = Coradoc::Element
+
+        def self.process(coradoc)
+          new(coradoc).process
+        end
 
-    # Extracts titles from lists. This happens in HTML files
-    # generated from DOCX documents by LibreOffice.
-    #
-    # We are interested in a particular tree:
-    # Element::List::Ordered items:
-    #   Element::List::Ordered items: (any depth)
-    #     Element::ListItem content:
-    #       Element::Title
-    #       (any number of other titles of the same scheme)
-    #
-    # This tree is flattened into:
-    # Element::Title
-    # Element::Title (any number of titles)
-    def extract_titles_from_lists
-      @tree = Element::Base.visit(@tree) do |elem, dir|
-        next elem unless dir == :pre
-        next elem unless elem.is_a?(Element::List::Ordered)
-        next elem if elem.items.length != 1
-
-        anchors = []
-        anchors << elem.anchor if elem.anchor
-
-        # Extract ListItem from any depth of List::Ordered
-        processed = elem
-        while processed.is_a?(Element::List::Ordered)
-          if processed.items.length != 1
-            backtrack = true
-            break
-          end
-          anchors << processed.anchor if processed.anchor
-          processed = processed.items.first
+        def initialize(coradoc)
+          @tree = coradoc
         end
 
-        # Something went wrong? Anything not matching on the way?
-        next elem if backtrack
-        next elem unless processed.is_a?(Element::ListItem)
+        # Extracts titles from lists. This happens in HTML files
+        # generated from DOCX documents by LibreOffice.
+        #
+        # We are interested in a particular tree:
+        # Element::List::Ordered items:
+        #   Element::List::Ordered items: (any depth)
+        #     Element::ListItem content:
+        #       Element::Title
+        #       (any number of other titles of the same scheme)
+        #
+        # This tree is flattened into:
+        # Element::Title
+        # Element::Title (any number of titles)
+        def extract_titles_from_lists
+          @tree = Element::Base.visit(@tree) do |elem, dir|
+            next elem unless dir == :pre
+            next elem unless elem.is_a?(Element::List::Ordered)
+            next elem if elem.items.length != 1
+
+            anchors = []
+            anchors << elem.anchor if elem.anchor
+
+            # Extract ListItem from any depth of List::Ordered
+            processed = elem
+            while processed.is_a?(Element::List::Ordered)
+              if processed.items.length != 1
+                backtrack = true
+                break
+              end
+              anchors << processed.anchor if processed.anchor
+              processed = processed.items.first
+            end
 
-        anchors << processed.anchor if processed.anchor
+            # Something went wrong? Anything not matching on the way?
+            next elem if backtrack
+            next elem unless processed.is_a?(Element::ListItem)
 
-        # Now we must have a title (or titles).
-        titles = processed.content.flatten
+            anchors << processed.anchor if processed.anchor
 
-        # Don't bother if there's no title in there.
-        next elem unless titles.any? { |i| i.is_a? Element::Title }
+            # Now we must have a title (or titles).
+            titles = processed.content.flatten
 
-        # Ordered is another iteration for our cleanup.
-        next elem unless titles.all? do |i|
-          i.is_a?(Element::Title) || i.is_a?(Element::List::Ordered)
-        end
+            # Don't bother if there's no title in there.
+            next elem unless titles.any? { |i| i.is_a? Element::Title }
 
-        # We are done now.
-        titles + anchors
-      end
-    end
+            # Ordered is another iteration for our cleanup.
+            next elem unless titles.all? do |i|
+              i.is_a?(Element::Title) || i.is_a?(Element::List::Ordered)
+            end
 
-    # Collapse DIVs that only have a title, or nest another DIV.
-    def collapse_meaningless_sections
-      @tree = Element::Base.visit(@tree) do |elem, _dir|
-        if elem.is_a?(Element::Section) && elem.safe_to_collapse?
-          children_classes = Array(elem.contents).map(&:class)
-          count = children_classes.length
-          safe_classes = [Element::Section, Element::Title]
-
-          # Count > 0 because some documents use <div> as a <br>.
-          if count > 0 && children_classes.all? { |i| safe_classes.include?(i) }
-            contents = elem.contents.dup
-            contents.prepend(elem.anchor) if elem.anchor
-            next contents
+            # We are done now.
+            titles + anchors
           end
         end
-        elem
-      end
-    end
 
-    # tree should now be more cleaned up, so we can progress with
-    # creating meaningful sections
-    def generate_meaningful_sections
-      @tree = Element::Base.visit(@tree) do |elem, dir|
-        # We are searching for an array, that has a title. This
-        # will be a candidate for our section array.
-        if dir == :post &&
-            elem.is_a?(Array) &&
-            !elem.flatten.grep(Element::Title).empty?
-
-          elem = elem.flatten
-
-          new_array = []
-          content_array = new_array
-          section_arrays_by_level = [new_array] * 8
-
-          # For each title element, we create a new section. Then we push
-          # all descendant sections into those sections. Otherwise, we push
-          # an element as content of current section.
-          elem.each do |e|
-            if e.is_a? Element::Title
-              title = e
-              content_array = []
-              section_array = []
-              level = title.level_int
-              section = Element::Section.new(
-                title, contents: content_array, sections: section_array
-              )
-              # Some documents may not be consistent and eg. follow H4 after
-              # H2. Let's ensure that proceeding sections will land in a
-              # correct place.
-              (8 - level).times do |j|
-                section_arrays_by_level[level + j] = section_array
+        # Collapse DIVs that only have a title, or nest another DIV.
+        def collapse_meaningless_sections
+          @tree = Element::Base.visit(@tree) do |elem, _dir|
+            if elem.is_a?(Element::Section) && elem.safe_to_collapse?
+              children_classes = Array(elem.contents).map(&:class)
+              count = children_classes.length
+              safe_classes = [Element::Section, Element::Title]
+
+              # Count > 0 because some documents use <div> as a <br>.
+              if count.positive? && children_classes.all? do |i|
+                safe_classes.include?(i)
+              end
+                contents = elem.contents.dup
+                contents.prepend(elem.anchor) if elem.anchor
+                next contents
               end
-              section_arrays_by_level[level - 1] << section
-            else
-              content_array << e
             end
+            elem
           end
-          next new_array
         end
-        elem
-      end
-    end
-
-    def split_sections
-      max_level = Coradoc::Input::HTML.config.split_sections
-
-      return unless max_level
 
-      sections = {}
-      parent_sections = []
-      previous_sections = {}
-
-      determine_section_id = ->(elem) do
-        level = if elem.title.style == "appendix"
-                  "A"
+        # tree should now be more cleaned up, so we can progress with
+        # creating meaningful sections
+        def generate_meaningful_sections
+          @tree = Element::Base.visit(@tree) do |elem, dir|
+            # We are searching for an array, that has a title. This
+            # will be a candidate for our section array.
+            if dir == :post &&
+                elem.is_a?(Array) &&
+                !elem.flatten.grep(Element::Title).empty?
+
+              elem = elem.flatten
+
+              new_array = []
+              content_array = new_array
+              section_arrays_by_level = [new_array] * 8
+
+              # For each title element, we create a new section. Then we push
+              # all descendant sections into those sections. Otherwise, we push
+              # an element as content of current section.
+              elem.each do |e|
+                if e.is_a? Element::Title
+                  title = e
+                  content_array = []
+                  section_array = []
+                  level = title.level_int
+                  section = Element::Section.new(
+                    title, contents: content_array, sections: section_array
+                  )
+                  # Some documents may not be consistent and eg. follow H4 after
+                  # H2. Let's ensure that proceeding sections will land in a
+                  # correct place.
+                  (8 - level).times do |j|
+                    section_arrays_by_level[level + j] = section_array
+                  end
+                  section_arrays_by_level[level - 1] << section
                 else
-                  1
+                  content_array << e
                 end
-
-        section = previous_sections[elem]
-        while section
-          level = level.succ if elem.title.style == section.title.style
-          section = previous_sections[section]
+              end
+              next new_array
+            end
+            elem
+          end
         end
-        level.is_a?(Integer) ? "%02d" % level : level
-      end
 
-      determine_style = ->(elem) do
-        style = elem.title.style || "section"
-        style += "-"
-        style
-      end
+        def split_sections
+          max_level = Coradoc::Input::Html.config.split_sections
 
-      @tree = Element::Base.visit(@tree) do |elem, dir|
-        title = elem.title if elem.is_a?(Element::Section)
+          return unless max_level
 
-        if title && title.level_int <= max_level
-          if dir == :pre
-            # In the PRE pass, we build a tree of sections, so that
-            # we can compute numbers
-            previous_sections[elem] = parent_sections[title.level_int]
-            parent_sections[title.level_int] = elem
-            parent_sections[(title.level_int + 1)..nil] = nil
+          sections = {}
+          parent_sections = []
+          previous_sections = {}
 
-            elem
-          else
-            # In the POST pass, we replace the sections with their
-            # include tag.
-            section_file = "sections/"
-            section_file += parent_sections[1..title.level_int].map do |parent|
-              determine_style.(parent) + determine_section_id.(parent)
-            end.join("/")
-            section_file += ".adoc"
-
-            sections[section_file] = elem
-            up = "../" * (title.level_int - 1)
-            "\ninclude::#{up}#{section_file}[]\n"
+          determine_section_id = ->(elem) do
+            level = if elem.title.style == "appendix"
+                      "A"
+                    else
+                      1
+                    end
+
+            section = previous_sections[elem]
+            while section
+              level = level.succ if elem.title.style == section.title.style
+              section = previous_sections[section]
+            end
+            level.is_a?(Integer) ? "%02d" % level : level
           end
-        else
-          elem
-        end
-      end
 
-      sections[nil] = @tree
-      @tree = sections
-    end
+          determine_style = ->(elem) do
+            style = elem.title.style || "section"
+            style += "-"
+            style
+          end
 
-    def process
-      extract_titles_from_lists
-      collapse_meaningless_sections
-      generate_meaningful_sections
-      # Do it again to simplify the document further.
-      # Since the structure is changed, we may have new meaningful
-      # sections as only children of some meaningless sections.
-      collapse_meaningless_sections
+          @tree = Element::Base.visit(@tree) do |elem, dir|
+            title = elem.title if elem.is_a?(Element::Section)
+
+            if title && title.level_int <= max_level
+              if dir == :pre
+                # In the PRE pass, we build a tree of sections, so that
+                # we can compute numbers
+                previous_sections[elem] = parent_sections[title.level_int]
+                parent_sections[title.level_int] = elem
+                parent_sections[(title.level_int + 1)..nil] = nil
+
+                elem
+              else
+                # In the POST pass, we replace the sections with their
+                # include tag.
+                section_file = "sections/"
+                section_file += parent_sections[1..title.level_int].map do |parent|
+                  determine_style.(parent) + determine_section_id.(parent)
+                end.join("/")
+                section_file += ".adoc"
+
+                sections[section_file] = elem
+                up = "../" * (title.level_int - 1)
+                "\ninclude::#{up}#{section_file}[]\n"
+              end
+            else
+              elem
+            end
+          end
 
-      split_sections
+          sections[nil] = @tree
+          @tree = sections
+        end
+
+        def process
+          extract_titles_from_lists
+          collapse_meaningless_sections
+          generate_meaningful_sections
+          # Do it again to simplify the document further.
+          # Since the structure is changed, we may have new meaningful
+          # sections as only children of some meaningless sections.
+          collapse_meaningless_sections
+
+          split_sections
 
-      @tree
+          @tree
+        end
+      end
     end
   end
 end

data/lib/coradoc/input/html.rb

@@ -13,47 +13,49 @@ require_relative "html/plugin"
 require_relative "html/postprocessor"
 
 module Coradoc
-  module Input::HTML
-    def self.convert(input, options = {})
-      Coradoc::Input::HTML::HtmlConverter.convert(input, options)
-    end
+  module Input
+    module Html
+      def self.convert(input, options = {})
+        Coradoc::Input::Html::HtmlConverter.convert(input, options)
+      end
 
-    def self.to_coradoc(input, options = {})
-      Input::HTML::HtmlConverter.to_coradoc(input, options)
-    end
+      def self.to_coradoc(input, options = {})
+        Input::Html::HtmlConverter.to_coradoc(input, options)
+      end
 
-    def self.config
-      @config ||= Config.new
-      yield @config if block_given?
-      @config
-    end
+      def self.config
+        @config ||= Config.new
+        yield @config if block_given?
+        @config
+      end
 
-    def self.cleaner
-      @cleaner ||= Cleaner.new
-    end
+      def self.cleaner
+        @cleaner ||= Cleaner.new
+      end
 
-    def self.processor_id
-      :html
-    end
+      def self.processor_id
+        :html
+      end
 
-    def self.processor_match?(filename)
-      %w[.html .htm].any? { |i| filename.downcase.end_with?(i) }
-    end
+      def self.processor_match?(filename)
+        %w[.html .htm].any? { |i| filename.downcase.end_with?(i) }
+      end
 
-    def self.processor_execute(input, options = {})
-      to_coradoc(input, options)
-    end
+      def self.processor_execute(input, options = {})
+        to_coradoc(input, options)
+      end
 
-    def self.processor_postprocess(data, options)
-      if options[:output_processor] == :adoc
-        data.transform_values do |v|
-          Input::HTML::HtmlConverter.cleanup_result(v, options)
+      def self.processor_postprocess(data, options)
+        if options[:output_processor] == :adoc
+          data.transform_values do |v|
+            Input::Html::HtmlConverter.cleanup_result(v, options)
+          end
+        else
+          data
         end
-      else
-        data
       end
-    end
 
-    Coradoc::Input.define(self)
+      Coradoc::Input.define(self)
+    end
   end
 end

data/lib/coradoc/oscal.rb

@@ -15,7 +15,7 @@ module Coradoc
     def to_oscal
       {
         "metadata" => _doc.document_attributes.to_hash,
-        "groups" => sections_as_groups,
+        "groups"   => sections_as_groups,
       }
     end
 
@@ -37,7 +37,15 @@ module Coradoc
       sections.map do |section|
         Hash.new.tap do |hash|
           hash["id"] = section.id
-          hash["props"] = build_oscal_props(section.glossaries.items)
+          # Use definition lists if present, otherwise fall back to glossaries
+          props_items = if section.respond_to?(:definition_lists) && section.definition_lists && !section.definition_lists.empty?
+                          section.definition_lists.first.items
+                        elsif section.glossaries && !section.glossaries.empty?
+                          section.glossaries.items
+                        else
+                          []
+                        end
+          hash["props"] = build_oscal_props(props_items)
           hash["parts"] = build_oscal_parts(section.sections)
         end
       end
@@ -71,16 +79,21 @@ module Coradoc
     end
 
     def build_oscal_props(attributes)
+      return [] unless attributes.respond_to?(:map)
+
       attributes.map do |attribute|
+        next unless attribute.respond_to?(:key) && attribute.respond_to?(:value)
+
         Hash.new.tap do |hash|
           hash["name"] = attribute.key.to_s.downcase
-          hash["value"] = attribute.value
+          hash["value"] = attribute.value.to_s
         end
-      end
+      end.compact
     end
 
     def build_oscal_prose(paragraph)
-      paragraph&.texts&.join(" ")
+      return nil unless paragraph.respond_to?(:texts)
+      paragraph.texts&.join(" ")
     end
   end
 end

data/lib/coradoc/output/adoc.rb

@@ -1,17 +1,19 @@
 module Coradoc
-  module Output::Adoc
-    def self.processor_id
-      :adoc
-    end
+  module Output
+    module Adoc
+      def self.processor_id
+        :adoc
+      end
 
-    def self.processor_match?(filename)
-      %w[.adoc].any? { |i| filename.downcase.end_with?(i) }
-    end
+      def self.processor_match?(filename)
+        %w[.adoc].any? { |i| filename.downcase.end_with?(i) }
+      end
 
-    def self.processor_execute(input, _options = {})
-      input.transform_values { |i| Coradoc::Generator.gen_adoc(i) }
-    end
+      def self.processor_execute(input, _options = {})
+        input.transform_values { |i| Coradoc::Generator.gen_adoc(i) }
+      end
 
-    Coradoc::Output.define(self)
+      Coradoc::Output.define(self)
+    end
   end
 end

data/lib/coradoc/output/coradoc_tree_debug.rb

@@ -1,19 +1,21 @@
 module Coradoc
-  module Output::CoradocTreeDebug
-    def self.processor_id
-      :coradoc_tree_debug
-    end
+  module Output
+    module CoradocTreeDebug
+      def self.processor_id
+        :coradoc_tree_debug
+      end
 
-    def self.processor_match?(filename)
-      false
-    end
+      def self.processor_match?(_filename)
+        false
+      end
 
-    def self.processor_execute(input, _options = {})
-      out = StringIO.new
-      PP.pp(input, out)
-      { nil => out.string }
-    end
+      def self.processor_execute(input, _options = {})
+        out = StringIO.new
+        PP.pp(input, out)
+        { nil => out.string }
+      end
 
-    Coradoc::Output.define(self)
+      Coradoc::Output.define(self)
+    end
   end
 end

data/lib/coradoc/parser/asciidoc/admonition.rb

@@ -3,20 +3,20 @@ module Coradoc
     module Asciidoc
       module Admonition
         def admonition_type
-          str('NOTE') | str('TIP') | str('EDITOR') |
-          str('IMPORTANT') | str('WARNING') | str('CAUTION') |
-          str('TODO') 
+          str("NOTE") | str("TIP") | str("EDITOR") |
+            str("IMPORTANT") | str("WARNING") | str("CAUTION") |
+            str("TODO")
           # requires atypical syntax for access?
           # | str('DANGER')
           # | str('SAFETY PRECAUTION')
         end
+
         def admonition_line
-          admonition_type.as(:admonition_type) >> str(': ') >>
-          (
+          admonition_type.as(:admonition_type) >> str(": ") >>
             (text.as(:text) >>
             line_ending.as(:line_break)
             ).repeat(1)
-            ).as(:content)
+              .as(:content)
         end
       end
     end