asciimath 1.0.9 → 2.0.0

data/lib/asciimath/cli.rb

@@ -1,6 +1,7 @@
 require_relative 'parser'
 require_relative 'mathml'
 require_relative 'html'
+require_relative 'latex'
 
 module AsciiMath
   module CLI
@@ -11,8 +12,10 @@ module AsciiMath
         output = AsciiMath.parse(asciimath).to_mathml
       elsif args.first == "html"
         output = AsciiMath.parse(asciimath).to_html
+      elsif args.first == "latex"
+        output = AsciiMath.parse(asciimath).to_latex
       end
       puts output
     end
   end
-end
+end

data/lib/asciimath/color_table.rb

@@ -0,0 +1,21 @@
+module AsciiMath
+  class ColorTableBuilder
+    def initialize()
+      @table = {}
+    end
+
+    def add(*names, r, g, b)
+      entry = {
+          :r => r,
+          :g => g,
+          :b => b
+      }.freeze
+
+      names.each { |name| @table[name.freeze] = entry }
+    end
+
+    def build
+      @table.dup.freeze
+    end
+  end
+end

data/lib/asciimath/html.rb

@@ -1,7 +1,12 @@
+require_relative 'markup'
+
 module AsciiMath
-  class HTMLBuilder
-    def initialize(prefix)
-      @prefix = prefix
+  class HTMLBuilder < ::AsciiMath::MarkupBuilder
+
+    def initialize(opts = {})
+      super(opts[:symbol_table] || DEFAULT_DISPLAY_SYMBOL_TABLE)
+      @prefix = opts[:prefifx] || ''
+      @inline = opts[:inline]
       @html = ''
     end
 
@@ -9,14 +14,14 @@ module AsciiMath
       @html
     end
 
-    def append_expression(expression, inline, attrs = {})
-      if inline
+    def append_expression(expression, attrs = {})
+      if @inline
         inline('', attrs) do
-          append(expression, :single_child => true)
+          append(expression, :row => :omit)
         end
       else
         block('', attrs) do
-          append(expression, :single_child => true)
+          append(expression, :row => :omit)
         end
       end
     end
@@ -25,131 +30,141 @@ module AsciiMath
 
     ZWJ = "\u200D"
 
-    def append(expression, opts = {})
-      case expression
-        when Array
-          row do
-            expression.each { |e| append(e) }
-          end
-        when Hash
-          case expression[:type]
-            when :operator
-              operator(expression[:c])
-            when :identifier
-              identifier(expression[:c])
-            when :number
-              number(expression[:c])
-            when :text
-              text(expression[:c])
-            when :paren
-              paren = !opts[:strip_paren]
-              if paren
-                if opts[:single_child]
-                  brace(expression[:lparen]) if expression[:lparen]
-                  append(expression[:e], :single_child => true)
-                  brace(expression[:rparen]) if expression[:rparen]
-                else
-                  row do
-                    brace(expression[:lparen]) if expression[:lparen]
-                    append(expression[:e], :single_child => true)
-                    brace(expression[:rparen]) if expression[:rparen]
-                  end
-                end
-              else
-                append(expression[:e])
-              end
-            when :font
-              #TODO - currently ignored
-            when :unary
-              operator = expression[:operator]
-              tag(operator) do
-                append(expression[:s], :single_child => true, :strip_paren => true)
-              end
-            when :binary
-              operator = expression[:operator]
-              if operator == :frac
-                append_fraction(expression[:s1],expression[:s2])
-              elsif operator == :sub
-                append_subsup(expression[:s1],expression[:s2],nil)
-              elsif operator == :sup
-                append_subsup(expression[:s1],nil,expression[:s2])
-              elsif operator == :under
-                append_underover(expression[:s1],expression[:s2],nil)
-              elsif operator == :over
-                append_underover(expression[:s1],nil,expression[:s2])
-              else
-                tag(operator) do
-                  append(expression[:s1], :strip_paren => true)
-                  append(expression[:s2], :strip_paren => true)
-                end
-              end
-            when :ternary
-              operator = expression[:operator]
-              if operator == :subsup
-                append_subsup(expression[:s1],expression[:s2],expression[:s3])
-              elsif operator == :underover
-                # TODO: Handle over/under braces in some way? SVG maybe?
-                append_underover(expression[:s1],expression[:s2],expression[:s3])
-              end
-            when :matrix
+    def append_row(expressions)
+      row do
+        expressions.each { |e| append(e) }
+      end
+    end
+
+    def append_operator(operator)
+      operator(operator)
+    end
+
+    def append_identifier(identifier)
+      identifier(identifier)
+    end
+
+    def append_text(text)
+      text(text)
+    end
+
+    def append_number(number)
+      number(number)
+    end
+
+    def append_sqrt(expression)
+      tag("sqrt") do
+        append(child, :row => :omit)
+      end
+    end
+
+    def append_cancel(expression)
+      #TODO - currently ignored
+      append(expression)
+    end
+
+    def append_root(base, index)
+      tag("sqrt") do
+        append(base)
+        append(index)
+      end
+    end
+
+    def append_font(style, e)
+      #TODO - currently ignored
+      append(e)
+    end
+
+    def append_color(color, expression)
+      #TODO - currently ignored
+      append(expression)
+    end
+
+    def append_matrix(lparen, rows, rparen)
+      row do
+        # Figures out a font size for the braces, based on the height of the matrix.
+        # NOTE: This does not currently consider the size of each element within the matrix.
+        brace_height = "font-size: " + rows.length.to_s + "00%;"
+
+        if lparen
+          brace(lparen, {:style => brace_height})
+        else
+          blank(ZWJ)
+        end
+        matrix_width = "grid-template-columns:repeat(" + rows[0].length.to_s + ",1fr);"
+        matrix_height = "grid-template-rows:repeat(" + rows.length.to_s + ",1fr);"
+
+        matrix({:style => (matrix_width + matrix_height)}) do
+          rows.each do |row|
+            row.each do |col|
               row do
