plurimath 0.7.1 → 0.8.0

data/lib/plurimath/math/function/table.rb

@@ -46,8 +46,8 @@ module Plurimath
           return norm_table(table_tag) if open_paren == "norm["
 
           if present?(open_paren) || present?(close_paren)
-            first_paren = Utility.ox_element("mo") << mathml_parenthesis(open_paren)
-            second_paren = Utility.ox_element("mo") << mathml_parenthesis(close_paren)
+            first_paren = mo_element(mathml_parenthesis(open_paren))
+            second_paren = mo_element(mathml_parenthesis(close_paren))
             mrow_tag = Utility.ox_element("mrow")
             return Utility.update_nodes(mrow_tag, [first_paren, table_tag, second_paren])
           end
@@ -72,7 +72,7 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          ox_table = if value.map { |d| d.parameter_one.length == 1 }.all?
+          ox_table = if single_table?
                        single_td_table(display_style)
                      else
                        multiple_td_table(display_style)
@@ -80,6 +80,14 @@ module Plurimath
           fenced_table(ox_table)
         end
 
+        def to_unicodemath
+          if unicodemath_table_class?
+            "#{unicodemath_class_name}(#{value.map(&:to_unicodemath).join("@")})"
+          else
+            "#{open_paren}■(#{value.map(&:to_unicodemath).join("@")})#{close_paren}"
+          end
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           [
             "#{spacing}\"table\" function apply\n",
@@ -115,7 +123,7 @@ module Plurimath
         end
 
         def mathml_parenthesis(field)
-          return "" if field&.include?(":")
+          return "" if field&.include?(":") || validate_paren(field)
 
           present?(field) ? field : ""
         end
@@ -235,13 +243,12 @@ module Plurimath
         end
 
         def norm_table(table_tag)
-          mo_tag = Utility.ox_element("mo") << "&#x2225;"
           Utility.update_nodes(
             Utility.ox_element("mrow"),
             [
-              mo_tag,
+              mo_element("&#x2016;"),
               table_tag,
-              mo_tag,
+              mo_element("&#x2016;"),
             ],
           )
         end
@@ -284,6 +291,50 @@ module Plurimath
         def parentheless_table
           "{:#{value.map(&:to_asciimath).join(", ")}:}"
         end
+
+        def single_table?
+          value.map { |d| d.parameter_one.length == 1 }.all? &&
+            nil_option?(:frame) &&
+            nil_option?(:columnlines) &&
+            nil_option?(:rowlines)
+        end
+
+        def nil_option?(option)
+          options[option].nil? ||
+            options[option] == "" ||
+            options[option] == "none"
+        end
+
+        def validate_paren(paren)
+          ["&#x3016;", "&#x3017;"].include?(paren)
+        end
+
+        def mo_element(value)
+          Utility.ox_element("mo") << value
+        end
+
+        def unicodemath_table_class?
+          return unless class_name == "table"
+          return if open_paren.nil? && close_paren.nil?
+
+          (!(open_paren.nil? || open_paren.empty?) && !(close_paren.nil? || close_paren.empty?)) ||
+            Utility::PARENTHESIS[open_paren&.to_sym] == close_paren ||
+            (open_paren.include?("|") && close_paren.include?("|"))
+        end
+
+        def unicodemath_class_name
+          return matrices_functions(:Vmatrix) if class_name == "vmatrix" && open_paren == "norm["
+          return matrices_functions(:vmatrix) if open_paren == "|" && close_paren == "|"
+          return matrices_functions(:matrix) if class_name == "Bmatrix" && open_paren == "{"
+          return unless unicodemath_table_class?
+
+          matrix_name = UnicodeMath::Constants::PARENTHESIS_MATRICES.key(open_paren)
+          matrices_functions(matrix_name)
+        end
+
+        def matrices_functions(matrix_name)
+          UnicodeMath::Constants::MATRIXS[matrix_name]
+        end
       end
     end
   end

data/lib/plurimath/math/function/td.rb

@@ -6,6 +6,11 @@ module Plurimath
   module Math
     module Function
       class Td < BinaryFunction
+        def initialize(parameter_one = nil, parameter_two = nil)
+          parameter_one&.delete_if { |td| td == "&" }
+          super(parameter_one, parameter_two)
+        end
+
         def to_asciimath
           parameter_one.map(&:to_asciimath).join(" ")
         end
@@ -40,6 +45,10 @@ module Plurimath
           [me]
         end
 
+        def to_unicodemath
+          parameter_one&.map(&:to_unicodemath)&.join
+        end
+
         def to_asciimath_math_zone(spacing, last = false, _)
           [
             "#{spacing}\"td\" function apply\n",

data/lib/plurimath/math/function/ternary_function.rb

@@ -125,7 +125,7 @@ module Plurimath
 
         def ascii_wrap(field)
           asciimath = field.to_asciimath
-          return latex if ["obrace", "ubrace"].include?(field.class_name)
+          return asciimath if ["obrace", "ubrace"].include?(field.class_name)
 
           case field
           when Formula || field.class.name.include?("Function")
@@ -180,6 +180,19 @@ module Plurimath
 
           Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style)
         end
+
+        def naryand_value(field)
+          return "" unless field
+
+          field_value = field.to_unicodemath
+          field.is_a?(Math::Function::Fenced) ? "▒#{field_value}" : "▒〖#{field_value}〗"
+        end
+
+        def prime_unicode?(field)
+          return unless field.is_a?(Math::Symbol)
+
+          UnicodeMath::Constants::PREFIXED_PRIMES.any? { |prefix, prime| field.value.include?(prime) || field.value.include?("'") }
+        end
       end
     end
   end

data/lib/plurimath/math/function/text.rb

@@ -35,6 +35,12 @@ module Plurimath
           [text]
         end
 
+        def to_unicodemath
+          return unless value
+
+          value&.start_with?("\\") ? value : "\"#{(Utility.html_entity_to_unicode(value))}\""
+        end
+
         def insert_t_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
           Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style))

