plurimath 0.3.9 → 0.4.2

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

@@ -51,6 +51,14 @@ module Plurimath
           "#{first_value}#{second_value}#{third_value}"
         end
 
+        def any_value_exist?
+          !(parameter_one.nil? || parameter_two.nil? || parameter_three.nil?)
+        end
+
+        def all_values_exist?
+          !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -104,8 +112,8 @@ module Plurimath
         def narypr(function_symbol, function_type: "undOvr")
           chr_arg     = { "m:val": function_symbol }
           limloc_arg  = { "m:val": function_type }
-          subhide_arg = { "m:val": "0" }
-          suphide_arg = { "m:val": "0" }
+          subhide_arg = { "m:val": parameter_one ? "0" : "1" }
+          suphide_arg = { "m:val": parameter_two ? "0" : "1" }
           chr_tag     = Utility.ox_element("chr", attributes: chr_arg, namespace: "m")
           limloc_tag  = Utility.ox_element("limLoc", attributes: limloc_arg, namespace: "m")
           subhide_tag = Utility.ox_element("subHide", attributes: subhide_arg, namespace: "m")
@@ -122,21 +130,17 @@ module Plurimath
           )
         end
 
-        def all_values_exist?
-          !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
-        end
-
         def validate_mathml_tag(parameter)
           return Array(Utility.ox_element("mrow")) unless parameter
 
           Array(parameter.to_mathml_without_math_tag)
         end
 
-        def underover
+        def underover(display_style)
           overset = Overset.new(parameter_one, parameter_three)
-          return overset unless parameter_two
+          return overset.to_omml_without_math_tag(display_style) unless parameter_two
 
-          Underset.new(overset, parameter_two)&.to_omml_without_math_tag
+          Underset.new(overset, parameter_two)&.to_omml_without_math_tag(display_style)
         end
       end
     end

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

@@ -27,15 +27,15 @@ module Plurimath
           parse_text("html") || parameter_one
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(_display_style)
           text = Utility.ox_element("t", namespace: "m")
           text << (parse_text("omml") || parameter_one)
           [text]
         end
 
-        def insert_t_tag
+        def insert_t_tag(display_style)
           r_tag = Utility.ox_element("r", namespace: "m")
-          Utility.update_nodes(r_tag, to_omml_without_math_tag)
+          Utility.update_nodes(r_tag, to_omml_without_math_tag(display_style))
           [r_tag]
         end
 
@@ -54,7 +54,8 @@ module Plurimath
           html_value = first_value(lang).dup
           html_value&.gsub!(PARSER_REGEX) do |_text|
             last_match = Regexp.last_match
-            if ["mathml", "html"].include?(lang)
+            case lang
+            when "mathml", "html"
               symbol_value(last_match[:unicode])
             else
               last_match[:unicode]
@@ -67,7 +68,7 @@ module Plurimath
           if lang == "omml"
             entities = HTMLEntities.new
             entities.encode(
-              entities.decode(parameter_one),
+              entities.decode(parameter_one&.gsub(/ /, "&#xa0;")),
               :named,
             )
           else

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

@@ -6,14 +6,39 @@ module Plurimath
   module Math
     module Function
       class Tilde < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
           mover = Utility.ox_element("mover")
+          mover.attributes.merge!({ accent: attributes[:accent]}) if attributes && attributes[:accent]
           first_value = (Utility.ox_element("mo") << "~")
           second_value = parameter_one.to_mathml_without_math_tag if parameter_one
           Utility.update_nodes(mover, [second_value, first_value])
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element("~", rpr_tag: false) unless parameter_one
+
+          if attributes && attributes[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new("~")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
+        end
+
+        def validate_function_formula
+          false
+        end
+
+        protected
+
+        def acc_tag(display_style)
           acc_tag    = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
           acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "˜" }))
@@ -21,7 +46,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [acc_tag]

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

@@ -31,8 +31,8 @@ module Plurimath
           "<tr>#{first_value}</tr>"
         end
 
-        def to_omml_without_math_tag
-          omml_content = parameter_one&.map(&:to_omml_without_math_tag)
+        def to_omml_without_math_tag(display_style)
+          omml_content = parameter_one&.map { |obj| obj.to_omml_without_math_tag(display_style) }
           if parameter_one.count.eql?(1)
             omml_content
           else

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

