asciimath 1.0.0.preview.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 79e61b8558a971dd887b6e48246a1ee34be6098e
+  data.tar.gz: c7f13147dbb2460cf4ab5564249a0391fdb57095
+SHA512:
+  metadata.gz: 6c7a2f710248ecf71df6a124aecf8e96e0e626b7448831166212572a24cccf615ef85c2f3749531499e3dc2155122c5b219dba012a6cc264de668532ab869962
+  data.tar.gz: 8350a5355cdf93da68d7c9224c8cc820a2fd01b2edee38cd758f6911c75e577f63d5a216b9e2d114c308bb8bd07af95ea1d717b55fd097afedb7b565de8284a4

data/.gitignore

@@ -0,0 +1,16 @@
+/.idea/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.iml
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in asciimath.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Pepijn Van Eeckhoudt
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Asciimath
+
+An [asciimath](http://asciimath.org) parser and MathML generator written in pure Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'asciimath'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install asciimath
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/asciimath/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/asciimath.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'asciimath/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "asciimath"
+  spec.version       = Asciimath::VERSION
+  spec.authors       = ["Pepijn Van Eeckhoudt"]
+  spec.email         = ["pepijn@vaneeckhoudt.net"]
+  spec.summary       = %q{Asciimath parser and converter}
+  spec.description   = %q{A pure Ruby Asciimath parsing and conversion library.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+end

data/bin/asciimath

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'asciimath/cli'
+::Asciimath::CLI.run(ARGV)

data/lib/asciimath.rb

@@ -0,0 +1,5 @@
+require_relative 'asciimath/version'
+
+require_relative 'asciimath/parser'
+
+require_relative 'asciimath/mathml'

data/lib/asciimath/cli.rb

@@ -0,0 +1,12 @@
+require_relative 'parser'
+require_relative 'mathml'
+
+module Asciimath
+  module CLI
+    def self.run(args)
+      asciimath = args.last
+      mathml = Asciimath.parse(asciimath).to_mathml
+      puts mathml
+    end
+  end
+end

data/lib/asciimath/mathml.rb

@@ -0,0 +1,126 @@
+module Asciimath
+  class MathMLBuilder
+    def initialize(prefix)
+      @prefix = prefix
+      @mathml = ''
+    end
+
+    def to_s
+      @mathml
+    end
+
+    def append_expression(expression, attrs = {})
+      math('', attrs) do
+        append(expression, :single_child => true)
+      end
+    end
+
+    private
+
+    def append(expression, opts = {})
+      case expression
+        when Array
+          if expression.length <= 1 || opts[:single_child]
+            expression.each { |e| append(e) }
+          else
+            mrow do
+              expression.each { |e| append(e) }
+            end
+          end
+        when Hash
+          case expression[:type]
+            when :operator
+              mo(expression[:c])
+            when :identifier
+              mi(expression[:c])
+            when :number
+              mn(expression[:c])
+            when :text
+              mtext(expression[:c])
+            when :paren
+              paren = !opts[:strip_paren]
+              if paren
+                if opts[:single_child]
+                  mo(expression[:lparen]) if expression[:lparen]
+                  append(expression[:e], :single_child => true)
+                  mo(expression[:rparen]) if expression[:rparen]
+                else
+                  mrow do
+                    mo(expression[:lparen]) if expression[:lparen]
+                    append(expression[:e], :single_child => true)
+                    mo(expression[:rparen]) if expression[:rparen]
+                  end
+                end
+              else
+                append(expression[:e])
+              end
+            when :unary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s], :single_child => true, :strip_paren => true)
+              end
+            when :binary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s1], :strip_paren => (operator != :sub && operator != :sup))
+                append(expression[:s2], :strip_paren => true)
+              end
+            when :ternary
+              operator = expression[:operator]
+              tag("m#{operator}") do
+                append(expression[:s1])
+                append(expression[:s2], :strip_paren => true)
+                append(expression[:s3], :strip_paren => true)
+              end
+            when :matrix
+              mrow do
+                mo(expression[:lparen]) if expression[:lparen]
+                mtable do
+                  expression[:rows].each do |row|
+                    mtr do
+                      row.each do |col|
+                        mtd do
+                          append(col)
+                        end
+                      end
+                    end
+                  end
+                end
+                mo(expression[:rparen]) if expression[:rparen]
+              end
+          end
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      tag(meth, *args, &block)
+    end
+
+    def tag(tag, *args)
+      attrs = args.last.is_a?(Hash) ? args.pop : {}
+      text = args.last.is_a?(String) ? args.pop : ''
+
+      @mathml << '<' << @prefix << tag.to_s
+
+      attrs.each_pair do |key, value|
+        @mathml << ' ' << key << '="' << value << '"'
+      end
+
+
+      if block_given? || text
+        @mathml << '>'
+        @mathml << text
+        yield self if block_given?
+        @mathml << '</' << @prefix << tag.to_s << '>'
+      else
+        @mathml << '/>'
+      end
+    end
+  end
+
+  class Expression
+    def to_mathml(prefix = "", attrs = {})
+      MathMLBuilder.new(prefix).append_expression(@parsed_expression, attrs).to_s
+    end
+  end
+end

data/lib/asciimath/parser.rb

