plurimath 0.10.0 → 0.10.2

data/lib/plurimath/mathml/utility/formula_transformation.rb

@@ -4,29 +4,8 @@ module Plurimath
   class Mathml
     module Utility
       module FormulaTransformation
-        CONDITIONAL_COMMON_UNARY_FUNCTIONS = %w[
-          scarries
-          phantom
-          mpadded
-          merror
-        ].freeze
-
         private
 
-        def update_temp(value)
-          @temp_mathml_order = Array(value)
-        end
-
-        def update_temp_order(value, order_name)
-          update_temp(
-            replace_order_with_value(
-              Array(@temp_mathml_order),
-              Array(update_temp_mathml_values(value)),
-              order_name,
-            ),
-          )
-        end
-
         def filter_values(value, array_to_instance: false, replacing_order: true)
           return value unless value.is_a?(Array)
           return array_to_instance ? nil : value if value.empty?
@@ -39,7 +18,7 @@ module Plurimath
             if array_to_instance
               filter_values(value.first.value, array_to_instance: true)
             else
-              value.first.value
+              value.first
             end
           elsif value.is_a?(Array) && value.any?(Math::Formula::Mrow)
             value.each_with_index do |element, index|
@@ -116,11 +95,7 @@ module Plurimath
           value.each_with_index do |val, index|
             next unless val.is_a?(Math::Symbols::Symbol)
 
-            if val.temp_mathml_order&.any?
-              update_symbol(val, value, index)
-            else
-              value[index] = mathml_symbol_to_class(val.value)
-            end
+            value[index] = mathml_symbol_to_class(val.value) unless val.value.nil?
           end
           value
         end
@@ -132,74 +107,6 @@ module Plurimath
           )
         end
 
-        def replace_order_with_value(order, value, tag_name)
-          value_index = 0
-          value_array = Array(value)
-
-          order.each_with_object([]) do |item, result|
-            next result << item if item != tag_name
-            next if value_index >= value_array.length
-
-            result << value_array[value_index]
-            value_index += 1
-          end
-        end
-
-        def update_temp_mathml_values(value)
-          value.each_with_index do |element, index|
-            next unless element.respond_to?(:temp_mathml_order)
-
-            if element.symbol? && element.temp_mathml_order&.none?
-              value[index] = validate_symbols(element)
-            end
-
-            next unless element.temp_mathml_order&.any?
-
-            if element.is_ternary_function?
-              if element.is_a?(Math::Function::Multiscript)
-                multi = multiscript(element.clear_temp_order)
-                element.parameter_one = multi[0]
-                element.parameter_two = filter_values(Array(multi[1])[0])
-                element.parameter_three = filter_values(Array(multi[1])[1])
-              elsif first_element_is_ternary_function?(element)
-                new_element = ternary_element_from(element.temp_mathml_order)
-                new_element.parameter_one = filter_values(
-                  Array(element.temp_mathml_order.shift),
-                  array_to_instance: true,
-                )
-                new_element.parameter_two = filter_values(
-                  Array(element.temp_mathml_order.shift),
-                  array_to_instance: true,
-                )
-                value[index] = new_element
-              elsif first_element_is_binary_function?(element)
-                new_element = element.temp_mathml_order.shift
-                new_element.parameter_one = element.temp_mathml_order.shift
-                new_element.parameter_two = element.temp_mathml_order.shift
-                value[index] = new_element
-              elsif element.is_a?(Math::Function::PowerBase)
-                update_power_base_value(element)
-              else
-                element.parameter_one = element.temp_mathml_order.shift
-                element.parameter_two = element.temp_mathml_order.shift
-                element.parameter_three = element.temp_mathml_order.shift
-              end
-            elsif element.is_binary_function?
-              update_binary_function_value(element, value, index)
-            elsif element.is_unary?
-              element.parameter_one = update_unary_function(element)
-            elsif element.symbol? && symbol_updatable?(element)
-              update_symbol(element, value, index)
-            end
-          end
-          value
-        end
-
-        def validated_order(order, rejectable_array: nil)
-          rejectable_array ||= ["comment", "text"]
-          order.reject { |str| rejectable_array.include?(str) }
-        end
-
         def value_is_ternary_or_nary?(value)
           return if value.any?(String)
 
