plurimath 0.8.16 → 0.8.18

data/lib/plurimath/mathml/utility.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+require_relative "utility/empty_defined_methods"
+require_relative "utility/formula_transformation"
+
+module Plurimath
+  class Mathml
+    module Utility
+      include EmptyDefinedMethods
+      include FormulaTransformation
+
+      attr_accessor :temp_mathml_order
+
+      def element_order=(value)
+        @temp_mathml_order = Array(validated_order(value))
+      end
+
+      def clear_temp_order
+        @temp_mathml_order.shift(@temp_mathml_order.count)
+      end
+
+      def mathvariant=(value)
+        return if value.nil? || value.empty?
+        return unless Plurimath::Utility::FONT_STYLES.key?(value.to_sym)
+
+        @temp_mathml_order = [
+          Plurimath::Utility::FONT_STYLES[value.to_sym].new(
+            nil,
+            value,
+          ),
+        ]
+      end
+
+      def accent=(value)
+        return if value.nil? || value.empty?
+
+        @options = Hash(@options).merge(accent: true)
+      end
+
+      def accentunder=(value)
+        return if value.nil? || value.empty?
+
+        @options = Hash(@options).merge(accentunder: true)
+      end
+
+      def bevelled=(value)
+        return if value.nil? || value.empty?
+
+        @options = (@options || {}).merge(bevelled: value)
+      end
+
+      def linebreak=(value)
+        return if value.nil? || value.empty?
+
+        @temp_mathml_order << Plurimath::Math::Function::Linebreak.new(
+          nil,
+          { linebreak: value },
+        )
+      end
+
+      def linebreakstyle=(value)
+        return if value.nil? || value.empty?
+
+        linebreak_object = @temp_mathml_order.find do |object|
+          object.is_a?(Math::Function::Linebreak)
+        end
+        linebreak_object.attributes[:linebreakstyle] = value if linebreak_object
+      end
+
+      def linethickness=(value)
+        return if value.nil? || value.empty?
+
+        @options = (@options || {}).merge(linethickness: value)
+      end
+
+      def notation=(value)
+        return if value.nil? || value.empty?
+
+        @parameter_one = value
+      end
+
+      def mi_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            validate_symbols(value),
+            "mi",
+          ),
+        )
+      end
+
+      def mo_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            validate_symbols(value),
+            "mo",
+          ),
+        )
+      end
+
+      def mn_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            value,
+            "mn",
+          ),
+        )
+      end
+
+      def ms_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            Array(value),
+            "ms",
+          ),
+        )
+      end
+
+      def mtext_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            Array(value),
+            "mtext",
+          ),
+        )
+      end
+
+      def mrow_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            filter_values(value, array_to_instance: true),
+            "mrow",
+          ),
+        )
+      end
+
+      def mstyle_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp(
+          replace_order_with_value(
+            @temp_mathml_order,
+            Array(value),
+            "mstyle",
+          ),
+        )
+      end
+
+      def mfrac_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mfrac")
+      end
+
+      def munderover_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "munderover")
+      end
+
+      def msubsup_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msubsup")
+      end
+
+      def munder_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "munder")
+      end
+
+      def mover_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mover")
+      end
+
+      def msup_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msup")
+      end
+
+      def msub_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msub")
+      end
+
+      def mtable_value=(value)
+        return if value.nil? || value.empty?
+
+        if respond_to?(:value)
+          self.value = replace_order_with_value(
+            self.value,
+            update_temp_mathml_values(value),
+            "mtable",
+          )
+        else
+          update_temp_order(value, "mtable")
+        end
+      end
+
+      def msqrt_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msqrt")
+      end
+
+      def mfenced_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mfenced")
+      end
+
+      def mroot_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mroot")
+      end
+
+      def msgroup_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msgroup")
+      end
+
+      def mscarries_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mscarries")
+      end
+
+      def msline_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msline")
+      end
+
+      def msrow_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "msrow")
+      end
+
+      def mspace_value=(value)
+        return if value.nil? || value.empty?
+
+        if value.first.linebreak
+          linebreak = Math::Function::Linebreak.new(
+            nil,
+            { linebreak: value.first.linebreak },
+          )
+          update_temp_order([linebreak], "mspace")
+        else
+          @temp_mathml_order&.delete("mspace")
+        end
+      end
+
+      def semantics_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "semantics")
+      end
+
+      def mstack_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mstack")
+      end
+
+      def merror_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "merror")
+      end
+
+      def mlongdiv_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mlongdiv")
+      end
+
+      def none_value=(_)
+        @temp_mathml_order&.delete("none")
+      end
+
+      def mscarry_value=(value)
+        return if value.nil? || value.empty?
+
+        @temp_mathml_order&.delete("mscarry")
+      end
+
+      def menclose_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "menclose")
+      end
+
+      def maligngroup_value=(_)
+        @temp_mathml_order&.delete("maligngroup")
+      end
+
+      def malignmark_value=(_)
+        @temp_mathml_order&.delete("malignmark")
+      end
+
+      def mpadded_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mpadded")
+      end
+
+      def mfraction_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mfraction")
+      end
+
+      def mlabeledtr_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mlabeledtr")
+      end
+
+      def mmultiscripts_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mmultiscripts")
+      end
+
+      def mphantom_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mphantom")
+      end
+
+      def mglyph_value=(value)
+        return if value.nil? || value.empty?
+
+        update_temp_order(value, "mglyph")
+      end
+    end
+  end
+end

