ritex 0.3 → 1.0

data/README

@@ -1,5 +1,5 @@
 Author::    William Morgan (mailto: wmorgan-ritex@masanjin.net)
-Copyright:: Copyright 2005--2009 William Morgan
+Copyright:: Copyright 2005--2010 William Morgan
 License::   GNU GPL version 2
 
 = Introduction

data/ReleaseNotes

@@ -1,3 +1,12 @@
+version 1.0, 04/13/2010
+=======================
+- API change: Parser#parse now takes an options hash instead of
+  the two boolean arguments.
+- Add a :raw format which outputs LaTeX math. You can use this to
+  take advantage of Ritex's macro resolution.
+- Remove the requirement that only one Parser exist. This has the
+  advantage of also making Ritex thread-save.
+
 version 0.3, 06/17/2009
 =======================
 Various Ruby 1.9 updates. No API changes.

data/lib/ritex.rb

@@ -1,6 +1,6 @@
 ## lib/ritex.rb -- contains Ritex::Parser
 ## Author::    William Morgan (mailto: wmorgan-ritex@masanjin.net)
-## Copyright:: Copyright 2005-2009 William Morgan
+## Copyright:: Copyright 2005-2010 William Morgan
 ## License::   GNU GPL version 2
 ##
 ## :title:Ritex: a Ruby WebTeX to MathML converter
@@ -17,17 +17,6 @@ require 'racc/parser' # just for Racc::ParserError
 ## Ritex::Parser.
 module Ritex
 
-## This is not ideal by any means. Until we can call a Proc with an
-## arbitrary binding (Ruby 1.9?), we will relay all #markup and
-## #lookup calls within the module to a registered parser, so that the
-## "functions" in lib/functions.rb can be written more easily. Any
-## better ideas?
-##
-## In the mean time, I'd recommend not having more than one parser at
-## a time going.
-attr_accessor :global_parser
-module_function :global_parser, :global_parser=
-
 ## Thrown by Parser upon errors. See Parser#merror=.
 class Error < StandardError; end
 
@@ -38,7 +27,7 @@ class Error < StandardError; end
 ## Create the parser with #new. Parse strings with #parse. That's all
 ## there is to it.
 class Parser
-  FORMATS = [:mathml]
+  FORMATS = [:mathml, :raw]
 
   ## If true, Ritex will output a <merror>...</merror> message in the
   ## MathML if an unknown entity is encountered. If false (the default),
@@ -50,26 +39,28 @@ class Parser
   def initialize format = :mathml
     self.format = format
     @macros = {}
-    Ritex.global_parser = self # lame
     @merror = false
   end
 
-  ## Parse a string. Returns the MathML output in string form. Note
-  ## that macro definitios are cumulative and persistent across calls
-  ## to #parse. If you don't want this behavior, you must explicitly
-  ## call #flush_macros after every #parse call.
+  ## Parse a string. Returns the MathML output in string form. Note that macro
+  ## definitions are cumulative and persistent across calls to #parse. If you
+  ## don't want this behavior, you must explicitly call #flush_macros after
+  ## every #parse call.
+  ##
+  ## _opts_ is a hash of options:
   ##
-  ## _wrap_ denotes whether you want the output wrapped in the
-  ## top-level XML math tag. Unless you're generating these tags
-  ## yourself, you want this.
+  ## _nowrap_, if true,  will omit wrapping the output in a top-level XML math
+  ## tag. Only useful if you're generating these tags yourself.
   ##
-  ## _inline_ denotes whether you want inline markup versus block or
-  ## "display" markup. For mathml output this only has an effect if
-  ## _wrap_ is true.
-  def parse s, wrap = true, inline = true
-    @lex = Lexer.new(self, s)
+  ## _display_, if true, emits display markup, as opposed to inline markup.
+  ## For mathml output this only has an effect if _nowrap_ is true.
+  def parse s, opts={}
+    nowrap = opts[:nowrap]
+    display = opts[:display]
+    @lex = Lexer.new self, s
     r = yyparse @lex, :lex
-    r = markup r, (inline ? :math : :displaymath) if wrap
+    r = markup r, (display ? :displaymath : :math) unless nowrap
+    r = raw_blob_to_string(r) if @format == :raw
     r
   end
 
