asciimath 1.0.9 → 2.0.0

data/CHANGELOG.adoc

@@ -1,5 +1,17 @@
 = Asciimath Changelog
 
+== 2.0.0
+
+Enhancements::
+
+  * The AsciiMath parser has been significantly improved and should now have reached feature parity with the original Javascript implementation.
+  * Issue #16: add initial LaTeX output support (@GarkGarcia)
+  * Issue #26: avoid generating `<mfenced>` tags in MathML output
+
+Bug fixes::
+
+  * Issue #14: add support for additional symbols and functions that are supported by Asciimath JS
+
 == 1.0.9
 
 Bug fixes::

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    asciimath (2.0.0.next1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    mini_portile2 (2.4.0)
+    nokogiri (1.10.9)
+      mini_portile2 (~> 2.4.0)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  asciimath!
+  bundler (> 0)
+  nokogiri (~> 1.10.9)
+  rake (~> 13.0.0)
+  rspec (~> 3.9.0)
+
+BUNDLED WITH
+   1.17.2

data/README.adoc

@@ -1,7 +1,7 @@
 # AsciiMath
 ifndef::env-site[:status:]
 
-An http://asciimath.org[AsciiMath] parser and MathML generator written in pure Ruby.
+An http://asciimath.org[AsciiMath] parser and MathML/LaTeX generator written in pure Ruby.
 
 ifdef::status[]
 [discrete]
@@ -48,15 +48,16 @@ parsed_expression = AsciiMath.parse(asciimath)
 
 The parsed expression is a set of nested Array and Hash objects.
 
-This expression can then be converted to MathML or HTML (experimental.
+This expression can then be converted to MathML, HTML (experimental) or LaTeX.
 
 [source,ruby]
 ----
 math_ml = parsed_expression.to_mathml
 html = parsed_expression.to_html
+latex = parsed_expression.to_latex
 ----
 
-The MathML or HTML code is returned as a String.
+The MathML, HTML or LaTeX code is returned as a String.
 
 ### Command line
 
@@ -78,6 +79,12 @@ asciimath mathml "an asciimath string"
 asciimath html "an asciimath string"
 ----
 
+.LaTeX Generation
+[source]
+----
+asciimath latex "an asciimath string"
+----
+
 This command will print out the generated code on stdout.
 
 
@@ -95,6 +102,23 @@ Known issues are as follows:
 Rendering the HTML output correctly requires the inclusion of `style/math.css` in the html document.
 There is currently no specific required font for this output, it simply selects a `serif` font family - change the `@font-family` attribute in the `.math-inline` class to select something specific.
 
+## Notes on the LaTeX Output
+
+All LaTeX commands and environments used in the output are coverved by 
+https://ctan.org/pkg/amsmath[`amsmath`] and `amssymb`, with a few exceptions:
+
+ * `\color`
+ * `\cancel`
+ * `\mathscr`
+ * `\twoheadrightarrowtail`
+
+The `\color` command is supported by the 
+https://www.ctan.org/pkg/xcolor[`xcolor`] package, which is included in most 
+LaTeX distributions. The `\cancel` command is supported by the 
+https://www.ctan.org/pkg/cancel[cancel] package, also included in most LaTeX 
+distributions. The other commands are supported by the 
+https://ctan.org/pkg/stix[`stix`] package.
+
 ## Contributing
 
 . Fork it (https://github.com/pepijnve/asciimath/fork)

data/asciimath.gemspec

@@ -1,24 +1,28 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'asciimath/version'
+require 'rake/file_list'
 
 Gem::Specification.new do |spec|
   spec.name          = "asciimath"
   spec.version       = AsciiMath::VERSION
-  spec.authors       = ["Pepijn Van Eeckhoudt"]
-  spec.email         = ["pepijn@vaneeckhoudt.net"]
+  spec.authors       = ["Pepijn Van Eeckhoudt", "Gark Garcia"]
+  spec.email         = ["pepijn@vaneeckhoudt.net", "pablo-ecobar@riseup.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.files         = Rake::FileList['**/*'].exclude(*File.read('.gitignore').split)
+                                             .exclude('dump_symbol_table.rb')
   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", "> 0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "rake", "~> 13.0.0"
+  spec.add_development_dependency "rspec", "~> 3.9.0"
+  spec.add_development_dependency "nokogiri", "~> 1.10.9"
 end

data/lib/asciimath.rb

@@ -1,4 +1,5 @@
-require File.join(File.dirname(__FILE__), 'asciimath/version')
-require File.join(File.dirname(__FILE__), 'asciimath/parser')
-require File.join(File.dirname(__FILE__), 'asciimath/mathml')
-require File.join(File.dirname(__FILE__), 'asciimath/html')
+require_relative 'asciimath/version'
+require_relative 'asciimath/parser'
+require_relative 'asciimath/mathml'
+require_relative 'asciimath/html'
+require_relative 'asciimath/latex'

data/lib/asciimath/ast.rb

@@ -0,0 +1,456 @@
+module AsciiMath
+  module AST
+    def expression(*e)
+      case e.length
+        when 0
+          nil
+        when 1
+          e[0]
+        else
+          Sequence.new(e)
+      end
+    end
+
+    def paren(lparen, e, rparen)
+      Paren.new(lparen, e, rparen)
+    end
+
+    def group(lparen, e, rparen)
+      Group.new(lparen, e, rparen)
+    end
+
+    def subsup(e, sub, sup)
+      SubSup.new(e, sub, sup)
+    end
+
+    def sub(e, sub)
+      SubSup.new(e, sub, nil)
+    end
+
+    def sup(e, sup)
+      SubSup.new(e, nil, sup)
+    end
+
+    def unary(operator, e)
+      UnaryOp.new(operator, e)
+    end
+
+    def binary(operator, e1, e2)
+      BinaryOp.new(operator, e1, e2)
+    end
+
+    def infix(e1, operator, e2)
+      InfixOp.new(operator, e1, e2)
+    end
+
+    def text(value)
+      Text.new(value)
+    end
+
+    def number(value)
+      Number.new(value)
+    end
+
+    def symbol(symbol, text)
+      Symbol.new(symbol, text)
+    end
+
+    def identifier(value)
+      Identifier.new(value)
+    end
+
+    def matrix(lparen, rows, rparen)
+      Matrix.new(lparen, rows, rparen)
+    end
+
+    def color(r, g, b, text)
+      Color.new(r, g, b, text)
+    end
+
+    class Node
+      attr_reader :parent
+
+      def initialize
+        @parent = nil
+      end
+
+      protected
+
+      attr_writer :parent
+    end
+
+    class InnerNode < Node
+      include Enumerable
+
+      def initialize
+        super
+        @children = []
+      end
+
+      def [](*args)
+        @children[*args]
+      end
+
+      def length
+        @children.length
+      end
+
+      def each(&block)
+        @children.each(&block)
+      end
+
+      protected
+
+      def child_nodes
+        @children
+      end
+      
+      def add(node)
+        node.parent.remove(node) if node.parent
+        node.parent = self
+        child_nodes << node
+      end
+
+      def remove(node)
+        node.parent = nil
+        child_nodes.delete(node)
+      end
+    end
+
+    class Sequence < InnerNode
+      def initialize(nodes)
+        super()
+        nodes.each { |node| add(node) }
+      end
+
+      def to_s
+        child_nodes.map { |node| node.to_s }.join(" ")
+      end
+
+      def ==(o)
+        o.class == self.class && o.child_nodes == child_nodes
+      end
+    end
+
+    class Paren < InnerNode
+      attr_reader :lparen
+      attr_reader :rparen
+
+      def initialize(lparen, e, rparen)
+        super()
+        @lparen = lparen
+        @rparen = rparen
+        add(e) if e
+      end
+
+      def expression
+        child_nodes[0]
+      end
+
+      def to_s
+        "#{lparen.nil? ? '' : lparen.text}#{expression}#{rparen.nil? ? '' : rparen.text}"
+      end
+
+      def ==(o)
+        o.class == self.class && o.lparen == lparen && o.expression == expression && o.rparen == rparen
+      end
+    end
+
+    class Group < InnerNode
+      attr_reader :lparen
+      attr_reader :rparen
+
+      def initialize(lparen, e, rparen)
+        super()
+        @lparen = lparen
+        @rparen = rparen
+        add(e) if e
+      end
+
+      def expression
+        child_nodes[0]
+      end
+
+      def to_s
+        "#{lparen.nil? ? '' : lparen.text}#{expression}#{rparen.nil? ? '' : rparen.text}"
+      end
+
+      def ==(o)
+        o.class == self.class && o.lparen == lparen && o.expression == expression && o.rparen == rparen
+      end
+    end
+
+    class SubSup < InnerNode
+      def initialize(e, sub, sup)
+        super()
+        add(e)
+        add(sub || Empty.new)
+        add(sup || Empty.new)
+      end
+
+      def base_expression
+        child_nodes[0]
+      end
+
+      def sub_expression
+        child = child_nodes[1]
+        child.is_a?(Empty) ? nil : child
+      end
+
+      def sup_expression
+        child = child_nodes[2]
+        child.is_a?(Empty) ? nil : child
+      end
+
+      def to_s
+        s = ""
+        s << base_expression.to_s
+        sub = sub_expression
+        if sub
+          s << "_" << sub.to_s
+        end
+        sup = sup_expression
+        if sup
+          s << "^" << sup.to_s
+        end
+        s
+      end
+
+      def ==(o)
+        o.class == self.class && o.base_expression == base_expression && o.sub_expression == sub_expression && o.sup_expression == sup_expression
+      end
+    end
+
+    class UnaryOp < InnerNode
+      def initialize(operator, e)
+        super()
+        add(operator)
+        add(e)
+      end
+
+      def operator
+        child_nodes[0]
+      end
+
+      def operand
+        child_nodes[1]
+      end
+
+      def to_s
+        "#{operator} #{operand}"
+      end
+
+      def ==(o)
+        o.class == self.class && o.operator == operator && o.operand == operand
+      end
+    end
+
+    class BinaryOp < InnerNode
+      def initialize(operator, e1, e2)
+        super()
+        add(operator)
+        add(e1)
+        add(e2)
+      end
+
+
+      def operator
+        child_nodes[0]
+      end
+
+      def operand1
+        child_nodes[1]
+      end
+
+      def operand2
+        child_nodes[2]
+      end
+
+      def to_s
+        "#{operator} #{operand1} #{operand2}"
+      end
+
+      def ==(o)
+        o.class == self.class && o.operator == operator && o.operand1 == operand1 && o.operand2 == operand2
+      end
+    end
+
+    class InfixOp < InnerNode
+      def initialize(operator, e1, e2)
+        super()
+        add(operator)
+        add(e1)
+        add(e2)
+      end
+
+
+      def operator
+        child_nodes[0]
+      end
+
+      def operand1
+        child_nodes[1]
+      end
+
+      def operand2
+        child_nodes[2]
+      end
+
+      def to_s
+        "#{operand1} #{operator} #{operand2}"
+      end
+
+      def ==(o)
+        o.class == self.class && o.operator == operator && o.operand1 == operand1 && o.operand2 == operand2
+      end
+    end
+
+    class ValueNode < Node
+      attr_reader :value
+
+      def initialize(value)
+        super()
+        @value = value
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      def ==(o)
+        o.class == self.class && o.value == value
+      end
+    end
+
+    class Text < ValueNode
+      def initialize(value)
+        super(value.dup.freeze)
+      end
+
+      def to_s
+        '"' + super + '"'
+      end
+    end
+
+    class Number < ValueNode
+      def initialize(value)
+        super(value.dup.freeze)
+      end
+    end
+
+    class Symbol < ValueNode
+      attr_reader :text
+
+      def initialize(value, text)
+        super(value)
+        @text = text.dup.freeze
+      end
+
+      def ==(o)
+        super && o.text == text
+      end
+
+      def to_s
+        text
+      end
+    end
+
+    class Identifier < ValueNode
+      def initialize(value)
+        super(value.dup.freeze)
+      end
+    end
+
+    class Color < ValueNode
+      attr_reader :text
+
+      def initialize(r, g, b, text)
+        super({:r => r, :g => g, :b => b}.freeze)
+        @text = text.dup.freeze
+      end
+
+      def red
+        value[:r]
+      end
+
+      def green
+        value[:g]
+      end
+
+      def blue
+        value[:b]
+      end
+
+      def ==(o)
+        o.class == self.class &&
+            o.red == red &&
+            o.green == green &&
+            o.blue == blue &&
+            o.text == text
+      end
+
+      def to_hex_rgb
+        sprintf('#%02x%02x%02x', red, green, blue)
+      end
+
+      def to_s
+        text
+      end
+    end
+
+    class Matrix < InnerNode
+      attr_reader :lparen
+      attr_reader :rparen
+
+      def initialize(lparen, rows, rparen)
+        super()
+        @lparen = lparen
+        @rparen = rparen
+        rows.map { |row| MatrixRow.new(row) }.each { |row_seq| add(row_seq) }
+      end
+
+      def to_s
+        s = ""
+        s << (lparen.nil? ? '{:' : lparen.text)
+        s << child_nodes.map { |node| node.to_s }.join(",")
+        s << (rparen.nil? ? ':}' : rparen.text)
+      end
+
+      def ==(o)
+        o.class == self.class &&
+            o.lparen == lparen &&
+            o.child_nodes == child_nodes &&
+            o.rparen == rparen
+      end
+    end
+
+    class MatrixRow < InnerNode
+      def initialize(nodes)
+        super()
+        nodes.each { |node| add(node || Empty.new) }
+      end
+
+      def to_s
+        "(" + child_nodes.map { |node| node.to_s }.join(",") + ")"
+      end
+
+      def ==(o)
+        o.class == self.class && o.child_nodes == child_nodes
+      end
+    end
+
+    class Empty < Node
+      def initialize()
+        super
+      end
+
+      def to_s
+        ''
+      end
+
+      def ==(o)
+        o.class == self.class
+      end
+    end
+  end
+end