plurimath 0.1.0 → 0.2.1

data/lib/plurimath/mathml/transform.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Mathml
+    class Transform < Parslet::Transform
+      rule(tag: simple(:tag))       { tag }
+      rule(tag: sequence(:tag))     { tag }
+      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
+        symbols = Constants::UNICODE_SYMBOLS.transform_keys(&:to_s)
+        symbols.each do |code, string|
+          text.gsub!(code, "unicode[:#{string}]")
+        end
+        Math::Function::Text.new(text)
+      end
+
+      rule(
+        tag: sequence(:tag),
+        sequence: sequence(:sequence),
+        iteration: simple(:iteration),
+      ) do
+        new_arr = []
+        new_arr = new_arr + tag unless tag.compact.empty?
+        new_arr = new_arr + sequence unless sequence.compact.empty?
+        new_arr << iteration unless iteration.to_s.empty?
+        new_arr
+      end
+
+      rule(
+        tag: sequence(:tag),
+        sequence: simple(:sequence),
+        iteration: simple(:iteration),
+      ) do
+        Math::Formula.new(tag + [sequence, iteration])
+      end
+
+      rule(
+        tag: simple(:tag),
+        sequence: simple(:sequence),
+        iteration: simple(:iteration),
+      ) do
+        iteration.size.zero? ? [tag, sequence] : [tag, sequence, iteration]
+      end
+
+      rule(tag: sequence(:tag), iteration: simple(:iteration)) do
+        new_arr = []
+        new_arr = tag unless tag.compact.empty?
+        new_arr << iteration unless iteration.to_s.empty?
+        new_arr
+      end
+
+      rule(tag: simple(:tag), sequence: simple(:sequence)) do
+        new_arr = []
+        new_arr << tag unless tag.nil?
+        new_arr << sequence unless sequence.nil?
+        new_arr
+      end
+
+      rule(tag: simple(:tag), iteration: simple(:iteration)) do
+        new_arr = []
+        new_arr << tag unless tag.to_s.empty?
+        new_arr << iteration unless iteration.to_s.empty?
+        new_arr
+      end
+
+      rule(symbol: simple(:symbol)) do
+        decoded_symbol = Constants::UNICODE_SYMBOLS[symbol.to_sym]
+        if Constants::CLASSES.include?(decoded_symbol)
+          [Utility.get_class(decoded_symbol).new]
+        elsif decoded_symbol.nil? && Constants::SYMBOLS[symbol.to_sym]
+          Math::Symbol.new(Constants::SYMBOLS[symbol.to_sym])
+        else
+          Math::Symbol.new(decoded_symbol)
+        end
+      end
+
+      rule(name: simple(:name), value: simple(:value)) do
+        if ["open", "close"].include?(name)
+          Math::Symbol.new(value)
+        elsif name == "mathcolor"
+          Math::Function::Color.new(value)
+        elsif name == "mathvariant"
+          value
+        end
+      end
+
+      rule(
+        tag: simple(:tag),
+        sequence: sequence(:sequence),
+        iteration: simple(:iteration),
+      ) do
+        new_arr = sequence.compact
+        new_arr = [tag] + new_arr unless tag.nil?
+        new_arr << iteration unless iteration.to_s.empty?
+        new_arr
+      end
+
+      rule(
+        open: simple(:open_tag),
+        attributes: sequence(:attributes),
+        iteration: sequence(:iteration),
+        close: simple(:close_tag),
+      ) do
+        Utility.raise_error!(open_tag, close_tag) unless open_tag == close_tag
+
+        if open_tag == "mrow"
+          Math::Formula.new(iteration)
+        elsif open_tag == "munder"
+          if iteration.last.class_name == "obrace"
+            iteration.last.parameter_one = iteration.first
+            iteration.last
+          else
+            Math::Function::Underset.new(iteration[1], iteration[0])
+          end
+        elsif open_tag == "munderover"
+          Utility.get_class(open_tag.delete_prefix("m")).new(
+            iteration[0],
+            iteration[1],
+            iteration[2],
+          )
+        elsif open_tag == "mover"
+          if iteration.last.class_name == "ubrace"
+            iteration.last.parameter_one = iteration.first
+            iteration.last
+          else
+            Math::Function::Overset.new(iteration[1], iteration[0])
+          end
+        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"
+          Math::Function::PowerBase.new(iteration[0],
+                                        iteration[1],
+                                        iteration[2])
+        elsif open_tag == "mfrac"
+          Math::Function::Frac.new(iteration.first, iteration.last)
+        elsif open_tag == "msqrt"
+          Math::Function::Sqrt.new(iteration.first)
+        elsif open_tag == "mroot"
+          Math::Function::Root.new(iteration[0], iteration[1])
+        elsif open_tag == "mfenced"
+          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
+          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
+        end
+      end
+
+      rule(
+        open: simple(:open_tag),
+        attributes: sequence(:attributes),
+        iteration: simple(:iteration),
+        close: simple(:close_tag),
+      ) do
+        Utility.raise_error!(open_tag, close_tag) unless open_tag == close_tag
+
+        if iteration.to_s.include?("Function")
+          iteration
+        else
+          [iteration.to_s.empty? ? nil : iteration]
+        end
+      end
+    end
+  end
+end

data/lib/plurimath/mathml.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "math"
+module Plurimath
+  class Mathml
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_formula
+      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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Omml
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_formula
+      Parser.new(text).parse
+    end
+  end
+end

data/lib/plurimath/unicode.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Unicode
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_formula
+      # TODO: Will be implemented soon
+    end
+  end
+end

data/lib/plurimath/unitsml.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Unitsml
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def to_formula
+      # TODO: Will be implemented soon
+    end
+  end
+end