@@ -84,19 +75,36 @@ class Parser
 
   def markup what, tag, opts=[] #:nodoc:
     case @format
-    when :mathml
-      tag, opts = case tag
-        when String
-          [tag, opts]
-        when Symbol
-          a, b = MathML::MARKUP[tag]
-          [a, [b, opts].flatten.compact.join(" ")]
-        end
-      unless opts.empty?
-        "<#{tag} #{opts}>#{what}</#{tag}>"
-      else
-        "<#{tag}>#{what}</#{tag}>"
+    when :mathml; handle_mathml_markup what, tag, opts
+    when :raw; handle_raw_markup what, tag, opts
+    end
+  end
+
+  def handle_mathml_markup what, tag, opts
+    tag, opts = case tag
+      when String
+        [tag, opts]
+      when Symbol
+        a, b = MathML::MARKUP[tag]
+        [a, [b, opts].flatten.compact.join(" ")]
       end
+    unless opts.empty?
+      "<#{tag} #{opts}>#{what}</#{tag}>"
+    else
+      "<#{tag}>#{what}</#{tag}>"
+    end
+  end
+
+  ## this is a great example of how much a horrible hack raw mode is
+  def handle_raw_markup what, tag, opts #:nodoc:
+    case tag
+    when :var; what
+    when :subsup; "#{what[0]}_#{what[1]}^#{what[2]}"
+    when :sub; "#{what[0]}_#{what[1]}"
+    when :sup; "#{what[0]}^#{what[1]}"
+    when :unaryminus; "-#{what[0]}"
+    when :group; "{#{raw_blob_to_string what}}"
+    else; what
     end
   end
 
@@ -105,34 +113,34 @@ class Parser
     when :mathml
       return error("unknown entity #{sym.inspect}") unless MathML::ENTITIES.member? sym
       MathML::ENTITIES[sym]
+    when :raw
+      "\\" + sym
     end
   end
 
   def token o #:nodoc:
     case @format
-    when :mathml
-      MathML::TOKENS[o] || o
+    when :mathml; MathML::TOKENS[o] || o
+    when :raw; o
     end
   end
 
   def op o, opts=[]
     case @format
-    when :mathml
-      markup(token(o), "mo", opts)
+    when :mathml; markup(token(o), "mo", opts)
+    when :raw; o
     end
   end
 
   def funcs #:nodoc:
     case @format
-    when :mathml
-      MathML::FUNCTIONS
+    when :mathml, :raw; MathML::FUNCTIONS
     end
   end
 
   def envs #:nodoc:
     case @format
-    when :mathml
-      MathML::ENVS
+    when :mathml, :raw; MathML::ENVS
     end
   end
 
@@ -142,12 +150,12 @@ class Parser
 
   def op_symbols #:nodoc:
     case @format
-    when :mathml
-      MathML::OPERATORS.merge(MathML::UNARY_OPERATORS).merge(MathML::MATH_FUNCTIONS)
+    when :mathml, :raw; MathML::OPERATORS.merge(MathML::UNARY_OPERATORS).merge(MathML::MATH_FUNCTIONS)
     end
   end
 
 private
+
   def error e
     if @merror
       "<merror>e</merror>"
@@ -158,35 +166,80 @@ private
 
   def safe s
     case @format
-    when :mathml
-      s.gsub("&", "&amp;").gsub(">", "&gt;").gsub("<", "&lt;")
+    when :mathml; s.gsub("&", "&amp;").gsub(">", "&gt;").gsub("<", "&lt;")
+    when :raw; s
     end
   end
 
   def join *a
     case @format
-    when :mathml
-      a.join ""
+    when :mathml; a.join
+    when :raw # horrible hack for raw "blobs"
+      if a.size == 1
+        a[0]
+      elsif a.size == 2 && a.first == ""
+        a[1]
+      else
+        a.flatten
+      end
     end    
   end
 
   def special name, *a
     if @macros.member? name
-      #      puts "evaluating macro (arity #{@macros[name].arity}): type #{name.inspect}, #{a.length} args #{a.inspect}"
+#puts "evaluating macro (arity #{@macros[name].arity}): type #{name.inspect}, #{a.length} args #{a.inspect}"
       res = @macros[name][*a]