data/lib/plurimath/math/function/tilde.rb

@@ -36,6 +36,10 @@ module Plurimath
           false
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̃"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

data/lib/plurimath/math/function/tr.rb

@@ -6,6 +6,11 @@ module Plurimath
   module Math
     module Function
       class Tr < UnaryFunction
+        def initialize(parameter_one = [])
+          parameter_one.map!.with_index { |_, index| Td.new([]) } if parameter_one&.all?("@")
+          super(parameter_one)
+        end
+
         def to_asciimath
           "[#{parameter_one.map(&:to_asciimath).join(', ')}]"
         end
@@ -45,6 +50,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          parameter_one&.map(&:to_unicodemath)&.join("&")
+        end
+
         def to_asciimath_math_zone(spacing, last = false, indent = true)
           [
             "#{spacing}\"tr\" function apply\n",

data/lib/plurimath/math/function/ubrace.rb

@@ -57,6 +57,11 @@ module Plurimath
           Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
 
+        def to_unicodemath
+          first_value = "(#{parameter_one&.to_unicodemath})" if parameter_one
+          "⏟#{first_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           obj.update(Utility.filter_values(obj.value)) if obj.value_exist?

data/lib/plurimath/math/function/ul.rb

@@ -49,6 +49,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "▁#{unicodemath_parens(parameter_one)}"
+        end
+
         def class_name
           "underline"
         end

data/lib/plurimath/math/function/unary_function.rb

@@ -64,6 +64,10 @@ module Plurimath
           Array(value)
         end
 
+        def to_unicodemath
+          "#{class_name}⁡#{parameter_one&.to_unicodemath}"
+        end
+
         def to_asciimath_math_zone(spacing, last = false, _)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [

data/lib/plurimath/math/function/underover.rb

@@ -47,6 +47,12 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          sub_value = "┬#{unicodemath_parens(parameter_two)}" if parameter_two
+          sup_value = "┴#{unicodemath_parens(parameter_three)}" if parameter_three
+          "#{parameter_one&.to_unicodemath}#{sub_value}#{sup_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -67,6 +73,14 @@ module Plurimath
             self.parameter_three = nil
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_one, parameter_two, parameter_three, fourth_value, { type: "undOvr" })
+        end
+
+        def is_nary_function?
+          parameter_one.is_nary_function? || parameter_one.is_nary_symbol?
+        end
       end
     end
   end

data/lib/plurimath/math/function/underset.rb

@@ -6,18 +6,27 @@ module Plurimath
   module Math
     module Function
       class Underset < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "underscript",
           first_value: "underscript value",
           second_value: "base expression",
         }.freeze
 
