plurimath 0.8.3 → 0.8.4

data/lib/plurimath/xml_engine/oga/dumper.rb

@@ -0,0 +1,96 @@
+module Plurimath
+  module XmlEngine
+    class Oga
+      # Dump the tree just as if we were Ox. This is a limited implementation.
+      class Dumper
+        def initialize(tree, indent: nil)
+          @tree = tree
+          @indent = indent
+          @depth = 0
+          @out = ""
+        end
+
+        def dump(node = @tree)
+          case node
+          when Node
+            nodes = node.nodes
+            if nodes.length == 0
+              line_break
+              @out += "<#{node.unwrap.name}#{dump_attrs(node)}/>"
+            else
+              line_break
+              @out += "<#{node.unwrap.name}#{dump_attrs(node)}>"
+              @depth += 1
+              nodes.each { |i| dump(i) }
+              @depth -= 1
+              line_break unless nodes.last.is_a?(::String)
+              @out += "</#{node.unwrap.name}>"
+            end
+          when ::String
+            @out += entities(node)
+          end
+
+          line_break if node.object_id == @tree.object_id
+
+          self
+        end
+
+        attr_reader :out
+
+        ORD_AMP="&".ord
+        ORD_LT="<".ord
+        ORD_GT=">".ord
+        ORD_APOS="'".ord
+        ORD_QUOT='"'.ord
+        ORD_NEWLINE="\n".ord
+        ORD_CARRIAGERETURN="\r".ord
+
+        def self.entities(text,attr=false)
+          text.to_s.chars.map(&:ord).map do |i|
+            if i == ORD_AMP
+              "&amp;"
+            elsif i == ORD_LT
+              "&lt;"
+            elsif i == ORD_GT
+              "&gt;"
+            elsif i == ORD_QUOT && attr
+              "&quot;"
+            elsif i == ORD_NEWLINE || i == ORD_CARRIAGERETURN
+              i.chr("utf-8")
+            elsif i < 0x20
+              "&#x#{i.to_s(16).rjust(4, "0")};"
+            else
+              i.chr("utf-8")
+            end
+          end.join
+        end
+
+        private
+
+        def dump_attrs(node)
+          node.unwrap.attributes.map do |i|
+            attr_key = i.namespace_name ? "#{i.namespace_name}:#{i.name}" : i.name
+            %{ #{attr_key}="#{attr_entities(i.value)}"}
+          end.join
+        end
+
+        def entities(text, attr = false)
+          self.class.entities(to_unicode(text, attr))
+        end
+
+        def attr_entities(text)
+          self.class.entities(text, true)
+        end
+
+        def line_break
+          @out += "\n"
+          @out += " " * (@indent * @depth) if @indent
+        end
+
+        def to_unicode(text, attr = false)
+          attr ? Utility.html_entity_to_unicode(text) : text
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/oga/element.rb

@@ -0,0 +1,8 @@
+module Plurimath
+  module XmlEngine
+    class Oga
+      class Element < ::Oga::XML::Element
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/oga/node.rb

@@ -0,0 +1,133 @@
+require "plurimath/xml_engine/oga/wrapper"
+
+module Plurimath
+  module XmlEngine
+    class Oga
+      class Node < Wrapper
+        # Ox removes text nodes that are whitespace-only.
+        # There exists a weird edge case on which Plurimath depends:
+        # <mi> <!-- xxx --> &#x3C0;<!--GREEK SMALL LETTER PI--> </mi>
+        # If the last text node of an element that does not contain other
+        # elements is a whitespace, it preserves it. The first one can be
+        # safely removed.
+        def nodes
+          children = @wrapped.children
+          length = children.length
+          preserve_last = true
+          children.map.with_index do |i,idx|
+            if preserve_last && idx == length-1 && i.is_a?(::Oga::XML::Text)
+              i.text
+            elsif i.is_a? ::Oga::XML::Text
+              remove_indentation(i)
+            elsif i.is_a? ::Oga::XML::Comment
+              Node.new(i)
+            else
+              preserve_last = false
+              Node.new(i)
+            end
+          end.compact
+        end
+
+        def [](attr)
+          attr = attr.to_s
+
+          @wrapped.attributes.each do |e|
+            return e.value if [e.name, e.name.split(":").last].include? attr
+          end
+
+          nil
+        end
+
+        def []=(attr, value)
+          # Here we tap into the internal representation due to some likely
+          # bug in Oga
+          attr = ::Oga::XML::Attribute.new(name: attr.to_s)
+          attr.element = @wrapped
+          attr.instance_variable_set(:@value, encode_entities(value.to_s))
+          attr.instance_variable_set(:@decoded, true)
+          @wrapped.attributes << attr
+        end
+
+        def <<(other)
+          other = other.unwrap if other.respond_to? :unwrap
+
+          case other
+          when String
+            text = other
+            # Here we tap into the internal representation due to some likely
+            # bug in Oga
+            other = ::Oga::XML::Text.new
+            other.instance_variable_set(:@from_plurimath, true)
+            other.instance_variable_set(:@text, text)
+            other.instance_variable_set(:@decoded, true)
+          end
+
+          @wrapped.children << other.dup
+          self
+        end
+
+        def attributes
+          @wrapped.attributes.to_h do |e|
+            [e.name.split(":").last, e.value]
+          end
+        end
+
+        def locate(xpath)
+          @wrapped.xpath(xpath).map do |i|
+            case i
+            when ::Oga::XML::Text
+              i.text
+            when ::Oga::XML::Attribute
+              i.value
+            else
+              Node.new(i)
+            end
+          end
+        end
+
+        def name
+          @wrapped.name
+        end
+
+        def name=(new_name)
+          @wrapped.name = new_name
+        end
+
+        def each
+          nodes.each
+        end
+
+        def set_attr(attr_hash)
+          Array(attr_hash)&.each { |key, value| @wrapped.set(key.to_s, encode_entities((value.to_s))) }
+        end
+
+        def xml_node?
+          true
+        end
+
+        def xml_nodes
+          self
+        end
+
+        def insert_in_nodes(index, element)
+          @wrapped.children.insert(index, element.unwrap)
+        end
+
+        def remove_attr(attr_key)
+          @wrapped.unset(attr_key)
+        end
+
+        private
+
+        def remove_indentation(text)
+          from_us = text.instance_variable_get(:@from_plurimath)
+          !from_us && text.text.strip == "" ? nil : text.text
+        end
+
+        def encode_entities(entity)
+          Utility.html_entity_to_unicode(entity)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/oga/wrapper.rb

@@ -0,0 +1,21 @@
+module Plurimath
+  module XmlEngine
+    class Oga
+      # Create API compatible with Ox, per Plurimath usage
+      class Wrapper
+        def initialize(value)
+          @wrapped = value
+        end
+
+        def unwrap
+          @wrapped
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            @wrapped.inspect == other.unwrap.inspect
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/oga.rb

@@ -3,9 +3,14 @@
 require "plurimath/xml_engine"
 require "corelib/array/pack" if RUBY_ENGINE == "opal"
 require "oga"
+require_relative "oga/document"
+require_relative "oga/wrapper"
+require_relative "oga/element"
+require_relative "oga/dumper"
+require_relative "oga/node"
 
 module Plurimath
-  module XMLEngine
+  module XmlEngine
     class Oga
       class << self
         def new_element(name)
@@ -19,233 +24,22 @@ module Plurimath
 
         def load(data)
           data = ::Oga::XML::Parser.new(data, html: true).parse
-          if data.xml_declaration
-            Document.new(data)
-          else
-            Document.new(data).nodes.first
-          end
+          return Document.new(data) if data.xml_declaration
+
+          Document.new(data).nodes.first
         end
 
         def is_xml_comment?(node)
           node = node.unwrap if node.respond_to? :unwrap
-          node.is_a?(Comment)
+          node.is_a?(::Oga::XML::Comment)
         end
 
         def replace_nodes(root, nodes)
-          root.unwrap.children = ::Oga::XML::NodeSet.new([::Oga::XML::Text.new(text: nodes)])
+          text_node = ::Oga::XML::Text.new(text: nodes)
+          root.unwrap.children = ::Oga::XML::NodeSet.new([text_node])
           root
         end
       end
-
-      # Create API compatible with Ox, per Plurimath usage
-      class Wrapper
-        def initialize(value)
-          @wrapped = value
-        end
-
-        def unwrap
-          @wrapped
-        end
-
-        def ==(other)
-          self.class == other.class &&
-            @wrapped.inspect == other.unwrap.inspect
-        end
-      end
-
-      class Node < Wrapper
-        # Ox removes text nodes that are whitespace-only.
-        # There exists a weird edge case on which Plurimath depends:
-        # <mi> <!-- xxx --> &#x3C0;<!--GREEK SMALL LETTER PI--> </mi>
-        # If the last text node of an element that does not contain other
-        # elements is a whitespace, it preserves it. The first one can be
-        # safely removed.
-        def nodes
-          children = @wrapped.children
-          length = children.length
-          preserve_last = true
-          children.map.with_index do |i,idx|
-            if preserve_last && idx == length-1 && i.is_a?(::Oga::XML::Text)
-              i.text
-            elsif i.is_a? ::Oga::XML::Text
-              remove_indentation(i)
-            elsif i.is_a? ::Oga::XML::Comment
-              Node.new(i)
-            else
-              preserve_last = false
-              Node.new(i)
-            end
-          end.compact
-        end
-
-        def [](attr)
-          attr = attr.to_s
-
-          @wrapped.attributes.each do |e|
-            return e.value if [e.name, e.name.split(":").last].include? attr
-          end
-
-          nil
-        end
-
-        def []=(attr, value)
-          # Here we tap into the internal representation due to some likely
-          # bug in Oga
-          attr = ::Oga::XML::Attribute.new(name: attr.to_s)
-          attr.element = @wrapped
-          attr.instance_variable_set(:@value, value.to_s)
-          attr.instance_variable_set(:@decoded, true)
-          @wrapped.attributes << attr
-        end
-
-        def <<(other)
-          other = other.unwrap if other.respond_to? :unwrap
-
-          case other
-          when String
-            text = other
-            # Here we tap into the internal representation due to some likely
-            # bug in Oga
-            other = ::Oga::XML::Text.new
-            other.instance_variable_set(:@from_plurimath, true)
-            other.instance_variable_set(:@text, text)
-            other.instance_variable_set(:@decoded, true)
-          end
-
-          @wrapped.children << other.dup
-          self
-        end
-
-        def attributes
-          @wrapped.attributes.to_h do |e|
-            [e.name.split(":").last, e.value]
-          end
-        end
-
-        def locate(xpath)
-          @wrapped.xpath(xpath).map do |i|
-            case i
-            when ::Oga::XML::Text
-              i.text
-            when ::Oga::XML::Attribute
-              i.value
-            else
-              Node.new(i)
-            end
-          end
-        end
-
-        def name
-          @wrapped.name
-        end
-
-        def name=(new_name)
-          @wrapped.name = new_name
-        end
-
-        private
-
-        def remove_indentation(text)
-          from_us = text.instance_variable_get(:@from_plurimath)
-          !from_us && text.text.strip == "" ? nil : text.text
-        end
-      end
-
-      class Document < Node
-      end
-
-      Comment = ::Oga::XML::Comment
-
-      # Dump the tree just as if we were Ox. This is a limited implementation.
-      class Dumper
-        def initialize(tree, indent: nil)
-          @tree = tree
-          @indent = indent
-          @depth = 0
-          @out = ""
-        end
-
-        def dump(node = @tree)
-          case node
-          when Node
-            nodes = node.nodes
-            if nodes.length == 0
-              line_break
-              @out += "<#{node.unwrap.name}#{dump_attrs(node)}/>"
-            else
-              line_break
-              @out += "<#{node.unwrap.name}#{dump_attrs(node)}>"
-              @depth += 1
-              nodes.each { |i| dump(i) }
-              @depth -= 1
-              line_break unless nodes.last.is_a?(::String)
-              @out += "</#{node.unwrap.name}>"
-            end
-          when ::String
-            @out += entities(node)
-          end
-
-          line_break if node.object_id == @tree.object_id
-
-          self
-        end
-
-        attr_reader :out
-
-        ORD_AMP="&".ord
-        ORD_LT="<".ord
-        ORD_GT=">".ord
-        ORD_APOS="'".ord
-        ORD_QUOT='"'.ord
-        ORD_NEWLINE="\n".ord
-        ORD_CARRIAGERETURN="\r".ord
-
-        def self.entities(text,attr=false)
-          text.to_s.chars.map(&:ord).map do |i|
-            if i == ORD_AMP
-              "&amp;"
-            elsif i == ORD_LT
-              "&lt;"
-            elsif i == ORD_GT
-              "&gt;"
-            elsif i == ORD_QUOT && attr
-              "&quot;"
-            elsif i == ORD_NEWLINE || i == ORD_CARRIAGERETURN
-              i.chr("utf-8")
-            elsif i < 0x20
-              "&#x#{i.to_s(16).rjust(4, "0")};"
-            else
-              i.chr("utf-8")
-            end
-          end.join
-        end
-
-        private
-
-        def dump_attrs(node)
-          node.unwrap.attributes.map do |i|
-            # Currently, this is not part of the contract. But in the future
-            # it may be needed to also handle namespaces:
-            #
-            # if i.namespace
-            #   %{ #{i.namespace.name}:#{i.name}="#{attr_entities i.value}"}
-            %{ #{i.name}="#{attr_entities i.value}"}
-          end.join
-        end
-
-        def entities(text)
-          self.class.entities(text)
-        end
-
-        def attr_entities(text)
-          self.class.entities(text, true)
-        end
-
-        def line_break
-          @out += "\n"
-          @out += " " * (@indent * @depth) if @indent
-        end
-      end
     end
   end
 end

data/lib/plurimath/xml_engine/ox/element.rb

@@ -0,0 +1,127 @@
+module Plurimath
+  module XmlEngine
+    class Ox
+      class Element
+        attr_accessor :attributes
+
+        def initialize(node)
+          @node = node.is_a?(String) ? ::Ox::Element.new(node) : node
+        end
+
+        def ==(object)
+          self.class == object.class &&
+            @node == object.xml_nodes &&
+            nodes == object.nodes
+        end
+
+        def [](object)
+          xml_nodes&.attributes&.dig(object.to_s)
+        end
+
+        def []=(attr, value)
+          update_attrs(@node, { attr.to_s => value.to_s })
+          update_attrs(self, { attr.to_s => value.to_s })
+        end
+
+        def name
+          @node.name
+        end
+
+        def name=(new_name)
+          @node.name = new_name
+        end
+
+        def set_attr(attrs)
+          update_attrs(@node, attrs)
+          update_attrs(self, attrs)
+        end
+
+        def remove_attr(attribute)
+          xml_nodes&.attributes&.delete(attribute)
+        end
+
+        def <<(object)
+          @node << (object.is_a?(String) ? object : object.xml_nodes)
+          self
+        end
+
+        def attributes
+          @node.attributes
+        end
+
+        def attributes=(attr_hash = {})
+          update_attrs(@node.node, attr_hash)
+          update_attrs(self, @node.attributes)
+        end
+
+        def xml_nodes
+          @node
+        end
+
+        def nodes
+          xml_nodes.nodes.map { |node| element_or_string(node) }
+        end
+
+        def each(&block)
+          xml_nodes.each(&block)
+        end
+
+        def map(&block)
+          xml_nodes.map(&block)
+        end
+
+        def xml_node?
+          true
+        end
+
+        def insert_in_nodes(index, element)
+          @node.nodes.insert(index, element.xml_nodes)
+        end
+
+        def locate(string)
+          @node.locate(string)
+        end
+
+        def replace_nodes(nodes_array)
+          xml_nodes.nodes.replace(nodes_array)
+        end
+
+        def is_xml_comment?
+          xml_nodes.is_a?(::Ox::Comment)
+        end
+
+        private
+
+        def update_nodes(element, all_nodes)
+          all_nodes&.each do |node|
+            next update_nodes(element, node) if node.is_a?(Array)
+
+            element << node unless node.nil?
+          end
+          element
+        end
+
+        def update_attrs(element, attributes = @attributes)
+          attributes&.each do |key, value|
+            element.attributes[key.to_s] = Utility.html_entity_to_unicode(value.to_s)
+          end
+          element
+        end
+
+        def init_nodes_vars(xml_nodes)
+          xml_nodes.each do |node|
+            if node.is_a?(::Ox::Element)
+              init_nodes_vars(node.nodes)
+              node.attributes
+              node.nodes
+            end
+          end
+        end
+
+        def element_or_string(node)
+          node.is_a?(String) ? node : self.class.new(node)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine/ox.rb

@@ -1,31 +1,36 @@
 # frozen_string_literal: true
 
 require "plurimath/xml_engine"
+require "plurimath/xml_engine/ox/element"
 require "ox"
 Ox.default_options = { encoding: "UTF-8" }
 
 module Plurimath
-  module XMLEngine
+  module XmlEngine
     class Ox
       class << self
         def new_element(name)
-          ::Ox::Element.new(name)
+          Element.new(name)
         end
 
         def dump(data, **options)
-          ::Ox.dump(data, **options)
+          ::Ox.dump(data.xml_nodes, **options)
         end
 
         def load(data)
-          ::Ox.load(data, strip_namespace: true)
+          Element.new(
+            ::Ox.load(data, strip_namespace: true),
+          )
         end
 
         def is_xml_comment?(node)
-          node.is_a?(::Ox::Comment)
+          return node.is_xml_comment? if node.is_a?(Element)
+
+          false
         end
 
         def replace_nodes(root, nodes)
-          root.nodes.replace(Array(nodes))
+          root.replace_nodes(Array(nodes))
           root
         end
       end

data/lib/plurimath/xml_engine.rb

@@ -1,6 +1,6 @@
 module Plurimath
   singleton_class.attr_accessor :xml_engine
 
-  module XMLEngine
+  module XmlEngine
   end
 end