plurimath 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af2ed460bf37f3496c528c6cb170f2c555873332771086113f90a875312b467a
-  data.tar.gz: d9311eaf4dfb84c188966346a38d273e544f035c573afb50898bd9f03f81c9fc
+  metadata.gz: d27853f7e998552c58b54113306cf188d8c8e64bad83cf31a688abc7414dd6d9
+  data.tar.gz: ccd6b77d70a82d3e2727a65d6f3976e4afc1b3454753ddb7d6a6837206735b7c
 SHA512:
-  metadata.gz: cffd311295a1f9e41d372c544909029da3f5798f5744e14e549dd1d7e220755971d5bec0a91cc3695fdef25f3d9b44de606da37876c615eee3cc3818eadbe6e9
-  data.tar.gz: f4035ab63d7f2f3f0aef261f9491ed163a1ffec03d52011b7dda140d6ce4c303bd277a5d05487028b8c77c32585359a826d85fcfc46bb32220e4d1b103b54fb3
+  metadata.gz: a8a69ff2bb1379646f798502cfb307adb9df9be44c129da7d1d2bf2ee1cca61086a0d1124e5d22d0460ab166da44ac9a82bf41ba770a097eef4d78f35127635d
+  data.tar.gz: 48aa6427c4a764e3736a0ca8b7af503bcc1d8000fb2807f5fe42ba902f1cd73221e74384da0ac0f14b482c3792c7941eb59d70699790cc100cad4b6ba5fab60a

data/Gemfile

@@ -11,3 +11,4 @@ gem 'equivalent-xml'
 gem 'opal-rspec', "~> 1.1.0a"
 gem 'oga'
 gem 'ox'
+gem "unitsml"

data/lib/plurimath/asciimath/parse.rb

@@ -69,7 +69,8 @@ module Plurimath
       end
 
       rule(:quoted_text) do
-        (str('"') >> match("[^\"]").repeat.as(:text) >> str('"')) |
+        (str('"') >> str("unitsml(") >> match("[^\)\"]").repeat.as(:unitsml) >> str(')"')) |
+          (str('"') >> match("[^\"]").repeat.as(:text) >> str('"')) |
           (str('"') >> str("").as(:text))
       end
 
@@ -188,7 +189,7 @@ module Plurimath
       def dynamic_parser_rules(expr)
         first_value = str(expr.first.to_s)
         case expr.last
-        when :symbol then first_value.as(:symbol)
+        when :symbol then (str("\\").as(:slash) >> match("\s").repeat >> str("\n")) | first_value.as(:symbol)
         when :unary_class then (first_value.as(:unary_class) >> space? >> sequence.maybe).as(:unary)
         when :fonts then first_value.as(:fonts_class) >> space? >> sequence.as(:fonts_value)
         when :special_fonts then first_value.as(:bold_fonts)

data/lib/plurimath/asciimath/transform.rb

@@ -8,6 +8,7 @@ module Plurimath
       rule(unary: simple(:unary))   { unary }
       rule(table: simple(:table))   { table }
       rule(comma: simple(:comma))   { Utility.symbol_object(comma) }
+      rule(slash: simple(:slash))   { Math::Function::Linebreak.new }
       rule(unary: sequence(:unary)) { Utility.filter_values(unary) }
       rule(rparen: simple(:rparen)) { Utility.symbol_object(rparen) }
       rule(number: simple(:number)) { Math::Number.new(number) }
@@ -27,6 +28,12 @@ module Plurimath
       rule(power_value: sequence(:power_value))    { power_value }
       rule(mod: simple(:mod), expr: simple(:expr)) { [mod, expr] }
 