+        def initialize(
+          parameter_one = nil,
+          parameter_two = nil,
+          options = {})
+          super(parameter_one, parameter_two)
+          @options = options unless options.empty?
+        end
+
         def to_mathml_without_math_tag
           value_array = [
             validate_mathml_fields(parameter_two),
             validate_mathml_fields(parameter_one),
           ]
-          Utility.update_nodes(ox_element("munder"), value_array)
+          Utility.update_nodes(ox_element("munder", attributes: options), value_array)
         end
 
         def to_omml_without_math_tag(display_style)
@@ -40,6 +49,18 @@ module Plurimath
           [limlow]
         end
 
+        def to_unicodemath
+          if horizontal_brackets?
+            "#{parameter_one.to_unicodemath}#{unicodemath_parens(parameter_two)}"
+          elsif unicode_classes_accent?(parameter_two)
+            "#{parameter_two.to_unicodemath}_#{unicodemath_parens(parameter_one)}"
+          elsif unicode_accent?
+            "#{unicodemath_parens(parameter_two)}#{parameter_one.value}"
+          else
+            "#{unicodemath_parens(parameter_two)}┬#{parameter_one.to_unicodemath}"
+          end
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -53,6 +74,33 @@ module Plurimath
             obj.update(self.class.new(nil, Utility.filter_values(obj.value)))
           end
         end
+
+        def new_nary_function(fourth_value)
+          Nary.new(parameter_two, parameter_one, nil, fourth_value, { type: "undOvr" })
+        end
+
+        def is_nary_function?
+          parameter_two.is_nary_function? || parameter_two.is_nary_symbol?
+        end
+
+        protected
+
+        def unicode_accent?
+          parameter_one.is_a?(Math::Symbol) &&
+            (
+              UnicodeMath::Constants::DIACRITIC_BELOWS.include?(parameter_one.value) ||
+                UnicodeMath::Constants::ACCENT_SYMBOLS.has_value?(parameter_one.value)
+            )
+        end
+
+        def horizontal_brackets?
+          parameter_one.is_a?(Math::Symbol) &&
+            UnicodeMath::Constants::HORIZONTAL_BRACKETS.value?(parameter_one.value)
+        end
+
+        def unicode_classes_accent?(field)
+          (field.is_a?(Math::Function::Obrace) || field.is_a?(Math::Function::Ubrace))
+        end
       end
     end
   end

data/lib/plurimath/math/function/vec.rb

@@ -37,6 +37,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}⃗"
+        end
+
         def to_asciimath_math_zone(spacing, last = false, _)
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [

data/lib/plurimath/math/number.rb

@@ -3,14 +3,19 @@
 module Plurimath
   module Math
     class Number < Core
-      attr_accessor :value
+      attr_accessor :value, :mini_sub_sized, :mini_sup_sized
 
-      def initialize(value)
+      def initialize(value, mini_sub_sized: false, mini_sup_sized: false)
         @value = value.is_a?(Parslet::Slice) ? value.to_s : value
+        @mini_sub_sized = mini_sub_sized if mini_sub_sized
+        @mini_sup_sized = mini_sup_sized if mini_sup_sized
       end
 
       def ==(object)
-        object.respond_to?(:value) && object.value == value
+        object.respond_to?(:value) &&
+          object.value == value &&
+          object.mini_sub_sized == mini_sub_sized &&
+          object.mini_sup_sized == mini_sup_sized
       end
 
       def to_asciimath
@@ -33,6 +38,13 @@ module Plurimath
         [t_tag]
       end
 
+      def to_unicodemath
+        return mini_sub if mini_sub_sized
+        return mini_sup if mini_sup_sized
+
+        value
+      end
+
       def insert_t_tag(_)
         [
           (Utility.ox_element("r", namespace: "m") << t_tag),
@@ -54,6 +66,24 @@ module Plurimath
       def validate_function_formula
         false
       end
+
+      def mini_sized?
+        mini_sub_sized || mini_sup_sized
+      end
+
+      protected
+
+      def mini_sub
+        unicode_const(:SUB_DIGITS)[value.to_sym]
+      end
+
+      def mini_sup
+        unicode_const(:SUP_DIGITS)[value.to_sym]
+      end
+
+      def unicode_const(const)
+        UnicodeMath::Constants.const_get(const)
+      end
     end
   end
 end

data/lib/plurimath/math/symbol.rb

@@ -3,14 +3,27 @@
 module Plurimath
   module Math
     class Symbol < Core
-      attr_accessor :value
+      attr_accessor :value, :slashed, :mini_sub_sized, :mini_sup_sized, :options
 
-      def initialize(sym = nil)
+      def initialize(sym = nil,
+                     slashed = nil,
+                     mini_sub_sized: false,
+                     mini_sup_sized: false,
+                     options: {})
         @value = sym.is_a?(Parslet::Slice) ? sym.to_s : sym
+        @slashed = slashed if slashed
+        @mini_sub_sized = mini_sub_sized if mini_sub_sized
+        @mini_sup_sized = mini_sup_sized if mini_sup_sized
+        @options = options unless options.empty?
       end
 
       def ==(object)
-        object.respond_to?(:value) && object.value == value
+        object.respond_to?(:value) &&
+          object.value == value &&
+          object.slashed == slashed &&
+          object.mini_sub_sized == mini_sub_sized &&
+          object.mini_sup_sized == mini_sup_sized &&
+          object.options == options
       end
 
       def to_asciimath
@@ -60,6 +73,14 @@ module Plurimath
         value
       end
 
+      def to_unicodemath
+        return "\\#{value}" if slashed || special_chars
+        return mini_sub if mini_sub_sized
+        return mini_sup if mini_sup_sized
+
+        value
+      end
+
       def insert_t_tag(_)
         [(Utility.ox_element("r", namespace: "m") << t_tag)]
       end
@@ -104,6 +125,25 @@ module Plurimath
         value == "\\\\"
       end
 
+      def is_nary_symbol?
+        %w[
+          &#x222c;
+          &#x222d;
+          &#x222f;
+          &#x2230;
+          &#x2232;
+          &#x2233;
+          &#x2231;
+          &#x2229;
+          &#x222a;
+          &#x2210;
+        ].include?(value)
+      end
+
+      def mini_sized?
+        mini_sub_sized || mini_sup_sized
+      end
+
       private
 
       def operator?(unicode)
@@ -114,6 +154,7 @@ module Plurimath
 
       def explicit_checks(unicode)
         return true if [unicode, value].any? { |v| ["∣", "|"].include?(v) }
+        return true if unicode_const(:ACCENT_SYMBOLS).has_value?(value)
       end
 
       def specific_values
@@ -123,6 +164,30 @@ module Plurimath
 
         return "\\operatorname{if}" if value == "if"
       end
+
+      def mini_sub
+        unicode_const(:SUB_ALPHABETS)[value.to_sym] ||
+          unicode_const(:SUB_OPERATORS)[value.to_sym] ||
+          mini_sized_parenthesis(unicode_const(:SUB_PARENTHESIS))
+      end
+
+      def mini_sup
+        unicode_const(:SUP_ALPHABETS)[value.to_sym] ||
+          unicode_const(:SUP_OPERATORS)[value.to_sym] ||
+          mini_sized_parenthesis(unicode_const(:SUP_PARENTHESIS))
+      end
+
+      def unicode_const(const)
+        UnicodeMath::Constants.const_get(const)
+      end
+
+      def mini_sized_parenthesis(parens)
+        parens.values.find { |paren| paren.dig(value.to_sym) }&.dig(value.to_sym)
+      end
+
+      def special_chars
+        %w[& @ ^].include?(value)
+      end
     end
   end
 end

data/lib/plurimath/math.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative "unicode"
 require_relative "asciimath"
 require_relative "omml"
+require_relative "unicode_math"
 require_relative "mathml"
 require_relative "html"
 require_relative "latex"
@@ -14,6 +14,7 @@ require_relative "math/unicode"
 require_relative "math/formula"
 require_relative "math/function"
 require_relative "asciimath/parser"
+require_relative "unicode_math/parser"
 require_relative "mathml/parser"
 require_relative "latex/parser"
 require_relative "html/parser"
@@ -32,7 +33,7 @@ module Plurimath
       latex: Latex,
       mathml: Mathml,
       unitsml: Unitsml,
-      unicode: Unicode,
+      unicode: UnicodeMath,
       asciimath: Asciimath,
     }.freeze
 

data/lib/plurimath/mathml/constants.rb

@@ -372,6 +372,22 @@ module Plurimath
         "[",
         "]",
       ].freeze
