plurimath 0.5.0 → 0.6.0

data/lib/plurimath/mathml/transform.rb

@@ -88,8 +88,7 @@ module Plurimath
 
       rule(merror: sequence(:merror)) do
         Math::Function::Merror.new(
-          merror[0],
-          merror[1],
+          Utility.filter_values(merror),
         )
       end
 
@@ -247,7 +246,7 @@ module Plurimath
         symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
         text     = entities.encode(mtext.flatten.join, :hexadecimal)
         symbols.each do |code, string|
-          text.gsub!(code.downcase, "unicode[:#{string}]")
+          text = text.gsub(code.downcase, "unicode[:#{string}]")
         end
         Math::Function::Text.new(text)
       end
@@ -257,7 +256,7 @@ module Plurimath
         symbols  = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
         text     = entities.encode(ms.first, :hexadecimal)
         symbols.each do |code, string|
-          text.gsub!(code.downcase, "unicode[:#{string}]")
+          text = text.gsub(code.downcase, "unicode[:#{string}]")
         end
         Math::Function::Text.new(text)
       end

data/lib/plurimath/omml/parser.rb

@@ -33,7 +33,7 @@ module Plurimath
       end
 
       def parse
-        nodes = Ox.load(text, strip_namespace: true)
+        nodes = Plurimath.xml_engine.load(text)
         @hash = { sequence: parse_nodes(nodes.nodes) }
         nodes = JSON.parse(@hash.to_json, symbolize_names: true)
         Math::Formula.new(
@@ -71,14 +71,14 @@ module Plurimath
       end
 
       def organize_table_td(node)
-        node.locate("e/?").each do |child_node|
+        node.locate("e/*").each do |child_node|
           child_node.name = "mtd" if child_node.name == "r"
         end
       end
 
       def organize_fonts(node)
         attrs_arr = { val: [] }
-        node.locate("rPr/?").each do |child|
+        node.locate("rPr/*").each do |child|
           attrs_arr[:val] << child.attributes["val"]
         end
         node.attributes.merge! attrs_arr

data/lib/plurimath/omml/transform.rb

@@ -98,11 +98,17 @@ module Plurimath
         open_paren   = fenced.shift if fenced&.first&.class_name == "symbol"
         close_paren  = fenced.shift if fenced&.first&.class_name == "symbol"
         fenced_value = fenced.compact
-        Math::Function::Fenced.new(
-          open_paren,
-          fenced_value,
-          close_paren,
-        )
+        if fenced_value.length == 1 && fenced_value.first.is_a?(Math::Function::Table)
+          fenced_value.first.open_paren = open_paren&.value
+          fenced_value.first.close_paren = close_paren&.value
+          fenced_value
+        else
+          Math::Function::Fenced.new(
+            open_paren,
+            fenced_value,
+            close_paren,
+          )
+        end
       end
 
       rule(dPr: subtree(:dpr)) do
@@ -176,12 +182,7 @@ module Plurimath
           ternary_class.parameter_three = Utility.filter_values(nary[3])
           ternary_class
         else
-          Math::Formula.new(
-            [
-              Utility.nary_fonts(nary),
-              Utility.filter_values(nary[3]),
-            ],
-          )
+          Utility.nary_fonts(nary)
         end
       end
 

data/lib/plurimath/setup/oga.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine/oga"
+
+Plurimath.xml_engine = Plurimath::XMLEngine::Oga

data/lib/plurimath/setup/opal.rb.erb

@@ -0,0 +1,8 @@
+require 'plurimath/math/core'
+require 'plurimath/math/function'
+<% (
+     Dir[File.dirname(__dir__)+"/math/function/*.rb"] +
+     Dir[File.dirname(__dir__)+"/math/function/**/*.rb"]
+   ).each do |f| %>
+  require 'plurimath/<%= f.split("lib/plurimath").last.gsub(/.rb$/,'') %>'
+<% end %>

data/lib/plurimath/setup/ox.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine/ox"
+
+Plurimath.xml_engine = Plurimath::XMLEngine::Ox

data/lib/plurimath/utility.rb

@@ -91,6 +91,12 @@ module Plurimath
       "{": "}",
       "[": "]",
     }.freeze
+    TEXT_CLASSES = %w[
+      unicode
+      symbol
+      number
+      text
+    ].freeze
 
     class << self
       def organize_table(array, column_align: nil, options: nil)
@@ -187,7 +193,7 @@ module Plurimath
       def ox_element(node, attributes: [], namespace: "")
         namespace = "#{namespace}:" unless namespace.empty?
 
-        element = Ox::Element.new("#{namespace}#{node}")
+        element = Plurimath.xml_engine.new_element("#{namespace}#{node}")
         attributes&.each do |attr_key, attr_value|
           element[attr_key] = attr_value
         end
@@ -249,12 +255,14 @@ module Plurimath
 
       def nary_fonts(nary)
         narypr  = nary.first.flatten.compact
-        subsup  = narypr.any?("undOvr") ? "underover" : "power_base"
+        subsup  = narypr.any?("undOvr") ? "undOvr" : "subSup"
         unicode = narypr.any?(Hash) ? narypr.first[:chr] : "∫"
