stepmod-utils 0.1.5 → 0.2.3

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/module_ref.rb

@@ -3,7 +3,7 @@
 module Stepmod
   module Utils
     module Converters
-      class ModuleRef < ReverseAsciidoctor::Converters::Base
+      class ModuleRef < ReverseAdoc::Converters::Base
         def convert(node, _state = {})
           ref = node['linkend']
           # #23:
@@ -27,7 +27,7 @@ module Stepmod
           ref.squeeze(' ').strip
         end
       end
-      ReverseAsciidoctor::Converters.register :module_ref, ModuleRef.new
+      ReverseAdoc::Converters.register :module_ref, ModuleRef.new
     end
   end
 end

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

@@ -3,17 +3,12 @@
 module Stepmod
   module Utils
     module Converters
-      class Note < ReverseAsciidoctor::Converters::Base
+      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
-      ReverseAsciidoctor::Converters.register :note, Note.new
+      ReverseAdoc::Converters.register :note, Note.new
     end
   end
 end

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

@@ -3,14 +3,15 @@
 module Stepmod
   module Utils
     module Converters
-      class Ol < ReverseAsciidoctor::Converters::Base
+      class Ol < ReverseAdoc::Converters::Base
         def convert(node, state = {})
           id = node['id']
           anchor = id ? "[[#{id}]]\n" : ""
           ol_count = state.fetch(:ol_count, 0) + 1
           attrs = ol_attrs(node)
-          res = "\n#{anchor}#{attrs}#{treat_children(node, state.merge(ol_count: ol_count))}"
-          res = "\n" + res if node.parent && node.parent.name == 'note'
+          res = "\n\n#{anchor}#{attrs}#{treat_children(node, state.merge(ol_count: ol_count))}\n"
+          # Why do we add this?
+          # res = "\n" + res if node.parent && node.parent.name == 'note'
           res
         end
 
@@ -44,9 +45,9 @@ module Stepmod
         end
       end
 
-      ReverseAsciidoctor::Converters.register :ol, Ol.new
-      ReverseAsciidoctor::Converters.register :ul, Ol.new
-      ReverseAsciidoctor::Converters.register :dir, Ol.new
+      ReverseAdoc::Converters.register :ol, Ol.new
+      ReverseAdoc::Converters.register :ul, Ol.new
+      ReverseAdoc::Converters.register :dir, Ol.new
     end
   end
 end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class P < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          id = node['id']
+          anchor = id ? "[[#{id}]]\n" : ""
+          if state[:tdsinglepara]
+            "#{anchor}#{treat_children(node, state).strip}"
+          else
+            "\n\n#{anchor}#{treat_children(node, state).strip}\n\n"
+          end
+        end
+      end
+
+      ReverseAdoc::Converters.register :p, P.new
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class PassThrough < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          node.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Q < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state)
+          "#{content[/^\s*/]}\"#{content.strip}\"#{content[/\s*$/]}"
+        end
+      end
+
+      ReverseAdoc::Converters.register :q, Q.new
+    end
+  end
+end

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

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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Schema < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          <<~TEMPLATE
+            (*"#{node['name']}"
+            #{treat_children(node, state).strip}
+            *)
+          TEMPLATE
+        end
+      end
+      ReverseAdoc::Converters.register :schema, Schema.new
+    end
+  end
+end

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

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

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

@@ -5,7 +5,7 @@ require 'stepmod/utils/converters/em'
 module Stepmod
   module Utils
     module Converters
-      class Stem < ReverseAsciidoctor::Converters::Base
+      class Stem < ReverseAdoc::Converters::Base
         def convert(node, state = {})
           return Em.new.convert(node, state) if node.text.strip.length > 8
 
@@ -13,7 +13,7 @@ module Stepmod
         end
       end
 
-      ReverseAsciidoctor::Converters.register :i, Stem.new
+      ReverseAdoc::Converters.register :i, Stem.new
     end
   end
 end

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

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Sub < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state)
+          "#{content[/^\s*/]}~#{content.strip}~#{content[/\s*$/]}"
+        end
+      end
+
+      ReverseAdoc::Converters.register :sub, Sub.new
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Sup < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state)
+          "#{content[/^\s*/]}^#{content.strip}^#{content[/\s*$/]}"
+        end
+      end
+
+      ReverseAdoc::Converters.register :sup, Sup.new
+    end
+  end
+end

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

@@ -3,13 +3,13 @@
 module Stepmod
   module Utils
     module Converters
