latexmath 0.1.4 → 1.0.0

data/Rakefile

@@ -1,95 +0,0 @@
-require 'bundler/setup'
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec)
-
-task 'build-opal' do
-  require 'opal'
-  require 'erb'
-  require 'json'
-
-  b = Opal::Builder.new
-
-  b.append_paths __dir__ + '/lib'
-  b.append_paths __dir__ + '/opal'
-  b.use_gem 'htmlentities'
-
-  build = b.build('latexmath-opal').to_s
-  # This is a hack intended for ExecJS to work properly.
-  build = build.gsub('Object freezing is not supported by Opal', '')
-
-  FileUtils.mkdir_p 'dist'
-  File.write('dist/latexmath.js', build)
-end
-
-task 'spec-opal' => 'build-opal' do
-  ENV['TEST_OPAL'] = '1'
-  Rake::Task['spec'].execute
-  ENV.delete 'TEST_OPAL'
-end
-
-def read_symbols(input)
-  @symbols = {}
-  File.readlines(input).each do |line|
-    next if line.start_with?('#')
-
-    columns = line.chop.split('^')
-    _unicode = columns[0]
-    latex = columns[2]
-    unicode_math = columns[3]
-
-    @symbols[latex] = _unicode if latex && !@symbols.include?(latex)
-    @symbols[unicode_math] = _unicode if unicode_math && !@symbols.include?(unicode_math)
-
-    matches = columns[-1].match(/=\s+(\\[^,^ ]+),?/)
-    if matches
-      @symbols[matches[1]] = _unicode unless @symbols[matches[1]]
-    end
-  end
-  @symbols
-end
-
-directory 'lib/latexmath/constants'
-file 'lib/latexmath/constants/symbols.rb' => [
-  'lib/latexmath/constants',
-  'lib/unimathsymbols.txt'
-  ] do |file|
-  symbols = read_symbols(file.prerequisites.last)
-
-  File.open(file.name, "w+") do |f|
-    f.puts <<~HERE
-    module Latexmath
-      module Constants
-        SYMBOLS = {
-    HERE
-
-    @symbols.each_pair do |k,v|
-      f.puts("     '#{k.to_s}' => '#{v}',")
-    end
-
-    f.puts <<~HERE
-        }.freeze
-      end
-    end
-    HERE
-  end
-end
-
-Rake::Task['build'].enhance ['lib/latexmath/constants/symbols.rb']
-Rake::Task[:spec].enhance ['lib/latexmath/constants/symbols.rb']
-
-desc 'Generate and write MathML fixtures'
-task 'create-mathml-fixtures' do
-  require_relative 'lib/latexmath'
-  records = Dir.glob('spec/fixtures/*/*.tex')
-
-  records.each do |file|
-    tex = File.read("./#{file}")
-    tokens = Latexmath::Tokenizer.new(tex).tokenize
-    aggr = Latexmath::Aggregator.new(tokens).aggregate
-
-    File.write("./#{file.chomp('.tex')}.html", Latexmath::Converter.new(aggr).convert)
-  end
-end
-
-task default: [:spec, 'spec-opal']

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'latexmath'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/exe/latexmath

@@ -1,8 +0,0 @@
-#!/usr/bin/env ruby
-require_relative '../lib/latexmath'
-
-latex = File.read(ARGV[0])
-
-tokens = Latexmath::Tokenizer.new(latex).tokenize
-aggr = Latexmath::Aggregator.new(tokens).aggregate
-puts Latexmath::Converter.new(aggr).convert

data/latexmath.gemspec

@@ -1,34 +0,0 @@
-require_relative 'lib/latexmath/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'latexmath'
-  spec.version       = Latexmath::VERSION
-  spec.authors       = ['Ribose Inc.']
-  spec.email         = ['open.source@ribose.com']
-
-  spec.summary       = 'Converts LaTeX math into MathML.'
-  spec.description   = 'Converts LaTeX math into MathML.'
-  spec.homepage      = 'https://github.com/plurimath/latexmath'
-  spec.license       = 'BSD-2-Clause'
-
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/plurimath/latexmath'
-  spec.metadata['changelog_uri'] = 'https://github.com/plurimath/latexmath/blob/master/CHANGELOG.md.'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'htmlentities', '~> 4.3'
-  spec.add_dependency 'ox', '~> 2.13'
-  spec.add_development_dependency 'equivalent-xml'
-  spec.add_development_dependency 'execjs'
-  spec.add_development_dependency 'opal'
-end

data/lib/latexmath/aggregator.rb

