stepmod-utils 0.2.0 → 0.2.7

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,17 @@
+module Stepmod
+  module Utils
+    module Converters
+      class ExtDescription < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          state = state.merge(schema_name: node['linkend'])
+          <<~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,21 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class FundCons < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          <<~TEXT
+
+            *)
+            (*"#{state.fetch(:schema_name)}.__fund_cons"
+
+            #{treat_children(node, state).strip}
+          TEXT
+        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 = {})
+          treat_children(node, state)
+        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

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

@@ -9,8 +9,9 @@ module Stepmod
           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, tdsinglepara: true))}\n"
+          # Why do we add this?
+          # res = "\n" + res if node.parent && node.parent.name == 'note'
           res
         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,19 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Schema < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          state = state.merge(schema_name: node['name'])
+          <<~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/strong.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Strong < ReverseAdoc::Converters::Base
+        BLANK_CHARS = "{blank}".freeze
+
+        def convert(node, state = {})
+          content = treat_children(node, state.merge(already_strong: true))
+          if content.strip.empty? || state[:already_strong]
+            content
+          else
+            handle_express_escape_seq(node, "#{content[/^\s*/]}*#{content.strip}*#{content[/\s*$/]}")
+          end
+        end
+
+        private
+
+        def handle_express_escape_seq(node, content)
+          res = content
+          if braces_sibling?(node.previous, true)
+            res = "#{BLANK_CHARS}#{res}"
+          end
+          if braces_sibling?(node.next)
+            res = "#{res}#{BLANK_CHARS}"
+          end
+          res
+        end
+
+        def braces_sibling?(sibling, end_of_text = false)
+          match = end_of_text ? /\($/ : /^\)/
+          sibling && sibling.text? && sibling.text =~ match
+        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,24 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Sub < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state)
+          return stem_notation(content) if node.parent.name == 'eqn'
+
+          "#{content[/^\s*/]}~#{content.strip}~#{content[/\s*$/]}"
+        end
+
+        private
+
+        def stem_notation(content)
+          "_{#{content}}"
+        end
+      end
+
+      ReverseAdoc::Converters.register :sub, Sub.new
+    end
+  end
+end

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

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

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Table < ReverseAdoc::Converters::Base
+        def convert(node, state = {})
+          id = node['id']
+          anchor = id ? "[[#{id}]]\n" : ""
+          title = node['caption'].to_s
+          title = ".#{title}\n" unless title.empty?
+          attrs = style(node)
+          "\n\n#{anchor}#{attrs}#{title}|===\n#{treat_children(node, state)}\n|===\n"
+        end
+
+        def frame(node)
+          case node["frame"]
+          when "void"
+            "frame=none"
+          when "hsides"
+            "frame=topbot"
+          when "vsides"
+            "frame=sides"
+          when "box", "border"
+            "frame=all"
+          else
+            nil
+          end
+        end
+
+        def rules(node)
+          case node["rules"]
+          when "all"
+            "rules=all"
+          when "rows"
+            "rules=rows"
+          when "cols"
+            "rules=cols"
+          when "none"
+            "rules=none"
+          else
+            nil
+          end
+        end
+
+        def style(node)
+          width = "width=#{node['width']}" if node['width']
+          attrs = []
+          frame_attr = frame(node)
+          rules_attr = rules(node)
+          attrs += width if width
+          attrs += frame_attr if frame_attr
+          attrs += rules_attr if rules_attr
+          return "" if attrs.empty?
+          "[#{attrs.join(',')}]\n"
+        end
+      end
+
+      ReverseAdoc::Converters.register :table, Table.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