plurimath 0.2.0 → 0.2.2

data/lib/plurimath/omml/transform.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "parslet"
+module Plurimath
+  class Omml
+    class Transform < Parslet::Transform
+      rule(t: simple(:t))   { Utility.text_classes(t) }
+      rule(e: subtree(:e))  { e.flatten.compact }
+      rule(i: sequence(:i)) { i }
+      rule(e: sequence(:e)) { e.flatten.compact }
+
+      rule(val: simple(:val))    { val }
+      rule(dPr: subtree(:dpr))   { dpr }
+      rule(num: subtree(:num))   { num }
+      rule(den: subtree(:den))   { den }
+      rule(rPr: subtree(:rPr))   { nil }
+      rule(fPr: subtree(:fPr))   { nil }
+      rule(mpr: subtree(:mpr))   { nil }
+      rule(mPr: subtree(:mPr))   { nil }
+      rule(box: subtree(:box))   { box.flatten.compact }
+      rule(deg: sequence(:deg))  { Utility.filter_values(deg) }
+      rule(sub: sequence(:sub))  { Utility.filter_values(sub) }
+      rule(sup: sequence(:sup))  { Utility.filter_values(sup) }
+      rule(boxPr: subtree(:box)) { nil }
+      rule(argPr: subtree(:arg)) { nil }
+      rule(accPr: subtree(:acc)) { acc.flatten.compact }
+
+      rule(sSubPr: subtree(:arg))   { nil }
+      rule(space: simple(:space))   { space }
+      rule(radPr: subtree(:radpr))  { nil }
+      rule(barPr: subtree(:barpr))  { barpr }
+      rule(oMath: subtree(:omath))  { omath.flatten.compact }
+      rule(fName: subtree(:fname))  { fname }
+      rule(oMath: sequence(:omath)) { omath }
+      rule(limLoc: simple(:limLoc)) { limLoc }
+      rule(begChr: simple(:begChr)) { Math::Symbol.new(begChr) }
+      rule(endChr: simple(:endChr)) { Math::Symbol.new(endChr) }
+
+      rule(rFonts: subtree(:rFonts))   { nil }
+      rule(sSupPr: subtree(:ssuppr))   { nil }
+      rule(sPrePr: subtree(:sprepr))   { nil }
+      rule(funcPr: subtree(:funcpr))   { nil }
+      rule(naryPr: subtree(:narypr))   { narypr }
+      rule(subHide: simple(:subHide))  { nil }
+      rule(supHide: simple(:supHide))  { nil }
+      rule(degHide: simple(:degHide))  { nil }
+      rule(ctrlPr: sequence(:ctrlpr))  { ctrlpr }
+      rule(eqArrPr: subtree(:eqarrpr)) { eqarrpr.flatten.compact }
+
+      rule(sequence: subtree(:sequence))   { sequence.flatten.compact }
+      rule(limUppPr: subtree(:limUppPr))   { nil }
+      rule(limLowPr: subtree(:limLowpr))   { nil }
+      rule(sequence: sequence(:sequence))  { sequence }
+      rule(sSubSupPr: subtree(:sSubSuppr)) { nil }
+
+      rule(groupChrPr: subtree(:groupchrpr))   { groupchrpr }
+      rule(borderBoxPr: subtree(:borderBoxpr)) { nil }
+      rule(lastRenderedPageBreak: sequence(:break)) { nil }
+
+      rule(f: subtree(:f)) do
+        Math::Function::Frac.new(
+          Utility.filter_values(f[1]),
+          Utility.filter_values(f[2]),
+        )
+      end
+
+      rule(r: sequence(:r)) do
+        Math::Formula.new(
+          r.flatten.compact,
+        )
+      end
+
+      rule(m: sequence(:m)) do
+        Math::Function::Table.new(
+          m.flatten.compact,
+        )
+      end
+
+      rule(t: sequence(:t)) do
+        if t.empty?
+          Math::Function::Text.new
+        else
+          Utility.text_classes(t)
+        end
+      end
+
+      rule(d: subtree(:data)) do
+        fenced       = data.flatten.compact
+        open_paren   = fenced.shift if fenced.first.class_name == "symbol"
+        close_paren  = fenced.shift if fenced.first.class_name == "symbol"
+        fenced_value = fenced
+        Math::Function::Fenced.new(
+          open_paren,
+          fenced_value,
+          close_paren,
+        )
+      end
+
+      rule(mr: subtree(:mr)) do
+        row = []
+        mr.each do |td|
+          row << Math::Function::Td.new(
+            td.is_a?(Array) ? td : [td],
+          )
+        end
+        Math::Function::Tr.new(row)
+      end
+
+      rule(lim: sequence(:lim)) do
+        if lim.any?(String)
+          Utility.text_classes(lim)
+        else
+          Utility.filter_values(lim)
+        end
+      end
+
+      rule(acc: subtree(:acc)) do
+        acc_value = acc.flatten.compact
+        chr = Utility.find_pos_chr(acc_value, :chr)
+        chr_value = chr ? chr[:chr] : "^"
+        Math::Function::Overset.new(
+          Math::Symbol.new(chr_value),
+          Utility.filter_values(acc.last),
+        )
+      end
+
+      rule(func: subtree(:func)) do
+        func_name = func.flatten.compact
+        class_object = Utility.find_class_name(func_name.first)
+        if class_object
+          class_object.new(func_name.last)
+        else
+          Math::Formula.new(
+            func_name,
+          )
+        end
+      end
+
+      rule(nary: subtree(:nary)) do
+        Math::Formula.new(
+          [
+            Utility.nary_fonts(nary),
+            Utility.filter_values(nary[3]),
+          ],
+        )
+      end
+
+      rule(groupChr: subtree(:groupchr)) do
+        chr_pos = groupchr.first
+        pos = Utility.find_pos_chr(chr_pos, :pos)
+        chr = Utility.find_pos_chr(chr_pos, :chr)
+        if pos&.value?("top")
+          Math::Function::Overset.new(
+            Math::Symbol.new(chr ? chr[:chr] : ""),
+            Utility.filter_values(groupchr[1]),
+          )
+        else
+          Math::Function::Underset.new(
+            Math::Symbol.new(chr ? chr[:chr] : "⏟"),
+            Utility.filter_values(groupchr[1]),
+          )
+        end
+      end
+
+      rule(sSubSup: subtree(:sSubSup)) do
+        subsup = sSubSup.flatten.compact
+        subsup.each_with_index do |object, ind|
+          subsup[ind] = Utility.mathml_unary_classes([object]) if object.is_a?(String)
+        end
+        Math::Function::PowerBase.new(
+          subsup[0],
+          subsup[1],
+          subsup[2],
+        )
+      end
+
+      rule(sSup: subtree(:ssup)) do
+        sup = ssup.flatten.compact
+        Math::Function::Power.new(
+          sup[0],
+          sup[1],
+        )
+      end
+
+      rule(rad: subtree(:rad)) do
+        if rad[1].nil?
+          Math::Function::Sqrt.new(
+            Utility.filter_values(rad[2]),
+          )
+        else
+          Math::Function::Root.new(
+            Utility.filter_values(rad[2]),
+            rad[1],
+          )
+        end
+      end
+
+      rule(sSub: subtree(:ssub)) do
+        sub = ssub.flatten.compact
+        Plurimath::Math::Function::Base.new(
+          sub[0],
+          sub[1],
+        )
+      end
+
+      rule(limUpp: subtree(:limUpp)) do
+        lim_values = limUpp.flatten.compact
+        first_value = lim_values[0]
+        Math::Function::Overset.new(
+          first_value,
+          lim_values[1],
+        )
+      end
+
+      rule(limLow: subtree(:lim)) do
+        Math::Function::Underset.new(
+          Utility.filter_values(lim[1]),
+          Utility.filter_values(lim[2]),
+        )
+      end
+
+      rule(borderBox: subtree(:box)) do
+        Math::Function::Menclose.new(
+          "longdiv",
+          Utility.filter_values(box[1]),
+        )
+      end
+
+      rule(bar: subtree(:bar)) do
+        barpr = bar&.flatten&.compact
+        pospr = Utility.find_pos_chr(bar.first, :pos)
+        class_name = if pospr&.value?("top")
+                       Math::Function::Bar
+                     else
+                       Math::Function::Ul
+                     end
+        class_name.new(barpr.last)
+      end
+
+      rule(sPre: subtree(:spre)) do
+        pre = spre.flatten.compact
+        Math::Function::Multiscript.new(
+          pre[2],
+          pre[0],
+          pre[1],
+        )
+      end
+
+      rule(eqArr: subtree(:eqArr)) do
+        table_value = []
+        eqArr.delete_at(0)
+        eqArr.each do |value|
+          table_value << Math::Function::Tr.new(
+            [
+              Math::Function::Td.new(
+                value.is_a?(Array) ? value : [value],
+              ),
+            ],
+          )
+        end
+        Math::Function::Table.new(table_value)
+      end
+
+      rule(ascii: simple(:ascii),
+           hAnsi: simple(:hansi)) do
+        nil
+      end
+
+      rule(attributes: simple(:attributes), value: sequence(:value)) do
+        if value.any? || attributes == "preserve"
+          value.any? ? value : [" "]
+        else
+          attributes
+        end
+      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

