plurimath 0.5.0 → 0.7.0

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

@@ -4,7 +4,7 @@ module Plurimath
   module Math
     module Function
       class TernaryFunction < Core
-        attr_accessor :parameter_one, :parameter_two, :parameter_three
+        attr_accessor :parameter_one, :parameter_two, :parameter_three, :hide_function_name
 
         def initialize(parameter_one = nil,
                        parameter_two = nil,
@@ -12,7 +12,7 @@ module Plurimath
           @parameter_one = parameter_one
           @parameter_two = parameter_two
           @parameter_three = parameter_three
-          Utility.validate_left_right([parameter_one, parameter_two, parameter_three])
+          Utility.validate_left_right(variables.map { |var| get(var) })
         end
 
         def to_asciimath
@@ -30,10 +30,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          value_arr = [parameter_one&.to_mathml_without_math_tag]
-          value_arr << parameter_two&.to_mathml_without_math_tag
-          value_arr << parameter_three&.to_mathml_without_math_tag
-          class_tag = Utility.ox_element("m#{class_name}")
+          value_arr = [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_three),
+          ]
+          class_tag = ox_element("m#{class_name}")
           Utility.update_nodes(class_tag, value_arr)
         end
 
@@ -59,6 +61,46 @@ module Plurimath
           !(parameter_one.nil? && parameter_two.nil? && parameter_three.nil?)
         end
 