@@ -209,74 +116,6 @@ module Plurimath
             (!value.first.parameter_one.nil? || !value.first.parameter_two.nil?)
         end
 
-        def first_element_is_ternary_function?(element)
-          (
-            element.temp_mathml_order.first&.is_ternary_function? &&
-            !(
-              element.temp_mathml_order.first.is_a?(Math::Function::FontStyle) ||
-              element.temp_mathml_order.first.is_a?(Math::Function::Fenced)
-            )
-          ) ||
-            ternary_filtered_function?(element)
-        end
-
-        def first_element_is_binary_function?(element)
-          (
-            element.temp_mathml_order.first&.is_binary_function? &&
-            !element.temp_mathml_order.first.is_a?(Math::Function::FontStyle)
-          ) ||
-            binary_filtered_function?(element)
-        end
-
-        def binary_filtered_function?(element)
-          new_element = filter_values(
-            [element.temp_mathml_order.first],
-            array_to_instance: true,
-          )
-          new_element&.is_binary_function? && !new_element.all_values_exist?
-        end
-
-        def ternary_filtered_function?(element)
-          new_element = filter_values(
-            [element.temp_mathml_order.first],
-            array_to_instance: true,
-          )
-          new_element&.is_ternary_function? &&
-            !new_element.all_values_exist?
-        end
-
-        def ternary_element_from(order)
-          element = order.shift
-          return element if element.is_ternary_function?
-
-          filter_values([element], array_to_instance: true)
-        end
-
-        def period_to_dot(element, value, index)
-          return element unless element.is_a?(Math::Symbols::Period)
-
-          value[index] = Math::Function::Dot.new
-        end
-
-        def multiscript(value)
-          value.slice_before("mprescripts").map do |val|
-            base_value   = val.shift
-            val          = Plurimath::Utility.nil_to_none_object(val)
-            part_val     = val.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, array_to_instance: true),
-                filter_values(first_value, array_to_instance: true),
-                filter_values(second_value, array_to_instance: true),
-              )
-            end
-          end
-        end
-
         def ternary_naryable?(value)
           value.length == 2 &&
             value.first.is_a?(Math::Function::PowerBase) &&
@@ -294,184 +133,6 @@ module Plurimath
             value.first.is_a?(Math::Function::Power) &&
             value.first.parameter_one.is_nary_symbol?
         end
