plurimath 0.5.0 → 0.7.0

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

@@ -39,26 +39,52 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           d = Utility.ox_element("d", namespace: "m")
           dpr = Utility.ox_element("dPr", namespace: "m")
-          first_value(dpr)
-          third_value(dpr)
+          parameter = Formula.new(Array(parameter_two))
+          open_paren(dpr)
+          close_paren(dpr)
+          fenced_value = omml_parameter(parameter, display_style, tag_name: "e")
           dpr << Utility.pr_element("ctrl", true, namespace: "m")
-          Utility.update_nodes(
-            d,
-            [
-              dpr,
-              omml_parameter(
-                Formula.new(Array(parameter_two)),
-                display_style,
-                tag_name: "e",
-              ),
-            ],
-          )
+          Utility.update_nodes(d, [dpr, fenced_value])
           [d]
         end
 
+        def to_asciimath_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_asciimath_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_latex_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_mathml_math_zone(spacing, last = false, indent = true)
+          filtered_values(parameter_two).map.with_index(1) do |object, index|
+            last = index == @values.length
+            object.to_mathml_math_zone(spacing, last, indent)
+          end
+        end
+
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+          filtered_values(parameter_two).map do |object|
+            object.to_omml_math_zone(spacing, last, !indent, display_style: display_style)
+          end
+        end
+
+        def line_breaking(obj)
+          field_values = result(Array(parameter_two))
+          return unless field_values.length > 1
+
+          obj.update(value_split(obj, field_values))
+        end
+
         protected
 
-        def first_value(dpr)
+        def open_paren(dpr)
           first_value = parameter_one&.value
           return dpr if first_value.nil? || first_value.empty?
 
@@ -70,7 +96,7 @@ module Plurimath
           )
         end
 
-        def third_value(dpr)
+        def close_paren(dpr)
           third_value = parameter_three&.value
           return dpr if third_value.nil? || third_value.empty?
 
@@ -96,6 +122,16 @@ module Plurimath
 
           field&.value
         end
+
+        def value_split(obj, field_value)
+          object = cloned_objects
+          breaked_result = field_value.first.last.omml_line_break(field_value)
+          self.parameter_two = Array(breaked_result.shift)
+          object.parameter_one = nil
+          object.parameter_two = breaked_result.flatten
+          self.parameter_three = nil
+          object
+        end
       end
     end
   end

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

@@ -6,28 +6,38 @@ module Plurimath
   module Math
     module Function
       class Floor < UnaryFunction
+        attr_accessor :open_paren, :close_paren
+
         def to_latex
-          "\\lfloor #{parameter_one.to_latex} \\rfloor"
+          "{\\lfloor #{parameter_one.to_latex} \\rfloor}"
         end
 
         def to_mathml_without_math_tag
           first_value = parameter_one&.to_mathml_without_math_tag
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            [
-              Utility.ox_element("mo") << "&#x230a;",
-              first_value,
-              Utility.ox_element("mo") << "&#x230b;",
-            ],
-          )
+          value_array = [first_value]
+          value_array.insert(0, (ox_element("mo") << "&#x230a;")) unless open_paren
+          value_array << (ox_element("mo") << "&#x230b;") unless close_paren
+          Utility.update_nodes(ox_element("mrow"), value_array)
         end
 
         def to_omml_without_math_tag(display_style)
-          [
-            r_element("⌊"),
-            omml_value(display_style),
-            r_element("⌋"),
-          ]
+          array = []
+          array << r_element("⌊") unless open_paren
+          array += Array(omml_value(display_style))
+          array << r_element("⌋") unless close_paren
+          array
+        end
+
+        def line_breaking(obj)
+          parameter_one.line_breaking(obj)
+          if obj.value_exist?
+            ceil_object = self.class.new(Utility.filter_values(obj.value))
+            ceil_object.open_paren = true
+            ceil_object.close_paren = false
+            obj.update(ceil_object)
+            self.close_paren = true
+            self.open_paren = false unless open_paren
+          end
         end
       end
     end

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

@@ -37,7 +37,7 @@ module Plurimath
           true
         end
 
-        def extract_class_from_text
+        def extract_class_name_from_text
           parameter_one.parameter_one if parameter_one.is_a?(Text)
           parameter_one.class_name
         end
@@ -47,18 +47,73 @@ module Plurimath
         end
 
         def font_styles(display_style, sty: "p", scr: nil)
-          r_tag   = Utility.ox_element("r", namespace: "m")
+          r_tag = Utility.ox_element("r", namespace: "m")
           rpr_tag = Utility.ox_element("rPr", namespace: "m")