-      class Synonym < ReverseAsciidoctor::Converters::Base
+      class Synonym < ReverseAdoc::Converters::Base
         def convert(node, state = {})
           "alt:[#{node.text.strip}]"
         end
       end
 
-      ReverseAsciidoctor::Converters.register :synonym, Synonym.new
+      ReverseAdoc::Converters.register :synonym, Synonym.new
     end
   end
 end

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

@@ -5,7 +5,7 @@ require 'stepmod/utils/converters/synonym'
 module Stepmod
   module Utils
     module Converters
-      class Term < ReverseAsciidoctor::Converters::Base
+      class Term < ReverseAdoc::Converters::Base
         def convert(node, state = {})
           first_child = node.children.find do |child|
                           child.name == 'text' && !child.text.to_s.strip.empty?
@@ -23,7 +23,7 @@ module Stepmod
         end
       end
 
-      ReverseAsciidoctor::Converters.register :term, Term.new
+      ReverseAdoc::Converters.register :term, Term.new
     end
   end
 end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Text < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          if node.text.strip.empty?
+            treat_empty(node, state)
+          else
+            treat_text(node)
+          end
+        end
+
+        private
+
+        def treat_empty(node, state)
+          parent = node.parent.name.to_sym
+          if [:ol, :ul].include?(parent)  # Otherwise the identation is broken
+            ''
+          elsif state[:tdsinglepara]
+            ''
+          elsif node.text == ' '          # Regular whitespace text node
+            ' '
+          else
+            ''
+          end
+        end
+
+        def treat_text(node)
+          text = node.text
+          text = preserve_nbsp(text)
+          # text = remove_border_newlines(text)
+          text = remove_inner_newlines(text)
+
+          text = preserve_keychars_within_backticks(text)
+          text = preserve_tags(text)
+
+          text
+        end
+
+        def preserve_nbsp(text)
+          text.gsub(/\u00A0/, "&nbsp;")
+        end
+
+        def preserve_tags(text)
+          text.gsub(/[<>]/, '>' => '\>', '<' => '\<')
+        end
+
+        def remove_border_newlines(text)
+          text.gsub(/\A\n+/, '').gsub(/\n+\z/, '')
+        end
+
+        def remove_inner_newlines(text)
+          text.tr("\n\t", ' ').squeeze(' ')
+        end
+
+        def preserve_keychars_within_backticks(text)
+          text.gsub(/`.*?`/) do |match|
+            match.gsub('\_', '_').gsub('\*', '*')
+          end
+        end
+      end
+
+      ReverseAdoc::Converters.register :text, Text.new
+    end
+  end
+end

data/lib/stepmod/utils/html_to_asciimath.rb

