plurimath 0.8.9 → 0.8.11

data/lib/plurimath/unicode_math/transform.rb

@@ -37,6 +37,9 @@ module Plurimath
       rule(sub_exp: sequence(:exp)) { exp }
       rule(factor: simple(:factor)) { factor }
       rule(hbrack: simple(:hbrack)) { hbrack }
+      rule(script: simple(:script)) { :script }
+      rule(double: simple(:double)) { :double }
+      rule(mitBbb: simple(:mitBbb)) { :mitBbb }
       rule(symbol: simple(:symbol)) { Utility.symbols_class(symbol, lang: :unicodemath) }
       rule(number: simple(:number)) { Math::Number.new(number) }
 
@@ -44,6 +47,7 @@ module Plurimath
       rule(sub_paren: simple(:paren)) { paren }
       rule(factor: sequence(:factor)) { factor }
       rule(operand: simple(:operand)) { operand }
+      rule(fraktur: simple(:fraktur)) { :fraktur }
       rule(accents: subtree(:accent)) { Utility.unicode_accents(accent) }
       rule(sup_alpha: simple(:alpha)) { Math::Symbols::Symbol.new(Constants::SUP_ALPHABETS.key(alpha).to_s, mini_sup_sized: true) }
 
@@ -183,6 +187,22 @@ module Plurimath
         Math::Number.new("#{decimal}#{whole.value}")
       end
 
+      rule(positive: simple(:positive),
+           infty: simple(:infty)) do
+        [
+          Utility.symbols_class(positive, lang: :unicodemath),
+          Utility.symbols_class(infty, lang: :unicodemath),
+        ]
+      end
+
+      rule(negative: simple(:negative),
+           infty: simple(:infty)) do
+        [
+          Utility.symbols_class(negative, lang: :unicodemath),
+          Utility.symbols_class(infty, lang: :unicodemath),
+        ]
+      end
+
       rule(unicode_fractions: simple(:fractions),
            expr: sequence(:expr)) do
         [Utility.unicode_fractions(fractions)] + expr
@@ -204,7 +224,7 @@ module Plurimath
           unicoded.to_sym,
           symbol.to_sym,
         )