-        get_class(subsup).new(
+        Math::Function::Nary.new(
           Math::Symbol.new(string_to_html_entity(unicode)),
-          nary[1],
-          nary[2],
+          filter_values(nary[1]),
+          filter_values(nary[2]),
+          filter_values(nary[3]),
+          { type: subsup }
         )
       end
 
@@ -283,7 +291,8 @@ module Plurimath
       end
 
       def td_value(td_object)
-        if td_object.is_a?(String) && td_object.empty?
+        str_classes = [String, Parslet::Slice]
+        if str_classes.include?(td_object.class) && td_object.to_s.empty?
           return Math::Function::Text.new(nil)
         end
 
@@ -452,7 +461,7 @@ module Plurimath
       end
 
       def left_right_objects(paren, function)
-        paren = if paren.to_s.match?(/\\{|\\}/)
+        paren = if paren.to_s.match?(/\\\{|\\\}/)
                   paren.to_s.gsub(/\\/, "")
                 else
                   Latex::Constants::LEFT_RIGHT_PARENTHESIS[paren.to_sym]
@@ -469,12 +478,7 @@ module Plurimath
       def mrow_left_right(mrow = [])
         object = mrow.first
         !(
-          (
-            (
-              object.is_a?(Math::Function::TernaryFunction) && object.any_value_exist?
-            ) &&
-            (mrow.length <= 2)
-          ) ||
+          ((object.is_a?(Math::Function::TernaryFunction) && object.any_value_exist?) && (mrow.length <= 2)) ||
           (object.is_a?(Math::Function::UnaryFunction) && mrow.length == 1)
         )
       end
@@ -564,6 +568,37 @@ module Plurimath
           end
         end
       end
+
+      def validate_math_zone(object)
+        return false unless object
+
+        if object.is_a?(Math::Formula)
+          filter_math_zone_values(object.value).find do |d|
+            !d.is_a?(Math::Function::Text)
+          end
+        else
+          !TEXT_CLASSES.include?(object.class_name)
+        end
+      end
+
+      def filter_math_zone_values(value)
+        return [] if value&.empty?
+
+        new_arr = []
+        temp_array = []
+        skip_index = nil
+        value.each_with_index do |obj, index|
+          object = obj.dup
+          next if index == skip_index
+          next temp_array << object.value if TEXT_CLASSES.include?(object.class_name)
+
+          new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+          temp_array = []
+          new_arr << object
+        end
+        new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
+        new_arr
+      end
     end
   end
 end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/plurimath/xml_engine/oga.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine"
+require "corelib/array/pack" if RUBY_ENGINE == "opal"
+require "oga"
+
+module Plurimath
+  module XMLEngine
+    class Oga
+      class << self
+        def new_element(name)
+          data = ::Oga::XML::Element.new(name: name)
+          Node.new(data)
+        end
+
+        def dump(data, indent: nil)
+          Dumper.new(data, indent: indent).dump.out
+        end
+
+        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
+        end
+
+        def is_xml_comment?(node)
+          node = node.unwrap if node.respond_to? :unwrap
+          node.is_a?(Comment)
+        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.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "plurimath/xml_engine"
+require "ox"
+Ox.default_options = { encoding: "UTF-8" }
+
+module Plurimath
+  module XMLEngine
+    class Ox
+      class << self
+        def new_element(name)
+          ::Ox::Element.new(name)
+        end
+
+        def dump(data, **options)
+          ::Ox.dump(data, **options)
+        end
+
+        def load(data)
+          ::Ox.load(data, strip_namespace: true)
+        end
+
+        def is_xml_comment?(node)
+          node.is_a?(::Ox::Comment)
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/xml_engine.rb

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

data/lib/plurimath.rb

@@ -1,4 +1,14 @@
-# frozen_string_literal: true
 
 require_relative "plurimath/version"
-require_relative "plurimath/math"
+
+# Select an XML engine
+if RUBY_ENGINE == 'opal'
+  require "plurimath/setup/oga"
+  require "plurimath/setup/opal"
+elsif ENV['PLURIMATH_OGA']
+  require "plurimath/setup/oga"
+else
+  require "plurimath/setup/ox"
+end
+
+require "plurimath/math"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-08 00:00:00.000000000 Z
+date: 2023-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -49,6 +49,8 @@ files:
 - ".github/workflows/release.yml"
 - ".gitignore"
 - ".hound.yml"
+- ".rspec"
+- ".rspec-opal"
 - ".rubocop.yml"
 - AsciiMath-Supported-Data.adoc
 - CODE_OF_CONDUCT.md
@@ -146,6 +148,7 @@ files:
 - lib/plurimath/math/function/msgroup.rb
 - lib/plurimath/math/function/msline.rb
 - lib/plurimath/math/function/multiscript.rb
+- lib/plurimath/math/function/nary.rb
 - lib/plurimath/math/function/norm.rb
 - lib/plurimath/math/function/obrace.rb
 - lib/plurimath/math/function/oint.rb
@@ -202,10 +205,16 @@ files:
 - lib/plurimath/omml.rb
 - lib/plurimath/omml/parser.rb
 - lib/plurimath/omml/transform.rb
+- lib/plurimath/setup/oga.rb
+- lib/plurimath/setup/opal.rb.erb
+- lib/plurimath/setup/ox.rb
 - lib/plurimath/unicode.rb
 - lib/plurimath/unitsml.rb
 - lib/plurimath/utility.rb
 - lib/plurimath/version.rb
+- lib/plurimath/xml_engine.rb
+- lib/plurimath/xml_engine/oga.rb
+- lib/plurimath/xml_engine/ox.rb
 - plurimath.gemspec
 homepage: https://github.com/plurimath/plurimath
 licenses: