plurimath 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c90b0eb8f6510c5a93742653d0a9d395de3adf3b7dfa53f43d53ce4d7821a27
-  data.tar.gz: 966c4a94fc1245cec98e7290e3761be0774a71d62403e38bfa405aa1db5cd9f8
+  metadata.gz: dc53f153a22d8b615db765dda8d7b22c72d8cf42ee522a678649d52b3eed66b6
+  data.tar.gz: d31664e4104fe46e1361adc6b4e1a38d189590d181cf04e668c6d5d8f3a5f1d5
 SHA512:
-  metadata.gz: 364d72c3e42db84c13b5896ec36ea4cdb5f856ebdd970e7ff1058f3c2251cb301dd641cb51e1addcb5c890cfbd83cdebc5cf91df48e495704a8eae355b502d82
-  data.tar.gz: 607a1cf277fcbdce40ab130397985e8bf5682662adb747debb42823b257201e110d9aa4d7cb1087a191e98efeadab5976e723c2a9a6f64deb4e38bdf8fa513a1
+  metadata.gz: 6e8b0ececc1885c1751a0a9753a548f775c4cf740173c423dddbcf76dbfec8bb42db60773f744344402ea83e46e2c6bd99d43f85c54a12386383f0d83448f535
+  data.tar.gz: 4313751a9dde187e15adfbf6faa8f0c6fe015a753e286c84c2ea5cb7d5dd57c81c3e2c2e8bdaacffd1db58ff90f08fe82c5803983fe6a4027c9aade374190e8a

data/lib/plurimath/asciimath/parse.rb

@@ -70,7 +70,7 @@ module Plurimath
           quoted_text |
           (str("d").as(:d) >> str("x").as(:x)).as(:intermediate_exp) |
           match["a-zA-Z"].as(:symbol) |
