plurimath 0.5.0 → 0.7.0

data/lib/plurimath/math/formula.rb

@@ -5,6 +5,13 @@ module Plurimath
     class Formula < Core
       attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string
 
+      MATH_ZONE_TYPES = %i[
+        omml
+        latex
+        mathml
+        asciimath
+      ].freeze
+
       def initialize(
         value = [],
         left_right_wrapper = true,
@@ -18,7 +25,9 @@ module Plurimath
       end
 
       def ==(object)
-        object.value == value &&
+        object.respond_to?(:value) &&
+          object.respond_to?(:left_right_wrapper) &&
+          object.value == value &&
           object.left_right_wrapper == left_right_wrapper
       end
 
@@ -28,21 +37,29 @@ module Plurimath
         parse_error!(:asciimath)
       end
 
-      def to_mathml(display_style: displaystyle)
+      def to_mathml(display_style: displaystyle, split_on_linebreak: false)
+        return line_breaked_mathml(display_style) if split_on_linebreak
+
         math_attrs = {
           xmlns: "http://www.w3.org/1998/Math/MathML",
           display: "block",
         }
         style_attrs = { displaystyle: boolean_display_style(display_style) }
-        math  = Utility.ox_element("math", attributes: math_attrs)
-        style = Utility.ox_element("mstyle", attributes: style_attrs)
+        math  = ox_element("math", attributes: math_attrs)
+        style = ox_element("mstyle", attributes: style_attrs)
         Utility.update_nodes(style, mathml_content)
         Utility.update_nodes(math, [style])
-        Ox.dump(math, indent: 2).gsub("&amp;", "&")
+        dump_nodes(math, indent: 2)
       rescue
         parse_error!(:mathml)
       end
 
+      def line_breaked_mathml(display_style)
+        new_line_support.map do |formula|
+          formula.to_mathml(display_style: display_style)
+        end.join
+      end
+
       def to_mathml_without_math_tag
         return mathml_content unless left_right_wrapper
 
@@ -68,7 +85,7 @@ module Plurimath
         parse_error!(:html)
       end
 
-      def omml_math_attrs
+      def omml_attrs
         {
           "xmlns:m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
           "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
@@ -91,16 +108,20 @@ module Plurimath
         }
       end
 
-      def to_omml(display_style: displaystyle)
-        para_element = Utility.ox_element(
-          "oMathPara",
-          attributes: omml_math_attrs,
-          namespace: "m",
-        )
-        math_element = Utility.ox_element("oMath", namespace: "m")
-        content = omml_content(boolean_display_style(display_style))
-        para_element << Utility.update_nodes(math_element, content)
-        Ox.dump(para_element, indent: 2).gsub("&amp;", "&").lstrip
+      def to_omml(display_style: displaystyle, split_on_linebreak: false)
+        objects = split_on_linebreak ? new_line_support : [self]
+
+        para_element = Utility.ox_element("oMathPara", attributes: omml_attrs, namespace: "m")
+        objects.each.with_index(1) do |object, index|
+          para_element << Utility.update_nodes(
+            Utility.ox_element("oMath", namespace: "m"),
+            object.omml_content(boolean_display_style(display_style)),
+          )
+          next if objects.length == index
+
+          para_element << omml_br_tag
+        end
+        dump_nodes(para_element, indent: 2)
       rescue
         parse_error!(:omml)
       end
@@ -110,24 +131,58 @@ module Plurimath
       end
 
       def to_omml_without_math_tag(display_style)
-        return nary_tag(display_style) if nary_tag_able?(display_style)
-
         omml_content(display_style)
       end
 
-      def nary_tag(display_style)
-        nary_element = Utility.ox_element("nary", namespace: "m")
-        e_tag    = Utility.ox_element("e", namespace: "m")
-        Utility.update_nodes(e_tag, value.last.insert_t_tag(display_style))
-        Utility.update_nodes(
-          nary_element,
-          (value.first.omml_nary_tag(display_style) << e_tag),
-        )
-        [nary_element]
+      def to_display(type = nil)
+        return type_error! unless MATH_ZONE_TYPES.include?(type.downcase.to_sym)
+
+        math_zone = case type
+                    when :asciimath
+                      "  |_ \"#{to_asciimath}\"\n#{to_asciimath_math_zone("     ").join}"
+                    when :latex
+                      "  |_ \"#{to_latex}\"\n#{to_latex_math_zone("     ").join}"
+                    when :mathml
+                      "  |_ \"#{to_mathml.gsub(/\n\s*/, "")}\"\n#{to_mathml_math_zone("     ").join}"
+                    when :omml
+                      "  |_ \"#{to_omml.gsub(/\n\s*/, "")}\"\n#{to_omml_math_zone("     ", display_style: displaystyle).join}"
+                    end
+        <<~MATHZONE.sub(/\n$/, "")
+        |_ Math zone
+        #{math_zone}
+        MATHZONE
       end
 
-      def extract_class_from_text
-        return false unless (value.length < 2 && value&.first&.is_a?(Function::Text))
+      def to_asciimath_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_asciimath_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_latex_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_latex_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_mathml_math_zone(spacing = "", last = false, indent = true)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_mathml_math_zone(new_space(spacing, indent), last, indent)
+        end
+      end
+
+      def to_omml_math_zone(spacing = "", last = false, indent = true, display_style:)
+        filtered_values(value).map.with_index(1) do |object, index|
+          last = index == @values.length
+          object.to_omml_math_zone(new_space(spacing, indent), last, indent, display_style: display_style)
+        end
+      end
+
+      def extract_class_name_from_text
+        return unless value.length < 2 && value.first.is_a?(Function::Text)
 
         value.first.parameter_one
       end
@@ -136,29 +191,88 @@ module Plurimath
         value.first.nary_attr_value
       end
 
-      def nary_tag_able?(display_style)
-        value.length == 2 &&
-          ["underover", "powerbase"].include?(value&.first&.class_name) &&
-          !value.first.parameter_one.is_a?(Function::FontStyle) &&
-          (
-            value&.first&.parameter_one&.to_omml_without_math_tag(display_style)&.length == 1 ||
-            value&.first&.parameter_one.to_omml_without_math_tag(display_style).match?(/^&#x\w*\d*;$/)
-          )
-      end
-
       def validate_function_formula
         (value.none?(Function::Left) || value.none?(Function::Right))
       end
 
+      def value_exist?
+        value && !value.empty?
+      end
+
+      def update(object)
+        self.value = Array(object)
+      end
+
+      def cloned_objects
+        cloned_obj = value.map(&:cloned_objects)
+        formula = self.class.new(cloned_obj)
+        formula.left_right_wrapper = @left_right_wrapper
+        formula
+      end
+
+      def new_line_support(array = [])
+        cloned = cloned_objects
+        obj = self.class.new
+        cloned.line_breaking(obj)
+        array << cloned
+        obj.value_exist? ? obj.new_line_support(array) : array
+      end
+
+      def line_breaking(obj)
+        if result.size > 1
+          breaked_result = result.first.last.omml_line_break(result)
+          update(Array(breaked_result.shift))
+          obj.update(breaked_result.flatten)
+          reprocess_value(obj)
+          return
+        end
+
+        value.each.with_index(1) do |object, index|
+          object.line_breaking(obj)
+          break obj.insert(value.slice!(index..value.size)) if obj.value_exist?
+        end
+      end
+
+      def reprocess_value(obj)
+        new_obj = self.class.new([])
+        self.line_breaking(new_obj)
+        if new_obj.value_exist?
+          obj.value.insert(0, Function::Linebreak.new)
+          obj.value.insert(0, self.class.new(new_obj.value))
+        end
+      end
+
+      def insert(values)
+        update(Array(value) + values)
+      end
+
+
       protected
 
       def boolean_display_style(display_style = displaystyle)
-        YAML.load(display_style.to_s)
+        YAML.safe_load(display_style.to_s)
+      end
+
+      def new_space(spacing, indent)
+        if value.any? { |val| val.class_name == "left" } && value.any? { |val| val.class_name == "right" }
+          return spacing
+        end
+
+        (indent && wrapable?(spacing)) ? spacing + "|_ " : spacing
+      end
+
+      def wrapable?(spacing)
+        left_right_wrapper && !spacing.end_with?("|_ ")
       end
 
       def parse_error!(type)
         Math.parse_error!(input_string, type)
       end
+
+      def omml_br_tag
+        r_tag = ox_element("r", namespace: "m")
+        r_tag << ox_element("br")
+      end
     end
   end
 end

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

@@ -6,32 +6,45 @@ module Plurimath
   module Math
     module Function
       class Abs < UnaryFunction
+        attr_accessor :open_paren, :close_paren
+
         def to_mathml_without_math_tag
           symbol = Utility.ox_element("mo") << "|"
-          first_value = mathml_value&.insert(0, symbol)
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            first_value << symbol,
-          )
+          first_value = mathml_value
+          first_value = first_value&.insert(0, symbol) unless open_paren
+          first_value << symbol unless close_paren
+          Utility.update_nodes(ox_element("mrow"), first_value)
         end
 
         def to_omml_without_math_tag(display_style)
-          md = (Utility.ox_element("d", namespace: "m") << mdpr_tag)
-          me = Utility.ox_element("e", namespace: "m")
-          Utility.update_nodes(me, omml_value(display_style))
-          Utility.update_nodes(md, Array(me))
-          [md]
+          Array(
+            md_tag << omml_parameter(parameter_one, display_style, tag_name: "e"),
+          )
+        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
 
         protected
 
-        def mdpr_tag
+        def md_tag
           attribute = { "m:val": "|" }
+          sepchr_attr = { "m:val": "" }
           mdpr = Utility.pr_element("d", namespace: "m")
-          mdpr << Utility.ox_element("begChr", namespace: "m", attributes: attribute)
-          mdpr << Utility.ox_element("endChr", namespace: "m", attributes: attribute)
-          mdpr << Utility.ox_element("sepChr", namespace: "m", attributes: { "m:val": "" })
-          mdpr << Utility.ox_element("grow", namespace: "m")
+          mdpr << ox_element("begChr", namespace: "m", attributes: attribute) unless open_paren
+          mdpr << ox_element("endChr", namespace: "m", attributes: attribute) unless close_paren
+          mdpr << ox_element("sepChr", namespace: "m", attributes: sepchr_attr)
+          mdpr << ox_element("grow", namespace: "m")
+          ox_element("d", namespace: "m") << mdpr
         end
       end
     end

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

@@ -48,6 +48,11 @@ module Plurimath
           Ul.new(parameter_one, attributes)
         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/base.rb

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Base < BinaryFunction
+        FUNCTION = {
+          name: "subscript",
+          first_value: "base",
+          second_value: "script",
+        }.freeze
+
         def to_asciimath
           first_value = parameter_one.to_asciimath if parameter_one
           second_value = "_#{wrapped(parameter_two)}" if parameter_two
@@ -16,8 +22,8 @@ module Plurimath
           tag_name = (Utility::MUNDER_CLASSES.include?(parameter_one&.class_name) ? "under" : "sub")
           sub_tag = Utility.ox_element("m#{tag_name}")
           mathml_value = []
-          mathml_value << parameter_one&.to_mathml_without_math_tag
-          mathml_value << parameter_two&.to_mathml_without_math_tag if parameter_two
+          mathml_value << validate_mathml_fields(parameter_one)
+          mathml_value << validate_mathml_fields(parameter_two)
           Utility.update_nodes(sub_tag, mathml_value)
         end
 
@@ -48,6 +54,20 @@ module Plurimath
           )
           [ssub_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
+            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/binary_function.rb

@@ -4,12 +4,12 @@ module Plurimath
   module Math
     module Function
       class BinaryFunction < Core
-        attr_accessor :parameter_one, :parameter_two
+        attr_accessor :parameter_one, :parameter_two, :hide_function_name
 
         def initialize(parameter_one = nil, parameter_two = nil)
           @parameter_one = parameter_one
           @parameter_two = parameter_two
-          Utility.validate_left_right([parameter_one, parameter_two])
+          Utility.validate_left_right(variables.map { |var| get(var) })
         end
 
         def to_asciimath
@@ -64,6 +64,42 @@ module Plurimath
           !(parameter_one.nil? && parameter_two.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 })