@@ -6,6 +6,18 @@ module Plurimath
   module Math
     module Function
       class Ubrace < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "ubrace#{first_value}"
+        end
+
         def to_latex
           first_value = "{#{parameter_one.to_latex}}" if parameter_one
           "\\underbrace#{first_value}"
@@ -13,13 +25,17 @@ module Plurimath
 
         def to_mathml_without_math_tag
           mo_tag = (Utility.ox_element("mo") << "&#x23df;")
-          if parameter_one
-            over_tag = Utility.ox_element("munder")
-            arr_value = mathml_value
-            Utility.update_nodes(over_tag, (arr_value << mo_tag))
-          else
-            mo_tag
-          end
+          return mo_tag unless parameter_one
+
+          over_tag = Utility.ox_element("munder")
+          over_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
+          Utility.update_nodes(
+            over_tag,
+            [
+              parameter_one.to_mathml_without_math_tag,
+              mo_tag,
+            ],
+          )
         end
 
         def tag_name
@@ -34,20 +50,11 @@ module Plurimath
           false
         end
 
-        def to_omml_without_math_tag
-          limlow   = Utility.ox_element("limLow", namespace: "m")
-          limlowpr = Utility.ox_element("limLowPr", namespace: "m")
-          limlowpr << Utility.pr_element("ctrl", true, namespace: "m")
-          lim = Utility.ox_element("lim", namespace: "m")
-          Utility.update_nodes(
-            limlow,
-            [
-              limlowpr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              Utility.update_nodes(lim, r_element("⏟")),
-            ],
-          )
-          [limlow]
+        def to_omml_without_math_tag(display_style)
+          return r_element("⏟", rpr_tag: false) unless parameter_one
+
+          symbol = Symbol.new("⏟")
+          Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
       end
 

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

@@ -6,36 +6,73 @@ module Plurimath
   module Math
     module Function
       class Ul < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
+        def to_asciimath
+          first_value = "(#{parameter_one.to_asciimath})" if parameter_one
+          "underline#{first_value}"
+        end
+
+        def to_latex
+          first_value = "{#{parameter_one.to_latex}}" if parameter_one
+          "\\underline#{first_value}"
+        end
+
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
+          mo_tag = Utility.ox_element("mo") << "&#x332;"
+          return mo_tag unless parameter_one
+
+          munder_tag = Utility.ox_element("munder")
+          munder_tag.attributes.merge!(attributes) if attributes && !attributes.empty?
           Utility.update_nodes(
-            Utility.ox_element("munder"),
+            munder_tag,
             [
-              first_value,
-              Utility.ox_element("mo") << "&#xaf;",
+              parameter_one&.to_mathml_without_math_tag,
+              mo_tag,
             ],
           )
         end
 
-        def to_omml_without_math_tag
-          bar    = Utility.ox_element("bar", namespace: "m")
-          barpr  = Utility.ox_element("barPr", namespace: "m")
-          barpr << Utility.pr_element("ctrl", true, namespace: "m")
-          me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value)
-          Utility.update_nodes(
-            bar,
-            [
-              barpr,
-              me,
-            ],
-          )
-          [bar]
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#x332;", rpr_tag: false) unless parameter_one
+
+          if attributes && attributes[:accentunder]
+            groupchr_tag(display_style)
+          else
+            symbol = Symbol.new("&#x332;")
+            Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
         end
 
         def class_name
           "underline"
         end
+
+        def swap_class
+          Bar.new(parameter_one, attributes)
+        end
+
+        protected
+
+        def groupchr_tag(display_style)
+          groupchr = Utility.ox_element("groupChr", namespace: "m")
+          groupchrpr = Utility.ox_element("groupChrPR", namespace: "m")
+          chr = Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "_" })
+          pos = Utility.ox_element("pos", namespace: "m", attributes: { "m:val": "bot" })
+          Utility.update_nodes(groupchrpr, [chr, pos])
+          Utility.update_nodes(
+            groupchr,
+            [
+              groupchrpr,
+              omml_parameter(parameter_one, display_style, tag_name: "e", namespace: "m"),
+            ],
+          )
+        end
       end
 
       Underline = Ul

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

@@ -39,8 +39,7 @@ module Plurimath
         end
 
         def to_latex
-          first_value = "{#{latex_value}}" if parameter_one
-          "\\#{class_name}#{first_value}"
+          "\\#{class_name}{#{latex_value}}"
         end
 
         def to_html
