plurimath 0.7.1 → 0.8.0

data/lib/plurimath/math/function/font_style/monospace.rb

@@ -33,6 +33,10 @@ module Plurimath
           def to_omml_without_math_tag(display_style)
             font_styles(display_style, sty: nil, scr: "monospace")
           end
+
+          def to_unicodemath
+            "ￗ#{unicodemath_parens(parameter_one)}"
+          end
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Plurimath
           Utility.update_nodes(
             Utility.ox_element(
               "mstyle",
-              attributes: { mathvariant: parameter_two },
+              attributes: { mathvariant: font_family(mathml: true) },
             ),
             [first_value],
           )
@@ -33,6 +33,10 @@ module Plurimath
           parameter_one&.to_latex
         end
 
+        def to_unicodemath
+          "#{font_family(unicode: true)}#{parameter_one&.to_unicodemath}"
+        end
+
         def validate_function_formula
           true
         end
@@ -82,7 +86,7 @@ module Plurimath
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
             "#{spacing}\"#{dump_mathml(self)}\" function apply\n",
-            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+            "#{new_spacing}|_ \"#{font_family(mathml: true)}\" font family\n",
           ]
           mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr })
           new_arr
@@ -92,15 +96,28 @@ module Plurimath
           new_spacing = gsub_spacing(spacing, last)
           new_arr = [
             "#{spacing}\"#{dump_omml(self, display_style)}\" function apply\n",
-            "#{new_spacing}|_ \"#{omml_and_mathml_font_family}\" font family\n",
+            "#{new_spacing}|_ \"#{font_family(omml: true)}\" font family\n",
           ]
           omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
           new_arr
         end
 
-        def omml_and_mathml_font_family
-          fonts = Utility::FONT_STYLES.select { |_font, font_class| font_class == self.class }.keys.map(&:to_s)
-          Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts.include?(value) }
+        def font_family(unicode: false, omml: false, mathml: false)
+          fonts = font_classes
+          fonts = font_classes(parameter_to_class) if fonts.empty?
+          supported_fonts(fonts, unicode: unicode, omml: omml, mathml: mathml)
+        end
+
+        def supported_fonts(fonts_array = [], unicode: false, omml: false, mathml: false)
+          if unicode
+            font = UnicodeMath::Constants::FONTS_CLASSES.find { |value| fonts_array.include?(value) }
+            return "\\#{font}" if font
+          end
+          return Omml::Parser::SUPPORTED_FONTS.values.find { |value| fonts_array.include?(value) } if omml
+          if mathml
+            Mathml::Constants::SUPPORTED_FONT_STYLES.find { |string, object| fonts_array.include?(string.to_s) }&.first ||
+              parameter_two
+          end
         end
 
         def line_breaking(obj)
@@ -114,6 +131,14 @@ module Plurimath
             )
           )
         end
+
+        def font_classes(object = self)
+          Utility::FONT_STYLES.select { |_font, font_class| font_class == object.class }.keys.map(&:to_s)
+        end
+
+        def parameter_to_class
+          Utility::FONT_STYLES.select { |font, _font_class| font == parameter_two.to_sym }&.values&.first&.new('')
+        end
       end
     end
   end

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Frac < BinaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "fraction",
           first_value: "numerator",
           second_value: "denominator",
         }.freeze
 
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       options = {})
+          super(parameter_one, parameter_two)
+          @options = options if options && !options&.empty?
+        end
+
+        def ==(object)
+          super(object) &&
+            object.options == options
+        end
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath})" if parameter_one
           second_value = "(#{parameter_two&.to_asciimath})" if parameter_two
@@ -19,12 +32,14 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          tag_name = hide_function_name ? "mfrac" : "mrow"
+          tag_name = hide_function_name ? "mrow" : "mfrac"
           mathml_value = [
             parameter_one&.to_mathml_without_math_tag,
             parameter_two&.to_mathml_without_math_tag,
           ]
-          Utility.update_nodes(ox_element("mfrac"), mathml_value)
+          frac_tag = ox_element(tag_name)
+          frac_tag.attributes.merge!(options) if tag_name == "mfrac" && options
+          Utility.update_nodes(frac_tag, mathml_value)
         end
 
         def to_latex
@@ -35,26 +50,35 @@ module Plurimath
 
         def to_omml_without_math_tag(display_style)
           f_element   = Utility.ox_element("f", namespace: "m")
-          fpr_element = Utility.ox_element("fPr", namespace: "m")
-          fpr_element << Utility.pr_element("ctrl", true, namespace: "m")
-          Array(
-            Utility.update_nodes(
-              f_element,
-              [
-                fpr_element,
-                omml_parameter(parameter_one, display_style, tag_name: "num"),
-                omml_parameter(parameter_two, display_style, tag_name: "den"),
-              ],
-            ),
+          Utility.update_nodes(
+            f_element,
+            [
+              fpr_element,
+              omml_parameter(parameter_one, display_style, tag_name: "num"),
+              omml_parameter(parameter_two, display_style, tag_name: "den"),
+            ],
           )
         end
 
+        def to_unicodemath
+          return unicodemath_fraction if options&.dig(:unicodemath_fraction)
+
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          second_value = unicodemath_parens(parameter_two) if parameter_two
+          return "#{first_value}/#{second_value}" unless options
+
+          return "#{first_value}¦#{second_value}" if options && options.key?(:linethickness)
+          return "#{parameter_one.to_unicodemath}⊘#{parameter_two.to_unicodemath}" if options && options.key?(:displaystyle)
+          "#{first_value}∕#{second_value}" if options && options.key?(:ldiv)
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
-            obj.update(self.class.new(Utility.filter_values(obj.value), parameter_two))
+            frac = self.class.new(Utility.filter_values(obj.value), parameter_two)
+            frac.hide_function_name = true
+            obj.update(frac)
             self.parameter_two = nil
-            self.hide_function_name = true
             return
           end
 
@@ -65,6 +89,36 @@ module Plurimath
             obj.update(frac)
           end
         end
+
+        def choose_frac
+          first_value = unicodemath_parens(parameter_one) if parameter_one
+          second_value = unicodemath_parens(parameter_two) if parameter_two
+          "#{first_value}⒞#{second_value}"
+        end
+
+        protected
+
+        def fpr_element
+          fpr_element = Utility.ox_element("fPr", namespace: "m")
+          if options
+            attributes = { "m:val":  attr_value }
+            fpr_element << Utility.ox_element("type", namespace: "m", attributes: attributes)
+          end
+          fpr_element << Utility.pr_element("ctrl", true, namespace: "m")
+        end
+
+        def attr_value
+          if options[:linethickness] == "0"
+            "noBar"
+          else
+            options[:bevelled] == 'true' ? 'skw' : "bar"
+          end
+        end
+
+        def unicodemath_fraction
+          frac_array = [parameter_one.value.to_i, parameter_two.value.to_i]
+          UnicodeMath::Constants::UNICODE_FRACTIONS.key(frac_array)
+        end
       end
     end
   end

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

@@ -54,6 +54,10 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          "#{unicodemath_parens(parameter_one)}̂"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?

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

@@ -49,6 +49,36 @@ module Plurimath
             self.parameter_two = nil
           end
         end
+
+        def to_unicodemath
+          "inf#{sub_value}#{sup_value}"
+        end
+
+        protected
+
+        def sup_value
+          return unless parameter_two
+
+          if parameter_two&.mini_sized? || prime_unicode?(parameter_two)
+            parameter_two.to_unicodemath
+          elsif parameter_two.is_a?(Math::Function::Power)
+            "^#{parameter_two.to_unicodemath}"
+          else
+            "^#{unicodemath_parens(parameter_two)}"
+          end
+        end
+
+        def sub_value
+          return unless parameter_one
+
+          if parameter_one&.mini_sized?
+            parameter_one.to_unicodemath
+          elsif parameter_one.is_a?(Math::Function::Base)
+            "_#{parameter_one.to_unicodemath}"
+          else
+            "_#{unicodemath_parens(parameter_one)}"
+          end
+        end
       end
     end
   end

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

@@ -6,12 +6,25 @@ module Plurimath
   module Math
     module Function
       class Int < TernaryFunction
+        attr_accessor :options
         FUNCTION = {
           name: "integral",
           first_value: "lower limit",
           second_value: "upper limit",
           third_value: "integrand"
-        }
+        }.freeze
+
+        def initialize(parameter_one = nil,
+                       parameter_two = nil,
+                       parameter_three = nil,
+                       options = {})
+          super(parameter_one, parameter_two, parameter_three)
+          @options = options unless options&.empty?
+        end
+
+        def ==(object)
+          super(object) && object.options == options
+        end
 
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
@@ -62,6 +75,13 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          first_value = sub_value if parameter_one
+          second_value = sup_value if parameter_two
+          mask = options&.dig(:mask) if options&.key?(:mask)
+          "∫#{mask}#{first_value}#{second_value}#{naryand_value(parameter_three)}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -88,6 +108,32 @@ module Plurimath
             omml_parameter(parameter_three, display_style, tag_name: "e"),
           ]
         end