+      rule(unitsml: simple(:unitsml)) do
+        Utility.filter_values(
+          Unitsml.new(unitsml.to_s).to_formula.value,
+        )
+      end
+
       rule(bold_fonts: simple(:font)) do
         Math::Function::FontStyle::DoubleStruck.new(
           Utility.symbol_object(font.to_s[0]),
@@ -303,11 +310,15 @@ module Plurimath
       end
 
       rule(td: simple(:td)) do
-        Math::Function::Td.new(
-          [
-            Utility.td_value(td),
-          ],
-        )
+        if td.is_a?(Math::Formula) && td.value.any?(Math::Function::Table)
+          Utility.td_values(td.value, ",")
+        else
+          Math::Function::Td.new(
+            [
+              Utility.td_value(td),
+            ],
+          )
+        end
       end
 
       rule(td: sequence(:td)) do
@@ -631,6 +642,13 @@ module Plurimath
         new_arr
       end
 
+      rule(sequence: sequence(:sequence),
+           left_right: simple(:left_right)) do
+        new_arr = sequence.flatten.compact
+        new_arr << left_right unless left_right.to_s.strip.empty?
+        new_arr
+      end
+
       rule(sequence: sequence(:sequence),
            expr: sequence(:expr)) do
         sequence.flatten.compact + expr.flatten.compact
@@ -860,6 +878,15 @@ module Plurimath
         )
       end
 
+      rule(unary_class: simple(:function),
+           unitsml: simple(:unitsml)) do
+        Utility.get_class(function).new(
+          Utility.filter_values(
+            Unitsml.new(unitsml.to_s).to_formula.value,
+          ),
+        )
+      end
+
       rule(number: simple(:number),
            comma: simple(:comma)) do
         [

data/lib/plurimath/latex/constants.rb

@@ -2856,6 +2856,7 @@ module Plurimath
         overline: :unary,
         underset: :binary,
         overset: :binary,
+        phantom: :unary,
         ddagger: :symbols,
         trprime: :symbols,
         closure: :symbols,
@@ -3562,7 +3563,7 @@ module Plurimath
         tanh: :unary,
         cosh: :unary,
         ddot: :unary,
-        mbox: :unary,
+        mbox: :text,
         text: :text,
         '"': :symbols,
         sum: :ternary,

data/lib/plurimath/latex/transform.rb

@@ -14,7 +14,7 @@ module Plurimath
       rule(lparen: simple(:lparen))   { Math::Symbol.new(lparen) }
       rule(rparen: simple(:rparen))   { Math::Symbol.new(rparen) }
       rule(limits: simple(:limits))   { limits }
-      rule("\\\\" => simple(:slash))  { Math::Symbol.new(slash) }
+      rule("\\\\" => simple(:slash))  { Math::Function::Linebreak.new }
       rule(expression: simple(:expr)) { expr }
       rule(environment: simple(:env)) { env }
       rule(ternary: simple(:ternary)) { Utility.get_class(ternary).new }
@@ -488,19 +488,19 @@ module Plurimath
 
       rule(text: simple(:text),
            first_value: simple(:first_value)) do
-        Math::Function::Text.new(first_value)
+        Utility.get_class(text).new(first_value)
       end
 
       rule(text: simple(:text),
            first_value: sequence(:first_value)) do
-        Math::Function::Text.new(first_value.join)
+        Utility.get_class(text).new(first_value.join)
       end
 
       rule(text: simple(:text),
            first_value: simple(:first_value),
            supscript: simple(:supscript),) do
         Math::Function::Power.new(
-          Math::Function::Text.new(first_value),
+          Utility.get_class(text).new(first_value),
           supscript,
         )
       end
@@ -509,7 +509,7 @@ module Plurimath
            first_value: sequence(:first_value),
            supscript: simple(:supscript),) do
         Math::Function::Power.new(
-          Math::Function::Text.new(first_value.join),
+          Utility.get_class(text).new(first_value.join),
           supscript,
         )
       end
@@ -518,7 +518,7 @@ module Plurimath
            first_value: sequence(:first_value),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
-          Math::Function::Text.new(first_value.join),
+          Utility.get_class(text).new(first_value.join),
           subscript,
         )
       end
@@ -527,7 +527,7 @@ module Plurimath
            first_value: simple(:first_value),
            subscript: simple(:subscript)) do
         Math::Function::Base.new(
-          Math::Function::Text.new(first_value),
+          Utility.get_class(text).new(first_value),
           subscript,
         )
       end
@@ -537,7 +537,7 @@ module Plurimath
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
         Math::Function::PowerBase.new(
-          Math::Function::Text.new(first_value),
+          Utility.get_class(text).new(first_value),
           subscript,
           supscript,
         )
@@ -948,12 +948,8 @@ module Plurimath
 
       rule(substack: simple(:substack),
            expression: sequence(:value)) do
