plurimath 0.5.0 → 0.7.0

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

@@ -6,12 +6,20 @@ module Plurimath
   module Math
     module Function
       class Limits < TernaryFunction
+        FUNCTION = {
+          name: "function apply",
+          first_value: "base",
+          second_value: "subscript",
+          third_value: "supscript",
+        }.freeze
+
         def to_mathml_without_math_tag
           underover = Utility.ox_element("munderover")
-          value_array = []
-          value_array << parameter_one&.to_mathml_without_math_tag
-          value_array << parameter_two&.to_mathml_without_math_tag
-          value_array << parameter_three&.to_mathml_without_math_tag
+          value_array = [
+            validate_mathml_fields(parameter_one),
+            validate_mathml_fields(parameter_two),
+            validate_mathml_fields(parameter_three),
+          ]
           Utility.update_nodes(underover, value_array)
         end
 
@@ -23,11 +31,23 @@ module Plurimath
         end
 
         def to_omml_without_math_tag(display_style)
-          value_array = []
-          value_array << parameter_one.insert_t_tag(display_style) if parameter_one
-          value_array << parameter_two.insert_t_tag(display_style) if parameter_two
-          value_array << parameter_three.insert_t_tag(display_style) if parameter_three
-          value_array
+          underover(display_style)
+        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, parameter_three))
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
+
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(self.class.new(nil, Utility.filter_values(obj.value), parameter_three))
+            self.parameter_three = nil
+          end
         end
       end
     end

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

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

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "unary_function"
+
+module Plurimath
+  module Math
+    module Function
+      class Linebreak < UnaryFunction
+        attr_accessor :attributes
+
+        def initialize(parameter_one = nil, attributes = {})
+          @parameter_one = parameter_one
+          @attributes = attributes
+          Utility.validate_left_right([parameter_one])
+        end
+
+        def ==(object)
+          object.class == self.class &&
+            object.parameter_one == parameter_one &&
+            object.linebreak == linebreak
+        end
+
+        def to_asciimath
+          linebreak_character = "\\\n "
+          return linebreak_character unless parameter_one
+
+          case attributes[:linebreakstyle]
+          when "after"
+            "#{asciimath_value}#{linebreak_character}"
+          else
+            "#{linebreak_character}#{asciimath_value}"
+          end
+        end
+
+        def to_latex
+          linebreak_character = "\\\\ "
+          return linebreak_character unless parameter_one
+
+          case attributes[:linebreakstyle]
+          when "after"
+            "#{latex_value}#{linebreak_character}"
+          else
+            "#{linebreak_character}#{latex_value}"
+          end
+        end
+
+        def to_mathml_without_math_tag
+          return Utility.ox_element("mo", attributes: { linebreak: "newline" }) unless parameter_one
+
+          mo_node = parameter_one.to_mathml_without_math_tag
+          mo_node.name = "mo" unless mo_node.name == "mo"
+          mo_node.attributes.merge!(attributes) unless attributes.empty?
+          mo_node
+        end
+
+        def to_html
+          br_tag = "<br/>"
+          return br_tag unless parameter_one
+
+          case attributes[:linebreakstyle]
+          when "after"
+            "#{parameter_one.to_html}#{br_tag}"
+          else
+            "#{br_tag}#{parameter_one.to_html}"
+          end
+        end
+
+        def to_omml_without_math_tag(display_style)
+          parameter_one&.insert_t_tag(display_style)
+        end
+
+        def omml_line_break(result)
+          result.first.pop
+          return result unless exist?
+
+          case attributes[:linebreakstyle]
+          when "after"
+            result[0] << parameter_one
+          else
+            result[1].insert(0, parameter_one)
+          end
+          result
+        end
+
+        def separate_table
+          true
+        end
+
+        def linebreak
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Log < BinaryFunction
+        FUNCTION = {
+          name: "function apply",
+          first_value: "subscript",
+          second_value: "supscript",
+        }
+
         def to_asciimath
           first_value = "_#{wrapped(parameter_one)}" if parameter_one
           second_value = "^#{wrapped(parameter_two)}" if parameter_two