data/lib/plurimath/utility.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Utility
+    FONT_STYLES = {
+      "double-struck": Math::Function::FontStyle::DoubleStruck,
+      "sans-serif": Math::Function::FontStyle::SansSerif,
+      monospace: Math::Function::FontStyle::Monospace,
+      fraktur: Math::Function::FontStyle::Fraktur,
+      script: Math::Function::FontStyle::Script,
+      normal: Math::Function::FontStyle::Normal,
+      bold: Math::Function::FontStyle::Bold,
+      mathfrak: Math::Function::FontStyle::Fraktur,
+      mathcal: Math::Function::FontStyle::Script,
+      mathbb: Math::Function::FontStyle::DoubleStruck,
+      mathtt: Math::Function::FontStyle::Monospace,
+      mathsf: Math::Function::FontStyle::SansSerif,
+      mathrm: Math::Function::FontStyle::Normal,
+      textrm: Math::Function::FontStyle::Normal,
+      mathbf: Math::Function::FontStyle::Bold,
+      textbf: Math::Function::FontStyle::Bold,
+      bbb: Math::Function::FontStyle::DoubleStruck,
+      cal: Math::Function::FontStyle::Script,
+      bf: Math::Function::FontStyle::Bold,
+      sf: Math::Function::FontStyle::SansSerif,
+      tt: Math::Function::FontStyle::Monospace,
+      fr: Math::Function::FontStyle::Fraktur,
+      rm: Math::Function::FontStyle::Normal,
+      cc: Math::Function::FontStyle::Script,
+      ii: Math::Function::FontStyle::Italic,
+      bb: Math::Function::FontStyle::Bold,
+    }.freeze
+    ALIGNMENT_LETTERS = {
+      c: "center",
+      r: "right",
+      l: "left",
+    }.freeze
+    UNARY_CLASSES = %w[
+      arccos
+      arcsin
+      arctan
+      right
+      sech
+      sinh
+      tanh
+      cosh
+      coth
+      csch
+      left
+      max
+      min
+      sec
+      sin
+      deg
+      det
+      dim
+      exp
+      gcd
+      glb
+      lub
+      tan
+      cos
+      cot
+      csc
+      ln
+      lg
+      f
+      g
+    ].freeze
+
+    class << self
+      def organize_table(array, column_align: nil, options: nil)
+        table = []
+        table_data = []
+        table_row = []
+        table_separators = ["&", "\\\\"].freeze
+        organize_options(array, column_align) if options
+        string_columns = column_align&.map(&:value)
+        array.each do |data|
+          if data.is_a?(Math::Symbol) && table_separators.include?(data.value)
+            table_row << Math::Function::Td.new(filter_table_data(table_data).compact)
+            table_data = []
+            if data.value == "\\\\"
+              organize_tds(table_row.flatten, string_columns.dup, options)
+              table << Math::Function::Tr.new(table_row)
+              table_row = []
+            end
+            next
+          end
+          table_data << data
+        end
+        table_row << Math::Function::Td.new(table_data.compact) if table_data
+        unless table_row.nil? || table_row.empty?
+          organize_tds(table_row.flatten, string_columns.dup, options)
+          table << Math::Function::Tr.new(table_row)
+        end
+        table_separator(string_columns, table, symbol: "|") unless column_align.nil? || column_align.empty?
+        table
+      end
+
+      def organize_options(table_data, column_align)
+        return column_align if column_align.length <= 1
+
+        align = [column_align&.shift]
+        table_data.insert(0, *column_align)
+        align
+      end
+
+      def table_options(table_data)
+        rowline = ""
+        table_data.map do |tr|
+          if symbol_value(tr&.parameter_one&.first&.parameter_one&.first, "&#x23af;")
+            rowline += "solid "
+          else
+            rowline += "none "
+          end
+        end
+        options = { rowline: rowline.strip } if rowline.include?("solid")
+        options || {}
+      end
+
+      def organize_tds(tr_array, column_align, options)
+        return tr_array if column_align.nil? || column_align.empty?
+
+        column_align.reject! { |string| string == "|" }
+        column_align = column_align * tr_array.length if options
+        tr_array.map.with_index do |td, ind|
+          columnalign = ALIGNMENT_LETTERS[column_align[ind]&.to_sym]
+          td.parameter_two = { columnalign: columnalign } if columnalign
+        end
+      end
+
+      def filter_table_data(table_data)
+        table_data.each_with_index do |object, ind|
+          if symbol_value(object, "-")
+            table_data[ind] = Math::Formula.new(
+              [object, table_data.delete_at(ind.next)],
+            )
+          end
+        end
+        table_data
+      end
+
+      def get_table_class(text)
+        Object.const_get(
+          "Plurimath::Math::Function::Table::#{text.to_s.capitalize}",
+        )
+      end
+
+      def sub_sup_method?(sub_sup)
+        if sub_sup.methods.include?(:class_name)
+          Html::Constants::SUB_SUP_CLASSES.value?(sub_sup.class_name.to_sym)
+        end
+      end
+
+      def get_class(text)
+        text = text.to_s.split("_").map(&:capitalize).join
+        Object.const_get(
+          "Plurimath::Math::Function::#{text}",
+        )
+      end
+
+      def ox_element(node, attributes: [], namespace: "")
+        namespace = "#{namespace}:" unless namespace.empty?
+
+        element = Ox::Element.new("#{namespace}#{node}")
+        attributes&.each do |attr_key, attr_value|
+          element[attr_key] = attr_value
+        end
+        element
+      end
+
+      def rpr_element(wi_tag: false)
+        rpr_element = ox_element("rPr", namespace: "w")
+        attributes = { "w:ascii": "Cambria Math", "w:hAnsi": "Cambria Math" }
+        rpr_element << ox_element(
+          "rFonts",
+          namespace: "w",
+          attributes: attributes,
+        )
+        rpr_element << ox_element("i", namespace: "w") if wi_tag
+        rpr_element
+      end
+
+      def update_nodes(element, nodes)
+        nodes&.each { |node| element << node unless node.nil? }
+        element
+      end
+
+      def pr_element(main_tag, wi_tag, namespace: "")
+        tag_name = "#{main_tag}Pr"
+        ox_element(
+          tag_name,
+          namespace: namespace,
+        ) << rpr_element(wi_tag: wi_tag)
+      end
+
+      def filter_values(array)
+        return array unless array.is_a?(Array)
+
+        array = array.flatten.compact
+        if array.length > 1
+          return Math::Formula.new(array)
+        end
+
+        array.first
+      end
+
+      def text_classes(text)
+        return nil if text.empty?
+
+        text = filter_values(text) unless text.is_a?(String)
+        if text.scan(/[[:digit:]]/).length == text.length
+          Math::Number.new(text)
+        elsif text.match?(/[a-zA-Z]/)
+          Math::Function::Text.new(text)
+        else
+          Math::Symbol.new(text)
+        end
+      end
+
+      def nary_fonts(nary)
+        narypr = nary.first.flatten.compact
+        subsup = narypr.any?("undOvr") ? "underover" : "power_base"
+        get_class(subsup).new(
+          Math::Symbol.new(narypr.any?(Hash) ? narypr.first[:chr] : "∫"),
+          nary[1],
+          nary[2],
+        )
+      end
+
+      def find_class_name(object)
+        new_object = object.value.first.parameter_one if object.is_a?(Math::Formula)
+        get_class(new_object) unless new_object.nil?
+      end
+
+      def find_pos_chr(fonts_array, key)
+        fonts_array.find { |d| d.is_a?(Hash) && d[key] }
+      end
+
+      def td_values(objects, slicer)
+        sliced = objects.slice_when { |object, _| symbol_value(object, slicer) }
+        tds = sliced.map do |slice|
+          Math::Function::Td.new(
+            slice.delete_if { |d| symbol_value(d, slicer) }.compact,
+          )
+        end
+        tds << Math::Function::Td.new([]) if symbol_value(objects.last, slicer)
+        tds
+      end
+
+      def symbol_value(object, value)
+        object.is_a?(Math::Symbol) && object.value.include?(value)
+      end
+
+      def td_value(td_object)
+        if td_object.is_a?(String) && td_object.empty?
+          return Math::Function::Text.new(nil)
+        end
+
+        td_object
+      end
+
+      def mathml_unary_classes(text_array)
+        return [] if text_array.empty?
+
+        compacted = text_array.compact
+        string = if compacted.count == 1
+                   compacted.first
+                 else
+                   compacted.join
+                 end
+        return string unless string.is_a?(String)
+
+        classes = Mathml::Constants::CLASSES
+        unicode = string_to_html_entity(string)
+        symbol  = Mathml::Constants::UNICODE_SYMBOLS[unicode.strip.to_sym]
+        if classes.include?(symbol&.strip)
+          get_class(symbol.strip).new
+        elsif classes.any?(string&.strip)
+          get_class(string.strip).new
+        else
+          Math::Symbol.new(unicode)
+        end
+      end
+
+      def string_to_html_entity(string)
+        entities = HTMLEntities.new
+        entities.encode(string, :hexadecimal)
+      end
+
+      def table_separator(separator, value, symbol: "solid")
+        sep_symbol = Math::Function::Td.new([Math::Symbol.new("|")])
+        separator&.each_with_index do |sep, ind|
+          next unless sep == symbol
+
+          value.map do |val|
+            val.parameter_one.insert((ind + 1), sep_symbol) if symbol == "solid"
+            val.parameter_one.insert(ind, sep_symbol) if symbol == "|"
+            (val.parameter_one[val.parameter_one.index(nil)] = Math::Function::Td.new([])) rescue nil
+            val
+          end
+        end
+        value
+      end
+
+      def join_attr_value(attrs, value)
+        if value.any?(String)
+          new_value = mathml_unary_classes(value)
+          array_value = Array(new_value)
+          attrs.nil? ? array_value : join_attr_value(attrs, array_value)
+        elsif attrs.nil?
+          value
+        elsif attrs.is_a?(Math::Function::Menclose)
+          attrs.parameter_two = filter_values(value)
+          attrs
+        elsif attrs.is_a?(Math::Function::Fenced)
+          attrs.parameter_two = value
+          attrs
+        elsif attrs.is_a?(Math::Function::FontStyle)
+          attrs.parameter_one = filter_values(value)
+          attrs
+        elsif attrs.is_a?(Math::Function::Color)
+          color_value = filter_values(value)
+          if attrs.parameter_two
+            attrs.parameter_two.parameter_one = color_value
+          else
+            attrs.parameter_two = color_value
+          end
+          attrs
+        elsif ["solid", "none"].include?(attrs.split.first.downcase)
+          table_separator(attrs.split, value)
+        end
+      end
+
+      def multiscript(values)
+        values.slice_before("mprescripts").map do |value|
+          base_value   = value.shift
+          part_val     = value.partition.with_index { |_, i| i.even? }
+          first_value  = part_val[0].empty? ? nil : filter_values(part_val[0])
+          second_value = part_val[1].empty? ? nil : filter_values(part_val[1])
+          if base_value.to_s.include?("mprescripts")
+            [first_value, second_value]
+          else
+            Math::Function::PowerBase.new(
+              base_value,
+              first_value,
+              second_value,
+            )
+          end
+        end
+      end
+
+      def unfenced_value(object)
+        case object
+        when Math::Function::Fenced
+          value = filter_values(object.parameter_two)
+          unfenced_value(value)
+        when Array
+          filter_values(object)
+        else
+          object
+        end
+      end
+
+      def frac_values(object)
+        case object
+        when Math::Formula
+          object.value.any? { |d| symbol_value(d, ",") }
+        when Array
+          object.any? { |d| symbol_value(d, ",") }
+        end
+      end
+
+      def table_td(object)
+        new_object = case object
+                     when Math::Function::Td
+                       object
+                     else
+                       Math::Function::Td.new([object])
+                     end
+        Array(new_object)
+      end
+
+      def symbol_object(value)
+        value = case value
+                when "ℒ" then "{:"
+                when "ℛ" then ":}"
+                else value
+                end
+        Math::Symbol.new(value)
+      end
+    end
+  end
+end

data/lib/plurimath/version.rb

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

data/plurimath.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.add_dependency 'parslet'
+  spec.add_dependency 'ox'
 end