stepmod-utils 0.1.6 → 0.2.4

data/lib/stepmod/utils/converters/def.rb

@@ -20,11 +20,14 @@ module Stepmod
           previous = nil
           result = ''
           converted.each.with_index do |(child, content), i|
-            if i == 0 || !block_tag?(child, previous)
-              result += " #{content}"
+            if block_tag?(child, previous)
+              result += "\n\n"
+            elsif comment_tag?(child, previous)
+              result += "\n"
             else
-              result += "\n\n#{content}"
+              result += ' '
             end
+            result += content
             previous = child
           end
           result.strip
@@ -32,7 +35,11 @@ module Stepmod
 
         def block_tag?(child, previous)
           %w[ul example note alt p].include?(child.name) ||
-            (child.previous && %w[ul example note alt p].include?(child.previous.name))
+            (previous && %w[ul example note alt p].include?(previous.name))
+        end
+
+        def comment_tag?(child, previous)
+          child.name == 'comment' || (previous && previous.name === 'comment')
         end
 
         def additional_block(node)

data/lib/stepmod/utils/converters/dl.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Dl < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          cleaned_node = cleanup_trash_tags(node.clone)
+          treat_children(cleaned_node, state)
+        end
+
+        private
+
+        # https://github.com/metanorma/stepmod-utils/issues/48#issuecomment-784000377
+        # For simplicity reasons and so that we don't depend on the CVS repository's updates, we directly converting:
+        # <dt></dt><dd>a3ma &#160; : &#160; annotated 3d model assembly</dd> into a3ma:: annotated 3d model assembly
+        def cleanup_trash_tags(node)
+          inner_content = node.inner_html
+          inner_content
+            .gsub!(/<dt><\/dt>\s*?<dd>(.+?) &#xA0; : &#xA0; (.+?)<\/dd>/) do
+              "<dt>#{$1}</dt><dd>#{$2}</dd>"
+            end
+          node.inner_html = inner_content
+          node
+        end
+
+        ReverseAdoc::Converters.register :dl, Dl.new
+      end
+    end
+  end
+end

data/lib/stepmod/utils/converters/drop.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Drop < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          ''
+        end
+      end
+
+      ReverseAdoc::Converters.register :caption, Drop.new
+      ReverseAdoc::Converters.register :figcaption, Drop.new
+      ReverseAdoc::Converters.register :title, Drop.new
+      ReverseAdoc::Converters.register :link, Drop.new
+      ReverseAdoc::Converters.register :style, Drop.new
+      ReverseAdoc::Converters.register :meta, Drop.new
+      ReverseAdoc::Converters.register :script, Drop.new
+      ReverseAdoc::Converters.register :comment, Drop.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/dt.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Dt < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          return "\n\n{blank}::" if node.text.strip.length.zero?
+
+          "\n\n#{node.text}:: "
+        end
+
+        ReverseAdoc::Converters.register :dt, Dt.new
+      end
+    end
+  end
+end

data/lib/stepmod/utils/converters/em_express_description.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Em < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state.merge(already_italic: true))
+          if content.strip.empty? || state[:already_italic]
+            content
+          else
+            "#{content[/^\s*/]}_#{content.strip}_#{content[/\s*$/]}"
+          end
+        end
+      end
+
+      ReverseAdoc::Converters.register :em, Em.new
+      ReverseAdoc::Converters.register :i,  Em.new
+      ReverseAdoc::Converters.register :cite,  Em.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/eqn.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'stepmod/utils/html_to_asciimath'
+
+module Stepmod
+  module Utils
+    module Converters
+      class Eqn < ReverseAdoc::Converters::Base
+        TAGS_NOT_IN_CONTEXT = %w[b i].freeze
+
+        def convert(node, state = {})
+          cloned_node = node.clone
+          if definition_node?(cloned_node)
+            return definition_converted(cloned_node, state)
+          end
+
+          stem_converted(cloned_node, state)
+        end
+
+        private
+
+        def definition_node?(node)
+          first_strong_node = node
+                                .children
+                                .find do |n|
+                                  return false if !n.text? && n.name != 'b'
+
+                                  n.name == 'b'
+                                end
+          first_strong_node &&
+            first_strong_node.next &&
+            first_strong_node.next.text? &&
+            first_strong_node.next.content =~ /\s+:/
+        end
+
+        def definition_converted(cloned_node, state)
+          first_strong_node = cloned_node
+                                .children
+                                .find do |n|
+                                  return false if !n.text? && n.name != 'b'
+
+                                  n.name == 'b'
+                                end
+          first_strong_node.next.content = first_strong_node.next.content.gsub(/\s?:/, '')
+          term = first_strong_node.text.strip
+          first_strong_node.remove
+          "#{term}:: #{treat_children(cloned_node, state)}"
+        end
+
+        def stem_converted(cloned_node, state)
+          remove_tags_not_in_context(cloned_node)
+          internal_content = treat_children(cloned_node, state)
+          content = Stepmod::Utils::HtmlToAsciimath.new.call(internal_content)
+          res = <<~TEMPLATE
+
+                [stem]
+                ++++
+                #{remove_trash_symbols(content.strip)}
+                ++++
+
+                TEMPLATE
+          res = "[[#{cloned_node['id']}]]\n#{res}" if cloned_node['id'] && cloned_node['id'].length > 0
+          res
+        end
+
+        def remove_trash_symbols(content)
+          content
+            .gsub(/ /, '')
+            .strip
+            .gsub(/\(\d\)$/, '')
+            .gsub(/\b(\w*?[_]+\w+)\b/, '"\1"')
+            .strip
+        end
+
+        # Remove all tags that make no sense in equations, eg: strong, italic
+        # Search for such tags, move their children into the root
+        # context and remove them
+        def remove_tags_not_in_context(node)
+          TAGS_NOT_IN_CONTEXT.each do |tag_name|
+            node
+              .children
+              .xpath("./#{tag_name}")
+              .map do |n|
+                n.tap{ |n| n.add_previous_sibling(n.children) }.remove
+              end
+          end
+          node.traverse do |descendant|
+            descendant.content = descendant.content.gsub('#8195;', '')
+          end
+        end
+      end
+
+      ReverseAdoc::Converters.register :eqn, Eqn.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/example.rb