-          match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?]/).as(:symbol) |
+          match(/[^\[{(\\\/@;:.,'"|\]})0-9a-zA-Z\-><$%^&*_=+!`~\s?ℒℛ]/).as(:symbol) |
           number
       end
 

data/lib/plurimath/asciimath/transform.rb

@@ -127,12 +127,6 @@ module Plurimath
         new_arr
       end
 
-      rule(sequence: simple(:sequence),
-           left_right: sequence(:left_right)) do
-        left_right.insert(0, sequence)
-        left_right
-      end
-
       rule(table_row: simple(:table_row),
            expr: simple(:expr)) do
         new_arr = [table_row]
@@ -157,6 +151,11 @@ module Plurimath
         expr.flatten.compact.insert(0, Utility.symbol_object(comma))
       end
 
+      rule(symbol: simple(:symbol),
+           expr: sequence(:expr)) do
+        expr.flatten.compact.insert(0, Utility.symbol_object(symbol))
+      end
+
       rule(rparen: simple(:rparen),
            expr: simple(:expr)) do
         [
@@ -316,19 +315,6 @@ module Plurimath
         )
       end
 
-      rule(fonts_class: simple(:font_style),
-           fonts_value: simple(:fonts_value),
-           power: simple(:power)) do
-        font_object = Utility::FONT_STYLES[font_style.to_sym].new(
-          Utility.unfenced_value(fonts_value),
-          font_style.to_s,
-        )
-        Math::Function::Power.new(
-          font_object,
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(unary_class: simple(:function),
            fonts_class: simple(:font_style),
            fonts_value: simple(:fonts_value)) do
@@ -344,24 +330,18 @@ module Plurimath
         Utility.get_class(function).new(first_value)
       end
 
-      rule(fonts_class: simple(:font_style),
-           fonts_value: simple(:fonts_value),
-           base: simple(:base)) do
-        font_object = Utility::FONT_STYLES[font_style.to_sym].new(
-          Utility.unfenced_value(fonts_value),
-          font_style.to_s,
-        )
-        Math::Function::Base.new(
-          font_object,
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(power_base: simple(:power_base),
            expr: subtree(:expr)) do
         expr.flatten.compact.insert(0, power_base)
       end
 
+      rule(power_base: simple(:power_base),
+           expr: simple(:expr)) do
+        new_arr = [power_base]
+        new_arr << expr unless expr.to_s.strip.empty?
+        new_arr
+      end
+
       rule(frac: simple(:frac),
            expr: subtree(:expr)) do
         case expr
@@ -386,29 +366,6 @@ module Plurimath
         new_arr
       end
 
-      rule(sequence: simple(:sequence),
-           frac: simple(:frac)) do
-        new_arr = [sequence]
-        new_arr << frac unless frac.to_s.strip.empty?
-        new_arr
-      end
-
-      rule(sequence: simple(:sequence),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          sequence,
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(power_base: simple(:power_base),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          power_base,
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(power_base: simple(:power_base),
            power: sequence(:power)) do
         first_value = power.shift if Utility.frac_values(power)
@@ -420,16 +377,6 @@ module Plurimath
         end
       end
 
-      rule(sequence: simple(:sequence),
-           symbol: simple(:symbol)) do
-        symbol_object = Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
-        new_arr = [sequence]
-        new_arr << symbol_object unless symbol.to_s.strip.empty?
-        new_arr
-      end
-
       rule(power_base: simple(:power_base),
            left_right: simple(:left_right)) do
         new_arr = [power_base]
@@ -459,10 +406,25 @@ module Plurimath
 
       rule(power_base: simple(:power_base),
            base: simple(:base)) do
-        Math::Function::Base.new(
-          power_base,
-          Utility.unfenced_value(base),
-        )
+        if base.is_a?(Math::Formula) && base.value.any? { |value| Utility.symbol_value(value, ",") }
+          sliced = base.value.slice_before { |object| Utility.symbol_value(object, ",")  }.to_a
+          base_object = Math::Function::Base.new(
+            power_base,
+            Utility.filter_values(
+              Utility.unfenced_value(sliced.shift),
+            ),
+          )
+          [
+            base_object,
+            sliced.shift.first,
+            Utility.filter_values(sliced),
+          ].compact
+        else
+          Math::Function::Base.new(
+            power_base,
+            Utility.unfenced_value(base),
+          )
+        end
       end
 
       rule(power_base: simple(:power_base),
@@ -510,16 +472,7 @@ module Plurimath
           Utility.unfenced_value(base_value),
           Utility.filter_values(first_value),
         )
-        if power_value.empty?
-          power_base_object
-        else
-          Math::Formula.new(
-            power_value.insert(
-              0,
-              power_base_object,
-            ),
-          )
-        end
+        power_value.insert(0, power_base_object)
       end
 
       rule(power_base: simple(:power_base),
@@ -630,37 +583,6 @@ module Plurimath
         new_arr
       end
 
-      rule(intermediate_exp: simple(:int_exp),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          int_exp,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          int_exp,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          int_exp,
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(power_base: simple(:power_base),
-           expr: simple(:expr)) do
-        new_arr = [power_base]
-        new_arr << expr unless expr.to_s.strip.empty?
-        new_arr
-      end
-
       rule(power_base: sequence(:power_base),
            expr: simple(:expr)) do
         new_arr = power_base
@@ -697,22 +619,6 @@ module Plurimath
         sequence.flatten.compact + expr.flatten.compact
       end
 
-      rule(unary: simple(:unary),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          unary,
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: simple(:unary),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          unary,
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(binary_class: simple(:function),
            base_value: simple(:base)) do
         Utility.get_class(function).new(
@@ -720,17 +626,6 @@ module Plurimath
         )
       end
 
-      rule(binary_class: simple(:function),
-           base_value: sequence(:base)) do
-        binary = Utility.get_class(function).new(
-          Utility.unfenced_value(base.shift),
-          Utility.unfenced_value(base.shift),
-        )
-        new_arr = [binary]
-        new_arr += base.flatten.compact unless base.empty?
-        new_arr
-      end
-
       rule(d: simple(:d),
            x: simple(:x)) do
         Math::Formula.new(
@@ -741,52 +636,6 @@ module Plurimath
         )
       end
 
-      rule(symbol: simple(:symbol),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:sym),
-           expr: sequence(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
-        expr.flatten.compact.insert(0, symbol)
-      end
-
-      rule(symbol: simple(:sym),
-           expr: simple(:expr)) do
-        symbol = Utility.symbol_object(
-          (Constants::SYMBOLS[sym.to_sym] || sym).to_s,
-        )
-        [symbol, expr]
-      end
-
-      rule(symbol: simple(:symbol),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(base),
-        )
-      end
-
       rule(binary_class: simple(:function),
            base: simple(:base)) do
         Utility.get_class(function).new(
@@ -831,31 +680,6 @@ module Plurimath
         )
       end
 
-      rule(binary_class: simple(:function),
-           base_value: simple(:base),
-           power_value: simple(:power),
-           expr: sequence(:expr)) do
-        [
-          Utility.get_class(function).new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-        ] + expr
-      end
-
-      rule(binary_class: simple(:function),
-           base_value: simple(:base),
-           power_value: simple(:power),
-           expr: simple(:expr)) do
-        [
-          Utility.get_class(function).new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-          expr,
-        ]
-      end
-
       rule(unary_class: simple(:function),
            intermediate_exp: simple(:int_exp)) do
         first_value = if Utility::UNARY_CLASSES.include?(function)
@@ -913,54 +737,6 @@ module Plurimath
         ]
       end
 
-      rule(number: simple(:number),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(number: simple(:number),
-           power: sequence(:power)) do
-        Math::Function::Power.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(text: simple(:text),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(text: sequence(:text),
-           base: simple(:base)) do
-        Math::Function::Base.new(
-          Math::Function::Text.new(text.join),
-          Utility.unfenced_value(base),
-        )
-      end
-
-      rule(text: simple(:text),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(text: sequence(:text),
-           power: simple(:power)) do
-        Math::Function::Power.new(
-          Math::Function::Text.new(text.join),
-          Utility.unfenced_value(power),
-        )
-      end
-
       rule(table: simple(:table),
            expr: sequence(:expr)) do
         Math::Formula.new([table] + expr.flatten.compact)
@@ -994,92 +770,6 @@ module Plurimath
         )
       end
 
-      rule(text: simple(:text),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Math::Function::Text.new(text),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(number: simple(:number),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Math::Number.new(number),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: simple(:unary),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          unary,
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(unary: sequence(:unary),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        unary.first.new(
-          unary.last.new(
-            Utility.unfenced_value(base),
-            Utility.unfenced_value(power),
-          ),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          int_exp,
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(intermediate_exp: simple(:int_exp),
-           base_value: simple(:base),
-           power_value: sequence(:power)) do
-        Math::Function::PowerBase.new(
-          int_exp,
-          Utility.unfenced_value(base),
-          Utility.filter_values(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           base_value: simple(:base),
-           power_value: simple(:power)) do
-        Math::Function::PowerBase.new(
-          Utility.symbol_object(
-            (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-          ),
-          Utility.unfenced_value(base),
-          Utility.unfenced_value(power),
-        )
-      end
-
-      rule(symbol: simple(:symbol),
-           base_value: simple(:base),
-           power_value: sequence(:power)) do
-        symbol_object = Utility.symbol_object(
-          (Constants::SYMBOLS[symbol.to_sym] || symbol).to_s,
-        )
-        Math::Function::PowerBase.new(
-          symbol_object,
-          Utility.unfenced_value(base),
-          Utility.filter_values(power),
-        )
-      end
-
       rule(lparen: simple(:lparen),
            expr: simple(:expr),
            rparen: simple(:rparen)) do
@@ -1107,18 +797,6 @@ module Plurimath
         )
       end
 
-      rule(lparen: simple(:lparen),
-           text: simple(:text),
-           rparen: simple(:rparen)) do
-        Math::Function::Text.new(text)
-      end
-
-      rule(lparen: simple(:lparen),
-           text: sequence(:text),
-           rparen: simple(:rparen)) do
-        Math::Function::Text.new(text.flatten.compact.join)
-      end
-
       rule(lparen: simple(:lparen),
            rgb_color: sequence(:color),
            rparen: simple(:rparen)) do

data/lib/plurimath/latex/transform.rb

@@ -310,8 +310,13 @@ module Plurimath
 
       rule(unary_functions: simple(:unary),
            supscript: simple(:supscript)) do
+        unary_function = if unary.is_a?(Parslet::Slice)
+                           Utility.get_class(unary).new
+                         else
+                           unary
+                         end
         Math::Function::Power.new(
-          unary,
+          unary_function,
           supscript,
         )
       end
@@ -319,8 +324,13 @@ module Plurimath
       rule(unary_functions: simple(:unary),
            subscript: simple(:subscript),
            supscript: simple(:supscript)) do
+        unary_function = if unary.is_a?(Parslet::Slice)
+                           Utility.get_class(unary).new
+                         else
+                           unary
+                         end
         Math::Function::PowerBase.new(
-          unary,
+          unary_function,
           subscript,
           supscript,
         )
@@ -554,14 +564,6 @@ module Plurimath
         )
       end
 
-      rule(rparen: simple(:rparen),
-           supscript: simple(:supscript)) do
-        Math::Function::Power.new(
-          Math::Symbol.new(rparen),
-          supscript,
-        )
-      end
-
       rule(expression: simple(:expr),
            supscript: simple(:supscript)) do
         Math::Function::Power.new(

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

@@ -6,6 +6,18 @@ module Plurimath
   module Math
     module Function
       class Dot < UnaryFunction
+        def to_mathml_without_math_tag
+          first_value = parameter_one&.to_mathml_without_math_tag
+          dot_tag = (Utility.ox_element("mo") << ".")
+          over_tag = Utility.ox_element("mover")
+          Utility.update_nodes(
+            over_tag,
+            [
+              first_value,
+              dot_tag,
+            ],
+          )
+        end
       end
     end
   end

data/lib/plurimath/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plurimath
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plurimath
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-11 00:00:00.000000000 Z
+date: 2023-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet