plurimath 0.4.4 → 0.6.0

data/lib/plurimath/math.rb

@@ -19,9 +19,7 @@ require_relative "latex/parser"
 require_relative "html/parser"
 require_relative "omml/parser"
 require_relative "utility"
-require "ox"
 require "yaml"
-Ox.default_options = { encoding: "UTF-8" }
 
 module Plurimath
   module Math
@@ -72,7 +70,7 @@ module Plurimath
 
     def type_error!
       raise InvalidTypeError.new(
-        "`type` must be one of: `#{VALID_TYPES.keys.join('`, `')}`"
+        "`type` must be one of: `#{VALID_TYPES.keys.join('`, `')}`",
       )
     end
 

data/lib/plurimath/mathml/parser.rb

@@ -23,8 +23,8 @@ module Plurimath
       end
 
       def parse
-        ox_nodes = Ox.load(text, strip_namespace: true)
-        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first
+        ox_nodes = Plurimath.xml_engine.load(text)
+        display_style = ox_nodes&.locate("mstyle/@displaystyle")&.first
         nodes = parse_nodes(ox_nodes.nodes)
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
@@ -34,7 +34,7 @@ module Plurimath
 
       def parse_nodes(nodes)
         nodes.map do |node|
-          next if node.is_a?(Ox::Comment)
+          next if Plurimath.xml_engine.is_xml_comment?(node)
 
           if node.is_a?(String)
             node
@@ -47,7 +47,7 @@ module Plurimath
       end
 
       def validate_attributes(attributes)
-        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key&.to_s) }
+        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key.to_s) }
         attributes&.transform_keys(&:to_sym) if attributes&.any?
       end
 

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

@@ -11,13 +11,29 @@ module Plurimath
         mr
         r
       ].freeze
+      SUPPORTED_FONTS = {
+        "sans-serif-bi": "sans-serif-bold-italic",
+        "double-struck": "double-struck",
+        "sans-serif-i": "sans-serif-italic",
+        "sans-serif-b": "bold-sans-serif",
+        "sans-serif-p": "sans-serif",
+        "fraktur-p": "fraktur",
+        "fraktur-b": "bold-fraktur",
+        "script-b": "bold-script",
+        "script-p": "script",
+        monospace: "monospace",
+        bi: "bold-italic",
+        p: "normal",
+        i: "italic",
+        b: "bold",
+      }.freeze
 
       def initialize(text)
         @text = text
       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(
@@ -55,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

@@ -72,7 +72,7 @@ module Plurimath
           font = flatten_row.shift
           font.new(
             Utility.filter_values(flatten_row),
-            Utility::OMML_FONTS.invert[font].to_s,
+            Utility::FONT_STYLES.key(font).to_s,
           )
         else
           Utility.filter_values(flatten_row)
@@ -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
@@ -116,7 +122,7 @@ module Plurimath
           font = flatten_mtd.shift
           font.new(
             Utility.filter_values(flatten_mtd),
-            Utility::OMML_FONTS.invert[font].to_s,
+            Utility::FONT_STYLES.rassoc(font).first.to_s,
           )
         else
           flatten_mtd
@@ -133,7 +139,11 @@ module Plurimath
 
       rule(rPr: subtree(:rpr)) do
         if rpr.is_a?(Array)
-          Utility::OMML_FONTS[rpr.join("-").to_sym]
+          Utility::FONT_STYLES[
+            Omml::Parser::SUPPORTED_FONTS[
+              rpr&.join("-")&.to_sym,
+            ]&.to_sym,
+          ]
         end
       end
 
@@ -172,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

@@ -4,24 +4,30 @@ module Plurimath
   class Utility
     FONT_STYLES = {
       "double-struck": Math::Function::FontStyle::DoubleStruck,
+      "sans-serif-bold-italic": Math::Function::FontStyle::SansSerifBoldItalic,
+      "sans-serif-italic": Math::Function::FontStyle::SansSerifItalic,
+      "bold-sans-serif": Math::Function::FontStyle::BoldSansSerif,
       "sans-serif": Math::Function::FontStyle::SansSerif,
+      "bold-fraktur": Math::Function::FontStyle::BoldFraktur,
+      "bold-italic": Math::Function::FontStyle::BoldItalic,
+      "bold-script": Math::Function::FontStyle::BoldScript,
       monospace: Math::Function::FontStyle::Monospace,
-      fraktur: Math::Function::FontStyle::Fraktur,
-      script: Math::Function::FontStyle::Script,
-      normal: Math::Function::FontStyle::Normal,
-      bold: Math::Function::FontStyle::Bold,
       mathfrak: Math::Function::FontStyle::Fraktur,
       mathcal: Math::Function::FontStyle::Script,
+      fraktur: Math::Function::FontStyle::Fraktur,
       mathbb: Math::Function::FontStyle::DoubleStruck,
       mathtt: Math::Function::FontStyle::Monospace,
       mathsf: Math::Function::FontStyle::SansSerif,
       mathrm: Math::Function::FontStyle::Normal,
       textrm: Math::Function::FontStyle::Normal,
+      italic: Math::Function::FontStyle::Italic,
       mathbf: Math::Function::FontStyle::Bold,
       textbf: Math::Function::FontStyle::Bold,
+      script: Math::Function::FontStyle::Script,
+      normal: Math::Function::FontStyle::Normal,
+      bold: Math::Function::FontStyle::Bold,
       bbb: Math::Function::FontStyle::DoubleStruck,
       cal: Math::Function::FontStyle::Script,
-      bf: Math::Function::FontStyle::Bold,
       sf: Math::Function::FontStyle::SansSerif,
       tt: Math::Function::FontStyle::Monospace,
       fr: Math::Function::FontStyle::Fraktur,
@@ -29,6 +35,7 @@ module Plurimath
       cc: Math::Function::FontStyle::Script,
       ii: Math::Function::FontStyle::Italic,
       bb: Math::Function::FontStyle::Bold,
+      bf: Math::Function::FontStyle::Bold,
     }.freeze
     ALIGNMENT_LETTERS = {
       c: "center",
@@ -72,22 +79,6 @@ module Plurimath
       max
       min
     ].freeze
-    OMML_FONTS = {
-      "sans-serif-bi": Math::Function::FontStyle::SansSerifBoldItalic,
-      "sans-serif-i": Math::Function::FontStyle::SansSerifItalic,
-      "sans-serif-b": Math::Function::FontStyle::BoldSansSerif,
-      "double-struck": Math::Function::FontStyle::DoubleStruck,
-      "sans-serif-p": Math::Function::FontStyle::SansSerif,
-      "fraktur-p": Math::Function::FontStyle::Fraktur,
-      "fraktur-b": Math::Function::FontStyle::BoldFraktur,
-      "script-b": Math::Function::FontStyle::BoldScript,
-      "script-p": Math::Function::FontStyle::Script,
-      monospace: Math::Function::FontStyle::Monospace,
-      bi: Math::Function::FontStyle::BoldItalic,
-      p: Math::Function::FontStyle::Normal,
-      i: Math::Function::FontStyle::Italic,
-      b: Math::Function::FontStyle::Bold,
-    }.freeze
     PARENTHESIS = {
       "〈": "〉",
       "⌊": "⌋",
@@ -100,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)
@@ -196,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
@@ -258,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
 
@@ -292,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
 
@@ -461,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]
@@ -478,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
@@ -573,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.4.4"
+  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