plurimath 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fabed12e1b85fa2c5d7b2cacfebaf2bafb8481025f6f0a9b072649ff2991131
-  data.tar.gz: ec912de1e4e356af0d7458c0b2147ea9aee1fb4676506429ac5e4161cd974c79
+  metadata.gz: f58b20082cd94488f247f22399522d777ea751a4eba4f21e45a7a792fc6d30f3
+  data.tar.gz: f6e55fa7493ac10ac6e8ded470ea547640b3b5b53f00ac36c8cf941d56d5cc87
 SHA512:
-  metadata.gz: d31d2f5b644402ab58c0f19a9c14e88f91fff26d44dff6c89484b66d45d3760087be0827002c87c3b9ca540ac7dd52ad2ceb014f4b0f6b16fc9f94630f823c70
-  data.tar.gz: 8f5ea828f70451af6ae075d8e06db4055145e096c83fc39b9a31cdcc57ddfff57afdd736e9f696d83e68d7b6c50ada74fa68f46acc00e878e08c1db22050ed2d
+  metadata.gz: 133860ffcca6250cb3bef1e9eb186536685b3697a7d26bcda1d287170d74b9ac98083d352143cc6a9fc3649832229c0e1c3c1963c3e787db4d8b6f992b3f5802
+  data.tar.gz: 3a2044197aa65f0820961c14a602ca6df69c316e48203b2d448263032837336053715d95c52290b5241486426d000588d632cd820563ddf6466b0f4ab5d46569

data/.gitignore

@@ -6,7 +6,11 @@
 /pkg/
 /spec/reports/
 /tmp/
+/Gemfile.lock
 
 # rspec failure tracking
 .rspec_status
 /coverage/
+
+# temp files
+*.kate-swp

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rspec-opal

@@ -0,0 +1,11 @@
+--default-path=spec
+-I lib
+-q oga/setup_opal
+-q ll/setup_opal
+--opal-opt=-g,htmlentities
+--opal-opt=-g,equivalent-xml
+--opal-opt=-g,parslet
+--opal-opt=-g,oga
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -8,3 +8,7 @@ gem "rspec", "~> 3.0"
 gem 'simplecov', require: false, group: :test
 gem 'htmlentities'
 gem 'equivalent-xml'
+gem 'opal-rspec', "~> 1.1.0a"
+gem 'oga'
+gem 'ox'
+gem "unitsml"

data/Rakefile

@@ -1,6 +1,17 @@
+require "erb"
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require 'opal/rspec/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
+# Opal testing support
+begin
+  Opal::RSpec::RakeTask.new(:"spec-opal")
+rescue LoadError
+  # Likely the dependencies haven't been upstreamed yet. Ensure you
+  # run those tests via the `plurimath-js` repo's `env/plurimath`
+  # script.
+end
+
 task :default => :spec

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]),
@@ -132,6 +139,13 @@ module Plurimath
         new_arr
       end
 
+      rule(sequence: simple(:sequence),
+           left_right: sequence(:left_right)) do
+        new_arr = [sequence]
+        new_arr += left_right unless left_right.empty?
+        new_arr
+      end
+
       rule(sequence: simple(:sequence),
            number: simple(:number)) do
         [sequence, Math::Number.new(number.to_s)]
@@ -296,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
@@ -624,11 +642,26 @@ 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
       end
 
+      rule(sequence: simple(:sequence),
+           symbol: simple(:symbol)) do
+        [
+          sequence,
+          Math::Symbol.new(symbol),
+        ]
+      end
+
       rule(binary_class: simple(:function),
            base_value: simple(:base)) do
         Utility.get_class(function).new(
@@ -845,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

@@ -1720,6 +1720,7 @@ module Plurimath
         cap: "∩",
         cup: "∪",
         sim: "∼",
+        int: "∫",
         neq: "≠",
         leq: "≤",
         geq: "≥",
@@ -2853,7 +2854,9 @@ module Plurimath
         mathbfit: :fonts,
         mathfrak: :fonts,
         overline: :unary,
+        underset: :binary,
         overset: :binary,
+        phantom: :unary,
         ddagger: :symbols,
         trprime: :symbols,
         closure: :symbols,
@@ -3245,6 +3248,7 @@ module Plurimath
         textrm: :fonts,
         textbf: :fonts,
         arccos: :unary,
+        cancel: :unary,
         arcsin: :unary,
         arctan: :unary,
         limsup: :unary,
@@ -3559,7 +3563,7 @@ module Plurimath
         tanh: :unary,
         cosh: :unary,
         ddot: :unary,
-        mbox: :unary,
+        mbox: :text,
         text: :text,
         '"': :symbols,
         sum: :ternary,

data/lib/plurimath/latex/parse.rb

@@ -4,11 +4,18 @@ require "parslet"
 module Plurimath
   class Latex
     class Parse < Parslet::Parser
-      rule(:base)       { str("_") }
-      rule(:power)      { str("^") }
-      rule(:slash)      { str("\\") }
-      rule(:under_over) { slash >> underover_classes }
-      rule(:array_args) { (str("{") >> expression.as(:args) >> str("}")) }
+      rule(:base)          { str("_") }
+      rule(:power)         { str("^") }
+      rule(:slash)         { str("\\") }
+      rule(:under_over)    { slash >> underover_classes }
+      rule(:array_args)    { (str("{") >> expression.as(:args) >> str("}")) }
+      rule(:array_begin)   { (str("\\begin{") >> str("array").as(:environment) >> str("}")) }
+      rule(:optional_args) { (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe }
+
+      rule(:color) do
+        (str("{") >> (str("}").absent? >> any).repeat.as(:symbol) >> str("}")) |
+          any.as(:symbol)
+      end
 
       rule(:optional_args) do
         (str("[") >> intermediate_exp.maybe.as(:options) >> str("]")).maybe
@@ -16,11 +23,7 @@ module Plurimath
 
       rule(:begining) do
         (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("*").as(:asterisk) >> str("}")) >> optional_args.maybe) |
-        (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("}")))
-      end
-
-      rule(:array_begin) do
-        (str("\\begin{") >> str("array").as(:environment) >> str("}"))
+          (slash >> str("begin") >> (str("{") >> symbol_text_or_integer >> str("}")))
       end
 
       rule(:ending) do