-#      puts "got #{res}"
+      res = raw_blob_to_string res if @format == :raw
+#puts "got #{res}"
       @lex.push res
       ""
     elsif funcs.member? name
 #      puts "*** running func #{name}"
-      funcs[name][*a]
+      if @format == :raw
+        "\\#{name}" + a.map { |x| raw_funarg(x) }.join
+      else
+        interpret funcs[name][*a]
+      end
     elsif envs.member? name
-      envs[name][*a]
+      if @format == :raw
+        "\\#{name}" + a.map { |x| raw_funarg(x) }.join
+      else
+        interpret envs[name][*a]
+      end
     else
       error "unknown function, macro or environment #{name.inspect}"
     end
   end
 
+  def raw_funarg f
+    f = raw_blob_to_string f
+    f[0, 1] == '{' ? f : "{#{f}}"
+  end
+
+  def raw_blob_to_string x #:nodoc:
+    case x
+    when String; x
+    when Array; x.join
+    else; x # ?
+    end
+  end
+
+  ## functions and environments return either a [method, [args]] array, or a
+  ## string. if the former, do the call; if the latter, just use the string
+  ## directly.
+  ##
+  ## possible one level too many of indirection going on here, but it makes
+  ## writing the functions really simple.
+  def interpret x # :nodoc:
+    case x
+    when Array
+      m, args = x
+      send m, *args
+    else
+      x
+    end
+  end
+
   def define sym, arity, exp
     arity = arity.to_i
     raise Error, "macro arity must be <= 3" unless arity <= 3
@@ -196,10 +249,11 @@ private
     warn "overriding definition for #{sym}" if @macros.member? sym
     @macros[sym] = lambda do |*a|
       raise Error, "expecting #{arity} arguments, got #{a.length}" unless a.length == arity