@@ -49,10 +48,12 @@ module Plurimath
                         elsif parameter_one
                           "<i>#{parameter_one.to_html}</i>"
                         end
-          "<i>#{class_name}</i>#{first_value}"
+        "<i>#{invert_unicode_symbols}</i>#{first_value}"
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element(class_name, rpr_tag: false) unless parameter_one
+
           func   = Utility.ox_element("func", namespace: "m")
           funcpr = Utility.ox_element("funcPr", namespace: "m")
           funcpr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -62,7 +63,7 @@ module Plurimath
           mt  = Utility.ox_element("t", namespace: "m") << class_name
           fname << Utility.update_nodes(mr, [rpr, mt])
           me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value) if parameter_one
+          Utility.update_nodes(me, omml_value(display_style)) if parameter_one
           Utility.update_nodes(
             func,
             [
@@ -76,6 +77,10 @@ module Plurimath
 
         protected
 
+        def invert_unicode_symbols
+          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+        end
+
         def asciimath_value
           return "" unless parameter_one
 
@@ -104,12 +109,12 @@ module Plurimath
           parameter_one&.to_latex
         end
 
-        def omml_value
+        def omml_value(display_style)
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map(&:insert_t_tag)
+            return parameter_one&.compact&.map { |obj| obj.insert_t_tag(display_style) }
           end
 
-          Array(parameter_one&.insert_t_tag)
+          Array(parameter_one&.insert_t_tag(display_style))
         end
       end
     end

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

@@ -35,16 +35,21 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
-          underover
+        def to_omml_without_math_tag(display_style)
+          if !display_style
+            power_base = PowerBase.new(parameter_one, parameter_two, parameter_three)
+            return power_base.to_omml_without_math_tag(display_style)
+          end
+
+          underover(display_style)
         end
 
-        def omml_nary_tag
+        def omml_nary_tag(display_style)
           pr = Utility.ox_element("naryPr", namespace: "m")
           [
             pr_element_value(pr),
-            omml_parameter(parameter_two, tag_name: "sub"),
-            omml_parameter(parameter_three, tag_name: "sup"),
+            omml_parameter(parameter_two, display_style, tag_name: "sub"),
+            omml_parameter(parameter_three, display_style, tag_name: "sup"),
           ]
         end
 

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

@@ -18,7 +18,12 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          if !display_style
+            base = Base.new(parameter_one, parameter_two)
+            return base.to_omml_without_math_tag(display_style)
+          end
+
           limlow   = Utility.ox_element("limLow", namespace: "m")
           limlowpr = Utility.ox_element("limLowPr", namespace: "m")
           limlowpr << Utility.pr_element("ctrl", true, namespace: "m")
@@ -26,8 +31,8 @@ module Plurimath
             limlow,
             [
               limlowpr,
-              omml_parameter(parameter_one, tag_name: "e"),
-              omml_parameter(parameter_two, tag_name: "lim"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
+              omml_parameter(parameter_two, display_style, tag_name: "lim"),
             ],
           )
           [limlow]

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

@@ -6,10 +6,19 @@ module Plurimath
   module Math
     module Function
       class Vec < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          super(parameter_one)
+          @attributes = attributes
+        end
+
         def to_mathml_without_math_tag
+          mover = Utility.ox_element("mover")
           first_value = parameter_one&.to_mathml_without_math_tag
+          mover.attributes.merge!({ accent: attributes[:accent] }) if attributes && attributes[:accent]
           Utility.update_nodes(
-            Utility.ox_element("mover"),
+            mover,
             [
               first_value,
               Utility.ox_element("mo") << "&#x2192;",
@@ -17,7 +26,20 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag
+        def to_omml_without_math_tag(display_style)
+          return r_element("&#x2192;", rpr_tag: false) unless parameter_one
+
+          if attributes && attributes[:accent]
+            acc_tag(display_style)
+          else
+            symbol = Symbol.new("→")
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+          end
+        end
+
+        protected
+
+        def acc_tag(display_style)
           acc_tag    = Utility.ox_element("acc", namespace: "m")
           acc_pr_tag = Utility.ox_element("accPr", namespace: "m")
           acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": "→" }))
@@ -25,7 +47,7 @@ module Plurimath
             acc_tag,
             [
               acc_pr_tag,
-              omml_parameter(parameter_one, tag_name: "e"),
+              omml_parameter(parameter_one, display_style, tag_name: "e"),
             ],
           )
           [acc_tag]

data/lib/plurimath/math/number.rb

@@ -29,16 +29,20 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag
+      def to_omml_without_math_tag(_display_style)
         [(Utility.ox_element("t", namespace: "m") << value)]
       end
 
-      def insert_t_tag
+      def insert_t_tag(_display_style)
         r_tag = Utility.ox_element("r", namespace: "m")
         r_tag << (Utility.ox_element("t", namespace: "m") << value)
         [r_tag]
       end
 
+      def font_style_t_tag(_display_style)
+        Utility.ox_element("t", namespace: "m") << value
+      end
+
       def nary_attr_value
         value
       end

data/lib/plurimath/math/symbol.rb

@@ -58,11 +58,11 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag
+      def to_omml_without_math_tag(_display_style)
         value
       end
 
-      def insert_t_tag
+      def insert_t_tag(_display_style)
         r_tag = Utility.ox_element("r", namespace: "m")
         r_tag << (Utility.ox_element("t", namespace: "m") << value)
         [r_tag]
@@ -80,6 +80,10 @@ module Plurimath
         "subSup"
       end
 
+      def font_style_t_tag(_display_style)
+        Utility.ox_element("t", namespace: "m") << value
+      end
+
       def nary_attr_value
         value
       end

data/lib/plurimath/math.rb

@@ -20,6 +20,7 @@ require_relative "html/parser"
 require_relative "omml/parser"
 require_relative "utility"
 require "ox"
+require "yaml"
 Ox.default_options = { encoding: "UTF-8" }
 
 module Plurimath

data/lib/plurimath/mathml/constants.rb

@@ -130,7 +130,6 @@ module Plurimath
         "⇒": "rArr",
         "⇐": "lArr",
         "⇔": "hArr",
-        "→": "->",
         "↣": ">->",
         "↠": "->>",
         "⤖": ">->>",
@@ -139,10 +138,19 @@ module Plurimath
         "−": "-",
         "⏞": "obrace",
         "⏟": "ubrace",
+        "→": "vec",
+        "̂": "hat",
+        "̲": "ul",
+        "¯": "bar",
         "&": "&",
         ">": ">",
         "&#x3c;": "<",
         "&amp;": "&",
+        "~": "tilde",
+        "..": "ddot",
+        "^": "hat",
+        "¯": "bar",
+        "_": "ul",
       }.freeze
       SYMBOLS = {
         "|": "|",

data/lib/plurimath/mathml/parser.rb

@@ -7,11 +7,13 @@ module Plurimath
     class Parser
       attr_accessor :text
 
-      SUPPORTED_ATTRIBUTES = %w[
+      SUPPORTED_ATTRS = %w[
         columnlines
         mathvariant
+        accentunder
         mathcolor
         notation
+        accent
         close
         open
       ].freeze
@@ -22,11 +24,11 @@ module Plurimath
 
       def parse
         ox_nodes = Ox.load(text, strip_namespace: true)
-        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first || true
+        display_style = ox_nodes&.locate("*/mstyle/@displaystyle")&.first
         nodes = parse_nodes(ox_nodes.nodes)
         Math::Formula.new(
           Transform.new.apply(nodes).flatten.compact,
-          displaystyle: display_style,
+          display_style: (display_style || true),
         )
       end
 
@@ -37,12 +39,7 @@ module Plurimath
           if node.is_a?(String)
             node
           elsif !node.attributes.empty?
-            {
-              node.name.to_sym => {
-                attributes: validate_attributes(node.attributes),
-                value: parse_nodes(node.nodes),
-              },
-            }
+            attrs_hash(node)
           else
             { node.name.to_sym => parse_nodes(node.nodes) }
           end
@@ -50,9 +47,18 @@ module Plurimath
       end
 
       def validate_attributes(attributes)
-        attributes&.select! { |key, _| SUPPORTED_ATTRIBUTES.include?(key&.to_s) }
+        attributes&.select! { |key, _| SUPPORTED_ATTRS.include?(key&.to_s) }
         attributes&.transform_keys(&:to_sym) if attributes&.any?
       end
+
+      def attrs_hash(node)
+        {
+          node.name.to_sym => {
+            attributes: validate_attributes(node.attributes),
+            value: parse_nodes(node.nodes),
+          },
+        }
+      end
     end
   end
 end