@@ -0,0 +1,529 @@
+require 'strscan'
+
+# Parser for ASCIIMath expressions.
+#
+# The syntax for ASCIIMath in EBNF style notation is
+#
+# expr = ( simp ( fraction | sub | super ) )+
+# simp = constant | paren_expr | unary_expr | binary_expr | text
+# fraction = '/' simp
+# super = '^' simp
+# sub =  '_' simp super?
+# paren_expr = lparen expr rparen
+# lparen = '(' | '[' | '{' | '(:' | '{:'
+# rparen = ')' | ']' | '}' | ':)' | ':}'
+# unary_expr = unary_op simp
+# unary_op = 'sqrt' | 'text'
+# binary_expr = binary_op simp simp
+# binary_op = 'frac' | 'root' | 'stackrel'
+# text = '"' [^"]* '"'
+# constant = number | symbol | identifier
+# number = '-'? [0-9]+ ( '.' [0-9]+ )?
+# symbol = /* any string in the symbol table */
+# identifier = [A-z]
+#
+# ASCIIMath is parsed left to right without any form of operator precedence.
+# When parsing the 'constant' the parser will try to find the longest matching string in the symbol
+# table starting at the current position of the parser. If no matching string can be found the
+# character at the current position of the parser is interpreted as an identifier instead.
+module Asciimath
+  # Internal: Splits an ASCIIMath expression into a sequence of tokens.
+  # Each token is represented as a Hash containing the keys :value and :type.
+  # The :value key is used to store the text associated with each token.
+  # The :type key indicates the semantics of the token. The value for :type will be one
+  # of the following symbols:
+  #
+  # - :identifier a symbolic name or a bit of text without any further semantics
+  # - :text a bit of arbitrary text
+  # - :number a number
+  # - :operator a mathematical operator symbol
+  # - :unary a unary operator (e.g., sqrt, text, ...)
+  # - :infix an infix operator (e.g, /, _, ^, ...)
+  # - :binary a binary operator (e.g., frac, root, ...)
+  # - :accent an accent character
+  # - :eof indicates no more tokens are available
+  #
+  # Each token type may also have an :underover modifier. When present and set to true
+  # sub- and superscript expressions associated with the token will be rendered as
+  # under- and overscriptabove and below rather than as sub- or superscript.
+  #
+  # :accent tokens additionally have a :postion value which is set to either :over or :under.
+  # This determines if the accent should be rendered over or under the expression to which
+  # it applies.
+  #
+  class Tokenizer
+    WHITESPACE = /^\s+/
+    NUMBER_START = /[-0-9]/
+    NUMBER = /-?[0-9]+(?:\.[0-9]+)?/
+    TEXT = /"[^"]+"/
+
+    # Public: Initializes an ASCIIMath tokenizer.
+    #
+    # string - The ASCIIMath expression to tokenize
+    # symbols - The symbol table to use while tokenizing
+    def initialize(string, symbols)
+      @string = StringScanner.new(string)
+      @symbols = symbols
+      lookahead = @symbols.keys.map { |k| k.length }.max
+      @symbol_regexp = /([^\s0-9]{1,#{lookahead}})/
+    end
+
+    # Public: Read the next token from the ASCIIMath expression and move the tokenizer
+    # ahead by one token.
+    #
+    # Returns the next token as a Hash
+    def next_token
+      if @push_back
+        t = @push_back
+        @push_back = nil
+        return t
+      end
+
+      @string.scan(WHITESPACE)
+
+      return {:value => nil, :type => :eof} if @string.eos?
+
+      case @string.peek(1)
+        when '"'
+          read_text
+        when NUMBER_START
+          read_number() || read_symbol
+        else
+          read_symbol()
+      end
+    end
+
+    # Public: Pushes the given token back to the tokenizer. A subsequent call to next_token
+    # will return the given token rather than generating a new one. At most one
+    # token can be pushed back.
+    #
+    # token - The token to push back
+    def push_back(token)
+      @push_back = token unless token[:type] == :eof
+    end
+
+    private
+
+    # Private: Reads a text token from the input string
+    #
+    # Returns the text token or nil if a text token could not be matched at
+    # the current position
+    def read_text
+      read_value(TEXT) do |text|
+        {:value => text[1..-2], :type => :text}
+      end
+    end
+
+    # Private: Reads a number token from the input string
+    #
+    # Returns the number token or nil if a number token could not be matched at
+    # the current position
+    def read_number
+      read_value(NUMBER) do |number|
+        {:value => number, :type => :number}
+      end
+    end
+
+    # Private: Reads a symbol token from the input string. This method first creates
+    # a String from the input String starting from the current position with a length
+    # that matches that of the longest key in the symbol table. It then looks up that
+    # substring in the symbol table. If the substring is present in the symbol table, the
+    # associated value is returned and the position is moved ahead by the length of the
+    # substring. Otherwise this method chops one character off the end of the substring
+    # and repeats the symbol lookup. This continues until a single character is left.
+    # If that character can still not be found in the symbol table, then an identifier
+    # token is returned whose value is the remaining single character string.
+    #
+    # Returns the token that was read or nil if a token could not be matched at
+    # the current position
+    def read_symbol
+      position = @string.pos
+      read_value(@symbol_regexp) do |s|
+        until s.length == 1 || @symbols.include?(s)
+          s.chop!
+        end
+        @string.pos = position + s.length
+        @symbols[s] || {:value => s, :type => :identifier}
+      end
+    end
+
+    # Private: Reads a String from the input String that matches the given RegExp
+    #
+    # regexp - a RegExp that will be used to match the token
+    # block  - if a block is provided the matched token will be passed to the block
+    #
+    # Returns the matched String or the value returned by the block if one was given
+    def read_value(regexp)
+      s = @string.scan(regexp)
+      if s
+        yield s
+      else
+        s
+      end
+    end
+  end
+
+  class Parser
+    SYMBOLS = {
+        # Operation symbols
+        '+' => {:value => '+', :type => :operator},
+        '-' => {:value => '−', :type => :operator},
+        '*' => {:value => '⋅', :type => :operator},
+        '**' => {:value => '⋆', :type => :operator},
+        '//' => {:value => '/', :type => :operator},
+        '\\\\' => {:value => '\\', :type => :operator},
+        'xx' => {:value => '×', :type => :operator},
+        '-:' => {:value => '÷', :type => :operator},
+        '@' => {:value => '⚬', :type => :operator},
+        'o+' => {:value => '⊕', :type => :operator},
+        'ox' => {:value => '⊗', :type => :operator},
+        'o.' => {:value => '⊙', :type => :operator},
+        'sum' => {:value => '∑', :type => :operator, :underover => true},
+        'prod' => {:value => '∏', :type => :operator, :underover => true},
+        '^^' => {:value => '∧', :type => :operator},
+        '^^^' => {:value => '⋀', :type => :operator, :underover => true},
+        'vv' => {:value => '∨', :type => :operator},
+        'vvv' => {:value => '⋁', :type => :operator, :underover => true},
+        'nn' => {:value => '∩', :type => :operator},
+        'nnn' => {:value => '⋂', :type => :operator, :underover => true},
+        'uu' => {:value => '∪', :type => :operator},
+        'uuu' => {:value => '⋃', :type => :operator, :underover => true},
+
+        # Relation symbols
+        '=' => {:value => '=', :type => :operator},
+        '!=' => {:value => '≠', :type => :operator},
+        ':=' => {:value => ':=', :type => :operator},
+        '<' => {:value => '&#x003C;', :type => :operator},
+        'lt' => {:value => '&#x003C;', :type => :operator},
+        '>' => {:value => '&#x003E;', :type => :operator},
+        'gt' => {:value => '&#x003E;', :type => :operator},
+        '<=' => {:value => '&#x2264;', :type => :operator},
+        'lt=' => {:value => '&#x2264;', :type => :operator},
+        '>=' => {:value => '&#x2265;', :type => :operator},
+        'geq' => {:value => '&#x2265;', :type => :operator},
+        '-<' => {:value => '&#x227A;', :type => :operator},
+        '-lt' => {:value => '&#x227A;', :type => :operator},
+        '>-' => {:value => '&#x227B;', :type => :operator},
+        '-<=' => {:value => '&#x2AAF;', :type => :operator},
+        '>-=' => {:value => '&#x2AB0;', :type => :operator},
+        'in' => {:value => '&#x2208;', :type => :operator},
+        '!in' => {:value => '&#x2209;', :type => :operator},
+        'sub' => {:value => '&#x2282;', :type => :operator},
+        'sup' => {:value => '&#x2283;', :type => :operator},
+        'sube' => {:value => '&#x2286;', :type => :operator},
+        'supe' => {:value => '&#x2287;', :type => :operator},
+        '-=' => {:value => '&#x2261;', :type => :operator},
+        '~=' => {:value => '&#x2245;', :type => :operator},
+        '~~' => {:value => '&#x2248;', :type => :operator},
+        'prop' => {:value => '&#x221D;', :type => :operator},
+
+        # Logical symbols
+        'and' => {:value => 'and', :type => :text},
+        'or' => {:value => 'or', :type => :text},
+        'not' => {:value => '&#x00AC;', :type => :operator},
+        '=>' => {:value => '&#x21D2;', :type => :operator},
+        'if' => {:value => 'if', :type => :operator},
+        '<=>' => {:value => '&#x21D4;', :type => :operator},
+        'AA' => {:value => '&#x2200;', :type => :operator},
+        'EE' => {:value => '&#x2203;', :type => :operator},
+        '_|_' => {:value => '&#x22A5;', :type => :operator},
+        'TT' => {:value => '&#x22A4;', :type => :operator},
+        '|--' => {:value => '&#x22A2;', :type => :operator},
+        '|==' => {:value => '&#x22A8;', :type => :operator},
+
+        # Grouping brackets
+        '(' => {:value => '(', :type => :lparen},
+        ')' => {:value => ')', :type => :rparen},
+        '[' => {:value => '[', :type => :lparen},
+        ']' => {:value => ']', :type => :rparen},
+        '{' => {:value => '{', :type => :lparen},
+        '}' => {:value => '}', :type => :rparen},
+        '|' => {:value => '|', :type => :lrparen},
+        '||' => {:value => '||', :type => :lrparen},
+        '(:' => {:value => '&#x2329;', :type => :lparen},
+        ':)' => {:value => '&#x232A;', :type => :rparen},
+        '<<' => {:value => '&#x2329;', :type => :lparen},
+        '>>' => {:value => '&#x232A;', :type => :rparen},
+        '{:' => {:value => nil, :type => :lparen},
+        ':}' => {:value => nil, :type => :rparen},
+
+        # Miscellaneous symbols
+        'int' => {:value => '&#x222B;', :type => :operator},
+        'dx' => {:value => 'dx', :type => :identifier},
+        'dy' => {:value => 'dy', :type => :identifier},
+        'dz' => {:value => 'dz', :type => :identifier},
+        'dt' => {:value => 'dt', :type => :identifier},
+        'oint' => {:value => '&#x222E;', :type => :operator},
+        'del' => {:value => '&#x2202;', :type => :operator},
+        'grad' => {:value => '&#x2207;', :type => :operator},
+        '+-' => {:value => '&#x00B1;', :type => :operator},
+        'O/' => {:value => '&#x2205;', :type => :operator},
+        'oo' => {:value => '&#x221E;', :type => :operator},
+        'aleph' => {:value => '&#x2135;', :type => :operator},
+        '...' => {:value => '...', :type => :operator},
+        ':.' => {:value => '&#x2234;', :type => :operator},
+        '/_' => {:value => '&#x2220;', :type => :operator},
+        '\\ ' => {:value => '&#x00A0;', :type => :operator},
+        'quad' => {:value => '\u00A0\u00A0', :type => :operator},
+        'qquad' => {:value => '\u00A0\u00A0\u00A0\u00A0', :type => :operator},
+        'cdots' => {:value => '&#x22EF;', :type => :operator},
+        'vdots' => {:value => '&#x22EE;', :type => :operator},
+        'ddots' => {:value => '&#x22F1;', :type => :operator},
+        'diamond' => {:value => '&#x22C4;', :type => :operator},
+        'square' => {:value => '&#x25A1;', :type => :operator},
+        '|__' => {:value => '&#x230A;', :type => :operator},
+        '__|' => {:value => '&#x230B;', :type => :operator},
+        '|~' => {:value => '&#x2308;', :type => :operator},
+        '~|' => {:value => '&#x2309;', :type => :operator},
+        'CC' => {:value => '&#x2102;', :type => :operator},
+        'NN' => {:value => '&#x2115;', :type => :operator},
+        'QQ' => {:value => '&#x211A;', :type => :operator},
+        'RR' => {:value => '&#x211D;', :type => :operator},
+        'ZZ' => {:value => '&#x2124;', :type => :operator},
+        'f' => {:value => 'f', :type => :identifier},
+        'g' => {:value => 'g', :type => :identifier},
+
+        # Standard functions
+        'lim' => {:value => 'lim', :type => :operator, :underover => true},
+        'Lim' => {:value => 'Lim', :type => :operator, :underover => true},
+        'sin' => {:value => 'sin', :type => :operator},
+        'cos' => {:value => 'cos', :type => :operator},
+        'tan' => {:value => 'tan', :type => :operator},
+        'sinh' => {:value => 'sinh', :type => :operator},
+        'cosh' => {:value => 'cosh', :type => :operator},
+        'tanh' => {:value => 'tanh', :type => :operator},
+        'cot' => {:value => 'cot', :type => :operator},
+        'sec' => {:value => 'sec', :type => :operator},
+        'csc' => {:value => 'csc', :type => :operator},
+        'log' => {:value => 'log', :type => :operator},
+        'ln' => {:value => 'ln', :type => :operator},
+        'det' => {:value => 'det', :type => :operator},
+        'dim' => {:value => 'dim', :type => :operator},
+        'mod' => {:value => 'mod', :type => :operator},
+        'gcd' => {:value => 'gcd', :type => :operator},
+        'lcm' => {:value => 'lcm', :type => :operator},
+        'lub' => {:value => 'lub', :type => :operator},
+        'glb' => {:value => 'glb', :type => :operator},
+        'min' => {:value => 'min', :type => :operator, :underover => true},
+        'max' => {:value => 'max', :type => :operator, :underover => true},
+
+        # Accents
+        'hat' => {:value => '&#x005E;', :type => :accent, :position => :over},
+        'bar' => {:value => '&#x00AF;', :type => :accent, :position => :over},
+        'ul' => {:value => '_', :type => :accent, :position => :under},
+        'vec' => {:value => '&#x2192;', :type => :accent, :position => :over},
+        'dot' => {:value => '.', :type => :accent, :position => :over},
+        'ddot' => {:value => '..', :type => :accent, :position => :over},
+
+        # Arrows
+        'uarr' => {:value => '&#x2191;', :type => :operator},
+        'darr' => {:value => '&#x2193;', :type => :operator},
+        'rarr' => {:value => '&#x2192;', :type => :operator},
+        '->' => {:value => '&#x2192;', :type => :operator},
+        '>->' => {:value => '&#x21A3;', :type => :operator},
+        '->>' => {:value => '&#x21A0;', :type => :operator},
+        '>->>' => {:value => '&#x2916;', :type => :operator},
+        '|->' => {:value => '&#x21A6;', :type => :operator},
+        'larr' => {:value => '&#x2190;', :type => :operator},
+        'harr' => {:value => '&#x2194;', :type => :operator},
+        'rArr' => {:value => '&#x21D2;', :type => :operator},
+        'lArr' => {:value => '&#x21D0;', :type => :operator},
+        'hArr' => {:value => '&#x21D4;', :type => :operator},
+
+        # Other
+        'sqrt' => {:value => :sqrt, :type => :unary},
+        'text' => {:value => :text, :type => :unary},
+        'frac' => {:value => :frac, :type => :binary},
+        'root' => {:value => :root, :type => :binary},
+        'stackrel' => {:value => :over, :type => :binary},
+        '/' => {:value => :frac, :type => :infix},
+        '_' => {:value => :sub, :type => :infix},
+        '^' => {:value => :sup, :type => :infix},
+
+        # Greek letters
+        'alpha' => {:value => '&#x03b1;', :type => :identifier},
+        'Alpha' => {:value => '&#x0391;', :type => :identifier},
+        'beta' => {:value => '&#x03b2;', :type => :identifier},
+        'Beta' => {:value => '&#x0392;', :type => :identifier},
+        'gamma' => {:value => '&#x03b3;', :type => :identifier},
+        'Gamma' => {:value => '&#x0393;', :type => :operator},
+        'delta' => {:value => '&#x03b4;', :type => :identifier},
+        'Delta' => {:value => '&#x0394;', :type => :operator},
+        'epsilon' => {:value => '&#x03b5;', :type => :identifier},
+        'Epsilon' => {:value => '&#x0395;', :type => :identifier},
+        'varepsilon' => {:value => '&#x025b;', :type => :identifier},
+        'zeta' => {:value => '&#x03b6;', :type => :identifier},
+        'Zeta' => {:value => '&#x0396;', :type => :identifier},
+        'eta' => {:value => '&#x03b7;', :type => :identifier},
+        'Eta' => {:value => '&#x0397;', :type => :identifier},
+        'theta' => {:value => '&#x03b8;', :type => :identifier},
+        'Theta' => {:value => '&#x0398;', :type => :operator},
+        'vartheta' => {:value => '&#x03d1;', :type => :identifier},
+        'iota' => {:value => '&#x03b9;', :type => :identifier},
+        'Iota' => {:value => '&#x0399;', :type => :identifier},
+        'kappa' => {:value => '&#x03ba;', :type => :identifier},
+        'Kappa' => {:value => '&#x039a;', :type => :identifier},
+        'lambda' => {:value => '&#x03bb;', :type => :identifier},
+        'Lambda' => {:value => '&#x039b;', :type => :operator},
+        'mu' => {:value => '&#x03bc;', :type => :identifier},
+        'Mu' => {:value => '&#x039c;', :type => :identifier},
+        'nu' => {:value => '&#x03bd;', :type => :identifier},
+        'Nu' => {:value => '&#x039d;', :type => :identifier},
+        'xi' => {:value => '&#x03be;', :type => :identifier},
+        'Xi' => {:value => '&#x039e;', :type => :operator},
+        'omicron' => {:value => '&#x03bf;', :type => :identifier},
+        'Omicron' => {:value => '&#x039f;', :type => :identifier},
+        'pi' => {:value => '&#x03c0;', :type => :identifier},
+        'Pi' => {:value => '&#x03a0;', :type => :operator},
+        'rho' => {:value => '&#x03c1;', :type => :identifier},
+        'Rho' => {:value => '&#x03a1;', :type => :identifier},
+        'sigma' => {:value => '&#x03c3;', :type => :identifier},
+        'Sigma' => {:value => '&#x03a3;', :type => :operator},
+        'tau' => {:value => '&#x03c4;', :type => :identifier},
+        'Tau' => {:value => '&#x03a4;', :type => :identifier},
+        'upsilon' => {:value => '&#x03c5;', :type => :identifier},
+        'Upsilon' => {:value => '&#x03a5;', :type => :identifier},
+        'phi' => {:value => '&#x03c6;', :type => :identifier},
+        'Phi' => {:value => '&#x03a6;', :type => :identifier},
+        'varphi' => {:value => '&#x03d5;', :type => :identifier},
+        'chi' => {:value => '\u03b3c7', :type => :identifier},
+        'Chi' => {:value => '\u0393a7', :type => :identifier},
+        'psi' => {:value => '&#x03c8;', :type => :identifier},
+        'Psi' => {:value => '&#x03a8;', :type => :identifier},
+        'omega' => {:value => '&#x03c9;', :type => :identifier},
+        'Omega' => {:value => '&#x03a9;', :type => :operator},
+    }
+
+    def parse(input)
+      Expression.new(
+          input,
+          parse_expression(Tokenizer.new(input, SYMBOLS), 0)
+      )
+    end
+
+    private
+    def parse_expression(tok, depth)
+      e = []
+
+      while (s1 = parse_simple_expression(tok, depth))
+        t1 = tok.next_token
+
+        if t1[:type] == :infix
+          s2 = parse_simple_expression(tok, depth)
+          t2 = tok.next_token
+          if t1[:value] == :sub && t2[:value] == :sup
+            s3 = parse_simple_expression(tok, depth)
+            operator = s1[:underover] ? :underover : :subsup
+            e << {:type => :ternary, :operator => operator, :s1 => s1, :s2 => s2, :s3 => s3}
+          else
+            operator = s1[:underover] ? (t1[:value] == :sub ? :under : :over) : t1[:value]
+            e << {:type => :binary, :operator => operator, :s1 => s1, :s2 => s2}
+            tok.push_back(t2)
+            if (t2[:type] == :lrparen || t2[:type] == :rparen) && depth > 0
+              break
+            end
+          end
+        elsif t1[:type] == :eof
+          e << s1
+          break
+        else
+          e << s1
+          tok.push_back(t1)
+          if (t1[:type] == :lrparen || t1[:type] == :rparen) && depth > 0
+            break
+          end
+        end
+      end
+
+      e
+    end
+
+    def parse_simple_expression(tok, depth)
+      t1 = tok.next_token
+
+      case t1[:type]
+        when :lparen, :lrparen
+          t2 = tok.next_token
+          case t2[:type]
+            when :rparen, :lrparen
+              {:type => :paren, :e => e, :lparen => t1[:value], :rparen => t2[:value]}
+            else
+              tok.push_back(t2)
+
+              e = parse_expression(tok, depth + 1)
+
+              t2 = tok.next_token
+              case t2[:type]
+                when :rparen, :lrparen
+                  convert_to_matrix({:type => :paren, :e => e, :lparen => t1[:value], :rparen => t2[:value]})
+                else
+                  tok.push_back(t2)
+                  {:type => :paren, :e => e, :lparen => t1[:value]}
+              end
+          end
+        when :accent
+          s = parse_simple_expression(tok, depth)
+          {:type => :binary, :s1 => s, :s2 => {:type => :operator, :c => t1[:value]}, :operator => t1[:position]}
+        when :unary
+          s = parse_simple_expression(tok, depth)
+          {:type => :unary, :s => s, :operator => t1[:value]}
+        when :binary
+          s1 = parse_simple_expression(tok, depth)
+          s2 = parse_simple_expression(tok, depth)
+          {:type => :binary, :s1 => s1, :s2 => s2, :operator => t1[:value]}
+        when :eof
+          nil
+        else
+          {:type => t1[:type], :c => t1[:value], :underover => t1[:underover]}
+      end
+    end
+
+    def convert_to_matrix(expression)
+      return expression unless matrix? expression
+
+      rows = expression[:e].select.with_index { |obj, i| i.even? }.map do |row|
+        row[:e].select.with_index { |obj, i| i.even? }
+      end
+
+      {:type => :matrix, :rows => rows, :lparen => expression[:lparen], :rparen => expression[:rparen]}
+    end
+
+    def matrix?(expression)
+      return false unless expression.is_a?(Hash) && expression[:type] == :paren
+
+      rows, separators = expression[:e].partition.with_index { |obj, i| i.even? }
+
+      rows.length > 1 &&
+          rows.length > separators.length &&
+          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' } &&
+          (rows.all? { |item| item[:type] == :paren && item[:lparen] == '(' && item[:rparen] == ')' } ||
+              rows.all? { |item| item[:type] == :paren && item[:lparen] == '[' && item[:rparen] == ']' }) &&
+          rows.all? { |item| item[:e].length == rows[0][:e].length } &&
+          rows.all? { |item| matrix_cols?(item[:e]) }
+    end
+
+    def matrix_cols?(expression)
+      return false unless expression.is_a?(Array)
+
+      cols, separators = expression.partition.with_index { |obj, i| i.even? }
+
+      cols.all? { |item| item[:type] != :identifier || item[:c] != ',' } &&
+          separators.all? { |item| item[:type] == :identifier && item[:c] == ',' }
+    end
+  end
+
+  class Expression
+    def initialize(asciimath, parsed_expression)
+      @asciimath = asciimath
+      @parsed_expression = parsed_expression
+    end
+
+    def to_s
+      @asciimath
+    end
+  end
+
+  def self.parse(asciimath)
+    Parser.new.parse(asciimath)
+  end
+end

data/lib/asciimath/version.rb

@@ -0,0 +1,3 @@
+module Asciimath
+  VERSION = "1.0.0.preview.1"
+end

data/test/parser_spec.rb

@@ -0,0 +1,67 @@
+require 'rspec'
+require 'asciimath'
+
+TEST_CASES = {
+    'x+b/(2a)<+-sqrt((b^2)/(4a^2)-c/a)' =>
+        '<math><mi>x</mi><mo>+</mo><mfrac><mi>b</mi><mrow><mn>2</mn><mi>a</mi></mrow></mfrac><mo>&#x003C;</mo><mo>&#x00B1;</mo><msqrt><mrow><mfrac><msup><mi>b</mi><mn>2</mn></msup><mrow><mn>4</mn><msup><mi>a</mi><mn>2</mn></msup></mrow></mfrac><mo>&#x2212;</mo><mfrac><mi>c</mi><mi>a</mi></mfrac></mrow></msqrt></math>',
+    'a^2 + b^2 = c^2' =>
+        '<math><msup><mi>a</mi><mn>2</mn></msup><mo>+</mo><msup><mi>b</mi><mn>2</mn></msup><mo>=</mo><msup><mi>c</mi><mn>2</mn></msup></math>',
+    'x = (-b+-sqrt(b^2-4ac))/(2a)' =>
+        '<math><mi>x</mi><mo>=</mo><mfrac><mrow><mo>&#x2212;</mo><mi>b</mi><mo>&#x00B1;</mo><msqrt><mrow><msup><mi>b</mi><mn>2</mn></msup><mn>-4</mn><mi>a</mi><mi>c</mi></mrow></msqrt></mrow><mrow><mn>2</mn><mi>a</mi></mrow></mfrac></math>',
+    'm = (y_2 - y_1)/(x_2 - x_1) = (Deltay)/(Deltax)' =>
+        '<math><mi>m</mi><mo>=</mo><mfrac><mrow><msub><mi>y</mi><mn>2</mn></msub><mo>&#x2212;</mo><msub><mi>y</mi><mn>1</mn></msub></mrow><mrow><msub><mi>x</mi><mn>2</mn></msub><mo>&#x2212;</mo><msub><mi>x</mi><mn>1</mn></msub></mrow></mfrac><mo>=</mo><mfrac><mrow><mo>&#x0394;</mo><mi>y</mi></mrow><mrow><mo>&#x0394;</mo><mi>x</mi></mrow></mfrac></math>',
+    'f\'(x) = lim_(Deltax->0)(f(x+Deltax)-f(x))/(Deltax)' =>
+        '<math><mi>f</mi><mi>\'</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mo>=</mo><munder><mo>lim</mo><mrow><mo>&#x0394;</mo><mi>x</mi><mo>&#x2192;</mo><mn>0</mn></mrow></munder><mfrac><mrow><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>+</mo><mo>&#x0394;</mo><mi>x</mi><mo>)</mo></mrow><mo>&#x2212;</mo><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow><mrow><mo>&#x0394;</mo><mi>x</mi></mrow></mfrac></math>',
+    'd/dx [x^n] = nx^(n - 1)' =>
+        '<math><mfrac><mi>d</mi><mi>dx</mi></mfrac><mrow><mo>[</mo><msup><mi>x</mi><mi>n</mi></msup><mo>]</mo></mrow><mo>=</mo><mi>n</mi><msup><mi>x</mi><mrow><mi>n</mi><mo>&#x2212;</mo><mn>1</mn></mrow></msup></math>',
+    'int_a^b f(x) dx = [F(x)]_a^b = F(b) - F(a)' =>
+        '<math><msubsup><mo>&#x222B;</mo><mi>a</mi><mi>b</mi></msubsup><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mi>dx</mi><mo>=</mo><msubsup><mrow><mo>[</mo><mi>F</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mo>]</mo></mrow><mi>a</mi><mi>b</mi></msubsup><mo>=</mo><mi>F</mi><mrow><mo>(</mo><mi>b</mi><mo>)</mo></mrow><mo>&#x2212;</mo><mi>F</mi><mrow><mo>(</mo><mi>a</mi><mo>)</mo></mrow></math>',
+    'int_a^b f(x) dx = f(c)(b - a)' =>
+        '<math><msubsup><mo>&#x222B;</mo><mi>a</mi><mi>b</mi></msubsup><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mi>dx</mi><mo>=</mo><mi>f</mi><mrow><mo>(</mo><mi>c</mi><mo>)</mo></mrow><mrow><mo>(</mo><mi>b</mi><mo>&#x2212;</mo><mi>a</mi><mo>)</mo></mrow></math>',
+    'ax^2 + bx + c = 0' =>
+        '<math><mi>a</mi><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><mi>b</mi><mi>x</mi><mo>+</mo><mi>c</mi><mo>=</mo><mn>0</mn></math>',
+    '"average value"=1/(b-a) int_a^b f(x) dx' =>
+        '<math><mtext>average value</mtext><mo>=</mo><mfrac><mn>1</mn><mrow><mi>b</mi><mo>&#x2212;</mo><mi>a</mi></mrow></mfrac><msubsup><mo>&#x222B;</mo><mi>a</mi><mi>b</mi></msubsup><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mi>dx</mi></math>',
+    'd/dx[int_a^x f(t) dt] = f(x)' =>
+        '<math><mfrac><mi>d</mi><mi>dx</mi></mfrac><mrow><mo>[</mo><msubsup><mo>&#x222B;</mo><mi>a</mi><mi>x</mi></msubsup><mi>f</mi><mrow><mo>(</mo><mi>t</mi><mo>)</mo></mrow><mi>dt</mi><mo>]</mo></mrow><mo>=</mo><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></math>',
+    'hat(ab) bar(xy) ul(A) vec(v)' =>
+        '<math><mover><mrow><mi>a</mi><mi>b</mi></mrow><mo>&#x005E;</mo></mover><mover><mrow><mi>x</mi><mi>y</mi></mrow><mo>&#x00AF;</mo></mover><munder><mi>A</mi><mo>_</mo></munder><mover><mi>v</mi><mo>&#x2192;</mo></mover></math>',
+    'z_12^34' =>
+        '<math><msubsup><mi>z</mi><mn>12</mn><mn>34</mn></msubsup></math>',
+    'lim_(x->c)(f(x)-f(c))/(x-c)' =>
+        '<math><munder><mo>lim</mo><mrow><mi>x</mi><mo>&#x2192;</mo><mi>c</mi></mrow></munder><mfrac><mrow><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mo>&#x2212;</mo><mi>f</mi><mrow><mo>(</mo><mi>c</mi><mo>)</mo></mrow></mrow><mrow><mi>x</mi><mo>&#x2212;</mo><mi>c</mi></mrow></mfrac></math>',
+    'int_0^(pi/2) g(x) dx' =>
+        '<math><msubsup><mo>&#x222B;</mo><mn>0</mn><mfrac><mi>&#x03c0;</mi><mn>2</mn></mfrac></msubsup><mi>g</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mi>dx</mi></math>',
+    'sum_(n=0)^oo a_n' =>
+        '<math><munderover><mo>&#x2211;</mo><mrow><mi>n</mi><mo>=</mo><mn>0</mn></mrow><mo>&#x221E;</mo></munderover><msub><mi>a</mi><mi>n</mi></msub></math>',
+    '((1,2,3),(4,5,6),(7,8,9))' =>
+        '<math><mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd><mtd><mn>3</mn></mtd></mtr><mtr><mtd><mn>4</mn></mtd><mtd><mn>5</mn></mtd><mtd><mn>6</mn></mtd></mtr><mtr><mtd><mn>7</mn></mtd><mtd><mn>8</mn></mtd><mtd><mn>9</mn></mtd></mtr></mtable><mo>)</mo></mrow></math>',
+    '|(a,b),(c,d)|=ad-bc' =>
+        '<math><mrow><mo>|</mo><mtable><mtr><mtd><mi>a</mi></mtd><mtd><mi>b</mi></mtd></mtr><mtr><mtd><mi>c</mi></mtd><mtd><mi>d</mi></mtd></mtr></mtable><mo>|</mo></mrow><mo>=</mo><mi>a</mi><mi>d</mi><mo>&#x2212;</mo><mi>b</mi><mi>c</mi></math>',
+    '((a_(11), cdots , a_(1n)),(vdots, ddots, vdots),(a_(m1), cdots , a_(mn)))' =>
+        '<math><mrow><mo>(</mo><mtable><mtr><mtd><msub><mi>a</mi><mn>11</mn></msub></mtd><mtd><mo>&#x22EF;</mo></mtd><mtd><msub><mi>a</mi><mrow><mn>1</mn><mi>n</mi></mrow></msub></mtd></mtr><mtr><mtd><mo>&#x22EE;</mo></mtd><mtd><mo>&#x22F1;</mo></mtd><mtd><mo>&#x22EE;</mo></mtd></mtr><mtr><mtd><msub><mi>a</mi><mrow><mi>m</mi><mn>1</mn></mrow></msub></mtd><mtd><mo>&#x22EF;</mo></mtd><mtd><msub><mi>a</mi><mrow><mi>m</mi><mi>n</mi></mrow></msub></mtd></mtr></mtable><mo>)</mo></mrow></math>',
+    'sum_(k=1)^n k = 1+2+ cdots +n=(n(n+1))/2' =>
+        '<math><munderover><mo>&#x2211;</mo><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><mi>k</mi><mo>=</mo><mn>1</mn><mo>+</mo><mn>2</mn><mo>+</mo><mo>&#x22EF;</mo><mo>+</mo><mi>n</mi><mo>=</mo><mfrac><mrow><mi>n</mi><mrow><mo>(</mo><mi>n</mi><mo>+</mo><mn>1</mn><mo>)</mo></mrow></mrow><mn>2</mn></mfrac></math>',
+}
+
+module AsciimathHelper
+  def expect_mathml(asciimath, mathml)
+    expect(Asciimath.parse(asciimath).to_mathml).to eq(mathml)
+  end
+end
+
+RSpec.configure do |c|
+  c.include AsciimathHelper
+end
+
+describe "Asciimath::MathMLBuilder" do
+  TEST_CASES.each_pair do |asciimath, mathml|
+    it "should produce identical output to asciimathml.js for '#{asciimath}'" do
+      expect_mathml(asciimath, mathml)
+    end
+  end
+
+  it 'should not generate mo elements for {: and :}' do
+    expect_mathml '{:(a,b),(c,d):}', '<math><mrow><mtable><mtr><mtd><mi>a</mi></mtd><mtd><mi>b</mi></mtd></mtr><mtr><mtd><mi>c</mi></mtd><mtd><mi>d</mi></mtd></mtr></mtable></mrow></math>'
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: asciimath
+version: !ruby/object:Gem::Version
+  version: 1.0.0.preview.1
+platform: ruby
+authors:
+- Pepijn Van Eeckhoudt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: A pure Ruby Asciimath parsing and conversion library.
+email:
+- pepijn@vaneeckhoudt.net
+executables:
+- asciimath
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- asciimath.gemspec
+- bin/asciimath
+- lib/asciimath.rb
+- lib/asciimath/cli.rb
+- lib/asciimath/mathml.rb
+- lib/asciimath/parser.rb
+- lib/asciimath/version.rb
+- test/parser_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Asciimath parser and converter
+test_files:
+- test/parser_spec.rb