@@ -1,351 +0,0 @@
-module Latexmath
-  class Aggregator
-    OPERATORS = '+-*/=[]_^{}()'.freeze
-
-    OPENING_BRACES = '{'.freeze
-    CLOSING_BRACES = '}'.freeze
-    OPENING_BRACKET = '['.freeze
-    CLOSING_BRACKET = ']'.freeze
-    OPENING_PARENTHESIS = '('.freeze
-    CLOSING_PARENTHESIS = ')'.freeze
-
-    BACKSLASH = '\\\\'.freeze
-    AMPERSAND = '&'.freeze
-    DASH = '-'.freeze
-
-    SUB_SUP = '_^'.freeze
-    SUBSCRIPT = '_'.freeze
-    SUPERSCRIPT = '^'.freeze
-
-    # Added prefix LATEX_ to avoid ruby reserved words
-    LATEX_LEFT = '\\left'.freeze
-    LATEX_RIGHT = '\\right'.freeze
-    LATEX_OVER = '\\over'.freeze
-    LATEX_HLINE = '\\hline'.freeze
-    LATEX_BEGIN = '\\begin'.freeze
-    LATEX_FRAC = '\\frac'.freeze
-    LATEX_ROOT = '\\root'.freeze
-    LATEX_SQRT = '\\sqrt'.freeze
-
-    def initialize(tokens)
-      @tokens = tokens
-    end
-
-    def aggregate(tokens = @tokens)
-      aggregated = []
-
-      loop do
-        begin
-          token = next_item_or_group(tokens)
-          raise StopIteration if token.nil?
-
-          if token.is_a?(Array)
-            aggregated << token
-          elsif token == OPENING_BRACKET
-            previous = nil
-            previous = aggregated[-1] if aggregated.any?
-            begin
-              g = group(tokens, opening: OPENING_BRACKET, closing: CLOSING_BRACKET)
-              if previous == LATEX_SQRT
-                root = tokens.shift
-                raise StopIteration if root.nil?
-
-                if root == OPENING_BRACES
-                  begin
-                    root = group(tokens)
-                  rescue EmptyGroupError
-                    root = ''
-                  end
-                end
-                aggregated[-1] = LATEX_ROOT
-                aggregated << root
-              end
-              aggregated << g
-            rescue EmptyGroupError
-              next if previous == LATEX_SQRT
-
-              aggregated += [OPENING_BRACKET, CLOSING_BRACKET]
-            end
-          elsif LIMITS.include?(token)
-            raise StopIteration if tokens.shift.nil?
-
-            a = next_item_or_group(tokens)
-            aggregated += [token, a]
-          elsif token == '\\limits'
-            previous = aggregated.pop
-            raise StopIteration if tokens.shift.nil?
-
-            a = next_item_or_group(tokens)
-            raise StopIteration if tokens.shift.nil?
-
-            b = next_item_or_group(tokens)
-            aggregated += [token, previous, a, b]
-          elsif token && SUB_SUP.include?(token)
-            aggregated = process_sub_sup(aggregated, token, tokens)
-          elsif token.start_with?(LATEX_BEGIN) || MATRICES.include?(token)
-            aggregated += environment(token, tokens)
-          elsif token == LATEX_OVER
-            numerator = aggregated
-            aggregated = []
-            aggregated << LATEX_FRAC
-            aggregated << numerator
-            aggregated << aggregate(tokens)
-          else
-            aggregated << token
-          end
-        rescue EmptyGroupError
-          aggregated += [OPENING_BRACES, CLOSING_BRACES]
-          next
-        rescue StopIteration
-          aggregated << token unless token.nil?
-          break
-        end
-      end
-
-      aggregated
-    end
-
-    def environment(token, tokens)
-      env = if token.start_with?(LATEX_BEGIN)
-              token[7..-2]
-            else
-              token[1..token.size]
-      end
-
-      alignment = nil
-      content = []
-      row = []
-      has_rowline = false
-
-      loop do
-        begin
-          token = next_item_or_group(tokens)
-          raise StopIteration if token.nil?
-
-          if token.is_a? Array
-            begin
-              if env == 'array' && token.all? { |x| 'lcr|'.include?(x) }
-                alignment = token
-              else
-                row << process_row(token)
-              end
-            rescue TypeError
-              row << token
-            end
-          elsif token == "\\end{#{env}}"
-            break
-          elsif token == AMPERSAND
-            row << token
-          elsif token == BACKSLASH
-            row = group_columns(row) if row.include?(AMPERSAND)
-            row.insert(0, LATEX_HLINE) if has_rowline
-            content << row
-            row = []
-            has_rowline = false
-          elsif token == LATEX_HLINE
-            has_rowline = true
-          elsif token == OPENING_BRACKET && content.empty?
-            begin
-              alignment = group(tokens, opening: OPENING_BRACKET, closing: CLOSING_BRACKET)
-            rescue EmptyGroupError
-              next
-            end
-          elsif token == DASH
-            next_token = tokens.shift
-            raise StopIteration if next_token.nil?
-
-            row << if next_token == "\\end{#{env}}"
-                    token
-                  else
-                    [token, next_token]
-                  end
-          elsif SUB_SUP.include?(token)
-            row = process_sub_sup(row, token, tokens)
-          elsif token.start_with?(LATEX_BEGIN)
-            row += environment(token, tokens)
-          else
-            row << token
-          end
-        rescue EmptyGroupError
-          row << []
-          next
-        rescue StopIteration
-          break
-        end
-      end
-
-      if row.any?
-        row = group_columns(row) if row.include?(AMPERSAND)
-        row.insert(0, LATEX_HLINE) if has_rowline
-        content << row
-      end
-
-      content = content.pop while content.size == 1 && content.first.is_a?(Array)
-
-      return ["\\#{env}", alignment.join, content] if alignment
-
-      ["\\#{env}", content]
-    end
-
-    def group(tokens, opening: OPENING_BRACES, closing: CLOSING_BRACES, delimiter: nil)
-      g = []
-
-      if delimiter
-        g << delimiter
-        g << tokens.shift
-      end
-
-      loop do
-        begin
-          token = tokens.shift
-          raise StopIteration if token.nil?
-
-          if token == closing && delimiter.nil?
-            break if g.any?
-
-            raise EmptyGroupError
-          elsif token == opening
-            begin
-              g << group(tokens)
-            rescue EmptyGroupError
-              g += [[]]
-            end
-          elsif token == LATEX_LEFT
-            g << group(tokens, delimiter: token)
-          elsif token == LATEX_RIGHT
-            g << token
-            _token = tokens.shift
-            raise StopIteration if _token.nil?
-
-            g << _token
-            break
-          else
-            g << token
-          end
-        rescue StopIteration
-          break
-        end
-      end
-
-      if delimiter
-        right = g.index(LATEX_RIGHT)
-        raise ExtraLeftOrMissingRight if right.nil?
-
-        content = g[2..right - 1]
-        g_ = g
-        g_ = g[0..1] + [aggregate(content)] + g[right..g.size] if content.any?
-
-        return g_
-      end
-
-      aggregate(g)
-    end
-
-    def group_columns(row)
-      grouped = [[]]
-      row.each do |item|
-        if item == AMPERSAND
-          grouped << []
-        else
-          grouped[-1] << item
-        end
-      end
-
-      grouped.map { |item| item.size > 1 ? item : item.pop }
-    end
-
-    def next_item_or_group(tokens)
-      token = tokens.shift
-      raise StopIteration if token.nil?
-
-      return group(tokens) if token == OPENING_BRACES
-
-      return group(tokens, delimiter: token) if token == LATEX_LEFT
-
-      token
-    end
-
-    def find_opening_parenthesis(tokens)
-      closing = 0
-
-      tokens.map.with_index { |x, i| [i, x] }.reverse.each do |index, token|
-        if token == CLOSING_PARENTHESIS
-          closing += 1
-        elsif token == OPENING_PARENTHESIS
-          return index if closing == 0
-
-          closing -= 1
-        end
-      end
-      raise ExtraLeftOrMissingRight
-    end
-
-    def process_row(tokens)
-      row = []
-      content = []
-
-      tokens.each do |token|
-        if token == AMPERSAND
-          next
-        elsif token == BACKSLASH
-          content << row if row.any?
-          row = []
-        else
-          row << token
-        end
-      end
-
-      content << row if row.any?
-
-      content = content.pop while content.size == 1 && content.first.is_a?(Array)
-
-      content
-    end
-
-    def process_sub_sup(aggregated, token, tokens)
-      begin
-        previous = aggregated.pop
-        raise IndexError if previous.nil?
-
-        if previous.is_a?(String) && OPERATORS.include?(previous)
-          if (previous == CLOSING_PARENTHESIS) && aggregated.include?(OPENING_PARENTHESIS)
-            index = find_opening_parenthesis(aggregated)
-            aggregated = aggregated[0, index] + [token] + [aggregated[index..aggregated.size] + [previous]]
-          else
-            aggregated += [previous, token]
-          end
-          return aggregated
-        end
-
-        begin
-          next_token = next_item_or_group(tokens)
-          if aggregated.size >= 2
-            if aggregated[-2] == SUBSCRIPT && token == SUPERSCRIPT
-              aggregated[-2] = SUB_SUP
-              aggregated += [previous, next_token]
-            elsif (aggregated[-2] == SUPERSCRIPT) && (token == SUBSCRIPT)
-              aggregated[-2] = SUB_SUP
-              aggregated += [next_token, previous]
-            else
-              aggregated += [token, previous, next_token]
-            end
-          else
-            aggregated += [token, previous, next_token]
-          end
-        rescue EmptyGroupError
-          aggregated += [token, previous, []]
-        end
-      rescue IndexError
-        next_token = next_item_or_group(tokens)
-        aggregated += [token, '', next_token]
-      end
-
-      aggregated
-    end
-  end
-
-  class EmptyGroupError < StandardError; end
-  class ExtraLeftOrMissingRight < StandardError; end
-  class MissingSuperScriptOrSubscript < StandardError; end
-  class StopIteration < StandardError; end
-end