-          fonts   = []
-          fonts << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
-          fonts << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
-          r_tag << Utility.update_nodes(rpr_tag, fonts)
+          rpr_tag << Utility.ox_element("scr", namespace: "m", attributes: { "m:val": scr }) if scr
+          rpr_tag << Utility.ox_element("sty", namespace: "m", attributes: { "m:val": sty }) if sty
           Utility.update_nodes(
-            r_tag,
-            Array(parameter_one.font_style_t_tag(display_style)),
+            (r_tag << rpr_tag),
+            Array(parameter_one&.font_style_t_tag(display_style)),
           )
           [r_tag]
         end
+
+        def to_asciimath_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{to_asciimath}\" function apply\n",
+            "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
+          ]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_latex_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{to_latex}\" function apply\n",
+            "#{new_spacing}|_ \"#{parameter_two}\" font family\n",
+          ]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ " , array: new_arr })
+          new_arr
+        end
+
+        def to_mathml_math_zone(spacing, last = false, _)
+          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",
+          ]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "argument", additional_space: "|  |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_omml_math_zone(spacing, last = false, _, display_style:)
+          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",
+          ]
+          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) }
+        end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          return unless obj.value_exist?
+
+          obj.update(
+            self.class.new(
+              Utility.filter_values(obj.value),
+              self.parameter_two,
+            )
+          )
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Frac < BinaryFunction
+        FUNCTION = {
+          name: "fraction",
+          first_value: "numerator",
+          second_value: "denominator",
+        }.freeze
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath})" if parameter_one
           second_value = "(#{parameter_two&.to_asciimath})" if parameter_two
@@ -13,16 +19,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          frac_tag     = Utility.ox_element("mfrac")
-          first_value  = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          Utility.update_nodes(
-            frac_tag,
-            [
-              first_value,
-              second_value,
-            ].flatten,
-          )
+          tag_name = hide_function_name ? "mfrac" : "mrow"
+          mathml_value = [
+            parameter_one&.to_mathml_without_math_tag,
+            parameter_two&.to_mathml_without_math_tag,
+          ]
+          Utility.update_nodes(ox_element("mfrac"), mathml_value)
         end
 
         def to_latex
@@ -35,15 +37,33 @@ module Plurimath
           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")
-          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"),
-            ],
+          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"),
+              ],
+            ),
           )
-          [f_element]
+        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))
+            self.parameter_two = nil
+            self.hide_function_name = true
+            return
+          end
+
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            frac = self.class.new(nil, Utility.filter_values(obj.value))
+            frac.hide_function_name = true
+            obj.update(frac)
+          end
         end
       end
     end

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