+        def to_asciimath_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{to_asciimath}\" #{parameters[:name]}\n"]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
+          ascii_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
+          ascii_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_latex_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{to_latex}\" #{parameters[:name]}\n"]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
+          latex_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
+          latex_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_mathml_math_zone(spacing, last = false, _)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{dump_mathml(self)}\" #{parameters[:name]}\n"]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr })
+          mathml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr })
+          mathml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr })
+          new_arr
+        end
+
+        def to_omml_math_zone(spacing, last = false, _, display_style:)
+          parameters = self.class::FUNCTION
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = ["#{spacing}\"#{dump_omml(self, display_style)}\" #{parameters[:name]}\n"]
+          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: parameters[:first_value], additional_space: "|  |_ ", array: new_arr, display_style: display_style })
+          omml_fields_to_print(parameter_two, { spacing: new_spacing, field_name: parameters[:second_value], additional_space: "  |_ ", array: new_arr, display_style: display_style })
+          omml_fields_to_print(parameter_three, { spacing: new_spacing, field_name: parameters[:third_value], additional_space: "   |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -69,10 +111,6 @@ module Plurimath
           end
         end
 
-        def invert_unicode_symbols
-          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
-        end
-
         def wrapped(field, type: "ascii")
           return "" unless field
 

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

@@ -15,7 +15,9 @@ module Plurimath
 
         def to_mathml_without_math_tag
           text = Utility.ox_element("mtext")
-          text << (parse_text("mathml") || parameter_one) if parameter_one
+          return text unless parameter_one
+
+          text << (parse_text("mathml") || parameter_one)
         end
 
         def to_latex
@@ -27,7 +29,7 @@ module Plurimath
           parse_text("html") || parameter_one
         end
 
-        def to_omml_without_math_tag(_display_style)
+        def to_omml_without_math_tag(_)
           text = Utility.ox_element("t", namespace: "m")
           text << (parse_text("omml") || parameter_one)
           [text]
@@ -43,6 +45,26 @@ module Plurimath
           false
         end
 
+        def to_asciimath_math_zone(spacing, _, _)
+          "#{spacing}#{to_asciimath} text\n"
+        end
+
+        def to_latex_math_zone(spacing, _, _)
+          "#{spacing}#{to_asciimath} text\n"
+        end
+
+        def to_mathml_math_zone(spacing, _, _)
+          "#{spacing}\"#{dump_mathml(self)}\" text\n"
+        end
+
+        def to_omml_math_zone(spacing, _, _, display_style:)
+          "#{spacing}\"#{dump_omml(self, display_style)}\" text\n"
+        end
+
+        def value
+          parameter_one
+        end
+
         protected
 
         def symbol_value(unicode)
@@ -52,7 +74,7 @@ module Plurimath
 
         def parse_text(lang)
           html_value = first_value(lang).dup
-          html_value&.gsub!(PARSER_REGEX) do |_text|
+          html_value = html_value&.gsub(PARSER_REGEX) do |_text|
             last_match = Regexp.last_match
             case lang
             when "mathml", "html", "omml"

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

@@ -36,6 +36,11 @@ module Plurimath
           false
         end
 
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
+
         protected
 
         def acc_tag(display_style)

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

@@ -32,7 +32,7 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          omml_content = parameter_one&.map { |obj| obj.to_omml_without_math_tag(display_style) }
+          omml_content = parameter_one&.map { |object| object.to_omml_without_math_tag(display_style) }
           if parameter_one.count.eql?(1)
             omml_content
           else
@@ -44,6 +44,34 @@ module Plurimath
             [mr]
           end
         end
+
+        def to_asciimath_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"tr\" function apply\n",
+            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"tr\" function apply\n",
+            Formula.new(parameter_one).to_latex_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_mathml_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"tr\" function apply\n",
+            Formula.new(parameter_one).to_mathml_math_zone(gsub_spacing(spacing, last), last, indent),
+          ]
+        end
+
+        def to_omml_math_zone(spacing, last = false, indent = true, display_style:)
+          [
+            "#{spacing}\"tr\" function apply\n",
+            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+          ]
+        end
       end
     end
   end

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

@@ -56,6 +56,11 @@ module Plurimath
           symbol = Symbol.new("⏟")
           Underset.new(parameter_one, symbol).to_omml_without_math_tag(true)
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
       end
 
       Underbrace = Ubrace

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

@@ -4,12 +4,13 @@ module Plurimath
   module Math
     module Function
       class UnaryFunction < Core
-        attr_accessor :parameter_one
+        attr_accessor :parameter_one, :hide_function_name
 
         def initialize(parameter_one = nil)
           parameter_one  = parameter_one.to_s if parameter_one.is_a?(Parslet::Slice)
           @parameter_one = parameter_one
-          Utility.validate_left_right([parameter_one])
+          method(:post_initialize).call if methods.include?(:post_initialize)
+          Utility.validate_left_right(variables.map { |var| get(var) })
         end
 
         def ==(object)
@@ -27,12 +28,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          row_tag = Utility.ox_element("mrow")
           tag_name = Utility::UNARY_CLASSES.include?(class_name) ? "mi" : "mo"
-          new_arr = [Utility.ox_element(tag_name) << class_name]
+          new_arr = []
+          new_arr << (ox_element(tag_name) << class_name) unless hide_function_name
           if parameter_one
             new_arr += mathml_value
-            Utility.update_nodes(row_tag, new_arr)
+            Utility.update_nodes(ox_element("mrow"), new_arr)
           else
             new_arr.first
           end
@@ -54,33 +55,90 @@ module Plurimath
         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")
-          fname  = Utility.ox_element("fName", namespace: "m")
-          mr  = Utility.ox_element("r", namespace: "m")
-          rpr = Utility.rpr_element
-          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(display_style)) if parameter_one
-          Utility.update_nodes(
-            func,
-            [
-              funcpr,
-              fname,
-              me,
-            ],
-          )
-          [func]
+          if @hide_function_name
+            value = omml_value(display_style)
+          else
+            func = Utility.ox_element("func", namespace: "m")
+            value = Utility.update_nodes(func, function_values(display_style))
+          end
+          Array(value)
         end
 