@@ -123,7 +126,8 @@ module Plurimath
       rule(:binary_functions) do
         (intermediate_exp.as(:first_value) >> under_over >> intermediate_exp.as(:second_value)).as(:under_over) |
           (slash >> str("sqrt").as(:root) >> sqrt_arg.as(:first_value) >> intermediate_exp.as(:second_value)).as(:binary) |
-          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary)
+          (slash >> str("sqrt").as(:sqrt) >> intermediate_exp.as(:intermediate_exp)).as(:binary) |
+          (color_rules)
       end
 
       rule(:sequence) do
@@ -242,6 +246,11 @@ module Plurimath
           (power >> intermediate_exp.as(:supscript)) |
           (base >> intermediate_exp.as(:subscript))
       end
+
+      def color_rules
+        (str("{") >> slash >> str("color").as(:binary) >> color.as(:first_value) >> (sequence >> iteration.maybe).as(:second_value).maybe >> str("}")) |
+          (slash >> str("color").as(:binary) >> color.as(:first_value) >> expression.as(:second_value).maybe)
+      end
     end
   end
 end

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,26 +509,37 @@ 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
 
       rule(text: simple(:text),
            first_value: sequence(:first_value),
-           subscript: simple(:subscript),) do
+           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
 
       rule(text: simple(:text),
            first_value: simple(:first_value),
-           subscript: simple(:subscript),) do
+           subscript: simple(:subscript)) do
         Math::Function::Base.new(
-          Math::Function::Text.new(first_value),
+          Utility.get_class(text).new(first_value),
+          subscript,
+        )
+      end
+
+      rule(text: simple(:text),
+           first_value: simple(:first_value),
+           subscript: simple(:subscript),
+           supscript: simple(:supscript)) do
+        Math::Function::PowerBase.new(
+          Utility.get_class(text).new(first_value),
           subscript,
+          supscript,
         )
       end
 
@@ -788,6 +799,17 @@ module Plurimath
         end
       end
 
+      rule(binary: simple(:binary),
+           first_value: simple(:first_value),
+           second_value: sequence(:second_value)) do
+        Utility.get_class(
+          binary.to_s.include?("mod") ? "mod" : binary,
+        ).new(
+          first_value,
+          Utility.filter_values(second_value),
+        )
+      end
+
       rule(underover: simple(:function),
            first_value: simple(:first),
            subscript: simple(:subscript),
@@ -926,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,13 +63,209 @@ module Plurimath
         false
       end
 
-      def extract_class_from_text
+      def extract_class_name_from_text
         ""
       end
 
       def font_style_t_tag(display_style)
         to_omml_without_math_tag(display_style)
       end
+
+      def ascii_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_asciimath}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_asciimath_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def latex_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{field&.to_latex}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_latex_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def mathml_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_mathml(field)}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_mathml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent])
+      end
+
+      def omml_fields_to_print(field, options = {})
+        return if field.nil?
+
+        hashed = common_math_zone_conversion(field, options)
+        display_style = options[:display_style]
+        options[:array] << "#{hashed[:spacing]}|_ \"#{dump_omml(field, display_style)}\"#{hashed[:field_name]}\n"
+        return unless Utility.validate_math_zone(field)
+
+        options[:array] << field&.to_omml_math_zone(hashed[:function_spacing], hashed[:last], hashed[:indent], display_style: display_style)
+      end
+
+      def dump_mathml(field)
+        dump_ox_nodes(field.to_mathml_without_math_tag).gsub(/\n\s*/, "")
+      end
+
+      def dump_omml(field, display_style)
+        return if field.nil?
+
+        dump_ox_nodes(field.omml_nodes(display_style)).gsub(/\n\s*/, "")
+      end
+
+      def omml_nodes(display_style)
+        to_omml_without_math_tag(display_style)
+      end
+
+      def validate_mathml_fields(field)
+        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),
+          function_spacing: "#{options[:spacing]}#{options[:additional_space]}",
+          field_name: (options[:field_name] ? " #{options[:field_name]}" : ""),
+        }
+      end
+
+      def filtered_values(value)
+        @values = Utility.filter_math_zone_values(value)
+      end
+
+      def dump_ox_nodes(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 ? "  " : "| ")
+      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