@@ -0,0 +1,157 @@
+module Stepmod
+  module Utils
+    class HtmlToAsciimath
+      def call(input)
+        return input if input.nil? || input.empty?
+
+        to_asciimath = Nokogiri::HTML.fragment(input, "UTF-8")
+
+        to_asciimath.css('i').each do |math_element|
+          # puts "HTML MATH!!  #{math_element.to_xml}"
+          # puts "HTML MATH!!  #{math_element.text}"
+          decoded = text_to_asciimath(math_element.text)
+          case decoded.length
+          when 1..12
+            # puts "(#{math_element.text} to => #{decoded})"
+            math_element.replace "stem:[#{decoded}]"
+          when 0
+            math_element.remove
+          else
+            math_element.replace "_#{decoded}_"
+          end
+        end
+
+        to_asciimath.css('sub').each do |math_element|
+          case math_element.text.length
+          when 0
+            math_element.remove
+          else
+            math_element.replace "~#{text_to_asciimath(math_element.text)}~"
+          end
+        end
+
+        to_asciimath.css('sup').each do |math_element|
+          case math_element.text.length
+          when 0
+            math_element.remove
+          else
+            math_element.replace "^#{text_to_asciimath(math_element.text)}^"
+          end
+        end
+
+        to_asciimath.css('ol').each do |element|
+          element.css('li').each do |li|
+            li.replace ". #{li.text}"
+          end
+        end
+
+        to_asciimath.css('ul').each do |element|
+          element.css('li').each do |li|
+            li.replace "* #{li.text}"
+          end
+        end
+
+        # Replace sans-serif font with monospace
+        to_asciimath.css('font[style*="sans-serif"]').each do |x|
+          x.replace "`#{x.text}`"
+        end
+
+        html_entities_to_stem(
+          to_asciimath.children.to_s.gsub(/\]stem:\[/, '').gsub(/<\/?[uo]l>/, '')
+        )
+      end
+
+      def text_to_asciimath(text)
+        html_entities_to_asciimath(text.decode_html)
+      end
+
+      def html_entities_to_asciimath(x)
+        x.gsub("&alpha;", "alpha").
+          gsub("&beta;", "beta").
+          gsub("&gamma;", "gamma").
+          gsub("&Gamma;", "Gamma").
+          gsub("&delta;", "delta").
+          gsub("&Delta;", "Delta").
+          gsub("&epsilon;", "epsilon").
+          gsub("&varepsilon;", "varepsilon").
+          gsub("&zeta;", "zeta").
+          gsub("&eta;", "eta").
+          gsub("&theta;", "theta").
+          gsub("&Theta;", "Theta").
+          gsub("&vartheta;", "vartheta").
+          gsub("&iota;", "iota").
+          gsub("&kappa;", "kappa").
+          gsub("&lambda;", "lambda").
+          gsub("&Lambda;", "Lambda").
+          gsub("&mu;", "mu").
+          gsub("&nu;", "nu").
+          gsub("&xi;", "xi").
+          gsub("&Xi;", "Xi").
+          gsub("&pi;", "pi").
+          gsub("&Pi;", "Pi").
+          gsub("&rho;", "rho").
+          gsub("&beta;", "beta").
+          gsub("&sigma;", "sigma").
+          gsub("&Sigma;", "Sigma").
+          gsub("&tau;", "tau").
+          gsub("&upsilon;", "upsilon").
+          gsub("&phi;", "phi").
+          gsub("&Phi;", "Phi").
+          gsub("&varphi;", "varphi").
+          gsub("&chi;", "chi").
+          gsub("&psi;", "psi").
+          gsub("&Psi;", "Psi").
+          gsub("&omega;", "omega")
+          gsub("&#967", "χ").
+          gsub("&#215", "×").
+          gsub("&#931", "Σ").
+          gsub("&#961", "ρ").
+          gsub("&#963", "σ").
+          gsub("&#955", "λ").
+          gsub("&#964", "τ").
+          gsub("&#8706", "∂").
+          gsub("&#8804", "≤").
+          gsub("&#8805", "≥")
+      end
+
+      def html_entities_to_stem(x)
+        x.gsub("&alpha;", "stem:[alpha]").
+          gsub("&beta;", "stem:[beta]").
+          gsub("&gamma;", "stem:[gamma]").
+          gsub("&Gamma;", "stem:[Gamma]").
+          gsub("&delta;", "stem:[delta]").
+          gsub("&Delta;", "stem:[Delta]").
+          gsub("&epsilon;", "stem:[epsilon]").
+          gsub("&varepsilon;", "stem:[varepsilon]").
+          gsub("&zeta;", "stem:[zeta]").
+          gsub("&eta;", "stem:[eta]").
+          gsub("&theta;", "stem:[theta]").
+          gsub("&Theta;", "stem:[Theta]").
+          gsub("&vartheta;", "stem:[vartheta]").
+          gsub("&iota;", "stem:[iota]").
+          gsub("&kappa;", "stem:[kappa]").
+          gsub("&lambda;", "stem:[lambda]").
+          gsub("&Lambda;", "stem:[Lambda]").
+          gsub("&mu;", "stem:[mu]").
+          gsub("&nu;", "stem:[nu]").
+          gsub("&xi;", "stem:[xi]").
+          gsub("&Xi;", "stem:[Xi]").
+          gsub("&pi;", "stem:[pi]").
+          gsub("&Pi;", "stem:[Pi]").
+          gsub("&rho;", "stem:[rho]").
+          gsub("&beta;", "stem:[beta]").
+          gsub("&sigma;", "stem:[sigma]").
+          gsub("&Sigma;", "stem:[Sigma]").
+          gsub("&tau;", "stem:[tau]").
+          gsub("&upsilon;", "stem:[upsilon]").
+          gsub("&phi;", "stem:[phi]").
+          gsub("&Phi;", "stem:[Phi]").
+          gsub("&varphi;", "stem:[varphi]").
+          gsub("&chi;", "stem:[chi]").
+          gsub("&psi;", "stem:[psi]").
+          gsub("&Psi;", "stem:[Psi]").
+          gsub("&omega;", "stem:[omega]")
+      end
+    end
+  end
+end