+          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 })
+          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 })
+          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 })
+          new_arr
+        end
+
         protected
 
         def latex_wrapped(field)
@@ -80,16 +116,6 @@ module Plurimath
           "(#{field.to_asciimath})"
         end
 
-        def invert_unicode_symbols
-          Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
-        end
-
-        def empty_tag(wrapper_tag)
-          r_tag = Utility.ox_element("r", namespace: "m")
-          r_tag << (Utility.ox_element("t", namespace: "m") << "&#8203;")
-          wrapper_tag << r_tag
-        end
-
         def underover(display_style)
           return r_element(class_name, rpr_tag: false) unless all_values_exist?
 

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

@@ -6,23 +6,22 @@ module Plurimath
   module Math
     module Function
       class Ceil < UnaryFunction
+        attr_accessor :open_paren, :close_paren
+
         def to_latex
           "{\\lceil #{latex_value} \\rceil}"
         end
 
         def to_mathml_without_math_tag
-          left_value = Utility.ox_element("mo") << "&#x2308;"
-          first_value = mathml_value&.insert(0, left_value)
-          right_value = Utility.ox_element("mo") << "&#x2309;"
-          Utility.update_nodes(
-            Utility.ox_element("mrow"),
-            first_value << right_value,
-          )
+          first_value = mathml_value
+          first_value = first_value&.insert(0, paren_node("&#x2308;")) unless open_paren
+          first_value = first_value << paren_node("&#x2309;") unless close_paren
+          Utility.update_nodes(ox_element("mrow"), first_value)
         end
 
         def to_omml_without_math_tag(display_style)
