plurimath 0.2.0 → 0.2.1

data/lib/plurimath/mathml/transform.rb

@@ -5,19 +5,29 @@ module Plurimath
     class Transform < Parslet::Transform
       rule(tag: simple(:tag))       { tag }
       rule(tag: sequence(:tag))     { tag }
-      rule(text: simple(:text))     { Plurimath::Math::Symbol.new(text.to_s) }
-      rule(class: simple(:string))  { Transform.get_class(string).new }
-      rule(number: simple(:number)) { Plurimath::Math::Number.new(number.to_s) }
-      rule(tag: sequence(:tag), sequence: simple(:sequence)) { tag + [sequence] }
-      rule(tag: simple(:tag), sequence: sequence(:sequence)) { [tag] + sequence }
-      rule(tag: sequence(:tag), sequence: sequence(:sequence)) { tag + sequence }
+      rule(text: simple(:text))     { Math::Symbol.new(text) }
+      rule(class: simple(:string))  { Utility.get_class(string).new }
+      rule(number: simple(:number)) { Math::Number.new(number) }
+
+      rule(tag: sequence(:tag), sequence: simple(:sequence)) do
+        tag + [sequence]
+      end
+
+      rule(tag: simple(:tag), sequence: sequence(:sequence)) do
+        [tag] + sequence
+      end
+
+      rule(tag: sequence(:tag), sequence: sequence(:sequence)) do
+        tag + sequence
+      end
 
       rule(quoted_text: simple(:quoted_text)) do
-        text = quoted_text.to_s
-        Constants::UNICODE_SYMBOLS.each do |code, string|
-          text.gsub!(code.to_s, "unicode[:#{string}]")
+        text = quoted_text
+        symbols = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
+        symbols.each do |code, string|
+          text.gsub!(code, "unicode[:#{string}]")
         end
-        Plurimath::Math::Function::Text.new(text)
+        Math::Function::Text.new(text)
       end
 
       rule(
@@ -37,7 +47,7 @@ module Plurimath
         sequence: simple(:sequence),
         iteration: simple(:iteration),
       ) do
-        Plurimath::Math::Formula.new(tag + [sequence])
+        Math::Formula.new(tag + [sequence, iteration])
       end
 
       rule(
@@ -45,7 +55,7 @@ module Plurimath
         sequence: simple(:sequence),
         iteration: simple(:iteration),
       ) do
-        [tag, sequence]
+        iteration.size.zero? ? [tag, sequence] : [tag, sequence, iteration]
       end
 
       rule(tag: sequence(:tag), iteration: simple(:iteration)) do
@@ -72,21 +82,21 @@ module Plurimath
       rule(symbol: simple(:symbol)) do
         decoded_symbol = Constants::UNICODE_SYMBOLS[symbol.to_sym]
         if Constants::CLASSES.include?(decoded_symbol)
-          [Transform.get_class(decoded_symbol).new]
+          [Utility.get_class(decoded_symbol).new]
         elsif decoded_symbol.nil? && Constants::SYMBOLS[symbol.to_sym]
-          Plurimath::Math::Symbol.new(Constants::SYMBOLS[symbol.to_sym])
+          Math::Symbol.new(Constants::SYMBOLS[symbol.to_sym])
         else
-          Plurimath::Math::Symbol.new(decoded_symbol)
+          Math::Symbol.new(decoded_symbol)
         end
       end
 
       rule(name: simple(:name), value: simple(:value)) do
-        if ["open", "close"].include?(name.to_s)
-          Plurimath::Math::Symbol.new(value.to_s)
-        elsif name.to_s == "mathcolor"
-          Plurimath::Math::Function::Color.new(value.to_s)
-        elsif name.to_s == "mathvariant"
-          value.to_s
+        if ["open", "close"].include?(name)
+          Math::Symbol.new(value)
+        elsif name == "mathcolor"
+          Math::Function::Color.new(value)
+        elsif name == "mathvariant"
+          value
         end
       end
 
@@ -95,15 +105,10 @@ module Plurimath
         sequence: sequence(:sequence),
         iteration: simple(:iteration),
       ) do