-        tds = Utility.td_values(value, "\\\\")
-
-        substack_values = tds.map { |td| Math::Function::Tr.new([td]) }
         Math::Function::Substack.new(
-          substack_values.shift,
-          substack_values.shift,
+          Utility.organize_table(value),
         )
       end
     end

data/lib/plurimath/math/core.rb

@@ -3,6 +3,11 @@
 module Plurimath
   module Math
     class Core
+      REPLACABLES = {
+        /&/ => "&",
+        /^\n/ => "",
+      }
+
       def class_name
         self.class.name.split("::").last.downcase
       end
@@ -24,18 +29,18 @@ module Plurimath
       end
 
       def empty_tag(wrapper_tag)
-        r_tag = Utility.ox_element("r", namespace: "m")
-        r_tag << (Utility.ox_element("t", namespace: "m") << "&#8203;")
+        r_tag = ox_element("r", namespace: "m")
+        r_tag << (ox_element("t", namespace: "m") << "&#8203;")
         wrapper_tag << r_tag
       end
 
-      def omml_parameter(field, display_style, tag_name: , namespace: "m")
-        tag = Utility.ox_element(tag_name, namespace: namespace)
+      def omml_parameter(field, display_style, tag_name:, namespace: "m")
+        tag = ox_element(tag_name, namespace: namespace)
         return empty_tag(tag) unless field
 
         Utility.update_nodes(
           tag,
-          field&.insert_t_tag(display_style),
+          field.insert_t_tag(display_style),
         )
       end
 
@@ -44,12 +49,13 @@ module Plurimath
       end
 
       def r_element(string, rpr_tag: true)
-        r_tag = Utility.ox_element("r", namespace: "m")
+        r_tag = ox_element("r", namespace: "m")
         if rpr_tag
-          sty_tag = Utility.ox_element("sty", namespace: "m", attributes: { "m:val": "p" })
-          r_tag << (Utility.ox_element("rPr", namespace: "m") << sty_tag)
+          attrs = { "m:val": "p" }
+          sty_tag = ox_element("sty", namespace: "m", attributes: attrs)
+          r_tag << (ox_element("rPr", namespace: "m") << sty_tag)
         end
-        r_tag << (Utility.ox_element("t", namespace: "m") << string)
+        r_tag << (ox_element("t", namespace: "m") << string)
         Array(r_tag)
       end
 
@@ -57,7 +63,7 @@ module Plurimath
         false
       end
 
-      def extract_class_from_text
+      def extract_class_name_from_text
         ""
       end
 
@@ -107,16 +113,13 @@ module Plurimath
       end
 
       def dump_mathml(field)
-        mathml = dump_ox_nodes(field.to_mathml_without_math_tag)
-        mathml.gsub(/\n\s*/, "").gsub("&amp;", "&")
+        dump_ox_nodes(field.to_mathml_without_math_tag).gsub(/\n\s*/, "")
       end
 
       def dump_omml(field, display_style)
         return if field.nil?
 
-        omml = field.omml_nodes(display_style)
-        omml_string = omml.is_a?(Array) ? omml.flatten.map { |obj| dump_ox_nodes(obj) }.join : dump_ox_nodes(omml)
-        omml_string.gsub(/\n\s*/, "").gsub("&amp;", "&")
+        dump_ox_nodes(field.omml_nodes(display_style)).gsub(/\n\s*/, "")
       end
 
       def omml_nodes(display_style)
@@ -124,16 +127,16 @@ module Plurimath
       end
 
       def validate_mathml_fields(field)
-        field.nil? ? Utility.ox_element("mi") : field.to_mathml_without_math_tag
+        field.nil? ? ox_element("mi") : field.to_mathml_without_math_tag
       end
 
       def common_math_zone_conversion(field, options = {})
         {
           spacing: options[:spacing],
           last: options[:last] || true,
-          indent: !field&.is_a?(Formula),
+          indent: !field.is_a?(Formula),
           function_spacing: "#{options[:spacing]}#{options[:additional_space]}",
-          field_name: options[:field_name] ?  " #{options[:field_name]}" : "",
+          field_name: (options[:field_name] ? " #{options[:field_name]}" : ""),
         }
       end
 