-          lceil = Symbol.new("⌈")
-          rceil = Symbol.new("⌉")
+          lceil = Symbol.new("⌈") unless open_paren
+          rceil = Symbol.new("⌉") unless close_paren
           fenced = Fenced.new(lceil, Array(parameter_one), rceil)
           Array(fenced.to_omml_without_math_tag(display_style))
         end
@@ -31,6 +30,22 @@ module Plurimath
           first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
           "<i>&#x2308;</i>#{first_value}<i>&#x2309;</i>"
         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
+
+        def paren_node(value)
+          ox_element("mo") << value
+        end
       end
     end
   end

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

@@ -6,6 +6,12 @@ module Plurimath
   module Math
     module Function
       class Color < BinaryFunction
+        FUNCTION = {
+          name: "color",
+          first_value: "mathcolor",
+          second_value: "text",
+        }.freeze
+
         def to_asciimath
           first_value = "(#{parameter_one&.to_asciimath&.gsub(/\s/, '')})"
           second_value = "(#{parameter_two&.to_asciimath})"
@@ -31,6 +37,14 @@ module Plurimath
         def to_omml_without_math_tag(display_style)
           Array(parameter_two.insert_t_tag(display_style))
         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_two, { spacing: new_spacing, field_name: "text", additional_space: "|  |_ ", array: new_arr, display_style: display_style })
+          new_arr
+        end
       end
     end
   end

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

@@ -21,7 +21,7 @@ module Plurimath
           )
         end
 
-        def to_omml_without_math_tag(display_style)
+        def to_omml_without_math_tag(_)
           return r_element("..", rpr_tag: false) unless parameter_one
 
           symbol = Symbol.new("..")
@@ -32,6 +32,11 @@ module Plurimath
           first_value = "<i>#{parameter_one.to_html}</i>" if parameter_one
           "#{first_value}<i>..</i>"
         end
+
+        def line_breaking(obj)
+          parameter_one&.line_breaking(obj)
+          obj.update(Utility.filter_values(obj.value)) if obj.value_exist?
+        end
       end
     end
   end

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

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

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

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

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

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

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

@@ -41,6 +41,11 @@ module Plurimath
           end
         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/exp.rb

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