latexmath 0.1.4 → 1.0.0

data/lib/latexmath/converter.rb

@@ -1,424 +0,0 @@
-module Latexmath
-  class Converter
-    def initialize(aggregate)
-      @aggregate = aggregate
-    end
-
-    def convert(xmlns = 'http://www.w3.org/1998/Math/MathML', display = 'block')
-      @doc = Ox::Document.new
-      math = Ox::Element.new('math')
-      math = Latexmath::XML::Element.new(@doc, 'math', { xmlns: xmlns, display: display })
-      mrow = Latexmath::XML::Element.new(math, 'mrow')
-
-      classify_subgroup(@aggregate, mrow)
-
-      Ox.dump(@doc, indent: -1)
-    end
-
-    private
-
-    def apply_style(element, elements, index, iterable, parent)
-      style = STYLES[element]
-      index += 1
-      iterable.next
-      classify_subgroup(elements[index], parent, false, style)
-    end
-
-    def classify(element, parent, is_math_mode = false, style = nil)
-      symbol = Latexmath::Symbol.get("\\mathbf{#{element}}") unless style.nil?
-      symbol ||= Latexmath::Symbol.get(element)
-      if element == '\\displaystyle'
-      elsif element.nil?
-        Latexmath::XML::Element.new(parent, 'mi')
-      elsif element.match?(/^\d+(.\d+)?$/)
-        el = Latexmath::XML::Element.new(parent, 'mn')
-        el.text = element
-      elsif element.size > 0 && '<>&'.include?(element)
-        el = Latexmath::XML::Element.new(parent, 'mo')
-        el.text = { '<' => '&lt;', '>' => '&gt;', '&' => '&amp;' }[element]
-      elsif element.size > 0 && '+-*/()='.include?(element)
-        el = Latexmath::XML::Element.new(parent, 'mo')
-        el.text = symbol.nil? ? element : "&#x#{symbol};"
-        el.set_attribute('stretchy', false) if '()'.include?(element)
-      elsif symbol &&
-            (
-                Range.new('2200'.to_i(16), '22FF'.to_i(16)).include?(symbol.to_i(16)) ||
-                Range.new('2190'.to_i(16), '21FF'.to_i(16)).include?(symbol.to_i(16))
-              ) ||
-            symbol == '.'
-
-        mo = Latexmath::XML::Element.new(parent, 'mo')
-        mo.text = "&#x#{symbol};"
-      elsif element.start_with?('\\textrm')
-        el = Latexmath::XML::Element.new(parent, 'mtext')
-        matches = element.match(/\\textrm{([^}]*)}/)
-        el.text = matches[1]
-      elsif element.start_with?('\\vec')
-        el = Latexmath::XML::Element.new(parent, 'mover', {accent: 'true'})
-        mi = Latexmath::XML::Element.new(el, 'mi')
-        matches = element.match(/\\vec{([^}]*)}/)
-        mi.text = matches[1]
-        mo = Latexmath::XML::Element.new(el, 'mo', {stretchy: 'false'})
-        mo.text = "&#x#{Latexmath::Symbol.get('\\vec')};"
-      elsif element.start_with?('\\hat')
-        el = Latexmath::XML::Element.new(parent, 'mover', {accent: 'true'})
-        mi = Latexmath::XML::Element.new(el, 'mi')
-        matches = element.match(/\\hat{([^}]*)}/)
-        mi.text = matches[1]
-        mo = Latexmath::XML::Element.new(el, 'mo', {stretchy: 'false'})
-        mo.text = "&#x#{Latexmath::Symbol.get('\\hat')};"
-      elsif element.start_with?('\\mbox')
-        el = Latexmath::XML::Element.new(parent, 'mtext')
-        matches = element.match(/\\mbox{([^}]*)}/)
-        el.text = matches[1]
-      elsif element.start_with?('\\')
-        tag_name = is_math_mode ? 'mo' : 'mi'
-        el = Latexmath::XML::Element.new(parent, tag_name)
-        el.text = if symbol
-                    "&#x#{symbol};"
-                  elsif ['\\log', '\\ln', '\\tan', '\\sec', '\\cos', '\\sin', '\\cot', '\\csc'].include?(element)
-                    element[1..element.size]
-                  else
-                    element
-                  end
-      else
-        tag_name = is_math_mode ? 'mo' : 'mi'
-        el = Latexmath::XML::Element.new(parent, tag_name)
-        el.text = symbol ? "&#x#{symbol};" : element
-      end
-    end
-
-    def classify_subgroup(elements, row, is_math_mode = false, style = nil)
-      return if elements.size == 0
-
-      iterable = Range.new(0, (elements.size - 1)).each_compat
-      while i = iterable.next
-        element = elements[i]
-        if element.is_a?(Array)
-          _row = Latexmath::XML::Element.new(row, 'mrow')
-          classify_subgroup(element, _row, is_math_mode)
-          is_math_mode = false
-        elsif COMMANDS.keys.include?(element)
-          convert_command(element, elements, i, iterable, row, style)
-        elsif STYLES.keys.include?(element)
-          apply_style(element, elements, i, iterable, row)
-        elsif element.start_with?('\\math')
-          is_math_mode = true
-        else
-          classify(element, row, is_math_mode, style)
-        end
-        begin
-          iterable.peek
-        rescue StandardError
-          break
-        end
-      end
-    end
-
-    def convert_and_append_operator(symbol, parent)
-      converted = Latexmath::Symbol.get(symbol)
-      mo = Latexmath::XML::Element.new(parent, 'mo')
-      mo.text = "&#x#{converted};"
-    end
-
-    def convert_array_content(param, parent, alignment = '')
-      all_are_list = param.all? { |item| item.is_a?(Array) }
-
-      if all_are_list
-        param.each do |row|
-          convert_array_array(row, parent, alignment)
-        end
-      else
-        convert_array_row(param, parent, alignment)
-      end
-    end
-
-    def convert_array_array(row, parent, alignment)
-      if alignment&.include?('|')
-        _alignment = []
-        column_lines = []
-        alignment.chars.each do |j|
-          if j == '|'
-            column_lines << 'solid'
-          else
-            _alignment << j
-          end
-          column_lines << 'none' if _alignment.size - column_lines.size == 2
-        end
-        parent.set_attribute('columnlines', column_lines.join(' '))
-      else
-        _alignment = alignment.chars
-      end
-
-      mtr = Latexmath::XML::Element.new(parent, 'mtr')
-      iterable = Range.new(0, row.size - 1).each_compat
-
-      has_row_line = false
-      index = 0
-      row_lines = []
-
-      while i = iterable.next
-        element = row[i]
-        if element == '\\hline'
-          row_lines << 'solid'
-          has_row_line = true
-          row_lines.insert(0, 'none')
-          next
-        end
-        align = _alignment[index]
-
-        mtd = if %w[r l c].include?(align)
-          column_align = { 'r' => 'right', 'l' => 'left', 'c' => 'center' }.fetch(align, nil)
-          Latexmath::XML::Element.new(mtr, 'mtd', { columnalign: column_align })
-        else
-          Latexmath::XML::Element.new(mtr, 'mtd')
-        end
-
-        if element.is_a?(Array)
-          classify_subgroup(element, mtd)
-        elsif COMMANDS.include?(element)
-          convert_command(element, row, i, iterable, mtd)
-        else
-          classify(element, mtd)
-        end
-        index += 1
-        begin
-          iterable.peek
-        rescue StandardError
-          break
-        end
-      end
-
-      parent.set_attribute('rowlines', row_lines.join(' ')) if row_lines.include?('solid')
-    end
-
-    def convert_array_row(param, parent, alignment = '')
-      if alignment&.include?('|')
-        _alignment = []
-        column_lines = []
-        alignment.chars.each do |j|
-          if j == '|'
-            column_lines << 'solid'
-          else
-            _alignment << j
-          end
-          column_lines << 'none' if _alignment.size - column_lines.size == 2
-        end
-        parent.set_attribute('columnlines', column_lines.join(' '))
-      else
-        _alignment = alignment.chars
-      end
-
-      row_lines = []
-      row_count = 0
-
-      if param.all?{|d| !d.is_a?(Array)}
-        mtr = Latexmath::XML::Element.new(parent, 'mtr')
-        param.each do |element  |
-          mtd = Latexmath::XML::Element.new(mtr, 'mtd')
-          classify(element, mtd)
-        end
-      else
-        param.each do |row|
-          next if row.nil?
-
-          row_count += 1
-          mtr = Latexmath::XML::Element.new(parent, 'mtr')
-          iterable = Range.new(0, row.size - 1).each_compat
-
-          index = 0
-          has_row_line = false
-
-          while i = iterable.next
-            element = row[i]
-            if element == '\\hline' && row_count > 1
-              row_lines << 'solid'
-              has_row_line = true
-              next
-            end
-            align = _alignment[index]
-
-            mtd = if %w[r l c].include?(align)
-                    column_align = { 'r' => 'right', 'l' => 'left', 'c' => 'center' }.fetch(align, nil)
-                    Latexmath::XML::Element.new(mtr, 'mtd', { columnalign: column_align })
-                  else
-                    Latexmath::XML::Element.new(mtr, 'mtd')
-            end
-
-            if element.is_a?(Array)
-              classify_subgroup(element, mtd)
-            else
-              classify(element, mtd)
-            end
-
-            index += 1
-
-            begin
-              iterable.peek
-            rescue StandardError
-              break
-            end
-          end
-
-          row_lines << 'none' if !has_row_line && row_count > 1
-        end
-      end
-
-
-      parent.set_attribute('rowlines', row_lines.join(' ')) if row_lines.include?('solid')
-    end
-
-    def convert_command(element, elements, index, iterable, parent, style = nil)
-      get_prefix_element(element, parent)
-
-      parent = Latexmath::XML::Element.new(parent, 'mstyle', { scriptlevel: '1' }) if element == '\\substack'
-
-      params, tag, attributes = COMMANDS[element]
-
-      if (elements.size - 1) < params
-        mo = Latexmath::XML::Element.new(parent, 'mo')
-        mo.text = element[1..element.size]
-        return
-      end
-
-      new_parent = Latexmath::XML::Element.new(parent, tag, attributes)
-      alignment = ''
-
-      if MATRICES.include?(element) && (element.end_with?('*') || element == '\\array')
-        index += 1
-        alignment = elements[index]
-        iterable.next
-      end
-
-      if LIMITS.include?(element)
-        limit = Latexmath::XML::Element.new(new_parent, 'mo')
-        limit.text = element[1..element.size]
-      end
-
-      Range.new(0, (params - 1)).each do |_j|
-        index += 1
-        param = elements[index]
-        if element == '_' && index == 1 && param == '\\sum'
-          new_parent.tag = 'munder'
-          classify(param, new_parent)
-        elsif element == '_^' && param == '\\sum'
-          new_parent.tag = 'munderover'
-          classify(param, new_parent)
-        elsif element == '\\left' || element == '\\right'
-          if param == '.'
-
-          else
-            symbol = Latexmath::Symbol.get(param)
-            new_parent.text = symbol.nil? ? param : "&#x#{symbol};"
-          end
-        elsif element == '\\array'
-          convert_array_content(param, new_parent, alignment)
-        elsif MATRICES.include?(element)
-          convert_matrix_content(
-            param, new_parent, alignment, element == '\\substack'
-          )
-        else
-          if param.is_a?(Array)
-            _parent = Latexmath::XML::Element.new(new_parent, 'mrow')
-            classify_subgroup(param, _parent, false, style)
-          else
-            classify(param, new_parent, false, style)
-          end
-        end
-      end
-
-      get_postfix_element(element, parent)
-      if ['\\overline', '\\bar'].include?(element)
-        mo = Latexmath::XML::Element.new(new_parent, 'mo', { stretchy: 'true' })
-        mo.text = '&#x000AF;'
-      elsif element == '\\underline'
-        mo = Latexmath::XML::Element.new(new_parent, 'mo', { stretchy: 'true' })
-        mo.text = '&#x00332;'
-      elsif element == '\\overrightarrow'
-        mo = Latexmath::XML::Element.new(new_parent, 'mo', { stretchy: 'true' })
-        mo.text = '&#x02192;'
-      end
-
-      params.times do
-        iterable.next
-      end
-    end
-
-    def convert_matrix_content(param, parent, alignment, single_mtd = true)
-      return if param.size == 0
-      return unless param.is_a?(Array)
-
-      all_are_list = param.all? { |item| item.is_a?(Array) }
-
-      if all_are_list
-        param.each do |row|
-          if row.empty?
-            mtr = Latexmath::XML::Element.new(parent, 'mtr')
-            Latexmath::XML::Element.new(mtr, 'mtd')
-          else
-            convert_matrix_row(row, parent, alignment, single_mtd)
-          end
-        end
-      else
-        convert_matrix_row(param, parent, alignment, single_mtd)
-      end
-    end
-
-    def convert_matrix_row(row, parent, alignment, single_mtd)
-      mtr = Latexmath::XML::Element.new(parent, 'mtr')
-      iterable = Range.new(0, row.size - 1).each_compat
-      mtd = Latexmath::XML::Element.new(mtr, 'mtd') if single_mtd
-
-      while i = iterable.next
-        element = row[i]
-        if %w[r l c].include?(alignment)
-          column_align = { 'r' => 'right', 'l' => 'left', 'c' => 'center' }.fetch(alignment, nil)
-          mtd = Latexmath::XML::Element.new(mtr, 'mtd', { columnalign: column_align })
-        elsif !single_mtd
-          mtd = Latexmath::XML::Element.new(mtr, 'mtd')
-        end
-
-        if element.is_a?(Array)
-          classify_subgroup(element, mtd)
-        elsif COMMANDS.include?(element)
-          convert_command(element, row, i, iterable, mtd)
-        else
-          classify(element, mtd)
-        end
-        begin
-          iterable.peek
-        rescue StandardError
-          break
-        end
-      end
-    end
-
-    def get_postfix_element(element, row)
-      if ['\\binom', '\\pmatrix'].include?(element)
-        convert_and_append_operator('\\rparen', row)
-      elsif element == '\\bmatrix'
-        convert_and_append_operator('\\rbrack', row)
-      elsif element == '\\Bmatrix'
-        convert_and_append_operator('\\rbrace', row)
-      elsif element == '\\vmatrix'
-        convert_and_append_operator('\\vert', row)
-      elsif element == '\\Vmatrix'
-        convert_and_append_operator('\\Vert', row)
-      end
-    end
-
-    def get_prefix_element(element, row)
-      if ['\\binom', '\\pmatrix'].include?(element)
-        convert_and_append_operator('\\lparen', row)
-      elsif element == '\\bmatrix'
-        convert_and_append_operator('\\lbrack', row)
-      elsif element == '\\Bmatrix'
-        convert_and_append_operator('\\lbrace', row)
-      elsif element == '\\vmatrix'
-        convert_and_append_operator('\\vert', row)
-      elsif element == '\\Vmatrix'
-        convert_and_append_operator('\\Vert', row)
-      end
-    end
-  end
-end