@@ -142,16 +145,127 @@ module Plurimath
       end
 
       def dump_ox_nodes(nodes)
-        Plurimath.xml_engine.dump(nodes)
+        return dump_nodes(nodes) unless nodes.is_a?(Array)
+
+        nodes.flatten.map { |node| dump_nodes(node) }.join
+      end
+
+      def dump_nodes(nodes, indent: nil)
+        replacable_values(
+          Plurimath.xml_engine.dump(nodes, indent: indent),
+        )
+      end
+
+      def replacable_values(string)
+        REPLACABLES.each { |regex, str| string.gsub!(regex, str) }
+        string
       end
 
       def gsub_spacing(spacing, last)
-        spacing.gsub(/\|\_/, last ? "  " : "| ")
+        spacing.gsub(/\|_/, last ? "  " : "| ")
       end
 
       def invert_unicode_symbols
         Mathml::Constants::UNICODE_SYMBOLS.invert[class_name] || class_name
       end
+
+      def separate_table
+        false
+      end
+
+      def linebreak
+        false
+      end
+
+      def cloned_objects
+        object = self.class.new rescue self.class.new(nil)
+        variables.each { |var| object.set(var, variable_value(get(var))) }
+        object
+      end
+
+      def variable_value(value)
+        case value
+        when Core
+          value.cloned_objects
+        when Array
+          value.map { |object| variable_value(object) }
+        else
+          value
+        end
+      end
+
+      def line_breaking(obj)
+        variables.each do |variable|
+          field = get(variable)
+          case field
+          when Core
+            field.line_breaking(obj)
+            updated_object_values(variable, obj: obj, update_value: true) if obj.value_exist?
+          when Array
+            if result(field).length > 1
+              updated_object_values(variable, obj: obj)
+            else
+              field.each { |object| object.line_breaking(obj) }
+            end
+          end
+        end
+      end
+
+      def updated_object_values(param, obj:, update_value: false)
+        object = self.class.new(nil)
+        found = false
+        variables.each do |variable|
+          value = if param == variable
+                    found = true
+                    if update_value
+                      return_value = obj.value
+                      obj.value = []
+                      return_value
+                    else
+                      formula = Formula.new(get(variable))
+                      formula.line_breaking(obj)
+                      set(variable, obj)
+                      get(variable)
+                    end
+                  else
+                    return_value = get(variable)
+                    set(variable, nil) if found
+                    return_value
+                  end
+          object.set(variable, Utility.filter_values(value))
+        end
+        object.hide_function_name = true if object.methods.include?(:hide_function_name)
+        obj.update(object)
+      end
+
+      def get(variable)
+        instance_variable_get(variable)
+      end
+
+      def set(variable, value)
+        instance_variable_set(variable, value)
+      end
+
+      def variables
+        instance_variables
+      end
+
+      def ox_element(node, attributes: [], namespace: "")
+        Utility.ox_element(
+          node,
+          attributes: attributes,
+          namespace: namespace,
+        )
+      end
+
+      def result(value = [])
+        value = get("@value") || value
+        value.slice_after { |d| d.is_a?(Math::Function::Linebreak) }.to_a
+      end
+
+      def is_unary?
+        is_a?(Math::Function::UnaryFunction)
+      end
     end
   end
 end

data/lib/plurimath/math/formula.rb

@@ -4,6 +4,7 @@ module Plurimath
   module Math
     class Formula < Core
       attr_accessor :value, :left_right_wrapper, :displaystyle, :input_string
+
       MATH_ZONE_TYPES = %i[
         omml
         latex
@@ -36,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])
-        Plurimath.xml_engine.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
 
@@ -76,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",
@@ -99,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)
-        Plurimath.xml_engine.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
@@ -168,8 +181,8 @@ module Plurimath
         end
       end
 
-      def extract_class_from_text
-        return false unless (value.length < 2 && value&.first&.is_a?(Function::Text))
+      def extract_class_name_from_text
+        return unless value.length < 2 && value.first.is_a?(Function::Text)
 
         value.first.parameter_one
       end
@@ -182,10 +195,62 @@ module Plurimath
         (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)
@@ -203,6 +268,11 @@ module Plurimath
       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)