-
-        def update_power_base_value(element)
-          element.parameter_one = filter_values(
-            Array(element.temp_mathml_order.shift),
-            array_to_instance: true,
-          )
-          element.parameter_two = filter_values(
-            Array(element.temp_mathml_order.shift),
-            array_to_instance: true,
-          )
-          return unless element.is_a?(Math::Function::PowerBase)
-
-          element.parameter_three = filter_values(
-            Array(element.temp_mathml_order.shift),
-            array_to_instance: true,
-          )
-        end
-
-        def update_overset_value(element, value, index)
-          case element.temp_mathml_order[1].class_name
-          when "obrace", "ubrace"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = element.temp_mathml_order.shift
-          when "hat", "ddot"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = filter_values(
-              Array(element.temp_mathml_order.shift),
-              array_to_instance: true,
-            )
-            return unless element.respond_to?(:options)
-
-            new_element.attributes = element.options
-          when "period", "dot"
-            new_element = period_to_dot(
-              element.temp_mathml_order.pop,
-              value,
-              index,
-            )
-            new_element.parameter_one = filter_values(
-              Array(element.temp_mathml_order.shift),
-              array_to_instance: true,
-            )
-            new_element.attributes = element.options
-          when "bar"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = element.temp_mathml_order.shift
-          when "vec"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = filter_values(
-              Array(element.temp_mathml_order.shift),
-              array_to_instance: true,
-            )
-            new_element.attributes = element.options
-          when "ul", "underline"
-            element.temp_mathml_order.pop
-            new_element = Math::Function::Bar.new(
-              filter_values(
-                element.clear_temp_order,
-                array_to_instance: true,
-              ),
-              element.options,
-            )
-          when "tilde"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = filter_values(
-              element.clear_temp_order,
-              array_to_instance: true,
-            )
-            new_element.attributes = element.options
-          else
-            element.parameter_two = element.temp_mathml_order.shift
-            element.parameter_one = element.temp_mathml_order.shift
-          end
-          value[index] = new_element if new_element
-        end
-
-        def update_underset_value(element, value, index)
-          return if update_underset_first_temp_element(element, value, index)
-
-          case element.temp_mathml_order[1]&.class_name
-          when "obrace", "ubrace", "ul", "underline"
-            new_element = element.temp_mathml_order.pop
-            new_element.parameter_one = element.temp_mathml_order.shift
-          when "bar"
-            element.temp_mathml_order.pop
-            new_element = Math::Function::Ul.new(
-              filter_values(
-                element.clear_temp_order,
-                array_to_instance: true,
-              ),
-              element.options,
-            )
-          else
-            element.parameter_two = element.temp_mathml_order.shift
-            element.parameter_one = element.temp_mathml_order.shift
-          end
-          value[index] = new_element if new_element
-        end
-
-        def update_underset_first_temp_element(element, value, index)
-          case element.temp_mathml_order[0]
-          when Math::Function::Vec,
-              ->(block_element) { updatable_ternary_function?(block_element) }
-            new_element = element.temp_mathml_order.shift
-            new_element.parameter_one = element.temp_mathml_order.shift
-            value[index] = new_element
-            return unless new_element.is_a?(Math::Function::Vec)
-
-            new_element.attributes = element.options
-          end
-        end
-
-        def updatable_ternary_function?(element)
-          element.is_ternary_function? && !element.any_value_exist?
-        end
-
-        def update_binary_function_value(element, value, index)
-          case element
-          when Math::Function::Semantics, Math::Function::Stackrel
-            element.parameter_one = filter_values(
-              Array(element.clear_temp_order),
-              array_to_instance: true,
-            )
-          when Math::Function::Overset
-            update_overset_value(element, value, index)
-          when Math::Function::Underset
-            update_underset_value(element, value, index)
-          when Math::Function::Power, Math::Function::Base
-            update_power_base_value(element)
-          when Math::Function::Td
-            element.parameter_one = element.clear_temp_order
-          when Math::Function::Root
-            element.parameter_two = element.temp_mathml_order.shift
-            element.parameter_one = element.temp_mathml_order.shift
-          when Math::Function::Menclose
-            element.parameter_two = filter_values(
-              Array(element.clear_temp_order),
-              array_to_instance: true,
-            )
-          else
-            element.parameter_one = element.temp_mathml_order.shift
-            element.parameter_two = element.temp_mathml_order.shift
-          end
-        end
-
-        def update_unary_function(element)
-          case element.class_name
-          when *CONDITIONAL_COMMON_UNARY_FUNCTIONS
-            filter_values(
-              element.clear_temp_order,
-              array_to_instance: true,
-            )
-          when "sqrt"
-            element.temp_mathml_order.shift
-          else
-            element.clear_temp_order
-          end
-        end
-
-        def symbol_updatable?(element)
-          temp_element = element.temp_mathml_order.first
-          return false unless temp_element
-
-          temp_element.is_a?(Math::Function::FontStyle) ||
-            temp_element.is_a?(Math::Function::Linebreak)
-        end
-
-        def update_symbol(element, value, index)
-          new_element = element.temp_mathml_order.shift
-          case new_element
-          when Math::Function::FontStyle
-            new_element.parameter_one = validate_symbols(element)
-            value[index] = new_element
-          when Math::Function::Linebreak
-            new_element.parameter_one = validate_symbols(element)
-            value[index] = new_element
-          end
-        end
       end
     end
   end

data/lib/plurimath/mathml.rb

@@ -2,6 +2,11 @@
 
 module Plurimath
   class Mathml
+    autoload :Constants, "#{__dir__}/mathml/constants"
+    autoload :FormulaTransformation, "#{__dir__}/mathml/formula_transformation"
+    autoload :Parser, "#{__dir__}/mathml/parser"
+    autoload :Translator, "#{__dir__}/mathml/translator"
+
     attr_accessor :text
 
     def initialize(text)

data/lib/plurimath/number_formatter.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "bigdecimal"
-require_relative "formatter"
 
 module Plurimath
   class NumberFormatter