+
+        def is_nary_function?
+          true
+        end
+
+        protected
+
+        def sup_value
+          if parameter_two&.mini_sized? || prime_unicode?(parameter_two)
+            parameter_two.to_unicodemath
+          elsif parameter_two.is_a?(Math::Function::Power)
+            "^#{parameter_two.to_unicodemath}"
+          else
+            "^#{unicodemath_parens(parameter_two)}"
+          end
+        end
+
+        def sub_value
+          if parameter_one&.mini_sized?
+            parameter_one.to_unicodemath
+          elsif parameter_one.is_a?(Math::Function::Base)
+            "_#{parameter_one.to_unicodemath}"
+          else
+            "_#{unicodemath_parens(parameter_one)}"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "binary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Intent < BinaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one.to_mathml_without_math_tag
+          first_value.attributes[:intent] = Utility.html_entity_to_unicode(parameter_two.value)
+          first_value
+        end
+
+        def to_unicodemath
+          first_value = "(#{parameter_two.to_unicodemath}#{parameter_one.to_unicodemath})" if parameter_one || parameter_two
+          "ⓘ#{first_value}"
+        end
+      end
+    end
+  end
+end

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

@@ -33,6 +33,10 @@ module Plurimath
           "\\left #{latex_paren}"
         end
 
+        def to_unicodemath
+          parameter_one
+        end
+
         def validate_function_formula
           false
         end

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

@@ -49,6 +49,12 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          first_value  = "_#{unicodemath_parens(parameter_one)}" if parameter_one
+          second_value = "^#{unicodemath_parens(parameter_two)}" if parameter_two
+          "lim#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one.line_breaking(obj)
           if obj.value_exist?

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

@@ -34,6 +34,10 @@ module Plurimath
           underover(display_style)
         end
 
+        def to_unicodemath
+          "#{parameter_one&.to_unicodemath}#{sup_value}#{sub_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -49,6 +53,30 @@ module Plurimath
             self.parameter_three = nil
           end
         end
+
+        protected
+
+        def sup_value
+          return unless parameter_three
+
+          if parameter_three.is_a?(Math::Function::Power)
+            "┴#{parameter_three.to_unicodemath}"
+          elsif parameter_one.is_a?(Math::Function::Power) && parameter_one&.prime_unicode?(parameter_one&.parameter_two)
+            "┴#{parameter_three.to_unicodemath}"
+          else
+            "┴#{unicodemath_parens(parameter_three)}"
+          end
+        end
+
+        def sub_value
+          return unless parameter_two
+
+          if parameter_two.is_a?(Math::Function::Base)
+            "┬#{parameter_two.to_unicodemath}"
+          else
+            "┬#{unicodemath_parens(parameter_two)}"
+          end
+        end
       end
     end
   end

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

@@ -82,6 +82,11 @@ module Plurimath
           result
         end
 
+        def to_unicodemath
+          first_value = parameter_one.to_unicodemath if parameter_one
+          "
#{first_value}"
+        end
+
         def separate_table
           true
         end

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

@@ -35,7 +35,7 @@ module Plurimath
 
           ssubsup   = Utility.ox_element("sSubSup", namespace: "m")
           ssubsuppr = Utility.ox_element("sSubSupPr", namespace: "m")