data/lib/plurimath/mathml.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "math"
+
 module Plurimath
   class Mathml
     attr_accessor :text

data/lib/plurimath/unicode_math/transform.rb

@@ -1249,7 +1249,7 @@ module Plurimath
         color_obj = Math::Function::Color.new(
           Math::Symbols::Symbol.new(color),
           first_value,
-          { backcolor: true }
+          { backgroundcolor: true }
         )
       end
 
@@ -1258,7 +1258,7 @@ module Plurimath
         color_obj = Math::Function::Color.new(
           Math::Symbols::Symbol.new(color),
           Utility.filter_values(first_value),
-          { backcolor: true }
+          { backgroundcolor: true }
         )
       end
 

data/lib/plurimath/utility/intent_encoding.rb

@@ -19,21 +19,21 @@ module Plurimath
         # Intent common code end
 
         # Naryand intent begin
-        def naryand_intent(field, intent_name)
-          return nary_intent(field, intent_name) if field.name == "mrow"
+        def naryand_intent(field, intent_name, options)
+          return nary_intent(field, intent_name, options) 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["intent"] = "#{intent_name}(#{base},#{power})"
           field
         end
 
-        def nary_intent(field, intent_name)
+        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["intent"] = "#{intent_name}(#{base},#{power},#{naryand})"
           field
         end
         # Naryand intent end
@@ -57,14 +57,14 @@ module Plurimath
         # SubSup intent end
 
         # Function intent begin
-        def function_intent(tag, intent_name = "function")
-          tag.attributes["intent"] = ":#{intent_name}"
+        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)
+        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})"
@@ -73,30 +73,31 @@ module Plurimath
         # 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"
+        def interval_fence_intent(tag, intent_name, options)
+          intent = options[intent_name]
+          return function_intent(tag, intent, options) if intent_name == :fenced
+          return binomial_fraction_intent(tag, intent, options) 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["intent"] = "#{intent}(#{first_value},#{second_value})"
           tag
         end
         # Interval fence intent end
 
         # Frac derivative intent begin
-        def frac_intent(tag, intent_name)
+        def frac_intent(tag, _, options)
           num = tag.nodes[0]
           den = tag.nodes[1]
-          return partial_derivative(tag) if partial_derivative?(num, den)
-          return derivative(tag) if derivative?(num, den)
+          return partial_derivative(tag, options[:partial_derivative]) if partial_derivative?(num, den)
+          return derivative(tag, options[:derivative]) if derivative?(num, den)
 
           tag
         end
         # Frac derivative intent end
 
         # Abs intent begin
-        def abs_intent(tag, intent_name)
+        def abs_intent(tag, intent_name, _options)
           tag["intent"] = "#{intent_name}(#{node_value(tag.nodes[1], 'a')})"
           tag
         end
@@ -156,9 +157,9 @@ module Plurimath
           found_node&.nodes[1]
         end
 
-        def partial_derivative(node)
+        def partial_derivative(node, intent_name)
           intent = "(#{partial_arg(node)},#{f_arg(node&.nodes[0])},#{den_arg(node&.nodes[1])})"
-          node["intent"] = ":partial-derivative#{intent}"
+          node["intent"] = intent_name + intent
           node
         end
 
@@ -255,11 +256,10 @@ module Plurimath
             node.nodes.length >= 2
         end
 
-        def derivative(node)
+        def derivative(node, intent_name)
           num = node.nodes[0]
           den = node.nodes[1]
-          intent_name = ":derivative(1,#{num_arg(num)},#{derivative_den_arg(den)})"
-          node["intent"] = intent_name
+          node["intent"] = "#{intent_name}(1,#{num_arg(num)},#{derivative_den_arg(den)})"
           node
         end
 

data/lib/plurimath/utility.rb