data/lib/plurimath/omml/parser.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "transform"
 module Plurimath
   class Omml
     class Parser
@@ -51,12 +50,16 @@ module Plurimath
           if node.is_a?(String)
             node == "​" ? nil : node
           elsif !node.attributes.empty?
-            {
-              node.name => {
-                attributes: node.attributes,
-                value: parse_nodes(node.nodes),
-              },
-            }
+            if node.attributes.key?("val")
+              { node.name => node.attributes["val"] }
+            else
+              {
+                node.name => {
+                  attributes: node.attributes,
+                  value: parse_nodes(node.nodes),
+                },
+              }
+            end
           else
             customize_tags(node) if CUSTOMIZABLE_TAGS.include?(node.name)
             { node.name => parse_nodes(node.nodes) }

data/lib/plurimath/omml/transform.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "parslet"
 module Plurimath
   class Omml
     class Transform < Parslet::Transform
@@ -110,8 +109,10 @@ module Plurimath
 
       rule(dPr: subtree(:dpr)) do
         flatten_dpr = dpr.flatten.compact
-        open_paren  = Utility.string_to_html_entity(flatten_dpr.find { |hash| hash[:begChr] }&.values&.first)
-        close_paren = Utility.string_to_html_entity(flatten_dpr.find { |hash| hash[:endChr] }&.values&.first)
+        beg_entry = flatten_dpr.find { |hash| hash[:begChr] }
+        end_entry = flatten_dpr.find { |hash| hash[:endChr] }
+        open_paren  = Utility.string_to_html_entity(beg_entry ? beg_entry.values.first : "(")
+        close_paren = Utility.string_to_html_entity(end_entry ? end_entry.values.first : ")")
         sep_chr     = flatten_dpr.find { |hash| hash[:sepChr] }
         open_paren_object = Utility.symbol_object(open_paren, lang: :omml) if open_paren && !open_paren.empty?
         close_paren_object = Utility.symbol_object(close_paren, lang: :omml) if close_paren && !close_paren.empty?
@@ -166,8 +167,17 @@ module Plurimath
         index = acc_value.index { |d| d[:chr] }
         acc_value[index] = chr_value
         Utility.unary_function_classes(acc_value, lang: :omml)
-        acc_value.first.attributes = { accent: true }
-        acc_value.first
+        first = acc_value.first
+        if first.is_a?(Math::Function::UnaryFunction)
+          first.attributes = { accent: true }
+          first
+        else
+          # chr resolved to a Symbol, wrap in Overset
+          Math::Function::Overset.new(
+            acc_value.last,
+            first,
+          )
+        end
       end
 
       rule(func: subtree(:func)) do
@@ -265,6 +275,8 @@ module Plurimath
           function_class.parameter_one = Utility.filter_values(lim.flatten.compact)
           function_class
         else
+          # OMML is parsed back into Overset's source argument order so the
+          # internal model stays format-neutral across conversion paths.
           Math::Function::Overset.new(
             first_value,
             lim_values[1],

data/lib/plurimath/omml.rb

@@ -2,6 +2,9 @@
 
 module Plurimath
   class Omml
+    autoload :Parser, "#{__dir__}/omml/parser"
+    autoload :Transform, "#{__dir__}/omml/transform"
+
     attr_accessor :text
 
     def initialize(text)

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

@@ -1,12 +1,11 @@
+# Preload Math namespace/core so symbol classes resolve correctly in Opal.
+require 'plurimath/math'
 require 'plurimath/math/core'
-require 'plurimath/math/function'
 require 'plurimath/math/symbols/symbol'
 require 'plurimath/math/symbols/paren'
 
 <% (
-     Dir[File.dirname(__dir__)+"/math/function/*.rb"] +
-     Dir[File.dirname(__dir__)+"/math/function/**/*.rb"] +
      Dir[File.dirname(__dir__)+"/math/symbols/**/*.rb"]
-   ).each do |f| %>
+   ).uniq.each do |f| %>
   require 'plurimath/<%= f.split("lib/plurimath").last.gsub(/.rb$/,'') %>'
 <% end %>