-          ssubsuppr << hide_tags(Utility.pr_element("ctrl", true, namespace: "m"))
+          ssubsuppr << Utility.pr_element("ctrl", true, namespace: "m")
           Utility.update_nodes(
             ssubsup,
             [
@@ -63,6 +63,12 @@ module Plurimath
           end
         end
 
+        def to_unicodemath
+          first_value = sub_value if parameter_one
+          second_value = sup_value if parameter_two
+          "log#{first_value}#{second_value}"
+        end
+
         def line_breaking(obj)
           parameter_one&.line_breaking(obj)
           if obj.value_exist?
@@ -82,25 +88,6 @@ module Plurimath
           e_tag << rpr_tag
         end
 
-        def hide_tags(nar)
-          attr = { "m:val": "1" }
-          if parameter_one.nil?
-            nar << Utility.ox_element(
-              "subHide",
-              namespace: "m",
-              attributes: attr,
-            )
-          end
-          if parameter_two.nil?
-            nar << Utility.ox_element(
-              "supHide",
-              namespace: "m",
-              attributes: attr,
-            )
-          end
-          nar
-        end
-
         def rpr_tag
           sty_atrs = { "m:val": "p" }
           sty_tag  = Utility.ox_element("sty", attributes: sty_atrs, namespace: "m")
@@ -109,6 +96,26 @@ module Plurimath
           t_tag = (Utility.ox_element("t", namespace: "m") << "log")
           Utility.update_nodes(r_tag, [rpr_tag, t_tag])
         end
+
+        def sup_value
+          if parameter_two&.mini_sized? || prime_unicode?(parameter_two)
+            parameter_two.to_unicodemath
+          elsif parameter_two.is_a?(Math::Function::Power)
+            "^#{parameter_two.to_unicodemath}"
+          else
+            "^#{unicodemath_parens(parameter_two)}"
+          end
+        end
+
+        def sub_value
+          if parameter_one&.mini_sized?
+            parameter_one.to_unicodemath
+          elsif parameter_one.is_a?(Math::Function::Base)
+            "_#{parameter_one.to_unicodemath}"
+          else
+            "_#{unicodemath_parens(parameter_one)}"
+          end
+        end
       end
     end
   end

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

@@ -25,6 +25,10 @@ module Plurimath
           omml_value(display_style)
         end
 
+        def to_unicodemath
+          parameter_one&.to_unicodemath
+        end
+
         def line_breaking(obj)
           custom_array_line_breaking(obj)
         end

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

@@ -24,6 +24,10 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           Text.new(parameter_one).to_omml_without_math_tag(display_style)
         end
+
+        def to_unicodemath
+          Text.new(parameter_one).to_unicodemath
+        end
       end
     end
   end

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

@@ -11,6 +11,18 @@ module Plurimath
           first_value: "enclosure type",
           second_value: "expression",
         }.freeze
+        FOUR_SIDED_NOTATIONS = {
+          top: "hideTop",
+          bottom: "hideBot",
+          left: "hideLeft",
+          right: "hideRight",
+        }
+        STRIKES_NOTATIONS = {
+          horizontalstrike: "strikeH",
+          verticalstrike: "strikeV",
+          updiagonalstrike: "strikeBLTR",
+          downdiagonalstrike: "strikeTLBR",
+        }
 
         def to_asciimath
           parameter_two&.to_asciimath
@@ -18,7 +30,7 @@ module Plurimath
 
         def to_mathml_without_math_tag
           attributes = { notation: parameter_one }
-          menclose = Utility.ox_element("menclose", attributes: attributes)
+          menclose = ox_element("menclose", attributes: attributes)
           menclose << parameter_two.to_mathml_without_math_tag if parameter_two
           menclose
         end
@@ -33,18 +45,75 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          borderbox = Utility.ox_element("borderBox", namespace: "m")
-          borderpr = Utility.ox_element("borderBoxPr", namespace: "m")
-          borderpr << Utility.pr_element("ctrl", true, namespace: "m")
+          borderbox = ox_element("borderBox", namespace: "m")
           Utility.update_nodes(
             borderbox,
             [
-              borderpr,
+              borderboxpr,
               omml_parameter(parameter_two, display_style, tag_name: "e"),
             ],
           )
           [borderbox]
         end
+
+        def to_unicodemath
+          if unicode_symbol?
+            "#{unicode_symbol}#{unicodemath_parens(parameter_two)}"
+          elsif masked_class?
+            first_value = Utility.notations_to_mask(parameter_one) if parameter_one
+            second_value = parameter_two&.to_unicodemath if parameter_two
+            "▭(#{first_value}&#{second_value})"
+          end
+        end
+
+        protected
+
+        def borderboxpr
+          return if %w[box circle roundedbox].include?(parameter_one)
+
+          borderpr = ox_element("borderBoxPr", namespace: "m")
+          four_sided_notations(borderpr)
+          strikes_notations(borderpr)
+          borderpr
+        end
+
+        def four_sided_notations(borderpr)
+          return if %w[box circle roundedbox].any? { |value| parameter_one.include?(value) }
+
+          FOUR_SIDED_NOTATIONS.each do |side, rep|
+            border_ox_element(rep, !parameter_one.include?(side.to_s), borderpr)
+          end
+        end
+
+        def strikes_notations(borderpr)
+          STRIKES_NOTATIONS.each do |strike, rep|
+            border_ox_element(rep, parameter_one.include?(strike.to_s), borderpr)
+          end
+        end
+
+        def border_ox_element(tag_name, condition, borderpr)
+          return unless condition
+
+          borderpr << ox_element(
+            tag_name,
+            namespace: "m",
+            attributes: { "m:val": "on" },
+          )
+        end
+
+        def masked_class?
+          Utility::MASK_CLASSES.values.any? { |mask| parameter_one.include?(mask) }
+        end
+
+        def unicode_symbol
+          class_name = Utility::UNICODEMATH_MENCLOSE_FUNCTIONS.key(parameter_one)
+          UnicodeMath::Constants::UNARY_ARG_FUNCTIONS[class_name] ||
+            UnicodeMath::Constants::UNARY_SYMBOLS[class_name]
+        end
+
+        def unicode_symbol?
+          Utility::UNICODEMATH_MENCLOSE_FUNCTIONS.value?(parameter_one)
+        end
       end
     end
   end

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

@@ -16,6 +16,8 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(_); end
+
+        def to_unicodemath; end
       end
     end
   end