@@ -29,9 +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 << hide_tags(Utility.pr_element("ctrl", true, namespace: "m"))
           Utility.update_nodes(
             ssubsup,
             [
@@ -45,25 +49,36 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          subsup_tag = Utility.ox_element("msubsup")
-          first_value = (Utility.ox_element("mi") << "log")
+          first_value = ox_element("mi")
+          first_value << "log" unless hide_function_name
           if parameter_one || parameter_two
-            new_arr = [first_value]
-            new_arr << parameter_one&.to_mathml_without_math_tag
-            new_arr << parameter_two&.to_mathml_without_math_tag
-            Utility.update_nodes(
-              subsup_tag,
-              new_arr,
-            )
+            new_arr = [
+              first_value,
+              validate_mathml_fields(parameter_one),
+              validate_mathml_fields(parameter_two),
+            ]
+            Utility.update_nodes(ox_element("msubsup"), new_arr)
           else
             first_value
           end
         end
 
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            log = self.class.new(Utility.filter_values(obj.value), parameter_two)
+            self.parameter_two = nil
+            log.hide_function_name = true
+            obj.update(log)
+          end
+        end
+
         protected
 
         def e_parameter
           e_tag = Utility.ox_element("e", namespace: "m")
+          return e_tag if hide_function_name
+
           e_tag << rpr_tag
         end
 

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

@@ -6,9 +6,28 @@ module Plurimath
   module Math
     module Function
       class Longdiv < UnaryFunction
+        def to_asciimath
+          asciimath_value
+        end
+
+        def to_latex
+          latex_value
+        end
+
+        def to_mathml_without_math_tag
+          Utility.update_nodes(
+            ox_element("m#{class_name}"),
+            mathml_value,
+          )
+        end
+
         def to_omml_without_math_tag(display_style)
           omml_value(display_style)
         end
+
+        def line_breaking(obj)
+          custom_array_line_breaking(obj)
+        end
       end
     end
   end

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

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

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

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

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

@@ -5,23 +5,24 @@ module Plurimath
   module Math
     module Function
       class Mbox < UnaryFunction
+        def to_asciimath
+          Text.new(parameter_one).to_asciimath
+        end
+
         def to_mathml_without_math_tag
-          text = Utility.ox_element("mtext")
-          text << (parameter_one.to_mathml_without_math_tag) if parameter_one
-          text
+          Text.new(parameter_one).to_mathml_without_math_tag
         end
 
         def to_latex
-          first_value = parameter_one&.to_latex
-          "\\mbox{#{first_value}}"
+          "\\mbox{#{parameter_one}}"
         end
 
         def to_html
-          parameter_one&.to_html
+          parameter_one
         end
 
         def to_omml_without_math_tag(display_style)
-          omml_value(display_style)
+          Text.new(parameter_one).to_omml_without_math_tag(display_style)
         end
       end
     end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Menclose < BinaryFunction
+        FUNCTION = {
+          name: "enclosure",
+          first_value: "enclosure type",
+          second_value: "expression",
+        }.freeze
+
         def to_asciimath
           parameter_two&.to_asciimath
         end

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

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "binary_function"
+require_relative "unary_function"
 
 module Plurimath
   module Math
     module Function
-      class Merror < BinaryFunction
-        def to_omml_without_math_tag(display_style); end
+      class Merror < UnaryFunction
+        def to_asciimath;end
+
+        def to_latex;end
+
+        def to_mathml_without_math_tag
+          merror = Utility.ox_element("merror")
+          Utility.update_nodes(merror, mathml_value)
+        end
+
+        def to_omml_without_math_tag(_); end
       end
     end
   end

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

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

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Mod < BinaryFunction
+        FUNCTION = {
+          name: "mod",
+          first_value: "base",
+          second_value: "argument",
+        }
+
         def to_asciimath
           first_value = parameter_one&.to_asciimath
           second_value = parameter_two&.to_asciimath
@@ -13,18 +19,12 @@ module Plurimath
         end
 
         def to_mathml_without_math_tag
-          mrow_tag = Utility.ox_element("mrow")
-          mo_tag = Utility.ox_element("mi") << "mod"
-          first_value = parameter_one&.to_mathml_without_math_tag if parameter_one
-          second_value = parameter_two&.to_mathml_without_math_tag if parameter_two
-          Utility.update_nodes(
-            mrow_tag,
-            [
-              first_value,
-              mo_tag,
-              second_value,
-            ],
-          )
+          mi_tag = ox_element("mi")
+          mi_tag << "mod" unless hide_function_name
+          value_array = [mi_tag]
+          value_array.insert(0, parameter_one&.to_mathml_without_math_tag) if parameter_one
+          value_array << parameter_two&.to_mathml_without_math_tag if parameter_two
+          Utility.update_nodes(ox_element("mrow"), value_array)
         end
 
         def to_latex
@@ -41,11 +41,44 @@ module Plurimath
 
         def to_omml_without_math_tag(display_style)
           values = []
-          values << parameter_one.insert_t_tag(display_style) if parameter_one
-          values << r_element("mod")
-          values << parameter_two.insert_t_tag(display_style) if parameter_two
+          first_value(display_style, values)
+          values << r_element("mod") unless hide_function_name
+          second_value(display_style, values)
           values
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          if obj.value_exist?
+            mod = self.class.new(Utility.filter_values(obj.value), parameter_two)
+            mod.hide_function_name = false
+            self.hide_function_name = true
+            obj.update(mod)
+            self.parameter_two = nil
+            return
+          end
+
+          parameter_two&.line_breaking(obj)
+          if obj.value_exist?
+            mod = self.class.new(nil, Utility.filter_values(obj.value))
+            mod.hide_function_name = true
+            obj.update(mod)
+          end
+        end
+
+        protected
+
+        def first_value(display_style, values)
+          return unless parameter_one
+
+          values << parameter_one.insert_t_tag(display_style)
+        end
+
+        def second_value(display_style, values)
+          return unless parameter_two
+
+          values << parameter_two.insert_t_tag(display_style)
+        end
       end
     end
   end

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

@@ -28,6 +28,38 @@ module Plurimath
         def to_html
           "<i>#{parameter_one.map(&:to_html).join}</i>"
         end
+
+        def to_asciimath_math_zone(spacing, last = false, _indent = true)
+          [
+            "#{spacing}\"msgroup\" function apply\n",
+            Formula.new(parameter_one).to_asciimath_math_zone(gsub_spacing(spacing, last)),
+          ]
+        end
+
+        def to_latex_math_zone(spacing, last = false, indent = true)
+          [
+            "#{spacing}\"msgroup\" 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}\"msgroup\" 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}\"msgroup\" function apply\n",
+            Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
+          ]
+        end
+
+        def line_breaking(obj)
+          custom_array_line_breaking(obj)
+        end
       end
     end
   end

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

@@ -6,9 +6,19 @@ module Plurimath
   module Math
     module Function
       class Msline < UnaryFunction
+        def to_asciimath;end
+
+        def to_latex;end
+
+        def to_mathml_without_math_tag
+          ox_element("msline")
+        end
+
         def to_omml_without_math_tag(display_style)
           omml_value(display_style)
         end
+
+        def to_omml_without_math_tag(display_style);end
       end
     end
   end

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

@@ -5,6 +5,13 @@ module Plurimath
   module Math
     module Function
       class Multiscript < TernaryFunction
+        FUNCTION = {
+          name: "multiscript",
+          first_value: "base",
+          second_value: "subscript",
+          third_value: "supscript",
+        }.freeze
+
         def to_omml_without_math_tag(display_style)
           pre_element = Utility.ox_element("sPre", namespace: "m")
           pr_element  = Utility.ox_element("sPrePr", namespace: "m")
@@ -19,6 +26,26 @@ module Plurimath
           )
           [pre_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, parameter_three)
+            )
+            self.parameter_two = nil
+            self.parameter_three = nil
+            return
+          end
+
+          parameter_two.line_breaking(obj)
+          if obj.value_exist?
+            obj.update(
+              self.class.new(nil, Utility.filter_values(obj.value), parameter_three)
+            )
+            self.parameter_three = nil
+          end
+        end
       end
     end
   end