data/lib/plurimath/unicode_math/parse.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "parsing_rules/masked"
-require_relative "parsing_rules/sub_sup"
-require_relative "parsing_rules/common_rules"
-require_relative "parsing_rules/absence_rules"
-require_relative "parsing_rules/constants_rules"
 module Plurimath
   class UnicodeMath
     class Parse < Parslet::Parser

data/lib/plurimath/unicode_math/parser.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "parslet"
-require "parslet/convenience"
-require_relative "parse"
-require_relative "transform"
-require_relative "constants"
 module Plurimath
   class UnicodeMath
     class Parser
@@ -14,7 +9,7 @@ module Plurimath
 
       def initialize(text)
         text = pre_processing(text)
-        @text = HTMLEntities.new.encode(text, :hexadecimal)
+        @text = ::HTMLEntities.new.encode(text, :hexadecimal)
         @text = @text.gsub("&", "&")
         @text = @text.gsub(""", "\"")
         @text = @text.gsub(/⫷.*⫸/, "")

data/lib/plurimath/unicode_math/parsing_rules/absence_rules.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helper"
 module Plurimath
   class UnicodeMath
     module ParsingRules

data/lib/plurimath/unicode_math/parsing_rules/common_rules.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helper"
 module Plurimath
   class UnicodeMath
     module ParsingRules

data/lib/plurimath/unicode_math/parsing_rules/constants_rules.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helper"
 module Plurimath
   class UnicodeMath
     module ParsingRules

data/lib/plurimath/unicode_math/parsing_rules/masked.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helper"
 module Plurimath
   class UnicodeMath
     module ParsingRules

data/lib/plurimath/unicode_math/parsing_rules/sub_sup.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "helper"
 module Plurimath
   class UnicodeMath
     module ParsingRules

data/lib/plurimath/unicode_math/parsing_rules.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class UnicodeMath
+    module ParsingRules
+      autoload :AbsenceRules, "#{__dir__}/parsing_rules/absence_rules"
+      autoload :CommonRules, "#{__dir__}/parsing_rules/common_rules"
+      autoload :ConstantsRules, "#{__dir__}/parsing_rules/constants_rules"
+      autoload :Helper, "#{__dir__}/parsing_rules/helper"
+      autoload :Masked, "#{__dir__}/parsing_rules/masked"
+      autoload :SubSup, "#{__dir__}/parsing_rules/sub_sup"
+    end
+  end
+end

data/lib/plurimath/unicode_math.rb

@@ -2,6 +2,12 @@
 
 module Plurimath
   class UnicodeMath
+    autoload :Constants, "#{__dir__}/unicode_math/constants"
+    autoload :Parse, "#{__dir__}/unicode_math/parse"
+    autoload :Parser, "#{__dir__}/unicode_math/parser"
+    autoload :ParsingRules, "#{__dir__}/unicode_math/parsing_rules"
+    autoload :Transform, "#{__dir__}/unicode_math/transform"
+
     attr_accessor :text
 
     def initialize(text)

data/lib/plurimath/utility.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "utility/intent_encoding"
 module Plurimath
   class Utility
+    autoload :IntentEncoding, "#{__dir__}/utility/intent_encoding"
     UNICODE_REGEX = %r{&#x[a-zA-Z0-9]+;}
     FONT_STYLES = {
       "double-struck": Math::Function::FontStyle::DoubleStruck,

data/lib/plurimath/version.rb

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

data/lib/plurimath/xml_engine/oga.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-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
@@ -40,6 +34,12 @@ module Plurimath
           root
         end
       end
+
+      autoload :Document, "#{__dir__}/oga/document"
+      autoload :Wrapper, "#{__dir__}/oga/wrapper"
+      autoload :Element, "#{__dir__}/oga/element"
+      autoload :Dumper, "#{__dir__}/oga/dumper"
+      autoload :Node, "#{__dir__}/oga/node"
     end
   end
 end

data/lib/plurimath/xml_engine/ox_engine.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "plurimath/xml_engine"
-require "plurimath/xml_engine/ox_engine/element"
 require "ox"
 Ox.default_options = { encoding: "UTF-8" }
 
@@ -34,6 +32,8 @@ module Plurimath
           root
         end
       end
+
+      autoload :Element, "#{__dir__}/ox_engine/element"
     end
   end
 end