-                # Figures out a font size for the braces, based on the height of the matrix.
-                # NOTE: This does not currently consider the size of each element within the matrix.
-                brace_height = "font-size: " + expression[:rows].length.to_s + "00%;"
-                
-                if expression[:lparen]
-                  brace(expression[:lparen], {:style => brace_height})
-                else
-                  blank(ZWJ)
-                end
-                matrix_width  = "grid-template-columns:repeat(" + expression[:rows][0].length.to_s + ",1fr);"
-                matrix_height = "grid-template-rows:repeat(" + expression[:rows].length.to_s + ",1fr);"
-                
-                matrix({:style => (matrix_width + matrix_height)}) do
-                  expression[:rows].each do |row|
-                    row.each do |col|
-                      row do
-                        append(col)
-                      end
-                    end
-                  end
-                end
-                if expression[:rparen]
-                  brace(expression[:rparen], {:style => brace_height})
-                else
-                  blank(ZWJ)
-                end
+                append(col)
               end
+            end
           end
+        end
+        if rparen
+          brace(rparen, {:style => brace_height})
+        else
+          blank(ZWJ)
+        end
       end
     end
-    
+
+    def append_operator_unary(operator, expression)
+      tag(operator) do
+        append(expression, :row => :omit)
+      end
+    end
+
+    def append_identifier_unary(identifier, expression)
+      row do
+        identifier(identifier)
+        append(expression, :row => :omit)
+      end
+    end
+
+    def append_paren(lparen, e, rparen, opts = {})
+      if opts[:row] == :omit
+        brace(lparen) if lparen
+        append(e, :row => :omit)
+        brace(rparen) if rparen
+      else
+        row do
+          brace(lparen) if lparen
+          append(e, :row => :omit)
+          brace(rparen) if rparen
+        end
+      end
+    end
+
     def append_subsup(base, sub, sup)
       append(base)
       subsup do
         if sup
           smaller do
-            append(sup, :strip_paren => true)
+            append(sup)
           end
         else
           smaller(ZWJ)
         end
         if sub
           smaller do
-            append(sub, :strip_paren => true)
+            append(sub)
           end
         else
           smaller(ZWJ)
         end
       end
     end
-    
+
     def append_underover(base, under, over)
+      # TODO: Handle over/under braces in some way? SVG maybe?
       blank(ZWJ)
       underover do
         smaller do
           if over