@@ -11,7 +11,10 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          [r_element("gcd", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("gcd", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -10,8 +10,15 @@ module Plurimath
           false
         end
 
+        def to_latex
+          "glb{#{latex_value}}"
+        end
+
         def to_omml_without_math_tag(display_style)
-          [r_element("glb", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("glb", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -43,22 +43,33 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          return r_element("^", rpr_tag: false)  unless parameter_one
+          return r_element("^", rpr_tag: false) unless parameter_one
+          return omml_value(display_style) if hide_function_name
 
           if attributes && attributes[:accent]
             accent_tag(display_style)
           else
-            symbol = Symbol.new("̂")
-            Overset.new(parameter_one, symbol).to_omml_without_math_tag(true)
+            symbol = Symbol.new("̂") unless hide_function_name
+            Overset.new(parameter_one, symbol).to_omml_without_math_tag(display_style)
+          end
+        end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              Overset.new(Utility.filter_values(obj.value), nil),
+            )
           end
         end
 
         protected
 
         def accent_tag(display_style)
-          acc_tag    = Utility.ox_element("acc", namespace: "m")
+          symbol  = "̂" unless hide_function_name
+          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": "̂" }))
+          acc_pr_tag << (Utility.ox_element("chr", namespace: "m", attributes: { "m:val": symbol }))
           Utility.update_nodes(
             acc_tag,
             [

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

@@ -7,7 +7,10 @@ module Plurimath
     module Function
       class Hom < UnaryFunction
         def to_omml_without_math_tag(display_style)
-          [r_element("hom", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("hom", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Inf < BinaryFunction
+        def to_asciimath
+          first_value = "_(#{parameter_one.to_asciimath})" if parameter_one
+          second_value = "^(#{parameter_two.to_asciimath})" if parameter_two
+          "#{class_name}#{first_value}#{second_value}"
+        end
+
         def to_latex
           first_value = "_{#{parameter_one.to_latex}}" if parameter_one
           second_value = "^{#{parameter_two.to_latex}}" if parameter_two
@@ -33,6 +39,16 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           underover(display_style)
         end
+
+        def line_breaking(obj)
+          parameter_one.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              Underover.new(nil, Utility.filter_values(obj.value), parameter_two)
+            )
+            self.parameter_two = nil
+          end
+        end
       end
     end
   end

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

@@ -6,6 +6,13 @@ module Plurimath
   module Math
     module Function
       class Int < TernaryFunction
+        FUNCTION = {
+          name: "integral",
+          first_value: "lower limit",
+          second_value: "upper limit",
+          third_value: "integrand"
+        }
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -45,15 +52,7 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           if all_values_exist?
             nary = Utility.ox_element("nary", namespace: "m")
-            Utility.update_nodes(
-              nary,
-              [
-                narypr("∫", function_type: "subSup"),
-                omml_parameter(parameter_one, display_style, tag_name: "sub"),
-                omml_parameter(parameter_two, display_style, tag_name: "sup"),
-                omml_parameter(parameter_three, display_style, tag_name: "e"),
-              ],
-            )
+            Utility.update_nodes(nary, nary_array(display_style))
             [nary]
           else
             r_tag = Utility.ox_element("r", namespace: "m")
@@ -62,6 +61,33 @@ module Plurimath
             [r_tag]
           end
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            int = Int.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            int.hide_function_name = true
+            obj.update(int)
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
+
+          parameter_three&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(Utility.filter_values(obj.value))
+          end
+        end
+
+        def nary_array(display_style)
+          symbol = hide_function_name ? "" : "∫"
+          [
+            narypr(symbol, function_type: "subSup"),
+            omml_parameter(parameter_one, display_style, tag_name: "sub"),
+            omml_parameter(parameter_two, display_style, tag_name: "sup"),
+            omml_parameter(parameter_three, display_style, tag_name: "e"),
+          ]
+        end
       end
     end
   end

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

@@ -7,7 +7,10 @@ module Plurimath
     module Function
       class Ker < UnaryFunction
         def to_omml_without_math_tag(display_style)
-          [r_element("ker", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("ker", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -6,8 +6,24 @@ module Plurimath
   module Math
     module Function
       class Lcm < UnaryFunction
+        def validate_function_formula
+          false
+        end
+
+        def to_asciimath
+          first_value = " #{asciimath_value}" if parameter_one
+          "lcm#{first_value}"
+        end
+
+        def to_latex
+          "lcm{#{latex_value}}"
+        end
+
         def to_omml_without_math_tag(display_style)
-          [r_element("lcm", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("lcm", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -16,7 +16,7 @@ module Plurimath
           mo
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(_)
           mr = Utility.ox_element("m:r")
           if parameter_one
             mt = Utility.ox_element("m:t")
@@ -30,13 +30,31 @@ module Plurimath
         end
 
         def to_latex
-          "\\left #{Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || '.'}"
+          "\\left #{latex_paren}"
         end
 
         def validate_function_formula
           false
         end
 
+        def to_asciimath_math_zone(spacing = "", _, _)
+          "#{spacing}\"#{latex_paren}\" left\n"
+        end
+
+        def to_latex_math_zone(spacing = "", _, _)
+          "#{spacing}\"#{latex_paren}\" left\n"
+        end
+
+        def to_mathml_math_zone(spacing = "", _, _)
+          mo_tag = (Utility.ox_element("mo") << left_paren)
+          "#{spacing}\"#{dump_ox_nodes(mo_tag).gsub(/\s+/, "")}\" left\n"
+        end
+
+        def to_omml_math_zone(spacing = "", _, _, display_style:)
+          t_tag = (Utility.ox_element("t", namespace: "m") << left_paren)
+          "#{spacing}\"#{dump_ox_nodes(t_tag).gsub(/\s+/, "")}\" left\n"
+        end
+
         protected
 
         def left_paren

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

@@ -11,7 +11,10 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          [r_element("lg", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("lg", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Lim < BinaryFunction
+        FUNCTION = {
+          name: "limit",
+          first_value: "limit subscript",
+          second_value: "limit supscript",
+        }.freeze
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -42,6 +48,16 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           underover(display_style)
         end
+
+        def line_breaking(obj)
+          parameter_one.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              Underover.new(nil, Utility.filter_values(obj.value), parameter_two)
+            )
+            self.parameter_two = nil
+          end
+        end
       end
     end
   end

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

@@ -7,7 +7,10 @@ module Plurimath
     module Function
       class Liminf < UnaryFunction
         def to_omml_without_math_tag(display_style)
-          [r_element("liminf", rpr_tag: false), omml_value(display_style)]
+          array = []
+          array << r_element("liminf", rpr_tag: false) unless hide_function_name
+          array += Array(omml_value(display_style))
+          array
         end
       end
     end