+      SUPPORTED_FONT_STYLES = {
+        "sans-serif-bold-italic": Math::Function::FontStyle::SansSerifBoldItalic,
+        "sans-serif-italic": Math::Function::FontStyle::SansSerifItalic,
+        "bold-sans-serif": Math::Function::FontStyle::BoldSansSerif,
+        "double-struck": Math::Function::FontStyle::DoubleStruck,
+        "bold-fraktur": Math::Function::FontStyle::BoldFraktur,
+        "bold-italic": Math::Function::FontStyle::BoldItalic,
+        "bold-script": Math::Function::FontStyle::BoldScript,
+        "sans-serif": Math::Function::FontStyle::SansSerif,
+        monospace: Math::Function::FontStyle::Monospace,
+        fraktur: Math::Function::FontStyle::Fraktur,
+        normal: Math::Function::FontStyle::Normal,
+        script: Math::Function::FontStyle::Script,
+        italic: Math::Function::FontStyle::Italic,
+        bold: Math::Function::FontStyle::Bold,
+      }.freeze
     end
   end
 end

data/lib/plurimath/mathml/parser.rb

@@ -9,14 +9,26 @@ module Plurimath
 
       SUPPORTED_ATTRS = %w[
         linebreakstyle
+        linethickness
         columnlines
         mathvariant
         accentunder
+        separators
         linebreak
         mathcolor
         notation
+        bevelled
+        rowlines
         accent
+        height
+        frame
+        depth
+        height
+        width
+        index
         close
+        alt
+        src
         open
       ].freeze
 
@@ -27,13 +39,15 @@ module Plurimath
       def parse
         ox_nodes = Plurimath.xml_engine.load(text)
         display_style = ox_nodes&.locate("mstyle/@displaystyle")&.first
-        nodes = parse_nodes(ox_nodes.nodes)
+        nodes = parse_nodes(Array(ox_nodes))
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
           display_style: (display_style || true),
         )
       end
 
+      protected
+
       def parse_nodes(nodes)
         nodes.map do |node|
           next if Plurimath.xml_engine.is_xml_comment?(node)
@@ -43,7 +57,7 @@ module Plurimath
           elsif !node.attributes.empty?
             attrs_hash(node)
           else
-            { node.name.to_sym => parse_nodes(node.nodes) }
+            manage_tags(node)
           end
         end
       end
@@ -61,6 +75,32 @@ module Plurimath
           },
         }
       end
+
+      def manage_tags(node)
+        if node.name == "ms"
+          Plurimath::xml_engine.replace_nodes(
+            node,
+            ms_tag(comment_remove(node.nodes)).join(" "),
+          )
+        end
+        { node.name.to_sym => parse_nodes(node.nodes) }
+      end
+
+      def ms_tag(nodes)
+        return nodes if nodes.any?(String)
+
+        nodes.map do |node|
+          if node.nodes.any?(String)
+            node.nodes
+          else
+            ms_tag(node.nodes)
+          end
+        end
+      end
+
+      def comment_remove(nodes)
+        nodes.delete_if { |node| node.is_a?(Ox::Comment)  }
+      end
     end
   end
 end