plurimath 0.7.1 → 0.8.0

data/lib/plurimath/{unicode.rb → unicode_math.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Plurimath
-  class Unicode
+  class UnicodeMath
     attr_accessor :text
 
     def initialize(text)
@@ -9,7 +9,7 @@ module Plurimath
     end
 
     def to_formula
-      # TODO: Will be implemented soon
+      Parser.new(text).parse
     end
   end
 end

data/lib/plurimath/unitsml.rb

@@ -7,10 +7,23 @@ module Plurimath
 
     def initialize(text)
       @text = text
+      raise Math::ParseError.new(error_message) if text.match?(/\^(([^\s].*?[a-z]+)|(\([^-\d]+\)|[^\(\d-]+))/)
     end
 
     def to_formula
-      ::Unitsml.parse(text).to_plurimath
+      formula = ::Unitsml.parse(text).to_plurimath
+      formula.unitsml = true
+      formula.input_string = text
+      formula
+    end
+
+    def error_message
+      <<~MESSAGE
+       [plurimath] Invalid formula `#{@text}`.
+       [plurimath] The use of a variable as an exponent is not valid.
+       [plurimath] If this is a bug, please report the formula at our issue tracker at:
+       [plurimath] https://github.com/plurimath/plurimath/issues
+      MESSAGE
     end
   end
 end

data/lib/plurimath/utility.rb

@@ -11,11 +11,17 @@ module Plurimath
       "bold-fraktur": Math::Function::FontStyle::BoldFraktur,
       "bold-italic": Math::Function::FontStyle::BoldItalic,
       "bold-script": Math::Function::FontStyle::BoldScript,
+      mbfitsans: Math::Function::FontStyle::SansSerifBoldItalic,
       monospace: Math::Function::FontStyle::Monospace,
       mathfrak: Math::Function::FontStyle::Fraktur,
+      mitsans: Math::Function::FontStyle::SansSerifItalic,
+      mbfsans: Math::Function::FontStyle::BoldSansSerif,
+      mbffrak: Math::Function::FontStyle::BoldFraktur,
       mathcal: Math::Function::FontStyle::Script,
       fraktur: Math::Function::FontStyle::Fraktur,
+      mbfscr: Math::Function::FontStyle::BoldScript,
       mathbb: Math::Function::FontStyle::DoubleStruck,
+      double: Math::Function::FontStyle::DoubleStruck,
       mathtt: Math::Function::FontStyle::Monospace,
       mathsf: Math::Function::FontStyle::SansSerif,
       mathrm: Math::Function::FontStyle::Normal,
@@ -26,9 +32,18 @@ module Plurimath
       textbf: Math::Function::FontStyle::Bold,
       script: Math::Function::FontStyle::Script,
       normal: Math::Function::FontStyle::Normal,
+      mbfit: Math::Function::FontStyle::BoldItalic,
+      msans: Math::Function::FontStyle::SansSerif,
+      mfrak: Math::Function::FontStyle::Fraktur,
+      mscr: Math::Function::FontStyle::Script,
       bold: Math::Function::FontStyle::Bold,
       bbb: Math::Function::FontStyle::DoubleStruck,
+      Bbb: Math::Function::FontStyle::DoubleStruck,
+      mtt: Math::Function::FontStyle::Monospace,
       cal: Math::Function::FontStyle::Script,
+      mit: Math::Function::FontStyle::Italic,
+      mup: Math::Function::FontStyle::Normal,
+      mbf: Math::Function::FontStyle::Bold,
       sf: Math::Function::FontStyle::SansSerif,
       tt: Math::Function::FontStyle::Monospace,
       fr: Math::Function::FontStyle::Fraktur,
@@ -103,6 +118,45 @@ module Plurimath
       number
       text
     ].freeze
+    TABLE_SUPPORTED_ATTRS = %i[
+      columnlines
+      rowlines
+      frame
+    ].freeze
+    MPADDED_ATTRS = %i[
+      height
+      depth
+      width
+    ].freeze
+    MGLYPH_ATTRS = %i[
+      height
+      width
+      index
+      alt
+      src
+    ].freeze
+    UNICODEMATH_MENCLOSE_FUNCTIONS = {
+      underline: "bottom",
+      underbar: "bottom",
+      longdiv: "longdiv",
+      xcancel: "updiagonalstrike downdiagonalstrike",
+      bcancel: "updiagonalstrike",
+      ellipse: "circle",
+      circle: "circle",
+      cancel: "downdiagonalstrike",
+      rrect: "roundedbox",
+      rect: "box",
+    }.freeze
+    MASK_CLASSES = {
+      1 => 'top',
+      2 => 'bottom',
+      4 => 'left',
+      8 => 'right',
+      16 => 'horizontalstrike',
+      32 => 'verticalstrike',
+      64 => 'downdiagonalstrike',
+      128 => 'updiagonalstrike'
+    }.freeze
 
     class << self
       def organize_table(array, column_align: nil, options: nil)
@@ -244,14 +298,23 @@ module Plurimath
       end
 
       def text_classes(text)
-        return nil if text&.empty?
+        return nil unless text
 
         text = filter_values(text) unless text.is_a?(String)
+        return text if text.is_a?(Math::Core)
+
         if text&.scan(/[[:digit:]]/)&.length == text&.length
           Math::Number.new(text)
         elsif text&.match?(/[a-zA-Z]/)
           Math::Function::Text.new(text)
         else
+          text = string_to_html_entity(text)
+                  .gsub("&#x26;", "&")
+                  .gsub("&#x3c;", "<")
+                  .gsub("&#x27;", "'")
+                  .gsub("&#xa0;", " ")
+                  .gsub("&#x3e;", ">")
+                  .gsub("&#xa;", "\n")
           Math::Symbol.new(text)
         end
       end
@@ -358,6 +421,29 @@ module Plurimath
             attr_is_accent(attrs, value)
           elsif attrs.key?(:linebreak)
             Math::Function::Linebreak.new(value.first, attrs)
+          elsif attrs.key?(:bevelled) || attrs.key?(:linethickness)
+            Math::Function::Frac.new(value[0], value[1], attrs)
+          elsif attrs.key?(:notation)
+            value << attrs
+          elsif attrs.key?(:separators)
+            fenced = Math::Function::Fenced.new(
+              symbol_object(attrs[:open] || "("),
+              value,
+              symbol_object(attrs[:close] || ")"),
+            )
+            fenced.options = { separators: attrs[:separators] }
+            fenced
+          elsif TABLE_SUPPORTED_ATTRS.any? { |atr| attrs.key?(atr) }
+            Math::Function::Table.new(value, nil, nil, attrs)
+          elsif MPADDED_ATTRS.any? { |atr| attrs.key?(atr) }
+            Math::Function::Mpadded.new(
+              filter_values(value),
+              attrs,
+            )
+          elsif MGLYPH_ATTRS.any? { |atr| attrs.key?(atr) }
+            Math::Function::Mglyph.new(
+              attrs,
+            )
           end
         elsif attrs.is_a?(Math::Core)
           attr_is_function(attrs, value)
@@ -374,9 +460,6 @@ module Plurimath
 
       def attr_is_function(attrs, value)
         case attrs
-        when Math::Function::Menclose
-          attrs.parameter_two = filter_values(value)
-          attrs
         when Math::Function::Fenced
           attrs.parameter_two = value.compact
           attrs
@@ -397,25 +480,40 @@ module Plurimath
       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 : filter_values(part_val[0])
-          second_value = part_val[1].empty? ? nil : filter_values(part_val[1])
+          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(
-              base_value,
-              first_value,
-              second_value,
+              filter_values(base_value),
+              filter_values(first_value),
+              filter_values(second_value),
             )
           end
         end
       end
 
-      def unfenced_value(object)
+      def nil_to_none_object(value)
+        return value unless value.any?(NilClass) || value.any? { |val| val.is_a?(Array) && val.empty? }
+
+        value.each.with_index do |val, index|
+          next unless val.nil? || val.is_a?(Array)
+
+          value[index] = Math::Function::None.new
+        end
+      end
+
+      def unfenced_value(object, paren_specific: false)
         case object
         when Math::Function::Fenced
-          filter_values(object.parameter_two)
+          if !paren_specific || (paren_specific && valid_paren?(object))
+            filter_values(object.parameter_two)
+          else
+            object
+          end
         when Array
           filter_values(object)
         else
@@ -423,6 +521,15 @@ module Plurimath
         end
       end
 
+      def valid_paren?(object)
+        object.parameter_one.value == "(" &&
+          object.parameter_three.value == ")" &&
+          !object.options.keys.any? { |k| [:open_paren, :close_paren].any?(k.to_sym) } &&
+          !object.parameter_one.mini_sup_sized &&
+          !object.parameter_three.mini_sub_sized &&
+          object.options.empty?
+      end
+
       def frac_values(object)
         case object
         when Math::Formula
@@ -600,6 +707,234 @@ module Plurimath
         new_arr << Math::Function::Text.new(temp_array.join(" ")) if temp_array.any?
         new_arr
       end
+
+      def unicode_accents(accents)
+        if accents.is_a?(Math::Function::BinaryFunction)
+          accents
+        else
+          if accents.any? { |acc| acc&.dig(:first_value)&.is_a?(Array) }
+            accent_value = accents.first[:first_value].pop
+            first_value = accents.first[:first_value]
+            accents.first[:first_value] = accent_value
+            Math::Formula.new(
+              first_value + [transform_accents(accents)]
+            )
+          else
+            transform_accents(accents)
+          end
+        end
+      end
+
+      def transform_accents(accents)
+        accents.reduce do |function, accent|
+          if function.is_a?(Hash)
+            if function[:prime_accent_symbols]
+              Math::Function::Power.new(
+                unfenced_value(accent_value(function, function: true), paren_specific: true),
+                accent_value(accent),
+              )
+            else
+              Math::Function::Overset.new(
+                accent_value(accent),
+                unfenced_value(accent_value(function, function: true), paren_specific: true),
+                { accent: true }
+              )
+            end
+          else
+            if accent[:prime_accent_symbols]
+              Math::Function::Power.new(
+                unfenced_value(function, paren_specific: true),
+                accent_value(accent),
+              )
+            else
+              Math::Function::Overset.new(
+                accent_value(accent),
+                unfenced_value(function, paren_specific: true),
+                { accent: true }
+              )
+            end
+          end
+        end
+      end
+
+      def accent_value(accent, function: false)
+        if accent[:accent_symbols]
+          Math::Symbol.new(UnicodeMath::Constants::ACCENT_SYMBOLS[accent[:accent_symbols].to_sym] || accent[:accent_symbols])
+        else
+          accent[:first_value] || filter_values(accent[:prime_accent_symbols])
+        end
+      end
+
+      def unicode_fractions(fractions)
+        frac_arr = UnicodeMath::Constants::UNICODE_FRACTIONS[fractions.to_sym]
+        Math::Function::Frac.new(
+          Math::Number.new(frac_arr.first.to_s, ),
+          Math::Number.new(frac_arr.last.to_s, ),
+          { displaystyle: false, unicodemath_fraction: true }
+        )
+      end
+
+      def fractions(numerator, denominator, options = nil)
+        frac_class = Math::Function::Frac
+        if denominator.is_a?(frac_class)
+          if denominator.parameter_one.is_a?(frac_class)
+            recursion_fraction(denominator, numerator, options)
+          else
+            denominator.parameter_one = frac_class.new(
+              unfenced_value(numerator, paren_specific: true),
+              unfenced_value(denominator.parameter_one, paren_specific: true),
+              options
+            )
+          end
+          denominator
+        else
+          frac_class.new(
+            unfenced_value(numerator, paren_specific: true),
+            unfenced_value(denominator, paren_specific: true),
+            options
+          )
+        end
+      end
+
+      def recursion_fraction(frac, numerator, options)
+        frac_class = Math::Function::Frac
+        new_numerator = frac.parameter_one
+        if new_numerator.is_a?(frac_class)
+          recursion_fraction(new_numerator, numerator, options)
+        else
+          frac.parameter_one = frac_class.new(
+            unfenced_value(numerator, paren_specific: true),
+            unfenced_value(frac.parameter_one, paren_specific: true),
+            options
+          )
+          frac
+        end
+      end
+
+      def recursive_sub(sub_script, sub_recursion)
+        base_class = Math::Function::Base
+        if sub_recursion.is_a?(base_class)
+          if sub_recursion.parameter_one.is_a?(base_class)
+            base_recursion(sub_script, sub_recursion)
+          else
+            sub_recursion.parameter_one = base_class.new(sub_script, sub_recursion.parameter_one)
+          end
+          sub_recursion
+        else
+          base_class.new(
+            sub_script,
+            sub_recursion,
+          )
+        end
+      end
+
+      def base_recursion(sub_script, sub_recursion)
+        base_class = Math::Function::Base
+        new_sub = sub_recursion.parameter_one
+        if new_sub.is_a?(base_class)
+          base_recursion(sub_script, new_sub)
+          sub_recursion
+        else
+          sub_recursion.parameter_one = base_class.new(sub_script, new_sub)
+          sub_recursion
+        end
+      end
+
+      def recursive_sup(sup_script, sup_recursion)
+        power_class = Math::Function::Power
+        if sup_recursion.is_a?(power_class)
+          if sup_recursion.parameter_one.is_a?(power_class)
+            sup_recursion(sup_script, sup_recursion)
+          else
+            sup_recursion.parameter_one = power_class.new(sup_script, sup_recursion.parameter_one)
+          end
+          sup_recursion
+        else
+          power_class.new(
+            sup_script,
+            sup_recursion,
+          )
+        end
+      end
+
+      def sup_recursion(sup_script, sup_recursion)
+        power_class = Math::Function::Power
+        new_sup = sup_recursion.parameter_one
+        if new_sup.is_a?(power_class)
+          sup_recursion(sup_script, new_sup)
+          sup_recursion
+        else
+          sup_recursion.parameter_one = power_class.new(sup_script, new_sup)
+          sup_recursion
+        end
+      end
+
+      def base_is_prime?(base)
+        UnicodeMath::Constants::PREFIXED_PRIMES.key(base.parameter_two.value) ||
+          (base.parameter_two.value == "&#x27;")
+      end
+
+      def base_is_sub_or_sup?(base)
+        if base.is_a?(Math::Formula)
+          base_is_sub_or_sup?(base.value.first)
+        elsif base.is_a?(Math::Function::Fenced)
+          base_is_sub_or_sup?(base.parameter_two.first)
+        elsif base.is_a?(Math::Symbol) || base.is_a?(Math::Number)
+          base.mini_sub_sized || base_mini_sup_sized
+        end
+      end
+
+      def identity_matrix(size)
+        matrix = Array.new(size) { Array.new(size, 0) }
+        size.times { |i| matrix[i][i] = 1 }
+        matrix.map do |tr|
+          tr.map.with_index do |td, i|
+            tr[i] = Math::Function::Td.new([Math::Number.new(td.to_s)])
+          end
+          Math::Function::Tr.new(tr)
+        end
+      end
+
+      def enclosure_attrs(mask)
+        raise "enclosure mask is not between 0 and 255" if (mask.nil? || mask < 0 || mask > 255)
+
+        ret = ""
+        unless mask.nil?
+          mask ^= 15
+          bin_mask = mask.to_s(2).reverse
+          classes = bin_mask.chars.each_with_index.map { |bit, i| MASK_CLASSES[2**i] if bit == '1' }.compact
+          ret = classes.join(' ')
+        end
+        ret
+      end
+
+      def notations_to_mask(notations)
+        mask = []
+        notations.split(" ").each { |notation| mask << MASK_CLASSES.key(notation) }
+        mask.inject(*:+)^15
+      end
+
+      def slashed_values(value)
+        decoded = HTMLEntities.new.decode(value)
+        if decoded.to_s.match?(/^\w+/)
+          Math::Function::Text.new("\\#{decoded}")
+        else
+          Math::Symbol.new(decoded, true)
+        end
+      end
+
+      def sequence_slashed_values(values)
+        values.each.with_index do |value, index|
+          decoded = HTMLEntities.new.decode(value.value)
+          slashed = if index == 0
+                      slashed_values(value.value)
+                    else
+                      decoded.match?(/[0-9]/) ? Math::Number.new(decoded) : Math::Symbol.new(decoded)
+                    end
+          values[index] = slashed
+        end
+        values
+      end
     end
   end
 end

data/lib/plurimath/version.rb

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

data/lib/plurimath/xml_engine/oga.rb

@@ -30,6 +30,11 @@ module Plurimath
           node = node.unwrap if node.respond_to? :unwrap
           node.is_a?(Comment)
         end
+
+        def replace_nodes(root, nodes)
+          root.unwrap.children = ::Oga::XML::NodeSet.new([::Oga::XML::Text.new(text: nodes)])
+          root
+        end
       end
 
       # Create API compatible with Ox, per Plurimath usage

data/lib/plurimath/xml_engine/ox.rb

@@ -23,6 +23,11 @@ module Plurimath
         def is_xml_comment?(node)
           node.is_a?(::Ox::Comment)
         end
+
+        def replace_nodes(root, nodes)
+          root.nodes.replace(Array(nodes))
+          root
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-19 00:00:00.000000000 Z
+date: 2024-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -48,6 +48,7 @@ files:
 - ".github/workflows/rake.yml"
 - ".github/workflows/release.yml"
 - ".gitignore"
+- ".gitmodules"
 - ".hound.yml"
 - ".rspec"
 - ".rspec-opal"
@@ -85,6 +86,7 @@ files:
 - lib/plurimath/math/function/arccos.rb
 - lib/plurimath/math/function/arcsin.rb
 - lib/plurimath/math/function/arctan.rb
+- lib/plurimath/math/function/arg.rb
 - lib/plurimath/math/function/bar.rb
 - lib/plurimath/math/function/base.rb
 - lib/plurimath/math/function/binary_function.rb
@@ -127,6 +129,7 @@ files:
 - lib/plurimath/math/function/hom.rb
 - lib/plurimath/math/function/inf.rb
 - lib/plurimath/math/function/int.rb
+- lib/plurimath/math/function/intent.rb
 - lib/plurimath/math/function/ker.rb
 - lib/plurimath/math/function/lcm.rb
 - lib/plurimath/math/function/left.rb
@@ -144,12 +147,17 @@ files:
 - lib/plurimath/math/function/mbox.rb
 - lib/plurimath/math/function/menclose.rb
 - lib/plurimath/math/function/merror.rb
+- lib/plurimath/math/function/mglyph.rb
 - lib/plurimath/math/function/min.rb
+- lib/plurimath/math/function/mlabeledtr.rb
 - lib/plurimath/math/function/mod.rb
+- lib/plurimath/math/function/mpadded.rb
+- lib/plurimath/math/function/ms.rb
 - 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/none.rb
 - lib/plurimath/math/function/norm.rb
 - lib/plurimath/math/function/obrace.rb
 - lib/plurimath/math/function/oint.rb
@@ -177,6 +185,8 @@ files:
 - lib/plurimath/math/function/table/align.rb
 - lib/plurimath/math/function/table/array.rb
 - lib/plurimath/math/function/table/bmatrix.rb
+- lib/plurimath/math/function/table/cases.rb
+- lib/plurimath/math/function/table/eqarray.rb
 - lib/plurimath/math/function/table/matrix.rb
 - lib/plurimath/math/function/table/multline.rb
 - lib/plurimath/math/function/table/pmatrix.rb
@@ -208,7 +218,17 @@ files:
 - lib/plurimath/setup/oga.rb
 - lib/plurimath/setup/opal.rb.erb
 - lib/plurimath/setup/ox.rb
-- lib/plurimath/unicode.rb
+- lib/plurimath/unicode_math.rb
+- lib/plurimath/unicode_math/constants.rb
+- lib/plurimath/unicode_math/parse.rb
+- lib/plurimath/unicode_math/parser.rb
+- lib/plurimath/unicode_math/parsing_rules/absence_rules.rb
+- lib/plurimath/unicode_math/parsing_rules/common_rules.rb
+- lib/plurimath/unicode_math/parsing_rules/constants_rules.rb
+- lib/plurimath/unicode_math/parsing_rules/helper.rb
+- lib/plurimath/unicode_math/parsing_rules/masked.rb
+- lib/plurimath/unicode_math/parsing_rules/sub_sup.rb
+- lib/plurimath/unicode_math/transform.rb
 - lib/plurimath/unitsml.rb
 - lib/plurimath/utility.rb
 - lib/plurimath/version.rb