-#      puts "evaluating macro #{sym}, args #{a.inspect}"
-      x = (0 ... arity).inject(exp) { |s, i| s.gsub(/\##{i + 1}/, a[i]) }
-#      puts "macro evals to: #{x.inspect}"
-      x
+      if @format == :raw
+        a = a.map { |x| raw_blob_to_string x }
+        exp = raw_blob_to_string(exp)
+      end
+      (0 ... arity).inject(exp) { |s, i| s.gsub(/\##{i + 1}/, a[i]) }
     end
     @macros[sym].instance_eval "def arity; #{arity}; end" # hack!
     ""

data/lib/ritex/lexer.rb

@@ -1,6 +1,6 @@
 ## lib/ritex/lexer.rb -- contains Ritex::Lexer
 ## Author::    William Morgan (mailto: wmorgan-ritex@masanjin.net)
-## Copyright:: Copyright 2005--2009 William Morgan
+## Copyright:: Copyright 2005--2010 William Morgan
 ## License::   GNU GPL version 2
 
 require 'racc/parser' # just for Racc::ParseError
@@ -77,7 +77,7 @@ private
           name = $1
           @s.first[1] += name.length + 1
           yield [token, name]
-          state = :env if @parser.envs[name]
+          state = :env if @parser.envs.member?(name)
           true
         end
       end
@@ -106,7 +106,7 @@ private
           proc = @parser.funcs[name]
           type = [:FUNC0, :FUNC1, :FUNC2, :FUNC3][proc.arity]
           raise LexError, "functions of arity '#{proc.arity}' unsupported" if type.nil?
-        elsif @parser.envs[name]
+        elsif @parser.envs.member? name
           type = :ENV
           state = :env
         elsif @parser.macros.member? name

data/lib/ritex/mathml/functions.rb

@@ -17,11 +17,8 @@ end
 module Ritex
 module MathML
 
-## this is not ideal by any means. until we can call lambda with
-## arbitrary bindings, though, we will relay markup and lookup calls
-## to a registered parser, so that "functions" can be written easily.
-def markup *a; Ritex::global_parser.markup(*a); end
-def lookup *a; Ritex::global_parser.lookup(*a); end
+def markup *a; [:markup, a] end
+def lookup *a; [:lookup, a] end
 module_function :markup, :lookup
 
 FUNCTIONS = {

data/lib/ritex/mathml/markup.rb

@@ -2,7 +2,7 @@
 ## See Ritex::MathML.
 ##
 ## Author::    William Morgan (mailto: wmorgan-ritex@masanjin.net)
-## Copyright:: Copyright 2005--2009 William Morgan
+## Copyright:: Copyright 2005--2010 William Morgan
 ## License::   GNU GPL version 2
 
 module Ritex

data/test/mathml.rb

@@ -1,6 +1,6 @@
 ## test/mathml.rb -- contains Ritex::Test::MathML
 ## Author::    William Morgan (mailto: wmorgan-ritex@masanjin.net)
-## Copyright:: Copyright 2005--2009 William Morgan
+## Copyright:: Copyright 2005--2010 William Morgan
 ## License::   GNU GPL version 2
 
 require 'test/unit'
@@ -51,17 +51,18 @@ class MathML < ::Test::Unit::TestCase
   ## by the binary answer-key generator.
   def cmp s, same_as=nil
     gold = gold_standard(same_as || s)
-    test = @p.parse s, false
+    test = @p.parse s, :nowrap => true
 
-    if gold.gsub('"', "'") != test.gsub('"', "'")
-      puts "BADBADBADBAD"
-      p gold
-      p test
-      exit
-    end
     assert_equal gold.gsub('"', "'"), test.gsub('"', "'"), "Difference in MathML output of #{s.inspect}"
   end
 
+  ## compare in raw mode
+  def cmp_raw s, gold
+    @raw_parser ||= Ritex::Parser.new :raw
+    x = @raw_parser.parse s
+    assert_equal gold, x
+  end
+
   ## fix up itex2MML's common known errors
   def fix_itex2mml_output l
     l.gsub(/<mi>&(lt|gt);<\/mi>/, "<mo>&\\1;</mo>").
@@ -226,6 +227,19 @@ class MathML < ::Test::Unit::TestCase
     cmp '\float{\goat}{\boat{\goat}}', '{\frac{\alpha-{\mathbb{GOAT}}}{\beta-{{\mathbb{GOAT}}-x}}}'
   end
 
+  def test_macros_in_raw_mode
+    cmp_raw '\define{\goat}{\mathbb{GOAT}}', ''
+    cmp_raw '\goat_3', '{\mathbb{GOAT}}_3'
+    cmp_raw '\define{\boat}[1]{#1-x}', ''
+    cmp_raw '\boat{y}', '{y-x}'
+    cmp_raw '\boat{\boat{N}}', '{{N-x}-x}'
+    cmp_raw '\boat{\boat{\boat{N}}}', '{{{N-x}-x}-x}'
+    cmp_raw '\frac{\boat{N}}{2}', '\frac{{N-x}}{2}'
+    cmp_raw '\define{\float}[2]{\frac{\alpha-#1}{\beta-#2}}', ''
+    cmp_raw '\float{\delta}{\gamma}', '{\frac{\alpha-\delta}{\beta-\gamma}}'
+    cmp_raw '\float{\goat}{\boat{\goat}}', '{\frac{\alpha-{\mathbb{GOAT}}}{\beta-{{\mathbb{GOAT}}-x}}}'
+  end
+
   def test_more_macros
     cmp '\define{\exp}[1]{E_\theta\left[#1\right]} \exp{\hat{\theta}}', '{E_\theta\left[\hat{\theta}\right]}'
   end
@@ -286,7 +300,7 @@ private
     ret = normalize_itex2mml_output(fix_itex2mml_output(ret))
 
     if ENV["ALLOW_OVERRIDE"]
-      test = Ritex::Parser.new.parse s, false
+      test = Ritex::Parser.new.parse s, :nowrap => true
 
       if ret.gsub('"', "'") != test.gsub('"', "'")
         puts

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ritex
 version: !ruby/object:Gem::Version 
-  version: "0.3"
+  version: "1.0"
 platform: ruby
 authors: 
 - William Morgan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -04:00
+date: 2010-04-13 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -28,12 +28,12 @@ files:
 - lib/ritex/mathml/functions.rb
 - lib/ritex/mathml/markup.rb
 - lib/ritex/lexer.rb
+- lib/ritex/parser.rb
 - test/all.rb
 - test/parser.rb
 - test/mathml.rb
 - README
 - ReleaseNotes
-- lib/ritex/parser.rb
 - test/answer-key.yaml
 has_rdoc: true
 homepage: http://masanjin.net/ritex/