plurimath 0.1.0 → 0.2.0

data/lib/plurimath/math.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "unicode"
+require_relative "asciimath"
+require_relative "omml"
+require_relative "mathml"
+require_relative "html"
+require_relative "latex"
+require_relative "unitsml"
+require_relative "math/formula"
+require_relative "math/function"
+require_relative "math/number"
+require_relative "math/symbol"
+require_relative "asciimath/parser"
+require_relative "mathml/parser"
+require_relative "latex/parser"
+module Plurimath
+  module Math
+    class Error < StandardError; end
+
+    VALID_TYPES = {
+      unicode: Unicode,
+      asciimath: Asciimath,
+      omml: Omml,
+      mathml: Mathml,
+      html: Html,
+      latex: Latex,
+    }.freeze
+
+    def parse(text, type)
+      raise_error! unless valid_type?(type)
+
+      klass = VALID_TYPES[type.to_sym]
+      klass.new(text).to_formula
+    end
+
+    private
+
+    def raise_error!
+      raise Plurimath::Math::Error, Error.new("Type is not valid, "\
+                                              "please enter string or symbol")
+    end
+
+    def valid_type?(type)
+      (type.is_a?(Symbol) || type.is_a?(String)) &&
+        VALID_TYPES.key?(type.to_sym)
+    end
+
+    module_function :parse, :raise_error!, :valid_type?
+  end
+end

data/lib/plurimath/mathml/constants.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Mathml
+    class Constants
+      UNICODE_SYMBOLS = {
+        "α": "alpha",
+        "β": "beta",
+        "γ": "gamma",
+        "Γ": "Gamma",
+        "δ": "delta",
+        "Δ": "Delta",
+        "∆": "Delta",
+        "ε": "epsilon",
+        "ɛ": "varepsilon",
+        "ζ": "zeta",
+        "η": "eta",
+        "θ": "theta",
+        "Θ": "Theta",
+        "ϑ": "vartheta",
+        "ι": "iota",
+        "κ": "kappa",
+        "λ": "lambda",
+        "Λ": "Lambda",
+        "μ": "mu",
+        "ν": "nu",
+        "ξ": "xi",
+        "Ξ": "Xi",
+        "π": "pi",
+        "Π": "Pi",
+        "ρ": "rho",
+        "ς": "beta",
+        "σ": "sigma",
+        "Σ": "Sigma",
+        "τ": "tau",
+        "υ": "upsilon",
+        "φ": "phi",
+        "Φ": "Phi",
+        "ϕ": "varphi",
+        "χ": "chi",
+        "ψ": "psi",
+        "Ψ": "Psi",
+        "ω": "omega",
+        "Ω": "omega",
+        "⋅": "dot",
+        "∙": "*",
+        "·": ".",
+        "∗": "**",
+        "⋆": "***",
+        "×": "xx",
+        "&#x22C9;": "|><",
+        "&#x22CA;": "><|",
+        "&#x22C8;": "|><|",
+        "&#xF7;": "-:",
+        "&#x2218;": "@",
+        "&#x2295;": "o+",
+        "&#x2A01;": "o+",
+        "&#x2297;": "ox",
+        "&#x2299;": " ",
+        "&#x2211;": "sum",
+        "&#x220F;": "prod",
+        "&#x220f;": "prod",
+        "&#x2227;": "^^",
+        "&#x22C0;": "^^^",
+        "&#x2228;": "vv",
+        "&#x22c1;": "vvv",
+        "&#x2229;": "nn",
+        "&#x22C2;": "nnn",
+        "&#x222A;": "cup",
+        "&#x22C3;": "uuu",
+        "&#x2260;": "!=",
+        "&#x2264;": "<=",
+        "&#x2265;": ">=",
+        "&#x227A;": "-<",
+        "&#x227B;": ">-",
+        "&#x2AAF;": "-<=",
+        "&#x2AB0;": " >-=",
+        "&#x2208;": "in",
+        "&#x2209;": "!in",
+        "&#x2282;": "sub",
+        "&#x2283;": "sup",
+        "&#x2286;": "sube",
+        "&#x2287;": "supe",
+        "&#x2261;": "-=",
+        "&#x2245;": "~=",
+        "&#x2248;": "~~",
+        "&#x221D;": "prop",
+        "&#xAC;": "not",
+        "&#x2200;": "AA",
+        "&#x2203;": "EE",
+        "&#x22A5;": "_|_",
+        "&#x22A4;": "TT",
+        "&#x22A2;": "|--",
+        "&#x22A8;": "|==",
+        "&#x2329;": "(:",
+        "&#x232A;": ":)",
+        "&#x27E8;": "<<",
+        "&#x27E9;": ">>",
+        "&#x222B;": "int",
+        "&#x222E;": "oint",
+        "&#x2202;": "del",
+        "&#x2207;": "grad",
+        "&#xB1;": "+-",
+        "&#x2205;": "O/",
+        "&#x221E;": "oo",
+        "&#x2135;": "aleph",
+        "&#x2234;": ":.",
+        "&#x2235;": ":'",
+        "&#x2220;": "/_",
+        "&#x25B3;": "/_\\",
+        "&#x2032;": "'",
+        "&#xA0;&#xA0;": "quad",
+        "&#xA0;&#xA0;&#xA0;&#xA0;": "qquad",
+        "&#x2322;": "frown",
+        "&#x22EF;": "cdots",
+        "&#x22EE;": "vdots",
+        "&#x22F1;": "ddots",
+        "&#x22C4;": "diamond",
+        "&#x25A1;": "square",
+        "&#x230A;": "|__",
+        "&#x230B;": "__|",
+        "&#x2308;": "|~",
+        "&#x2309;": "~|",
+        "&#x2102;": "CC",
+        "&#x2115;": "NN",
+        "&#x211A;": "QQ",
+        "&#x211D;": "RR",
+        "&#x2124;": "ZZ",
+        "&#x2191;": "uarr",
+        "&#x2193;": "darr",
+        "&#x2190;": "larr",
+        "&#x2194;": "harr",
+        "&#x21D2;": "rArr",
+        "&#x21D0;": "lArr",
+        "&#x21D4;": "hArr",
+        "&#x2192;": "->",
+        "&#x21A3;": ">->",
+        "&#x21A0;": "->>",
+        "&#x2916;": ">->>",
+        "&#x21A6;": "|->",
+        "&#x2026;": "...",
+        "&#x2212;": "-",
+        "&#x2061;": "",
+        "&#x23DE;": "obrace",
+        "&#x23DF;": "ubrace",
+      }.freeze
+      SYMBOLS = {
+        "|": "|",
+        "/": "//",
+        "\\": "\\\\",
+        "~": "tilde",
+        "(": "(",
+        ")": ")",
+        "(:": "(:",
+        ":)": ":)",
+        "{": "{",
+        "}": "}",
+        "{:": "{:",
+        ":}": ":}",
+        "]": "]",
+        "[": "[",
+        "=": "=",
+        "+": "+",
+        "-": "-",
+      }.freeze
+      CLASSES = %w[
+        mathfrak
+        underset
+        stackrel
+        overset
+        mathcal
+        arccos
+        arcsin
+        arctan
+        mathsf
+        mathbb
+        mathbf
+        mathtt
+        ubrace
+        obrace
+        cancel
+        tilde
+        floor
+        color
+        frac
+        root
+        oint
+        ceil
+        ddot
+        coth
+        csch
+        sech
+        sinh
+        tanh
+        cosh
+        sqrt
+        norm
+        text
+        prod
+        sec
+        int
+        sin
+        tan
+        cos
+        sum
+        exp
+        gcd
+        glb
+        lcm
+        lub
+        cot
+        csc
+        det
+        dim
+        max
+        min
+        abs
+        bar
+        dot
+        hat
+        vec
+        mod
+        log
+        ul
+        ln
+        f
+        g
+      ].freeze
+      TAGS = %i[
+        annotation-xml
+        annotation_xml
+        mmultiscripts
+        maligngroup
+        malignmark
+        annotation
+        munderover
+        mscarries
+        semantics
+        mphantom
+        mlongdiv
+        menclose
+        mscarry
+        msubsup
+        mpadded
+        maction
+        msgroup
+        mfenced
+        merror
+        munder
+        mtable
+        mstyle
+        mstack
+        mspace
+        msline
+        mfrac
+        mover
+        msrow
+        mroot
+        msqrt
+        msup
+        msub
+        mrow
+        math
+        mtr
+        mtd
+        ms
+        mi
+        mo
+        mn
+      ].freeze
+      BINARY_CLASSES = %i[
+        underset
+        stackrel
+        overset
+        color
+        prod
+        frac
+        root
+        oint
+        int
+        sum
+        mod
+        log
+      ].freeze
+      FONT_CLASSES = %i[
+        fraktur
+        sans-serif
+        monospace
+        script
+        double-struck
+        bold
+      ].freeze
+      FONT_TYPES = {
+        :bb=>"bold",
+        :fr=>"fraktur",
+        :cc=>"script",
+        :sf=>"sans-serif",
+        :tt=>"monospace",
+        :mbf=>"bold",
+        :mit=>"italic",
+        :mtt=>"monospace",
+        :Bbb=>"double-struck",
+        :bbb=>"double-struck",
+        :mscr=>"mathbb",
+        :mfrak=>"fraktur",
+        :msans=>"sans-serif",
+        :mbfit=>"bold italic",
+        :mathbf=>"bold",
+        :mathit=>"italic",
+        :mathds=>"mathbb",
+        :mathrm=>"mathrm",
+        :mathtt=>"monospace",
+        :mathsf=>"sans-serif",
+        :mathbb=>"double-struck",
+        :mbfsans=>"bold sans-serif",
+        :mathcal=>"script",
+        :mathbold=>"bold",
+        :mathfrak=>"fraktur",
+        :mathbfit=>"bold italic",
+        :mathsfbf=>"sans-serif bold",
+        :mathsfit=>"sans-serif italic",
+        :mbfitsans=>"bold italic sans-serif",
+        :mathsfbfit=>"sans-serif bold italic",
+      }.freeze
+    end
+  end
+end

data/lib/plurimath/mathml/parse.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Plurimath
+  class Mathml
+    class Parse < Parslet::Parser
+      rule(:parse_record) do
+        array_to_expression(Constants::CLASSES).as(:class) |
+          array_to_expression(Constants::UNICODE_SYMBOLS.keys).as(:symbol) |
+          array_to_expression(Constants::SYMBOLS.keys).as(:symbol) |
+          match["a-zA-Z"].repeat(1).as(:text) |
+          match(/[0-9]/).repeat(1).as(:number) |
+          str("")
+      end
+
+      rule(:tag) { (parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close)).as(:tag) | parse_text_tag.as(:tag) }
+
+      rule(:sequence) { (tag >> sequence.as(:sequence)) | tag }
+
+      rule(:iteration) { (sequence >> iteration.as(:iteration)) | parse_record }
+
+      rule(:expression) { parse_tag(:open) >> iteration.as(:iteration) >> parse_tag(:close) }
+
+      root :expression
+
+      def array_to_expression(array, name = nil)
+        initial_type = array.first.class
+        array.reduce do |expr, tag|
+          expr = str_to_expression(expr, name) if expr.is_a?(initial_type)
+          expr | str_to_expression(tag, name)
+        end
+      end
+
+      def str_to_expression(string, name)
+        return str(string) if name.nil?
+
+        str(string).as(name)
+      end
+
+      def parse_tag(opts)
+        tag = str("<")
+        tag = tag >> str("/") if opts == :close
+        tag = tag >> array_to_expression(Constants::TAGS, opts)
+        tag = tag >> attributes.as(:attributes) if opts == :open
+        tag >> str(">")
+      end
+
+      def attributes
+        (match["a-zA-Z"].repeat.as(:name) >>
+          str("=") >> quoted_string).repeat
+      end
+
+      def quoted_string
+        (str('"') >> match("[^\"]").repeat.as(:value) >> str('"')) |
+          (str("'") >> match("[^\']").repeat.as(:value) >> str("'"))
+      end
+
+      def parse_text_tag
+        str("<mtext>") >> match("[^<]").repeat.as(:quoted_text) >> str("</mtext>")
+      end
+    end
+  end
+end

data/lib/plurimath/mathml/parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "parse"
+require_relative "constants"
+require_relative "transform"
+module Plurimath
+  class Mathml
+    class Parser
+      attr_accessor :text
+
+      def initialize(text)
+        @text = text.gsub("\n", "").gsub(" ", "")
+      end
+
+      def parse
+        tree_t = Plurimath::Mathml::Parse.new.parse(text)
+        formula = Plurimath::Mathml::Transform.new.apply(tree_t)
+        formula = [formula] unless formula.is_a?(Array) || formula.nil?
+        return if formula.nil?
+
+        Plurimath::Math::Formula.new(formula)
+      end
+    end
+  end
+end

data/lib/plurimath/mathml/transform.rb

@@ -0,0 +1,195 @@
+# 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))     { 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(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}]")
+        end
+        Plurimath::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
+        Plurimath::Math::Formula.new(tag + [sequence])
+      end
+
+      rule(
+        tag: simple(:tag),
+        sequence: simple(:sequence),
+        iteration: simple(:iteration),
+      ) do
+        [tag, sequence]
+      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)
+          [Transform.get_class(decoded_symbol).new]
+        elsif decoded_symbol.nil? && Constants::SYMBOLS[symbol.to_sym]
+          Plurimath::Math::Symbol.new(Constants::SYMBOLS[symbol.to_sym])
+        else
+          Plurimath::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
+        end
+      end
+
+      rule(
+        tag: simple(:tag),
+        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
+      end
+
+      rule(
+        open: simple(:open_tag),
+        attributes: sequence(:attributes),
+        iteration: sequence(:iteration),
+        close: simple(:close_tag),
+      ) do
+        Transform.raise_error!(open_tag, close_tag) unless open_tag == close_tag
+
+        if open_tag == "mrow"
+          Plurimath::Math::Formula.new(iteration)
+        elsif open_tag == "munder"
+          if Transform.get_class("obrace") == iteration.last.class
+            iteration.last.parameter_one = iteration.first
+            iteration.last
+          else
+            Plurimath::Math::Function::Underset.new(iteration[1], iteration[0])
+          end
+        elsif open_tag == "munderover"
+          Plurimath::Math::Function::Underover.new(iteration[0], iteration[1], iteration[2])
+        elsif open_tag == "mover"
+          if Transform.get_class("ubrace") == iteration.last.class
+            iteration.last.parameter_one = iteration.first
+            iteration.last
+          else
+            Plurimath::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 open_tag == "msubsup"
+          Plurimath::Math::Function::PowerBase.new(iteration[0], iteration[1], iteration[2])
+        elsif open_tag == "mfrac"
+          Plurimath::Math::Function::Frac.new(iteration.first, iteration.last)
+        elsif open_tag == "msqrt"
+          Plurimath::Math::Function::Sqrt.new(iteration.first)
+        elsif open_tag == "mroot"
+          Plurimath::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)
+          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)
+          end
+        else
+          iteration
+        end
+      end
+
+      rule(
+        open: simple(:open_tag),
+        attributes: sequence(:attributes),
+        iteration: simple(:iteration),
+        close: simple(:close_tag),
+      ) do
+        Transform.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
+
+      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

@@ -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
+      Plurimath::Mathml::Parser.new(text).parse
+    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
+      # TODO: Will be implemented soon
+    end
+  end
+end