-        protected
+        def to_asciimath_math_zone(spacing, last = false, _)
+          new_spacing = gsub_spacing(spacing, last)
+          new_arr = [
+            "#{spacing}\"#{to_asciimath}\" function apply\n",
+            "#{new_spacing}|_ \"#{class_name}\" function name\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}|_ \"#{class_name}\" function name\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}|_ \"#{class_name}\" function name\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}|_ \"#{class_name}\" function name\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 custom_array_line_breaking(obj)
+          parameter_value = result(parameter_one)
+          if parameter_value.size > 1
+            breaked_result = parameter_value.first.last.omml_line_break(parameter_value)
+            update(Array(breaked_result.shift))
+            obj.update(self.class.new(breaked_result.flatten))
+            reprocess_parameter_one(obj)
+            return
+          end
+
+          parameter_one.each.with_index(1) do |object, index|
+            object.line_breaking(obj)
+            break obj.insert(parameter_one.slice!(index..parameter_one.size)) if obj.value_exist?
+          end
+        end
 
-        def invert_unicode_symbols
-          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
+        def update(value)
+          self.parameter_one = value
         end
 
+        def reprocess_parameter_one(obj)
+          new_obj = Formula.new([])
+          self.line_breaking(new_obj)
+          if new_obj.value_exist?
+            obj.value.insert(0, Linebreak.new)
+            obj.value.insert(0, self.class.new(new_obj.value))
+          end
+        end
+
+        def value_nil?
+          !parameter_one
+        end
+
+        protected
+
         def asciimath_value
           return "" unless parameter_one
 
@@ -111,10 +169,38 @@ module Plurimath
 
         def omml_value(display_style)
           if parameter_one.is_a?(Array)
-            return parameter_one&.compact&.map { |obj| obj.insert_t_tag(display_style) }
+            return parameter_one&.compact&.map { |object| formula_to_nodes(object, display_style) }
           end
 
-          Array(parameter_one&.insert_t_tag(display_style))
+          Array(formula_to_nodes(parameter_one, display_style))
+        end
+
+        def formula_to_nodes(object, display_style)
+          object&.insert_t_tag(display_style)
+        end
+
+        def latex_paren
+          Latex::Constants::LEFT_RIGHT_PARENTHESIS.invert[parameter_one] || '.'
+        end
+
+        def exist?
+          !(parameter_one.is_a?(Array) ? parameter_one.empty? : parameter_one.nil?)
+        end
+
+        def function_values(display_style)
+          funcpr = Utility.ox_element("funcPr", namespace: "m")
+          funcpr << Utility.pr_element("ctrl", true, namespace: "m")
+          fname  = Utility.ox_element("fName", namespace: "m")
+          fname << Utility.update_nodes(
+            Utility.ox_element("r", namespace: "m"),
+            [
+              Utility.rpr_element,
+              (Utility.ox_element("t", namespace: "m") << class_name),
+            ],
+          )
+          me = Utility.ox_element("e", namespace: "m")
+          Utility.update_nodes(me, omml_value(display_style)) if parameter_one
+          [funcpr, fname, me]
         end
       end
     end

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

@@ -6,6 +6,13 @@ module Plurimath
   module Math
     module Function
       class Underover < TernaryFunction
+        FUNCTION = {
+          name: "UnderOver",
+          first_value: "base",
+          second_value: "Under",
+          third_value: "Over",
+        }.freeze
+
         def to_asciimath
           first_value = first_field_wrap(parameter_one) if parameter_one
           second_value = "_#{wrapped(parameter_two)}" if parameter_two
@@ -21,16 +28,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          first_value  = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          third_value  = parameter_three&.to_mathml_without_math_tag
-          class_tag = Utility.ox_element("m#{class_name}")
           Utility.update_nodes(
-            class_tag,
+            ox_element("m#{class_name}"),
             [
-              first_value,
-              second_value,
-              third_value,
+              validate_mathml_fields(parameter_one),
+              validate_mathml_fields(parameter_two),
+              validate_mathml_fields(parameter_three),
             ],
           )
         end
@@ -44,58 +47,24 @@ module Plurimath
           underover(display_style)
         end
 
-        def omml_nary_tag(display_style)
-          pr = Utility.ox_element("naryPr", namespace: "m")
-          [
-            pr_element_value(pr),
-            omml_parameter(parameter_two, display_style, tag_name: "sub"),
-            omml_parameter(parameter_three, display_style, tag_name: "sup"),
-          ]
-        end
-
-        protected
-
-        def hidden_sub_tag(pr_element)
-          return true unless parameter_two.nil?
-
-          pr_element << Utility.ox_element(
-            "subHide",
-            namespace: "m",
-            attributes: { "m:val": 1 },
-          )
-        end
-
-        def hidden_sup_tag(pr_element)
-          return true unless parameter_three.nil?
-
-          pr_element << Utility.ox_element(
-            "supHide",
-            namespace: "m",
-            attributes: { "m:val": 1 },
-          )
-        end
-
-        def pr_element_value(pr_element)
-          first_value(pr_element)
-          pr_element << Utility.ox_element(
-            "limLoc",
-            namespace: "m",
-            attributes: { "m:val": "undOvr" },
-          )
-          hidden_sub_tag(pr_element)
-          hidden_sup_tag(pr_element)
-          pr_element << Utility.pr_element("ctrl", true, namespace: "m")
-        end
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              Underover.new(Utility.filter_values(obj.value), parameter_two, parameter_three)
+            )
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
 