-            append(over, :strip_paren => true)
+            append(over)
           else
             blank(ZWJ)
           end
@@ -157,14 +172,14 @@ module AsciiMath
         append(base)
         smaller do
           if under
-            append(under, :strip_paren => true)
+            append(under)
           else
             blank(ZWJ)
           end
         end
       end
     end
-        
+
     def append_fraction(numerator, denominator)
       blank(ZWJ)
       fraction do
@@ -172,7 +187,7 @@ module AsciiMath
           fraction_cell do
             smaller do
               row do
-                append(numerator, :strip_paren => true)
+                append(numerator)
               end
             end
           end
@@ -181,7 +196,7 @@ module AsciiMath
           fraction_cell do
             smaller do
               row do
-                append(denominator, :strip_paren => true)
+                append(denominator)
               end
             end
           end
@@ -192,7 +207,7 @@ module AsciiMath
     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 : ''
@@ -228,7 +243,7 @@ module AsciiMath
 
   class Expression
     def to_html(prefix = "", inline = true, attrs = {})
-      HTMLBuilder.new(prefix).append_expression(@parsed_expression, inline, attrs).to_s
+      HTMLBuilder.new(:prefix => prefix, :inline => inline).append_expression(ast, attrs).to_s
     end
   end
 end

data/lib/asciimath/latex.rb