-        Utility.symbols_class(unicode, lang: :unicodemath)
+        Utility.symbols_class((unicode || symbol), lang: :unicodemath)
       end
 
       rule(font_class: simple(:fonts),
@@ -392,6 +412,11 @@ module Plurimath
         [fonts] + expr
       end
 
+      rule(fonts: simple(:fonts),
+           expr: simple(:expr)) do
+        [fonts, expr]
+      end
+
       rule(phantom: simple(:phantom),
            expr: sequence(:expr)) do
         [phantom] + expr
@@ -690,6 +715,11 @@ module Plurimath
         [nary, naryand_recursion]
       end
 
+      rule(nary: simple(:nary),
+           naryand_recursion: sequence(:naryand_recursion)) do
+        [nary] + naryand_recursion
+      end
+
       rule(factor: simple(:factor),
            operand: simple(:operand)) do
         [factor, operand]
@@ -705,6 +735,16 @@ module Plurimath
         [factor] + operand
       end
 
+      rule(operand: sequence(:operand),
+           expr: simple(:expr)) do
+        operand + [expr]
+      end
+
+      rule(operand: sequence(:operand),
+           expr: sequence(:expr)) do
+        operand + expr
+      end
+
       rule(factor: simple(:factor),
            unary_subsup: sequence(:subsup)) do
         [factor] + subsup
@@ -750,6 +790,11 @@ module Plurimath
         [sub_exp] + naryand
       end
 
+      rule(sup_exp: simple(:sup_exp),
+           naryand_recursion: simple(:naryand)) do
+        [sup_exp, naryand]
+      end
+
       rule(exp: simple(:exp),
            expr: simple(:expr)) do
         [exp, expr]
@@ -1123,6 +1168,16 @@ module Plurimath
         end
       end
 
+      rule(unary_sub_sup: simple(:sub_sup),
+           first_value: sequence(:first_value)) do
+        if sub_sup.is_unary?
+          sub_sup.parameter_one.parameter_one = Utility.filter_values(first_value)
+          sub_sup
+        else
+          Math::Formula.new([sub_sup] + first_value)
+        end
+      end
+
       rule(color_value: simple(:color),
            first_value: simple(:first_value)) do
         Math::Function::Color.new(
@@ -1740,6 +1795,11 @@ module Plurimath
         [frac, exp]
       end
 
+      rule(frac: simple(:frac),
+           naryand_recursion: sequence(:naryand)) do
+        [frac] + naryand
+      end
+
       rule(expr: simple(:expr),
            func_expr: simple(:func_expr)) do
         [expr, func_expr]
@@ -1813,6 +1873,11 @@ module Plurimath
         if subsup_exp.is_ternary_function?
           subsup_exp.parameter_three = Utility.filter_values(naryand)
           subsup_exp
+        elsif subsup_exp.is_a?(Math::Function::Nary)
+          if subsup_exp.parameter_four.nil?
+            subsup_exp.parameter_four = Utility.filter_values(naryand)
+          end
+          subsup_exp
         else
           Math::Function::Nary.new(
             subsup_exp.parameter_one,
@@ -2180,6 +2245,12 @@ module Plurimath
         [factor] + operand + naryand_recursion
       end
 
+      rule(factor: simple(:factor),
+           operand: sequence(:operand),
+           naryand_recursion: simple(:naryand_recursion)) do
+        [factor] + operand + [naryand_recursion]
+      end
+
       rule(factor: sequence(:factor),
            operand: simple(:operand),
            expr: sequence(:expr)) do
@@ -2834,34 +2905,6 @@ module Plurimath
         end
       end
 
-      rule(nary_class: simple(:nary_class),
-           mask: simple(:mask),
-           sup: simple(:sup)) do
-        nary_function = if Constants::NARY_CLASSES.key?(nary_class.to_sym)
-                          nary_class
-                        else
-                          (Constants::NARY_CLASSES.invert[nary_class.to_s] || Constants::NARY_SYMBOLS[nary_class.to_sym] || nary_class)
-                        end
-        sup_value = sup.is_a?(Math::Function::Overset) ? sup.parameter_one : Utility.unfenced_value(sup, paren_specific: true)
-        options = { mask: mask.value }
-        if Constants::NARY_CLASSES.key?(nary_function.to_sym)
-          Utility.get_class(nary_function).new(
-            nil,
-            sup_value,
-            nil,
-            options
-          )
-        else
-          Math::Function::Nary.new(
-            Utility.symbols_class(nary_function, lang: :unicodemath),
-            nil,
-            sup_value,
-            nil,
-            options
-          )
-        end
-      end
-
       rule(nary_class: simple(:nary_class),
            mask: simple(:mask),
            sup: simple(:sup)) do
@@ -3250,6 +3293,19 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           unicode_symbols: simple(:symbol),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren),
+           sup: simple(:sup)) do
+        fenced = Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [Utility.symbols_class(symbol, lang: :unicodemath), exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+        Math::Function::Power.new(fenced, sup)
+      end
+
       rule(open_paren: simple(:open_paren),
            operator: simple(:operator),
            expr: simple(:expr),
@@ -3556,6 +3612,28 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           fonts: simple(:fonts),
+           expr: simple(:expr),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [fonts, expr],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           fonts: simple(:fonts),
+           exp: simple(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          [fonts, exp],
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            operator: simple(:operator),
            exp: sequence(:exp),
@@ -3709,6 +3787,18 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           factor: simple(:factor),
+           operand: sequence(:operand),
+           exp: sequence(:exp),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          open_paren.is_a?(Slice) ? Utility.symbols_class(open_paren, lang: :unicodemath) : open_paren,
+          ([factor] + operand + exp),
+          close_paren.is_a?(Slice) ? Utility.symbols_class(close_paren, lang: :unicodemath) : close_paren,
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            factor: simple(:factor),
            operand: simple(:operand),
@@ -3790,6 +3880,61 @@ module Plurimath
         )
       end
 
+      rule(open_paren: simple(:open_paren),
+           left_value: simple(:left_value),
+           comma: simple(:comma),
+           right_value: simple(:right_value),
+           close_paren: simple(:close_paren)) do
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          [left_value, Utility.symbols_class(comma, lang: :unicodemath), right_value],
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: simple(:left_value),
+           comma: simple(:comma),
+           right_value: sequence(:right_value),
+           close_paren: simple(:close_paren)) do
+        fence_value = [left_value, Utility.symbols_class(comma, lang: :unicodemath)]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fence_value.concat([Utility.filter_values(right_value)]),
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: sequence(:left_value),
+           comma: simple(:comma),
+           right_value: simple(:right_value),
+           close_paren: simple(:close_paren)) do
+        fence_value = [Utility.symbols_class(comma, lang: :unicodemath), right_value]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fence_value.insert(0, Utility.filter_values(left_value)),
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
+      rule(open_paren: simple(:open_paren),
+           left_value: sequence(:left_value),
+           comma: simple(:comma),
+           right_value: sequence(:right_value),
+           close_paren: simple(:close_paren)) do
+        fenced_value = [
+          Utility.filter_values(left_value),
+          Utility.symbols_class(comma, lang: :unicodemath),
+          Utility.filter_values(right_value),
+        ]
+        Math::Function::Fenced.new(
+          Utility.symbols_class(open_paren, lang: :unicodemath),
+          fenced_value,
+          Utility.symbols_class(close_paren, lang: :unicodemath),
+        )
+      end
+
       rule(open_paren: simple(:open_paren),
            pre_subscript: simple(:pre_sub),
            pre_supscript: simple(:pre_sup),

data/lib/plurimath/utility/intent_encoding.rb

@@ -0,0 +1,301 @@
+module Plurimath
+  class Utility
+    class IntentEncoding < Utility
+      SUP_TAGS = %w[msup mover].freeze
+      SUB_TAGS = %w[msub munder].freeze
+      INTENT_TEXT_NODES = %w[mi mo mn].freeze
+
+      class << self
+        # Intent common code begin
+        def node_value(node, field_name)
+          return unless node
+          return if node.name == "mo" && node.nodes[0] == "&#x2b1a;"
+          return html_entity_to_unicode(node.nodes.first) if valid_node_value?(node)
+          return all_numeric(node) if all_numeric?(node)
+
+          node[:arg] = field_name
+          "$#{field_name}"
+        end
+        # Intent common code end
+
+        # Naryand intent begin
+        def naryand_intent(field, intent_name)
+          return nary_intent(field, intent_name) if field.name == "mrow"
+
+          base, power = power_base_intent(field)
+          base, power = power_or_base_intent(field) unless base && power
+          field["intent"] = ":#{intent_name}(#{base},#{power})"
+          field
+        end
+
+        def nary_intent(field, intent_name)
+          sub_sup = field.nodes[0]
+          base, power = power_base_intent(sub_sup)
+          base, power = power_or_base_intent(sub_sup) unless base || power
+          naryand = node_value(field.nodes[1], "naryand")
+          field["intent"] = ":#{intent_name}(#{base},#{power},#{naryand})"
+          field
+        end
+        # Naryand intent end
+
+        # SubSup intent begin
+        def power_base_intent(field)
+          return nil unless ["munderover", "msubsup"].include?(field.name)
+
+          base = node_value(field.nodes[1], "l")
+          power = node_value(field.nodes[2], "h")
+          [base, power]
+        end
+
+        def power_or_base_intent(field)
+          value_node = field.nodes[1]
+          return nil unless SUP_TAGS.include?(field.name) || SUB_TAGS.include?(field.name)
+          return [nil, node_value(value_node, "h")] if SUP_TAGS.include?(field.name)
+
+          [node_value(value_node, "l"), nil]
+        end
+        # SubSup intent end
+
+        # Function intent begin
+        def function_intent(tag, intent_name = "function")
+          tag.attributes["intent"] = ":#{intent_name}"
+          tag
+        end
+        # Function intent end
+
+        # Binomial fraction intent begin
+        def binomial_fraction_intent(tag, intent_name)
+          numerator = node_value(tag.nodes[1].nodes[0], "t")
+          denominator = node_value(tag.nodes[1].nodes[1], "b")
+          tag["intent"] = "#{intent_name}(#{numerator},#{denominator})"
+          tag
+        end
+        # Binomial fraction intent end
+
+        # Interval fence intent begin
+        def interval_fence_intent(tag, intent_name)
+          return function_intent(tag, intent_name) if intent_name == "fenced"
+          return binomial_fraction_intent(tag, intent_name) if intent_name == "binomial-coefficient"
+
+          first_value = fence_node_value(tag.nodes[1], "a")
+          second_value = fence_node_value(tag.nodes[3], "b")
+          tag["intent"] = "#{intent_name}(#{first_value},#{second_value})"
+          tag
+        end
+        # Interval fence intent end
+
+        # Frac derivative intent begin
+        def frac_intent(tag, intent_name)
+          num = tag.nodes[0]
+          den = tag.nodes[1]
+          return partial_derivative(tag) if partial_derivative?(num, den)
+          return derivative(tag) if derivative?(num, den)
+
+          tag
+        end
+        # Frac derivative intent end
+
+        # Abs intent begin
+        def abs_intent(tag, intent_name)
+          tag["intent"] = "#{intent_name}(#{node_value(tag.nodes[1], 'a')})"
+          tag
+        end
+        # Abs intent end
+
+        private
+
+        def fence_node_value(tag, arg_name)
+          return node_value(tag, arg_name) unless infty_nodes?(tag&.nodes)
+
+          first_node = html_entity_to_unicode(tag.nodes.first.nodes.first)
+          last_node = html_entity_to_unicode(tag.nodes.last.nodes.first)
+          arg_name = "#{first_node}#{last_node}"
+          tag[:arg] = arg_name
+          arg_name
+        end
+
+        def infty_nodes?(nodes)
+          return unless nodes&.length == 2
+
+          ["&#x2212;", "-", "+"].include?(nodes&.first&.nodes&.first) &&
+            ["&#x221e;"].include?(nodes&.last&.nodes&.first)
+        end
+
+        def valid_node_value?(node)
+          INTENT_TEXT_NODES.include?(node.name) ||
+            node.name == "mrow" && node.nodes.empty?
+        end
+
+        # Frac Partial derivative intent begin
+        # num == numerator && den == denominator
+        def partial_derivative?(num, den)
+          validate_field_and_value(num) &&
+            validate_field_and_value(den)
+        end
+
+        def validate_field_and_value(node, parent_node = nil)
+          case node.name
+          when "mo"
+            node.nodes[0] == "&#x2202;"
+          when "mrow"
+            validate_field_and_value(node.nodes[0], node)
+          when "msup", "msubsup"
+            if validate_field_and_value(node.nodes[0], parent_node)
+              wrap_in_mrow(parent_node) if parent_node
+              true
+            end
+          end
+        end
+
+        def find_power_base_nodes(node)
+          return node.nodes[1] if %w[msup msubsup].include?(node&.name)
+
+          found_node = node.nodes.find { |node| %w[msup msubsup].include?(node&.name) }
+          return unless found_node
+
+          found_node&.nodes[1]
+        end
+
+        def partial_derivative(node)
+          intent = "(#{partial_arg(node)},#{f_arg(node&.nodes[0])},#{den_arg(node&.nodes[1])})"
+          node["intent"] = ":partial-derivative#{intent}"
+          node
+        end
+
+        def f_arg(node)
+          nodes = node&.nodes[1..-1]
+          all_m_tags = nodes&.all? { |element| element.name == "mi" }
+          return insert_f_arg(node, nodes) unless all_m_tags
+
+          nodes&.first&.nodes&.first
+        end
+
+        def insert_f_arg(node, nodes)
+          if !nodes.empty? && !%w[msup msubsup].include?(node.name)
+            mrow = ox_element("mrow", attributes: { arg: "$f" })
+            Plurimath.xml_engine.replace_nodes(
+              node,
+              [
+                node.nodes.first,
+                update_nodes(mrow, nodes),
+              ],
+            )
+          end
+          "$f"
+        end
+
+        def den_arg(node, nodes = [])
+          str = []
+          case node.name
+          when "mo" then str = extract_string(nodes[1..-1], str)
+          when "msup" then str = power_arg(node.nodes, str)
+          when "mrow" then str << den_arg(node.nodes.first, node.nodes)
+          end
+          str.join(",")
+        end
+
+        def power_arg(nodes, str)
+          nodes[0].each do |node|
+            next if node.nodes[0] == "&#x2202;"
+
+            str << html_entity_to_unicode(node.nodes[0])
+          end
+          str.last << nodes[1].nodes[0] if primes_constants.value?(nodes[1].nodes[0])
+          str
+        end
+
+        def wrap_in_mrow(node)
+          nodes = node&.nodes[1..-1]
+          return if nodes&.empty?
+
+          mrow = ox_element("mrow", attributes: { arg: "n" })
+          update_nodes(mrow, nodes)
+          replace_nodes = [node.nodes.first.xml_nodes, mrow.xml_nodes.nodes]
+          Plurimath.xml_engine.replace_nodes(node, replace_nodes.flatten)
+          node
+        end
+
+        def extract_string(nodes, str)
+          nodes.each do |node|
+            case node.name
+            when "mi"
+              str << html_entity_to_unicode(node.nodes.first)
+            when "msup", "msubsup"
+              str << html_entity_to_unicode(node.nodes.first.nodes.first)
+            end
+          end
+          str
+        end
+
+        def partial_arg(node)
+          found_node = find_power_base_nodes(node.nodes[0])
+          return "1" unless found_node
+
+          case found_node.name
+          when "mo", "mi", "mn"
+            html_entity_to_unicode(found_node.nodes.first)
+          else
+            "$n"
+          end
+        end
+        # Frac Partial derivative intent end
+
+        # Frac derivative intent begin
+        def derivative?(num, den)
+          return unless num || den
+
+          valid_derivative?(num) && valid_derivative?(den)
+        end
+
+        def valid_derivative?(node)
+          return node.nodes.first.match?(/(&#x214(6|5);)|^d$/) if INTENT_TEXT_NODES.include?(node.name)
+
+          node.nodes.first.name == "mi" &&
+            node.nodes.first.nodes.first.match?(/(&#x214(6|5);)|^d$/) &&
+            node.nodes.length >= 2
+        end
+
+        def derivative(node)
+          num = node.nodes[0]
+          den = node.nodes[1]
+          intent_name = ":derivative(1,#{num_arg(num)},#{derivative_den_arg(den)})"
+          node["intent"] = intent_name
+          node
+        end
+
+        def num_arg(num)
+          return "$f" if num.nodes.length <= 1
+
+          case num.nodes[1].name
+          when "mi", "mo", "mn"
+            num.nodes[1].nodes.first
+          else
+            num.nodes[1]["arg"] = "f"
+            "$f"
+          end
+        end
+
+        def derivative_den_arg(den)
+          return if den.nodes.length <= 1
+
+          den.nodes[1].nodes.first
+        end
+        # Frac derivative intent end
+
+        # Intent common but private begin
+        def all_numeric?(node)
+          return unless node.name == "mrow"
+
+          node.nodes.all? { |element| element.name == "mn" }
+        end
+
+        def all_numeric(node)
+          str = ""
+          node.nodes.each { |element| str += element.nodes.first }
+          str
+        end
+        # Intent common but private end
+      end
+    end
+  end
+end

data/lib/plurimath/utility.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "utility/intent_encoding"
 module Plurimath
   class Utility
     UNICODE_REGEX = %r{&#x[a-zA-Z0-9]+;}
@@ -758,11 +759,11 @@ module Plurimath
         end
       end
 
-      def validate_math_zone(object, lang:)
+      def validate_math_zone(object, lang:, intent: false)
         return false unless object
 
         if object.is_a?(Math::Formula)
-          filter_math_zone_values(object.value, lang: lang).find do |value|
+          filter_math_zone_values(object.value, lang: lang, intent: intent).find do |value|
             !(value.is_a?(Math::Function::Text) || value.is_a?(Math::Symbols::Symbol))
           end
         else
@@ -770,7 +771,7 @@ module Plurimath
         end
       end
 
-      def filter_math_zone_values(value, lang:)
+      def filter_math_zone_values(value, lang:, intent: false)
         return [] if value&.empty?
 
         new_arr = []
@@ -780,7 +781,7 @@ module Plurimath
           object = obj.dup
           next if index == skip_index
           if TEXT_CLASSES.include?(object.class_name) || math_display_text_objects(object)
-            next temp_array << (object.is_a?(Math::Symbols::Symbol) ? symbol_to_text(object, lang: lang) : object.value)
+            next temp_array << (object.is_a?(Math::Symbols::Symbol) ? symbol_to_text(object, lang: lang, intent: intent) : object.value)
           end
 
           new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
@@ -791,14 +792,14 @@ module Plurimath
         new_arr
       end
 
-      def symbol_to_text(symbol, lang:)
+      def symbol_to_text(symbol, lang:, intent: false)
         case lang
         when :asciimath
           symbol.to_asciimath
         when :latex
           symbol.to_latex
         when :mathml
-          symbol.to_mathml_without_math_tag.nodes.first
+          symbol.to_mathml_without_math_tag(intent).nodes.first
         when :omml
           symbol.to_omml_without_math_tag(true)
         when :unicodemath

data/lib/plurimath/version.rb

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

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

@@ -83,7 +83,9 @@ module Plurimath
         end
 
         def replace_nodes(nodes_array)
-          xml_nodes.nodes.replace(nodes_array)
+          xml_nodes.nodes.replace(
+            nodes_array.all?(Element) ? nodes_array.map(&:xml_nodes) : nodes_array
+          )
         end
 
         def is_xml_comment?