-        def first_value(pr_element)
-          first_value = parameter_one.nary_attr_value
-          first_value = Utility.html_entity_to_unicode(first_value)
-          unless first_value == "∫"
-            pr_element << Utility.ox_element(
-              "chr",
-              namespace: "m",
-              attributes: { "m:val": first_value },
+          parameter_two.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              Underover.new(nil, Utility.filter_values(obj.value), parameter_three)
             )
+            self.parameter_two = nil
+            self.parameter_three = nil
           end
         end
       end

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

@@ -6,16 +6,18 @@ module Plurimath
   module Math
     module Function
       class Underset < BinaryFunction
+        FUNCTION = {
+          name: "underscript",
+          first_value: "underscript value",
+          second_value: "base expression",
+        }.freeze
+
         def to_mathml_without_math_tag
-          first_value = parameter_one&.to_mathml_without_math_tag
-          second_value = parameter_two&.to_mathml_without_math_tag
-          Utility.update_nodes(
-            Utility.ox_element("munder"),
-            [
-              second_value,
-              first_value,
-            ],
-          )
+          value_array = [
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_one),
+          ]
+          Utility.update_nodes(ox_element("munder"), value_array)
         end
 
         def to_omml_without_math_tag(display_style)
@@ -37,6 +39,20 @@ module Plurimath
           )
           [limlow]
         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
+            return
+          end
+
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(nil, Utility.filter_values(obj.value)))
+          end
+        end
       end
     end
   end

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

@@ -37,6 +37,51 @@ module Plurimath
           end
         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}|_ \"#{class_name}\" function name\n",
+          ]
+          ascii_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "supscript", 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}|_ \"#{class_name}\" function name\n",
+          ]
+          latex_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "supscript", 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)}\" overset\n",
+            "#{new_spacing}|_ \"<mo>&#x2192;</mo>\" base\n",
+          ]
+          mathml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "supscript", 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)}\" overset\n",
+            "#{new_spacing}|_ \"<m:t>&#x2192;</m:t>\" base\n",
+          ]
+          omml_fields_to_print(parameter_one, { spacing: new_spacing, field_name: "supscript", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
+
         protected
 
         def acc_tag(display_style)

data/lib/plurimath/math/function.rb

@@ -6,9 +6,11 @@ module Plurimath
 end
 
 # Include the first level files before the next
-(
-  Dir.glob(File.join(__dir__, "function", "*.rb")) +
-  Dir.glob(File.join(__dir__, "function", "*", "*.rb"))
-).each do |file|
-  require file
+if RUBY_ENGINE != 'opal'
+  (
+    Dir.glob(File.join(__dir__, "function", "*.rb")) +
+    Dir.glob(File.join(__dir__, "function", "*", "*.rb"))
+  ).each do |file|
+    require file
+  end
 end

data/lib/plurimath/math/number.rb

@@ -10,7 +10,7 @@ module Plurimath
       end
 
       def ==(object)
-        object.value == value
+        object.respond_to?(:value) && object.value == value
       end
 
       def to_asciimath
@@ -29,17 +29,21 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag(_display_style)
-        [(Utility.ox_element("t", namespace: "m") << value)]
+      def to_omml_without_math_tag(_)
+        [t_tag]
       end
 
-      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]
+      def insert_t_tag(_)
+        [
+          (Utility.ox_element("r", namespace: "m") << t_tag),
+        ]
       end
 
-      def font_style_t_tag(_display_style)
+      def font_style_t_tag(_)
+        t_tag
+      end
+
+      def t_tag
         Utility.ox_element("t", namespace: "m") << value
       end