@@ -171,7 +171,7 @@ module Plurimath
           if data&.separate_table
             table_row << Math::Function::Td.new(filter_table_data(table_data).compact)
             table_data = []
-            if data.linebreak
+            if data.linebreak?
               organize_tds(table_row.flatten, string_columns.dup, options)
               table << Math::Function::Tr.new(table_row)
               table_row = []
@@ -264,7 +264,7 @@ module Plurimath
         Math::Symbols::Paren.descendants
       end
 
-      def symbols_files 
+      def symbols_files
         Math::Symbols::Symbol.descendants
       end
 
@@ -342,11 +342,12 @@ module Plurimath
         ) << rpr_element(wi_tag: wi_tag)
       end
 
-      def filter_values(array)
+      def filter_values(array, new_formula: true)
         return array unless array.is_a?(Array) || array.is_a?(Math::Formula)
 
         array = array.is_a?(Math::Formula) ? array.value : array.flatten.compact
-        return Math::Formula.new(array) if array.length > 1
+        return Math::Formula.new(array) if array.length > 1 && new_formula
+        return array if array.length > 1 && !new_formula
 
         array.first
       end
@@ -552,25 +553,6 @@ module Plurimath
         end
       end
 
-      def multiscript(values)
-        values.slice_before("mprescripts").map do |value|
-          base_value   = value.shift
-          value        = nil_to_none_object(value)
-          part_val     = value.partition.with_index { |_, i| i.even? }
-          first_value  = part_val[0].empty? ? nil : part_val[0]
-          second_value = part_val[1].empty? ? nil : part_val[1]
-          if base_value.to_s.include?("mprescripts")
-            [first_value, second_value]
-          else
-            Math::Function::PowerBase.new(
-              filter_values(base_value),
-              filter_values(first_value),
-              filter_values(second_value),
-            )
-          end
-        end
-      end
-
       def nil_to_none_object(value)
         return value unless value.any?(NilClass) || value.any? { |val| val.is_a?(Array) && val.empty? }
 

data/lib/plurimath/version.rb

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

data/lib/plurimath.rb

@@ -1,14 +1,23 @@
 
 require_relative "plurimath/version"
+require "lutaml/model"
+require "mml/configuration"
+
+def mml_adapter(adapter)
+  Mml::Configuration.adapter = adapter unless Mml::Configuration.adapter
+end
 
 # Select an XML engine
 if RUBY_ENGINE == 'opal'
   require "plurimath/setup/oga"
   require "plurimath/setup/opal"
+  mml_adapter(:oga)
 elsif ENV['PLURIMATH_OGA']
   require "plurimath/setup/oga"
+  mml_adapter(:oga)
 else
   require "plurimath/setup/ox"
+  mml_adapter(:ox)
 end
 
 require "plurimath/math"

data/plurimath.gemspec

@@ -24,8 +24,10 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.add_dependency 'parslet'
-  spec.add_dependency 'thor'
   spec.add_dependency 'ox'
+  spec.add_dependency 'mml'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'parslet'
   spec.add_dependency 'bigdecimal'
+  spec.add_dependency 'lutaml-model'
 end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.8.16
+  version: 0.8.18
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-30 00:00:00.000000000 Z
+date: 2024-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ox
+  name: parslet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Converts LaTeX math into MathML.
 email:
 - open.source@ribose.com
@@ -95,6 +123,7 @@ files:
 - bin/console
 - bin/setup
 - exe/plurimath
+- intent_supported_classes.adoc
 - lib/plurimath.rb
 - lib/plurimath/asciimath.rb
 - lib/plurimath/asciimath/constants.rb
@@ -124,6 +153,8 @@ files:
 - lib/plurimath/math.rb
 - lib/plurimath/math/core.rb
 - lib/plurimath/math/formula.rb
+- lib/plurimath/math/formula/mrow.rb
+- lib/plurimath/math/formula/mstyle.rb
 - lib/plurimath/math/function.rb
 - lib/plurimath/math/function/abs.rb
 - lib/plurimath/math/function/arccos.rb
@@ -1713,7 +1744,9 @@ files:
 - lib/plurimath/mathml.rb
 - lib/plurimath/mathml/constants.rb
 - lib/plurimath/mathml/parser.rb
-- lib/plurimath/mathml/transform.rb
+- lib/plurimath/mathml/utility.rb
+- lib/plurimath/mathml/utility/empty_defined_methods.rb
+- lib/plurimath/mathml/utility/formula_transformation.rb
 - lib/plurimath/number_formatter.rb
 - lib/plurimath/omml.rb
 - lib/plurimath/omml/parser.rb