@@ -5,12 +5,7 @@ module Stepmod
     module Converters
       class Example < ReverseAdoc::Converters::Base
         def convert(node, state = {})
-          <<~TEMPLATE
-            [example]
-            ====
-            #{treat_children(node, state).strip}
-            ====
-          TEMPLATE
+          "\n\n[example]\n====\n#{treat_children(node, state).strip}\n====\n\n"
         end
       end
       ReverseAdoc::Converters.register :example, Example.new

data/lib/stepmod/utils/converters/express_g.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class ExpressG < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          node.children.map do |child|
+            next unless child.name == 'imgfile'
+
+            parse_to_svg_reference(child['file'])
+          end.join("\n")
+        end
+
+        private
+
+        def parse_to_svg_reference(file)
+          return '' unless File.file?(file)
+
+          image_document = Nokogiri::XML(File.read(file))
+          svg_path = File.basename(image_document.xpath('//img').first['src'], '.*')
+          <<~SVGMAP
+            [.svgmap]
+            ====
+            image::#{svg_path}.svg[]
+
+            #{image_document.xpath('//img.area').map.with_index(1) {|n, i| schema_reference(n['href'], i) }.join("\n")}
+            ====
+          SVGMAP
+        end
+
+        def schema_reference(xml_path, index)
+          if xml_path =~ /#/
+            _,express_path_part = xml_path.split('#')
+            "* <<express:#{express_path_part.strip}>>; #{index}"
+          else
+            schema_name = File.basename(xml_path, '.*')
+            "* <<express:#{schema_name.strip}>>; #{index}"
+          end
+        end
+      end
+
+      ReverseAdoc::Converters.register 'express-g', ExpressG.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/express_ref_express_description.rb

@@ -0,0 +1,13 @@
+module Stepmod
+  module Utils
+    module Converters
+      class ExpressRefExpressDescription < ReverseAdoc::Converters::Base
+        def convert(node, _state = {})
+          parts = node['linkend'].to_s.split(':').last.split('.')
+          "<<express:#{parts.join('.').strip},#{parts.last.strip}>>"
+        end
+      end
+      ReverseAdoc::Converters.register :express_ref, ExpressRefExpressDescription.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/ext_description.rb

@@ -0,0 +1,16 @@
+module Stepmod
+  module Utils
+    module Converters
+      class ExtDescription < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          <<~TEMPLATE
+            (*"#{node['linkend']}"
+            #{treat_children(node, state).strip}
+            *)
+          TEMPLATE
+        end
+      end
+      ReverseAdoc::Converters.register :ext_description, ExtDescription.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/ext_descriptions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class ExtDescriptions < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          treat_children(node, state)
+        end
+      end
+      ReverseAdoc::Converters.register :ext_descriptions, ExtDescriptions.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/fund_cons.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class FundCons < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          "\n\n== Fundamental concerns\n\n#{treat_children(node, state).strip}\n\n"
+        end
+      end
+
+      ReverseAdoc::Converters.register :fund_cons, FundCons.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/head.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Head < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          title = extract_title(node)
+          "= #{title}\n:stem:\n\n"
+        end
+
+        def extract_title(node)
+          title = node.at("./title")
+          return "(???)" if title.nil?
+          title.text
+        end
+      end
+
+      ReverseAdoc::Converters.register :head, Head.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/hr.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Hr < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          "\n* * *\n"
+        end
+      end
+
+      ReverseAdoc::Converters.register :hr, Hr.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/ignore.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Ignore < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          '' # noop
+        end
+      end
+
+      ReverseAdoc::Converters.register :colgroup, Ignore.new
+      ReverseAdoc::Converters.register :col,      Ignore.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/introduction.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Introduction < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          "\n\n== Introduction\n\n#{treat_children(node, state).strip}\n\n"
+        end
+      end
+
+      ReverseAdoc::Converters.register :introduction, Introduction.new
+    end
+  end
+end

data/lib/stepmod/utils/converters/note.rb

@@ -5,12 +5,7 @@ module Stepmod
     module Converters
       class Note < ReverseAdoc::Converters::Base
         def convert(node, state = {})
-          <<~TEMPLATE
-            [NOTE]
-            --
-            #{treat_children(node, state).strip}
-            --
-          TEMPLATE
+          "\n\n[NOTE]\n--\n#{treat_children(node, state).strip}\n--\n\n"
         end
       end
       ReverseAdoc::Converters.register :note, Note.new