-        tag_str = tag.to_s.split("::").last.downcase.to_sym
-        if Constants::BINARY_CLASSES.include?(tag_str)
-          tag.new(sequence.first, sequence.last)
-        else
-          new_arr = sequence.compact
-          new_arr = [tag] + new_arr unless tag.nil?
-          new_arr << iteration unless iteration.to_s.empty?
-          new_arr
-        end
+        new_arr = sequence.compact
+        new_arr = [tag] + new_arr unless tag.nil?
+        new_arr << iteration unless iteration.to_s.empty?
+        new_arr
       end
 
       rule(
@@ -112,53 +117,64 @@ module Plurimath
         iteration: sequence(:iteration),
         close: simple(:close_tag),
       ) do
-        Transform.raise_error!(open_tag, close_tag) unless open_tag == close_tag
+        Utility.raise_error!(open_tag, close_tag) unless open_tag == close_tag
 
         if open_tag == "mrow"
-          Plurimath::Math::Formula.new(iteration)
+          Math::Formula.new(iteration)
         elsif open_tag == "munder"
-          if Transform.get_class("obrace") == iteration.last.class
+          if iteration.last.class_name == "obrace"
             iteration.last.parameter_one = iteration.first
             iteration.last
           else
-            Plurimath::Math::Function::Underset.new(iteration[1], iteration[0])
+            Math::Function::Underset.new(iteration[1], iteration[0])
           end
         elsif open_tag == "munderover"
-          Plurimath::Math::Function::Underover.new(iteration[0], iteration[1], iteration[2])
+          Utility.get_class(open_tag.delete_prefix("m")).new(
+            iteration[0],
+            iteration[1],
+            iteration[2],
+          )
         elsif open_tag == "mover"
-          if Transform.get_class("ubrace") == iteration.last.class
+          if iteration.last.class_name == "ubrace"
             iteration.last.parameter_one = iteration.first
             iteration.last
           else
-            Plurimath::Math::Function::Overset.new(iteration[1], iteration[0])
+            Math::Function::Overset.new(iteration[1], iteration[0])
           end
-        elsif open_tag == "msup"
-          Plurimath::Math::Function::Power.new(iteration[0], iteration[1])
-        elsif open_tag == "msub"
-          Plurimath::Math::Function::Base.new(iteration[0], iteration[1])
+        elsif ["msub", "msup"].include?(open_tag)
+          tag = (open_tag == "msup" ? "power" : "base")
+          Utility.get_class(tag).new(iteration[0], iteration[1])
         elsif open_tag == "msubsup"
-          Plurimath::Math::Function::PowerBase.new(iteration[0], iteration[1], iteration[2])
+          Math::Function::PowerBase.new(iteration[0],
+                                        iteration[1],
+                                        iteration[2])
         elsif open_tag == "mfrac"
-          Plurimath::Math::Function::Frac.new(iteration.first, iteration.last)
+          Math::Function::Frac.new(iteration.first, iteration.last)
         elsif open_tag == "msqrt"
-          Plurimath::Math::Function::Sqrt.new(iteration.first)
+          Math::Function::Sqrt.new(iteration.first)
         elsif open_tag == "mroot"
-          Plurimath::Math::Function::Root.new(iteration[0], iteration[1])
+          Math::Function::Root.new(iteration[0], iteration[1])
         elsif open_tag == "mfenced"
-          Plurimath::Math::Function::Fenced.new(attributes[0], iteration, attributes[1])
-        elsif open_tag == "mtable"
-          Plurimath::Math::Function::Table.new(iteration)
-        elsif open_tag == "mtr"
-          Plurimath::Math::Function::Tr.new(iteration)
-        elsif open_tag == "mtd"
-          Plurimath::Math::Function::Td.new(iteration)
-        elsif attributes.first.is_a?(Plurimath::Math::Function::Color)
+          Math::Function::Fenced.new(
+            attributes[0],
+            iteration,
+            attributes[1],
+          )
+        elsif ["mtr", "mtd", "mtable"].include?(open_tag)
+          tag = open_tag.delete_prefix("m")
+          Utility.get_class(tag).new(iteration)
+        elsif attributes.first.is_a?(Math::Function::Color)
           attributes.first.parameter_two = iteration.first
           attributes.first
         elsif open_tag == "mstyle" && !attributes.compact.empty?
