plurimath 0.6.0 → 0.7.1

data/lib/plurimath/math/function/table/matrix.rb

@@ -14,6 +14,10 @@ module Plurimath
             super
           end
 
+          def to_asciimath
+            "{:#{value.map(&:to_asciimath).join(", ")}:}"
+          end
+
           def to_latex
             "\\begin#{opening}#{latex_content}\\end#{matrix_class}"
           end

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

@@ -6,6 +6,8 @@ module Plurimath
       class Table < Core
         attr_accessor :value, :open_paren, :close_paren, :options
 
+        SIMPLE_TABLES = %w[array align split].freeze
+
         def initialize(value = nil,
                        open_paren = nil,
                        close_paren = nil,
@@ -25,6 +27,8 @@ module Plurimath
         end
 
         def to_asciimath
+          return parentheless_table if SIMPLE_TABLES.include?(class_name)
+
           parenthesis = Asciimath::Constants::TABLE_PARENTHESIS
           first_value = value.map(&:to_asciimath).join(", ")
           third_value = close_paren.is_a?(::Array) || close_paren.nil?
@@ -193,7 +197,7 @@ module Plurimath
           eqarrpr  = Utility.ox_element("eqArrPr", namespace: "m")
           eqarrpr  << Utility.pr_element("ctrl", true, namespace: "m")
           eqarr    << eqarrpr
-          tr_value = value.map { |obj| obj.to_omml_without_math_tag(display_style) }.flatten
+          tr_value = value.map { |object| object.to_omml_without_math_tag(display_style) }.flatten
           Utility.update_nodes(eqarr, tr_value.compact)
           [eqarr]
         end
@@ -202,7 +206,7 @@ module Plurimath
           count  = { "m:val": value&.first&.parameter_one&.count }
           mcjc   = { "m:val": "center" }
           mm     = Utility.ox_element("m", namespace: "m")
-          mpr    = Utility.ox_element("mpr", namespace: "m")
+          mpr    = Utility.ox_element("mPr", namespace: "m")
           mcs    = Utility.ox_element("mcs", namespace: "m")
           mc     = Utility.ox_element("mc", namespace: "m")
           mcpr   = Utility.ox_element("mcPr", namespace: "m")
@@ -222,7 +226,7 @@ module Plurimath
           mcs << mc
           mpr << mcs
           mpr << ctrlpr
-          mm_value = value&.map { |obj| obj.to_omml_without_math_tag(display_style) }
+          mm_value = value&.map { |object| object.to_omml_without_math_tag(display_style) }
           Utility.update_nodes(
             mm,
             mm_value.insert(0, mpr).flatten,
@@ -276,6 +280,10 @@ module Plurimath
 
           parenthesis
         end
+
+        def parentheless_table
+          "{:#{value.map(&:to_asciimath).join(", ")}:}"
+        end
       end
     end
   end

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

@@ -36,10 +36,7 @@ module Plurimath
           me = Utility.ox_element("e", namespace: "m")
           return [me] if parameter_one&.empty?
 
-          Utility.update_nodes(
-            me,
-            Formula.new(parameter_one).omml_content(display_style),
-          )
+          Utility.update_nodes(me, omml_content(display_style))
           [me]
         end
 
@@ -70,6 +67,19 @@ module Plurimath
             Formula.new(parameter_one).to_omml_math_zone(gsub_spacing(spacing, last), last, indent, display_style: display_style),
           ]
         end
+
+        def omml_content(display_style)
+          parameter_one&.map { |val| val.insert_t_tag(display_style) }
+        end
+
+        def line_breaking(obj)
+          sliced_value = result(Array(parameter_one))
+          return unless sliced_value.length > 1
+
+          sliced_result = sliced_value.first.last.omml_line_break(sliced_value)
+          table = Table.new(sliced_result.map { |res| Tr.new(Array(Td.new(Array(res)))) })
+          self.parameter_one = [table]
+        end
       end
     end
   end

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
 
@@ -99,10 +101,6 @@ module Plurimath
           new_arr
         end
 
-        def any_value_exist?
-          !(parameter_one.nil? || parameter_two.nil? || parameter_three.nil?)
-        end
-
         protected
 
         def latex_wrapped(field)

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

@@ -29,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]

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

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,25 +55,13 @@ 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
 
         def to_asciimath_math_zone(spacing, last = false, _)
@@ -115,6 +104,39 @@ module Plurimath
           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 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
@@ -147,15 +169,39 @@ 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
   end

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

@@ -28,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
@@ -50,6 +46,27 @@ module Plurimath
 
           underover(display_style)
         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
+
+          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
     end
   end

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

@@ -13,15 +13,11 @@ module Plurimath
         }.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)
@@ -43,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

@@ -77,6 +77,11 @@ module Plurimath
           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/number.rb

@@ -29,17 +29,17 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag(_display_style)
+      def to_omml_without_math_tag(_)
         [t_tag]
       end
 
-      def insert_t_tag(_display_style)
+      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
 

data/lib/plurimath/math/symbol.rb

@@ -5,7 +5,7 @@ module Plurimath
     class Symbol < Core
       attr_accessor :value
 
-      def initialize(sym)
+      def initialize(sym = nil)
         @value = sym.is_a?(Parslet::Slice) ? sym.to_s : sym
       end
 
@@ -56,11 +56,11 @@ module Plurimath
         value
       end
 
-      def to_omml_without_math_tag(_display_style)
+      def to_omml_without_math_tag(_, _)
         value
       end
 
-      def insert_t_tag(_display_style)
+      def insert_t_tag(_)
         [(Utility.ox_element("r", namespace: "m") << t_tag)]
       end
 
@@ -76,7 +76,7 @@ module Plurimath
         "subSup"
       end
 
-      def font_style_t_tag(_display_style)
+      def font_style_t_tag(_)
         t_tag
       end
 
@@ -88,7 +88,7 @@ module Plurimath
         false
       end
 
-      def omml_nodes(display_style)
+      def omml_nodes(_)
         Array(t_tag)
       end
 
@@ -96,6 +96,14 @@ module Plurimath
         Utility.ox_element("t", namespace: "m") << value
       end
 
+      def separate_table
+        ["&", "\\\\"].include?(value)
+      end
+
+      def linebreak
+        value == "\\\\"
+      end
+
       private
 
       def operator?(unicode)

data/lib/plurimath/mathml/parser.rb

@@ -8,9 +8,11 @@ module Plurimath
       attr_accessor :text
 
       SUPPORTED_ATTRS = %w[
+        linebreakstyle
         columnlines
         mathvariant
         accentunder
+        linebreak
         mathcolor
         notation
         accent

data/lib/plurimath/mathml/transform.rb

@@ -9,6 +9,7 @@ module Plurimath
       rule(mtd: sequence(:mtd))     { Math::Function::Td.new(mtd) }
       rule(mtr: sequence(:mtr))     { Math::Function::Tr.new(mtr) }
       rule(none: sequence(:none))   { nil }
+      rule(mspace: simple(:space))  { nil }
       rule(notation: simple(:att))  { Math::Function::Menclose.new(att) }
       rule(mtable: simple(:table))  { table }
       rule(msqrt: sequence(:sqrt))  { Math::Function::Sqrt.new(sqrt.first) }
@@ -36,7 +37,9 @@ module Plurimath
       end
 
       rule(mphantom: sequence(:phantom)) do
-        Math::Function::Phantom.new(phantom)
+        Math::Function::Phantom.new(
+          Utility.filter_values(phantom),
+        )
       end
 
       rule(mn: sequence(:mn)) do
@@ -316,11 +319,6 @@ module Plurimath
         end
       end
 
-      rule(attributes: simple(:attrs),
-           value: subtree(:value)) do
-        Utility.join_attr_value(attrs, value&.flatten&.compact)
-      end
-
       rule(semantics: subtree(:value)) do
         Math::Function::Semantics.new(
           value.shift,
@@ -328,17 +326,27 @@ module Plurimath
         )
       end
 
+      rule(attributes: simple(:attrs),
+           value: subtree(:value)) do
+        Utility.join_attr_value(attrs, value&.flatten&.compact)
+      end
+
       rule(attributes: subtree(:attrs),
            value: sequence(:value)) do
-        approved_attrs = if attrs.is_a?(Hash)
-                           supported_attrs = %w[accentunder accent]
-                           attrs if attrs.keys.any? do |k|
-                             supported_attrs.include?(k.to_s)
-                           end
-                         else
-                           attrs
-                         end
-        Utility.join_attr_value(approved_attrs, value&.flatten&.compact)
+        approved = if attrs.is_a?(Hash)
+                     supported = %w[accentunder accent linebreak]
+                     if attrs.keys.any? { |k| supported.include?(k.to_s) }
+                       unicode_only = true if attrs.key?(:linebreak)
+                       attrs
+                     end
+                   else
+                     attrs
+                   end
+        Utility.join_attr_value(
+          approved,
+          value&.flatten&.compact,
+          unicode_only: unicode_only,
+        )
       end
     end
   end

data/lib/plurimath/omml/transform.rb

@@ -9,6 +9,7 @@ module Plurimath
       rule(i: sequence(:i)) { i }
       rule(e: sequence(:e)) { e.flatten.compact }
 
+      rule(br: sequence(:br))    { Math::Function::Linebreak.new }
       rule(val: simple(:val))    { val }
       rule(scr: simple(:scr))    { scr }
       rule(sty: simple(:sty))    { sty }
@@ -210,7 +211,7 @@ module Plurimath
         end
         if Utility.valid_class(subsup[0])
           Utility.get_class(
-            subsup[0].extract_class_from_text,
+            subsup[0].extract_class_name_from_text,
           ).new(
             subsup[1],
             subsup[2],
@@ -256,20 +257,31 @@ module Plurimath
       rule(limUpp: subtree(:lim)) do
         lim_values = lim.flatten.compact
         first_value = lim_values[0]
-        Math::Function::Overset.new(
-          first_value,
-          lim_values[1],
-        )
+        if lim.last.is_unary? && lim.last.value_nil?
+          function_class = lim.pop
+          function_class.parameter_one = Utility.filter_values(lim.flatten.compact)
+          function_class
+        else
+          Math::Function::Overset.new(
+            first_value,
+            lim_values[1],
+          )
+        end
       end
 
       rule(limLow: subtree(:lim)) do
         second_value = Utility.filter_values(lim[2])
-        unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[second_value.class_name]
+        unicode = Mathml::Constants::UNICODE_SYMBOLS.invert[second_value&.class_name]
         second_value = unicode ? Math::Symbol.new(unicode.to_s) : second_value
-        Math::Function::Underset.new(
-          Utility.filter_values(lim[1]),
-          second_value,
-        )
+        if second_value.is_unary? && second_value.value_nil?
+          second_value.parameter_one = Utility.filter_values(lim[1])
+          second_value
+        else
+          Math::Function::Underset.new(
+            Utility.filter_values(lim[1]),
+            second_value,
+          )
+        end
       end
 
       rule(borderBox: subtree(:box)) do

data/lib/plurimath/unitsml.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "unitsml"
 module Plurimath
   class Unitsml
     attr_accessor :text
@@ -9,7 +10,7 @@ module Plurimath
     end
 
     def to_formula
-      # TODO: Will be implemented soon
+      ::Unitsml.parse(text).to_plurimath
     end
   end
 end