data/lib/latexmath/equation.rb

@@ -1,13 +0,0 @@
-module Latexmath
-  class Equation
-    def initialize(string)
-      @latex = string
-    end
-
-    def to_mathml
-      tokens = Tokenizer.new(@latex).tokenize
-      aggregate = Aggregator.new(tokens).aggregate
-      Converter.new(aggregate).convert
-    end
-  end
-end

data/lib/latexmath/ext.rb

@@ -1,9 +0,0 @@
-class Range
-  def each_compat
-    if RUBY_ENGINE == 'opal'
-      Pseudoenumerator.new(self)
-    else
-      each
-    end
-  end
-end

data/lib/latexmath/symbol.rb

@@ -1,21 +0,0 @@
-require 'singleton'
-module Latexmath
-  class Symbol
-    include Singleton
-
-    def self.get(symbol)
-      instance.symbols[symbol]
-    end
-
-    def symbols
-      if RUBY_ENGINE == 'opal'
-        require 'unimathsymbols'
-        require 'native'
-        @symbols ||= Native::Object.new(`globalThis.unimathsymbols`)
-      else
-        @symbols ||= Latexmath::Constants::SYMBOLS
-      end
-    end
-
-  end
-end

data/lib/latexmath/tokenizer.rb

@@ -1,82 +0,0 @@
-require 'strscan'
-
-module Latexmath
-  class Tokenizer < StringScanner
-    def tokenize
-      exp = []
-
-      while token = fetch_token
-        exp << token
-      end
-
-      if exp.first == '\[' && exp.last == '\]'
-        exp.pop
-        exp.shift
-      end
-
-      exp
-    end
-
-    def fetch_token
-      skip(/\s+/)
-      skip(/\$\$/)
-
-      token = if scan(/\\mathbb\{[^}]+}/)
-                if Latexmath::Symbol.get(matched)
-                  "&#x#{Latexmath::Symbol.get(matched)};"
-                else
-                  matched
-                end
-              elsif scan(/{\\bf [^}]+}/)
-                matches = matched.match(/{\\bf ([^}]+)}/)
-                symbol = Latexmath::Symbol.get("\\mathbf{#{matches[1]}}")
-                "&#x#{symbol};" if symbol
-              elsif scan(/\\\\\[\d+mm\]/)
-                '\\\\' # matched
-              elsif scan(/\\mbox{[^\}]+}/)
-                matched
-              elsif scan(/\\Delta/)
-                matched
-              elsif scan(/\\vec{[^\}]+}/)
-                matched
-              elsif scan(/\\hat{[^\}]+}/)
-                matched
-              elsif scan(/\\textrm{[^\}]+}/)
-                matched
-              elsif scan(/{\\rm [^}]+}/)
-                matches = matched.match(/{\\rm ([^}]+)}/)
-                matches[1]
-              elsif scan(/\\[a-z]+\{(bmatrix|Bmatrix|matrix|vmatrix|Vmatrix|array|pmatrix|split)\*?\}/)
-                matched
-              elsif scan(/\\[a-z]+/)
-                matched
-              elsif scan(/\\\\/)
-                matched
-              elsif scan(/\\\[/)
-                matched
-              elsif scan(/\\\]/)
-                matched
-              elsif scan(/\\\{/)
-                matched
-              elsif scan(/\\[:;,]/)
-                matched
-              elsif scan(/\\/)
-                matched
-              elsif scan(/[a-z]/)
-                matched
-              elsif scan(/[0-9]+\.[0-9]+/)
-                matched
-              elsif scan(/[0-9]+/)
-                matched
-              elsif scan(/ /)
-                matched
-              elsif scan(/[\{\}\*]/)
-                matched
-              elsif scan(/./)
-                matched
-              end
-
-      token
-    end
-  end
-end

data/lib/latexmath/xml/builder.rb

@@ -1,4 +0,0 @@
-module Latexmath::XML
-  class Builder
-  end
-end

data/lib/latexmath/xml/element.rb

@@ -1,25 +0,0 @@
-module Latexmath::XML
-  class Element
-    attr_accessor :element
-    def initialize(parent, tag, attributes = {})
-      @element = Ox::Element.new(tag)
-      attributes.each do |key, value|
-        @element[key] = value
-      end
-      @parent = parent.is_a?(Latexmath::XML::Element) ? parent.element : parent
-      @parent << @element
-    end
-
-    def tag=(tag)
-      @element.value = tag
-    end
-
-    def text=(value)
-      @element << Ox::Raw.new(value)
-    end
-
-    def set_attribute(key, value)
-      @element[key] = value
-    end
-  end
-end

data/lib/unimathsymbols.js.erb

@@ -1,4 +0,0 @@
-<%# This preprocesses Latexmath::SYMBOLS constant for Opal %>
-<% require_relative 'lib/latexmath/constants/symbols' %>
-
-globalThis.unimathsymbols = <%= Latexmath::Constants::SYMBOLS.to_json %>;