-          font_type = attributes.compact.last.to_sym
-          if Constants::FONT_CLASSES.include?(font_type)
-            Math::Function::FontStyle.new(iteration.last, font_type.to_s)
+          font_type = attributes.compact.last
+          if Utility::FONT_STYLES.key?(font_type.to_sym)
+            Utility::FONT_STYLES[font_type.to_sym].new(
+              iteration.last,
+              font_type,
+            )
+          else
+            Math::Function::FontStyle.new(iteration.last, font_type)
           end
         else
           iteration
@@ -171,7 +187,7 @@ module Plurimath
         iteration: simple(:iteration),
         close: simple(:close_tag),
       ) do
-        Transform.raise_error!(open_tag, close_tag) unless open_tag == close_tag
+        Utility.raise_error!(open_tag, close_tag) unless open_tag == close_tag
 
         if iteration.to_s.include?("Function")
           iteration
@@ -179,17 +195,6 @@ module Plurimath
           [iteration.to_s.empty? ? nil : iteration]
         end
       end
-
-      def self.get_class(text)
-        Object.const_get("Plurimath::Math::Function::#{text.to_s.capitalize}")
-      end
-
-      def self.raise_error!(open_tag, close_tag)
-        message = "Please check your input."\
-                  " Opening tag is \"#{open_tag}\""\
-                  " and closing tag is \"#{close_tag}\""
-        raise Plurimath::Math::Error.new(message)
-      end
     end
   end
 end

data/lib/plurimath/mathml.rb

@@ -10,7 +10,7 @@ module Plurimath
     end
 
     def to_formula
-      Plurimath::Mathml::Parser.new(text).parse
+      Parser.new(text).parse
     end
   end
 end

data/lib/plurimath/omml/constants.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Omml
+    class Constants
+      TAGS = %w[
+        lastRenderedPageBreak
+        oMathParaPr
+        borderBoxPr
+        wrapIndent
+        strikeTLBR
+        strikeBLTR
+        groupChrPr
+        wrapRight
+        smallFrac
+        oMathPara
+        hideRight
+        brkBinSub
+        borderBox
+        sSubSupPr
+        zeroDesc
+        mathFont
+        limUppPr
+        limLowPr
+        hideLeft
+        groupChr
+        zeroWid
+        zeroAsc
+        strikeV
+        strikeH
+        rSpRule
+        rMargin
+        plcHide
+        phantPr
+        objDist
+        noBreak
+        naryLim
+        maxDist
+        lMargin
+        intraSp
+        interSp
+        hideTop
+        hideBot
+        eqArrPr
+        dispDef
+        degHide
+        cGpRule
+        supHide
+        subHide
+        vertJc
+        transp
+        sSupPr
+        sSubPr
+        sepChr
+        postSp
+        naryPr
+        mathPr
+        limUpp
+        limLow
+        rFonts
+        limLoc
+        intLim
+        funcPr
+        endChr
+        ctrlPr
+        brkBin
+        begChr
+        baseJc
+        alnScr
+        sPrePr
+        radPr
+        preSp
+        phant
+        opEmu
+        oMath
+        fName
+        eqArr
+        defJc
+        count
+        boxPr
+        barPr
+        argSz
+        argPr
+        accPr
+        type
+        show
+        mcPr
+        mcJc
+        grow
+        diff
+        sty
+        shp
+        scr
+        rSp
+        rPr
+        sup
+        sub
+        pos
+        num
+        nor
+        mPr
+        mcs
+        lit
+        lim
+        fPr
+        dPr
+        den
+        deg
+        cSp
+        chr
+        cGp
+        brk
+        box
+        bar
+        aln
+        mr
+        mc
+        jc
+        t
+        r
+        i
+        m
+        e
+      ].freeze
+      SUB_SUP_TAG = %w[
+        sSubSup
+        func
+        sPre
+        sSup
+        sSub
+        nary
+        acc
+        rad
+        f
+        d
+      ].freeze
+      UNARY_FUNCTIONS = %w[
+        arcsin
+        arctan
+        arccos
+        coth
+        tanh
+        sinh
+        cosh
+        tan
+        cos
+        cot
+        csc
+        sin
+        sec
+      ].freeze
+    end
+  end
+end