@@ -0,0 +1,386 @@
+require_relative 'ast'
+
+module AsciiMath
+  class LatexBuilder
+    def initialize
+      @latex = ''
+    end
+
+    def to_s
+      @latex
+    end
+
+    def append_expression(expression)
+      append(expression)
+      self
+    end
+
+    private
+
+    SPECIAL_CHARACTERS = [?&, ?%, ?$, ?#, ?_, ?{, ?}, ?~, ?^, ?[, ?]].map(&:ord)
+
+    SYMBOLS = {
+      :plus => ?+,
+      :minus => ?-,
+      :ast => ?*,
+      :slash => ?/,
+      :eq => ?=,
+      :ne => "\\neq",
+      :assign => ":=",
+      :lt => ?<,
+      :gt => ?>,
+      :sub => "\\text{–}",
+      :sup => "\\text{^}",
+      :implies => "\\Rightarrow",
+      :iff => "\\Leftrightarrow",
+      :if => "\\operatorname{if}",
+      :and => "\\operatorname{and}",
+      :or => "\\operatorname{or}",
+      :lparen => ?(,
+      :rparen => ?),
+      :lbracket => ?[,
+      :rbracket => ?],
+      :lbrace => "\\{",
+      :rbrace => "\\}",
+      :lvert => "\\lVert",
+      :rvert => "\\rVert",
+      :vbar => ?|,
+      nil => ?.,
+      :integral => "\\int",
+      :dx => "dx",
+      :dy => "dy",
+      :dz => "dz",
+      :dt => "dt",
+      :contourintegral => "\\oint",
+      :Lim => "\\operatorname{Lim}",
+      :Sin => "\\operatorname{Sin}",
+      :Cos => "\\operatorname{Cos}",
+      :Tan => "\\operatorname{Tan}",
+      :Sinh => "\\operatorname{Sinh}",
+      :Cosh => "\\operatorname{Cosh}",
+      :Tanh => "\\operatorname{Tanh}",
+      :Cot => "\\operatorname{Cot}",
+      :Sec => "\\operatorname{Sec}",
+      :Csc => "\\operatorname{Csc}",
+      :sech => "\\operatorname{sech}",
+      :csch => "\\operatorname{csch}",
+      :Abs => "\\operatorname{Abs}",
+      :Log => "\\operatorname{Log}",
+      :Ln => "\\operatorname{Ln}",
+      :lcm => "\\operatorname{lcm}",
+      :lub => "\\operatorname{lub}",
+      :glb => "\\operatorname{glb}",
+      :partial => "\\del",
+      :prime => ?',
+      :tilde => "\\~",
+      :nbsp => "\\;",
+      :lceiling => "\\lceil",
+      :rceiling => "\\rceil",
+      :dstruck_captial_c => "\\mathbb{C}",
+      :dstruck_captial_n => "\\mathbb{N}",
+      :dstruck_captial_q => "\\mathbb{Q}",
+      :dstruck_captial_r => "\\mathbb{R}",
+      :dstruck_captial_z => "\\mathbb{Z}",
+      :f => "f",
+      :g => "g",
+      :to => "\\rightarrow",
+      :bold => "\\mathbf",
+      :double_struck => "\\mathbb",
+      :italic => "\\mathit",
+      :bold_italic => "\\mathbf",
+      :script => "\\mathscr",
+      :bold_script => "\\mathscr",
+      :monospace => "\\mathtt",
+      :fraktur => "\\mathfrak",
+      :bold_fraktur => "\\mathfrak",
+      :sans_serif => "\\mathsf",
+      :bold_sans_serif => "\\mathsf",
+      :sans_serif_italic => "\\mathsf",
+      :sans_serif_bold_italic => "\\mathsf",
+    }
+
+    COLOURS = {
+      [0xFF, 0xFF, 0xFF] => "white",
+      [0xFF, 0x00, 0x00] => "red",
+      [0x00, 0xFF, 0x00] => "green",
+      [0x00, 0x00, 0xFF] => "blue",
+      [0xBF, 0x80, 0x40] => "brown",
+      [0x00, 0xAD, 0xEF] => "cyan",
+      [0x40, 0x40, 0x40] => "darkgray",
+      [0x80, 0x80, 0x80] => "gray",
+      [0xBF, 0xBF, 0xBF] => "lightgray",
+      [0xA4, 0xDB, 0x00] => "lime",
+      [0xE9, 0x00, 0x8A] => "magenta",
+      [0x8E, 0x86, 0x00] => "olive",
+      [0xFF, 0x80, 0x00] => "orange",
+      [0xFF, 0xBF, 0xBF] => "pink",
+      [0xBF, 0x00, 0x40] => "purple",
+      [0x00, 0x80, 0x80] => "teal",
+      [0x80, 0x00, 0x80] => "violet",
+      [0xFF, 0xF2, 0x00] => "yellow",
+    }
+
+    def append(expression, separator = " ")
+      case expression
+        when Array
+          expression.each { |e| append(e, separator) }
+        when String
+          @latex << expression
+        when Symbol
+          @latex << expression.to_s
+        when AsciiMath::AST::Sequence, AsciiMath::AST::MatrixRow 
+          c = expression.length
+
+          expression.each do |e|
+            c -= 1
+            append(e)
+            @latex << separator if c > 0
+          end
+
+        when AsciiMath::AST::Symbol
+          @latex << symbol(expression.value)
+
+        when AsciiMath::AST::Identifier
+          append_escaped(expression.value)
+
+        when AsciiMath::AST::Text
+          text do
+            append_escaped(expression.value)
+          end
+
+        when AsciiMath::AST::Number
+          @latex << expression.value
+
+        when AsciiMath::AST::Paren
+          parens(expression.lparen, expression.rparen, expression.expression)
+
+        when AsciiMath::AST::Group
+          append(expression.expression)
+
+        when AsciiMath::AST::SubSup
+          sub = expression.sub_expression
+          sup = expression.sup_expression
+          e = expression.base_expression
+
+          curly(e)
+
+          if sub
+            @latex << "_"
+            curly(sub)
+          end       
+
+          if sup
+            @latex << "^"
+            curly(sup)
+          end
+
+        when AsciiMath::AST::UnaryOp
+          op = expression.operator.value
+
+          case op
+          when :norm
+            parens(:lvert, :rvert, expression.operand)
+          when :floor
+            parens(:lfloor, :rfloor, expression.operand)
+          when :ceil
+            parens(:lceiling, :rceiling, expression.operand)
+          when :overarc
+            overset do
+              @latex << "\\frown"
+            end
+            
+            curly do
+              append(expression.operand)
+            end
+          else
+            macro(op) do
+              append(expression.operand)
+            end
+          end
+
+        when AsciiMath::AST::BinaryOp, AsciiMath::AST::InfixOp
+          op = expression.operator.value
+
+          case op
+          when :root
+            macro("sqrt", expression.operand1) do
+              append(expression.operand2)
+            end
+        
+          when :color
+            curly do
+              color_value = expression.operand1
+              red = color_value.red
+              green = color_value.green
+              blue = color_value.blue
+
+              if COLOURS.has_key? [red, green, blue]
+                  color do
+                    @latex << COLOURS[[red, green, blue]]
+                  end
+              else
+                color('RGB') do
+                  @latex << red.to_s << ',' << green.to_s << ',' << blue.to_s
+                end
+              end
+
+              @latex << " "
+              append(expression.operand2)
+            end
+
+          else
+            @latex << symbol(op)
+
+            curly do
+              append(expression.operand1)
+            end
+
+            curly do
+              append(expression.operand2)
+            end
+          end
+        
+        when AsciiMath::AST::Matrix
+          len = expression.length - 1
+          
+          parens(expression.lparen, expression.rparen) do
+            c = expression.length
+            @latex << "\\begin{matrix} "
+
+            expression.each do |row|
+              c -= 1
+              append(row, " & ")
+              @latex << " \\\\ " if c > 0
+            end
+
+            @latex << " \\end{matrix}"
+          end
+      end
+    end
+
+    def macro(macro, *args)
+      @latex << symbol(macro)
+
+      if args.length != 0
+        @latex << "["
+        append(args, "][")
+        @latex << "]"
+      end
+
+      if block_given?
+        curly do
+          yield self
+        end
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      macro(meth, *args, &block)
+    end
+
+    def parens(lparen, rparen, content = nil, &block)
+      l = lparen.is_a?(AsciiMath::AST::Symbol) ? lparen.value : lparen
+      r = rparen.is_a?(AsciiMath::AST::Symbol) ? rparen.value : rparen
+
+      if block_given?
+        if l || r
+          @latex << "\\left " << symbol(l) << " "
+          yield self
+          @latex << " \\right " << symbol(r)
+        else
+          yield self
+        end
+      else
+        needs_left_right = !is_small(content)
+
+        @latex << "\\left " if needs_left_right
+        @latex << symbol(l) << " " if l or needs_left_right
+
+        append(content)
+
+        @latex << " \\right" if needs_left_right
+        @latex << " " << symbol(r) if r or needs_left_right
+      end
+    end
+
+    def curly(expression = nil, &block)
+      if block_given?
+        @latex << ?{
+        yield self
+        @latex << ?}
+      else
+        case expression
+        when AsciiMath::AST::Symbol, AsciiMath::AST::Text
+          append(expression)
+          return
+        when AsciiMath::AST::Identifier, AsciiMath::AST::Number
+          if expression.value.length <= 1
+            append(expression)
+            return
+          end
+        end
+
+        @latex << ?{
+        append(expression)
+        @latex << ?}
+      end
+    end
+
+    def append_escaped(text)
+      text.each_codepoint do |cp|
+        @latex << "\\" if SPECIAL_CHARACTERS.include? cp
+        @latex << cp
+      end
+    end
+
+    def symbol(s)
+      SYMBOLS[s] || "\\#{s.to_s}"
+    end
+
+    def is_small(e)
+      case e
+        when AsciiMath::AST::SubSup
+          is_very_small(e.sub_expression) and is_very_small(e.sup_expression) and is_very_small(e.base_expression)
+        when AsciiMath::AST::Sequence
+          e.all? { |s| is_small(s) }
+        else
+          is_very_small(e)
+      end
+    end
+
+    def is_very_small(e)
+      case e
+      when AsciiMath::AST::Identifier, AsciiMath::AST::Number
+        e.value.length <= 1
+      when AsciiMath::AST::Symbol
+        case e.value
+        when :plus, :minus, :cdot, :dx, :dy, :dz, :dt, :f, :g, :mod
+          true
+        else
+          false
+        end
+      when AsciiMath::AST::UnaryOp
+        case e.operator
+        when :hat, :overline, :underline, :vec, :dot, :ddot, :color
+          is_very_small(e.operand)
+        else
+          false
+        end
+      when AsciiMath::AST::Group
+        is_very_small(e.expression)
+      when AsciiMath::AST::Sequence
+        e.all? { |s| is_very_small(e) }
+      when nil
+        true
+      else
+        false
+      end
+    end
+  end
+
+  class Expression
+    def to_latex
+      LatexBuilder.new().append_expression(ast).to_s
+    end
+  end
+end