data/lib/plurimath/omml/parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "transform"
+module Plurimath
+  class Omml
+    class Parser
+      attr_accessor :text
+
+      def initialize(text)
+        @text = CGI.unescape(text)
+      end
+
+      def parse
+        nodes = Ox.load(text, mode: :hash, strip_namespace: true)
+        Math::Formula.new(
+          Transform.new.apply(nodes),
+        )
+      end
+    end
+  end
+end

data/lib/plurimath/omml/transform.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Plurimath
+  class Omml
+    class Transform < Parslet::Transform
+      rule(r: simple(:r)) { r }
+      rule(f: simple(:f)) { f }
+      rule(d: simple(:d)) { Math::Function::Fenced.new(nil, [d], nil) }
+      rule(val: simple(:val)) { val }
+      rule(box: simple(:box)) { box }
+      rule(rPr: simple(:rpr)) { nil }
+      rule(rad: simple(:rad)) { rad }
+      rule(sSub: simple(:sub)) { sub }
+      rule(eqArr: simple(:arr)) { arr }
+      rule(nary: simple(:nary)) { nary }
+      rule(sSup: simple(:sSup)) { sSup }
+      rule(sPre: simple(:sPre)) { sPre }
+      rule(ctrlPr: simple(:ctrlPr)) { nil }
+      rule(argSz: sequence(:argsz)) { nil }
+      rule(rFonts: sequence(:fonts)) { nil }
+      rule(sSubSup: simple(:sSubSup)) { sSubSup }
+      rule(oMathPara: subtree(:omath)) { omath.drop(1) }
+      rule(rPr: simple(:rpr), i: simple(:i)) { nil }
+      rule(dPr: simple(:dpr), e: simple(:e)) { e }
+      rule(dPr: simple(:dpr), e: sequence(:e)) { e }
+      rule(boxPr: simple(:boxpr), e: simple(:e)) { e }
+      rule(argPr: simple(:argPr), f: simple(:f)) { f }
+      rule(rFonts: sequence(:fonts), i: simple(:i)) { nil }
+      rule(type: sequence(:type), ctrlPr: simple(:ctrl)) { nil }
+      rule(ascii: simple(:ascii), hAnsi: simple(:hansi)) { nil }
+      rule(diff: sequence(:diff), ctrlPr: simple(:ctrl)) { nil }
+      rule(limLoc: sequence(:limloc), ctrlPr: simple(:ctrl)) { limloc }
+      rule(degHide: sequence(:degHide), ctrlPr: simple(:ctrl)) { nil }
+
+      rule(oMath: subtree(:omath)) do
+        omath.is_a?(Array) ? omath.drop(1) : omath
+      end
+
+      rule(d: sequence(:d)) do
+        open_paren = d.shift if d.first.class_name == "symbol"
+        close_paren = d.pop if d.last.class_name == "symbol"
+        Math::Function::Fenced.new(
+          open_paren,
+          d,
+          close_paren,
+        )
+      end
+
+      rule(dPr: sequence(:dpr),
+           e: simple(:e)) do
+        [
+          dpr[0],
+          e,
+          dpr[1],
+        ]
+      end
+
+      rule(sSub: sequence(:sub), r: simple(:r)) do
+        [
+          Math::Formula.new(
+            sub.insert(1, r),
+          ),
+        ]
+      end
+
+      rule(rPr: simple(:rpr), t: subtree(:t)) do
+        Math::Function::Text.new(t.last)
+      end
+
+      rule(r: simple(:r), d: simple(:d)) do
+        Math::Formula.new(
+          [
+            r,
+            d,
+          ],
+        )
+      end
+
+      rule(eqArrPr: simple(:aqArrPr), e: sequence(:e)) do
+        table_value = []
+        e.each do |value|
+          table_value << Math::Function::Tr.new(
+            [
+              Math::Function::Td.new(
+                [
+                  value,
+                ],
+              ),
+            ],
+          )
+        end
+        Math::Function::Table.new(table_value)
+      end
+
+      rule(rPr: simple(:rpr),
+           t: simple(:text)) do
+        if text.scan(/[[:digit:]]/).length == text.length
+          Math::Number.new(text)
+        elsif text.match?(/[[:alpha:]]/)
+          Math::Function::Text.new(text)
+        else
+          Math::Symbol.new(text)
+        end
+      end
+
+      rule(radPr: simple(:rad),
+           deg: simple(:deg),
+           e: simple(:e)) do
+        if deg.nil?
+          Math::Function::Sqrt.new(e)
+        else
+          Math::Function::Root.new(deg, e)
+        end
+      end
+
+      rule(fPr: simple(:fpr), num: simple(:num), den: simple(:den)) do
+        Math::Function::Frac.new(num, den)
+      end
+
+      rule(sSupPr: simple(:sSuppr), e: simple(:e), sup: simple(:power)) do
+        Math::Function::Power.new(e, power)
+      end
+
+      rule(sSubPr: simple(:sSubpr), e: simple(:e), sub: simple(:base)) do
+        Math::Function::Base.new(e, base)
+      end
+
+      rule(chr: sequence(:chr),
+           ctrlPr: simple(:ctrl)) do
+        [nil] + chr
+      end
+
+      rule(chr: sequence(:chr),
+           limLoc: sequence(:limloc),
+           ctrlPr: simple(:ctrl)) do
+        limloc + chr
+      end
+
+      rule(begChr: sequence(:begChr),
+           endChr: sequence(:endChr),
+           ctrlPr: simple(:ctrl)) do
+        [
+          Math::Symbol.new(begChr.first),
+          Math::Symbol.new(endChr.first),
+        ]
+      end
+
+      rule(chr: sequence(:chr),
+           supHide: sequence(:supHide),
+           ctrlPr: simple(:ctrl)) do
+        [nil] + chr
+      end
+
+      rule(chr: sequence(:chr),
+           limLoc: sequence(:limloc),
+           supHide: sequence(:sup),
+           ctrlPr: simple(:ctrl)) do
+        limloc + chr
+      end
+
+      rule(limLoc: sequence(:limloc),
+           subHide: sequence(:sub),
+           supHide: sequence(:sup),
+           ctrlPr: simple(:ctrl)) do
+        limloc
+      end
+
+      rule(chr: sequence(:chr),
+           limLoc: sequence(:limloc),
+           subHide: sequence(:sub),
+           supHide: sequence(:sup),
+           ctrlPr: simple(:ctrl)) do
+        limloc + chr
+      end
+
+      rule(naryPr: sequence(:naryPr),
+           sub: simple(:base),
+           sup: simple(:power),
+           e: simple(:e)) do
+        fonts = Plurimath::Math::Symbol.new(naryPr[1] || "∫")
+        first_value = if base.nil? && power.nil?
+                        fonts
+                      elsif naryPr.first == "undOvr"
+                        Math::Function::Underover.new(fonts, base, power)
+                      else
+                        Math::Function::PowerBase.new(fonts, base, power)
+                      end
+        Math::Formula.new(
+          [
+            first_value,
+            Math::Formula.new(
+              [
+                e,
+              ],
+            ),
+          ],
+        )
+      end
+
+      rule(sSubSupPr: simple(:sSubSuppr),
+           e: simple(:e),
+           sub: simple(:base),
+           sup: simple(:power)) do
+        Math::Function::PowerBase.new(e, base, power)
+      end
+
+      rule(sPrePr: simple(:sPrePr),
+           e: simple(:e),
+           sub: simple(:base),
+           sup: simple(:power)) do
+        Math::Function::Multiscript.new(e, base, power)
+      end
+    end
+  end
+end

data/lib/plurimath/omml.rb

@@ -9,7 +9,7 @@ module Plurimath
     end
 
     def to_formula
-      # TODO: Will be implemented soon
+      Parser.new(text).parse
     end
   end
 end

data/lib/plurimath/unitsml.rb

@@ -7,5 +7,9 @@ module Plurimath
     def initialize(text)
       @text = text
     end
+
+    def to_formula
+      # TODO: Will be implemented soon
+    end
   end
 end