sexpistol 0.0.6 → 0.0.7

data/README.rdoc

@@ -1,6 +1,6 @@
 = Sexpistol
 
-Sexpistol is a simple library for parsing S-Expressions in Ruby. Sexpistol takes an S-Expression and turns it into a native Ruby data structure made up of nested sets of arrays.
+Sexpistol is a very fast and easy-to-use library for parsing S-Expressions in Ruby. Sexpistol takes an S-Expression in string form and turns it into a native Ruby data structure made up of nested sets of arrays.
 
 === Example
 
@@ -42,6 +42,15 @@ Sexpistol also supports mapping the Ruby keyword literals (nil, true, false) to
   @parser.parse_string("nil false true")
   #=> [nil, false, true]
   
+== Scheme compatibility
+
+Above all Sexpistol strives to be compatible with Scheme-style S-Expressions. This means that Sexpistol supports comma quoting, though quasi-quoting is not yet implemented. Sexpistol can also generate Scheme compatible external representations when the 'scheme_compatability' options is set to true:
+
+  @parser = Sexpistol.new
+  @parser.scheme_compatability = true
+  @parser.to_sexp([:test, false, true, nil])
+  #=> "(test #f #t ())"
+  
 === Installation
 
 For convenience Sexpistol is packaged as a RubyGem, to install it simply enter the following at your command line:
@@ -66,8 +75,15 @@ For convenience Sexpistol is packaged as a RubyGem, to install it simply enter t
   @parser.to_sexp( ast )
   #=> "( string ( is ( parsed ) ) )"
   
+=== Performance
+
+The core of Sexpistol was recently re-written using StringScanner and the new version is roughly twice as fast as the older ones.
+
+Parsing throughput on my test machine (2Ghz Core 2 Duo, 4GB RAM, Ruby 1.9) is approximately 1 Megabytes/sec. This is fairly high given that Sexpistol is pure Ruby. Benchmarking Sexpistol against other popular S-Expression parser gems shows that it is roughly 8x faster than the nearest competitor.
+
 === Author & Credits
 
 Author:: {Aaron Gough}[mailto:aaron@aarongough.com]
+Contributors:: {Shane Hanna}[http://github.com/shanna]
 
 Copyright (c) 2010 {Aaron Gough}[http://thingsaaronmade.com/] ({thingsaaronmade.com}[http://thingsaaronmade.com/]), released under the MIT license

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/lib/sexpistol.rb

@@ -1 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'sexpistol', 'sexpistol_parser.rb'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'sexpistol', 'sexpistol.rb'))

data/lib/sexpistol/sexpistol.rb

@@ -4,151 +4,73 @@
 #   [:def, :something [:lambda, [:a], [:do_something]]]
 class Sexpistol
 
-  attr_accessor :ruby_keyword_literals
-
-  def initialize
-    @ruby_keyword_literals = false
-    
-    # Setup all of our token patterns as instance variables
-    # so they don't have to be re-instantiated for each
-    # run & match
-    @string_literal_pattern = /"([^"\\]|\\.)*"/
-    @integer_literal_pattern = /[\-\+]?[0-9]+/
-    @float_literal_pattern = /[\-\+]?[0-9]+\.[0-9]+(e[0-9]+)?/
-    @symbol_pattern = /[^\"\'\,\(\)]+/
-    
-    @string_replacement_token = "__++STRING_LITERAL++__"
-  end
+  attr_accessor :ruby_keyword_literals, :scheme_compatability
 
   # Parse a string containing an S-Expression into a
   # nested set of Ruby arrays
-  def parse_string( string )
-    string_array = split_outside_strings(string)
-    tokens = process_tokens( string_array )
-    structure( tokens )[1]
+  def parse_string(string)
+    tree = SexpistolParser.new(string).parse
+    return convert_ruby_keyword_literals(tree) if(@ruby_keyword_literals)
+    return tree
   end
 
-  # Iterate over an array of strings and turn each
-  # item into it's relevant token. ie: "string" -> :string, "1" -> 1
-  def process_tokens( token_array )
-    tokens = []
-    token_array.each do |t|
-      if(@ruby_keyword_literals)
-        tokens << nil and next if(t == "nil")
-        tokens << true and next if(t == "true")
-        tokens << false and next if(t == "false")
+  # Convert symbols corresponding to Ruby's keyword literals
+  # into their literal forms
+  def convert_ruby_keyword_literals(expression)
+    return recursive_map(expression) do |x|
+      case x
+        when :'nil' then nil
+        when :'true' then true
+        when :'false' then false
+        else x
       end
-      tokens << "'" and next if(t == "'")
-      tokens << t and next if(t == "(" || t == ")")
-      tokens << t.to_f and next if( is_float?(t))
-      tokens << t.to_i and next if( is_integer?(t))
-      tokens << t.to_sym and next if( is_symbol?(t))
-      tokens << eval(t) and next if( is_string_literal?(t))
-      raise "\nUnrecognized token: #{t}\n"
     end
-    return tokens
-  end
-
-  # Iterate over a flat array of tokens and turn it
-  # a nested set of arrays by detecting '(' and ')'
-  def structure( token_array, offset = 0, internal = false )
-    program = []
-    while(offset < token_array.length)
-      if( token_array[offset] == "(" )
-        offset, array = structure( token_array, offset + 1, true )
-        program << array
-      elsif( token_array[offset] == "'" )  
-        offset, array = structure( token_array, offset + 1, true )
-        program << array.unshift( :quote )
-      elsif( token_array[offset] == ")" )
-        break  
-      else
-        program << token_array[offset]
-      end
-      offset += 1
-    end
-    return [offset, program]
   end
   
-  # Split up a string into an array where delimited by whitespace,
-  # except inside string literals
-  def split_outside_strings( string )
-    # Find and extract all the string literals
-    string_literals = []
-    string = string.gsub(@string_literal_pattern) do |x| 
-      string_literals << x
-      @string_replacement_token
-    end
-    # Make sure the s-expression is valid
-    unless( string.count("(") == string.count(")") )
-      raise Exception, "Invalid S-Expression. The number of opening and closing parentheses does not match."
-    end
-    # Split the string up on whitespace and parentheses
-    array = string.gsub("(", " ( ").gsub(")", " ) ").split(" ")
-    # replace the special string token with the original string literals
-    array.collect! do |x|
-      if( x == @string_replacement_token)
-        string_literals.shift
-      else
-        x
+  # Convert nil, true and false into (), #t and #f for compatability
+  # with Scheme
+  def convert_scheme_literals(data)
+    return recursive_map(data) do |x|
+      case x
+        when nil then []
+        when true then :"#t"
+        when false then :"#f"
+        else x
       end
-    end
-    return array
-  end
-
-  # Test to see whether or not a string represents an integer
-  def is_integer?( string )
-    is_match?( string, @integer_literal_pattern )
-  end
-  
-  # Test to see whether or not a string represents a float
-  def is_float?( string )
-    is_match?( string, @float_literal_pattern )
-  end
-
-  # Test to see whether or not a string represents a symbol
-  def is_symbol?( string )
-    is_match?( string, @symbol_pattern )
-  end
-  
-  # Test to see whether or not a string represents a string literal
-  def is_string_literal?( string )
-    is_match?( string, @string_literal_pattern )
+     end
   end
   
   # Convert a set of nested arrays back into an S-Expression
-  def to_sexp( data )
+  def to_sexp(data)
+    data = convert_scheme_literals(data) if(@scheme_compatability)
     if( data.is_a?(Array))
       mapped = data.map do |item|
         if( item.is_a?(Array))
           to_sexp(item)
         else
-          if(item === false)
-            "#f"
-          elsif(item === true)
-            "#t"
-          else
-            item.to_s
-          end
+          item.to_s
         end
       end
       "(" + mapped.join(" ") + ")"
     else
-      if(data === false)
-        "#f"
-      elsif(data === true)
-        "#t"
-      else
-        data.to_s
-      end
+      data.to_s
     end
   end
-
+  
   private
-
-    def is_match?( string, pattern )
-      match = string.match(pattern)
-      return false unless match
-      match[0].length == string.length
+  
+    def recursive_map(data, &block)
+      if(data.is_a?(Array))
+        return data.map do |x|
+          if(x.is_a?(Array))
+            recursive_map(x, &block)
+          else
+            block.call(x)
+          end
+        end
+      else
+        block.call(data)
+      end
     end
-end
+  
+end

data/lib/sexpistol/sexpistol_parser.rb

@@ -0,0 +1,64 @@
+require 'strscan'	
+
+class SexpistolParser < StringScanner
+
+  def initialize(string)
+    unless(string.count('(') == string.count(')'))
+      raise Exception, "Missing closing parentheses"
+    end
+    super(string)
+  end
+
+  def parse
+    exp = []
+    while true
+      case fetch_token
+        when '('
+          exp << parse
+        when ')'
+          break
+        when :"'"
+          case fetch_token
+          when '(' then exp << [:quote].concat([parse])
+          else exp << [:quote, @token]
+          end
+        when String, Fixnum, Float, Symbol 
+          exp << @token
+        when nil 
+          break
+      end
+    end
+    exp
+  end
+  
+  def fetch_token
+    skip(/\s+/)
+    return nil if(eos?)
+    
+    @token = 
+    # Match parentheses
+    if scan(/[\(\)]/)      
+      matched
+    # Match a string literal
+    elsif scan(/"([^"\\]|\\.)*"/)
+      eval(matched)
+    # Match a float literal
+    elsif scan(/[\-\+]? [0-9]+ ((e[0-9]+) | (\.[0-9]+(e[0-9]+)?))/x)
+      matched.to_f
+    # Match an integer literal
+    elsif scan(/[\-\+]?[0-9]+/)
+      matched.to_i
+    # Match a comma (for comma quoting)
+    elsif scan(/'/)
+      matched.to_sym
+    # Match a symbol
+    elsif scan(/[^\(\)\s]+/)
+      matched.to_sym
+    # If we've gotten here then we have an invalid token
+    else
+      near = scan %r{.{0,20}}
+      raise "Invalid character at position #{pos} near '#{near}'."
+    end
+  end
+
+end

data/sexpistol.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sexpistol}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Gough"]
-  s.date = %q{2010-10-11}
+  s.date = %q{2010-10-15}
   s.description = %q{Sexpistol is an easy-to-use S-Expression parser for Ruby. It is fast and has no dependencies.}
   s.email = %q{aaron@aarongough.com}
   s.extra_rdoc_files = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
      "VERSION",
      "lib/sexpistol.rb",
      "lib/sexpistol/sexpistol.rb",
+     "lib/sexpistol/sexpistol_parser.rb",
      "sexpistol.gemspec",
      "test/performance/benchmark_test.rb",
      "test/setup/test_unit_extensions.rb",

data/test/performance/benchmark_test.rb

@@ -3,31 +3,43 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb
 class BenchmarkTest < Test::Unit::TestCase
 
   require 'benchmark'
+  
+  def setup
+  @example_sexp = <<-EOD
+      (display "This is a test string!")
+      
+      (define test (lambda () (begin
+        (display (== 1 1))
+        (display (== true true))
+        (display (== false false))
+        (display (== nil nil))
+        (display (== 2.09 1.08))
+        (display (== 2e6 2e12))
+      )))
+    EOD
+  end
 
   test "benchmark sexpistol" do
     puts "\nRunning performance test...\n"
+    
     parser = Sexpistol.new
     parser.ruby_keyword_literals = true
+    
     Benchmark.bmbm do |b|
-      b.report do
+      b.report("Parse") do
+        5000.times do
+          parser.parse_string(@example_sexp)
+        end
+      end
+      
+      b.report("to_sexp") do
+        ast = parser.parse_string(@example_sexp)
         5000.times do
-          parser.parse_string <<-EOD
-          
-            (display "This is a test string!")
-            
-            (define test (lambda () (begin
-              (display (== 1 1))
-              (display (== true true))
-              (display (== false false))
-              (display (== nil nil))
-              (display (== 2.09 1.08))
-              (display (== 2e6 2e12))
-            )))
-            
-          EOD
+          parser.to_sexp(ast)
         end
       end
     end
+    
     puts
   end    
     

data/test/unit/float_literal_test.rb

@@ -7,28 +7,33 @@ class FloatLiteralTest < Test::Unit::TestCase
   end
 
   test "should parse sexp containing an implicitly positive float literal" do
-    ast = @parser.parse_string("10.00")
-    assert_equal [10.00], ast
+    ast = @parser.parse_string("(10.00)")
+    assert_equal [[10.00]], ast
   end
   
   test "should parse sexp containing an explicitly positive float literal" do
-    ast = @parser.parse_string("+910.00")
-    assert_equal [910.00], ast
+    ast = @parser.parse_string("(+910.00)")
+    assert_equal [[910.00]], ast
   end
   
   test "should parse sexp containing an explicitly negative float literal" do
-    ast = @parser.parse_string("-10.00")
-    assert_equal [-10.00], ast
+    ast = @parser.parse_string("(-10.00)")
+    assert_equal [[-10.00]], ast
   end
   
   test "should parse sexp containing a large float literal" do
-    ast = @parser.parse_string("1.0000127829")
-    assert_equal [1.0000127829], ast
+    ast = @parser.parse_string("(1.0000127829)")
+    assert_equal [[1.0000127829]], ast
   end
   
   test "should parse sexp containing a float defined in scientific notation" do
-    ast = @parser.parse_string("1.0e6")
-    assert_equal [1.0e6], ast
+    ast = @parser.parse_string("(1.0e6)")
+    assert_equal [[1.0e6]], ast
+  end
+  
+  test "should parse sexp containing a float defined in scientific notation with no decimal place" do
+    ast = @parser.parse_string("(10e2)")
+    assert_equal [[10e2]], ast
   end
     
     

data/test/unit/integer_literal_test.rb

@@ -7,18 +7,18 @@ class IntegerLiteralTest < Test::Unit::TestCase
   end
 
   test "should parse sexp containing an implicitly positive integer literal" do
-    ast = @parser.parse_string("10")
-    assert_equal [10], ast
+    ast = @parser.parse_string("(10)")
+    assert_equal [[10]], ast
   end
   
   test "should parse sexp containing an explicitly positive integer literal" do
-    ast = @parser.parse_string("+910")
-    assert_equal [910], ast
+    ast = @parser.parse_string("(+910)")
+    assert_equal [[910]], ast
   end
   
   test "should parse sexp containing an explicitly negative integer literal" do
-    ast = @parser.parse_string("-10")
-    assert_equal [-10], ast
+    ast = @parser.parse_string("(-10)")
+    assert_equal [[-10]], ast
   end
     
 end

data/test/unit/ruby_keyword_literals_test.rb

@@ -8,38 +8,38 @@ class RubyKeywordLiteralsTest < Test::Unit::TestCase
 
   test "should parse nil as literal" do
     @parser.ruby_keyword_literals = true
-    ast = @parser.parse_string('nil')
-    assert_equal [nil], ast
+    ast = @parser.parse_string('(nil)')
+    assert_equal [[nil]], ast
   end
   
   test "should not parse nil as literal" do
     @parser.ruby_keyword_literals = false
-    ast = @parser.parse_string('nil')
-    assert_equal [:nil], ast
+    ast = @parser.parse_string('(nil)')
+    assert_equal [[:nil]], ast
   end
   
   test "should parse true as literal" do
     @parser.ruby_keyword_literals = true
-    ast = @parser.parse_string('true')
-    assert_equal [true], ast
+    ast = @parser.parse_string('(true)')
+    assert_equal [[true]], ast
   end
   
   test "should not parse true as literal" do
     @parser.ruby_keyword_literals = false
-    ast = @parser.parse_string('true')
-    assert_equal [:true], ast
+    ast = @parser.parse_string('(true)')
+    assert_equal [[:true]], ast
   end
   
   test "should parse false as literal" do
     @parser.ruby_keyword_literals = true
-    ast = @parser.parse_string('false')
-    assert_equal [false], ast
+    ast = @parser.parse_string('(false)')
+    assert_equal [[false]], ast
   end
   
   test "should notparse false as literal" do
     @parser.ruby_keyword_literals = false
-    ast = @parser.parse_string('false')
-    assert_equal [:false], ast
+    ast = @parser.parse_string('(false)')
+    assert_equal [[:false]], ast
   end
     
 end

data/test/unit/scheme_compatability_test.rb

@@ -4,26 +4,43 @@ class SchemeCompatabilityTest < Test::Unit::TestCase
 
   def setup
     @parser = Sexpistol.new
+    @parser.scheme_compatability = true
   end
 
-  test "should parse #t as true" do
-    ast = @parser.parse_string('#t')
-    assert_equal [:"#t"], ast
+  test "should parse #t as symbol" do
+    ast = @parser.parse_string('(#t)')
+    assert_equal [[:"#t"]], ast
   end
   
-  test "should parse #f as false" do
-    ast = @parser.parse_string('#f')
-    assert_equal [:"#f"], ast
+  test "should parse #f as symbol" do
+    ast = @parser.parse_string('(#f)')
+    assert_equal [[:"#f"]], ast
   end
   
   test "should allow comma quoting" do
-    ast = @parser.parse_string("(this is '( a test))")
-    assert_equal [[:this, :is, [:quote, [:a, :test]]]], ast
+    ast = @parser.parse_string("(this is '( a test) too foo)(foo)")
+    assert_equal [[:this, :is, [:quote, [:a, :test]], :too, :foo ],[:foo]], ast
   end
   
   test "should allow complicated comma quoting" do
-    ast = @parser.parse_string("(this is '( a test (also)))")
-    assert_equal [[:this, :is, [:quote, [:a, :test, [:also]]]]], ast
+    ast = @parser.parse_string("(this is '( a test) (also))")
+    assert_equal [[:this, :is, [:quote, [:a, :test]], [:also]]], ast
+  end
+  
+  test "should allow comma quoting of integer literal" do
+    ast = @parser.parse_string("(this is '1 (also))")
+    assert_equal [[:this, :is, [:quote, 1], [:also]]], ast
+  end
+  
+  test "should allow comma quoting of string literal" do
+    ast = @parser.parse_string("(this is '\"test\" (also))")
+    assert_equal [[:this, :is, [:quote, "test"], [:also]]], ast
+  end
+  
+  test "should return scheme compatible external representation" do
+    ast = [true, false, nil]
+    string = @parser.to_sexp(ast)
+    assert_equal "(#t #f ())", string
   end
     
 end

data/test/unit/string_literal_test.rb

@@ -7,33 +7,33 @@ class StringLiteralTest < Test::Unit::TestCase
   end
 
   test "should parse empty string literal" do
-    ast = @parser.parse_string('""')
-    assert_equal [""], ast
+    ast = @parser.parse_string('("")')
+    assert_equal [[""]], ast
   end
 
   test "should parse string literal" do
-    ast = @parser.parse_string('"test"')
-    assert_equal ["test"], ast
+    ast = @parser.parse_string('("test")')
+    assert_equal [["test"]], ast
   end
   
   test "should parse string literal containing escaped quotes" do
-    ast = @parser.parse_string('"te\"st"')
-    assert_equal ["te\"st"], ast
+    ast = @parser.parse_string('("te\"st")')
+    assert_equal [["te\"st"]], ast
   end
   
   test "should parse string literal containing escaped characters" do
-    ast = @parser.parse_string('"\n\t\r"')
-    assert_equal ["\n\t\r"], ast
+    ast = @parser.parse_string('("\n\t\r")')
+    assert_equal [["\n\t\r"]], ast
   end
   
   test "should parse string literal containing spaces" do
-    ast = @parser.parse_string('"blah foo"')
-    assert_equal ["blah foo"], ast
+    ast = @parser.parse_string('("blah foo")')
+    assert_equal [["blah foo"]], ast
   end
   
   test "should parse string literal containing newlines" do
-    ast = @parser.parse_string('"blah' + "\n" + 'foo"')
-    assert_equal ["blah\nfoo"], ast
+    ast = @parser.parse_string('("blah' + "\n" + 'foo")')
+    assert_equal [["blah\nfoo"]], ast
   end
     
 end

data/test/unit/symbol_test.rb

@@ -7,68 +7,68 @@ class SymbolTest < Test::Unit::TestCase
   end
 
   test "should parse simple symbol" do
-    ast = @parser.parse_string("test")
-    assert_equal [:test], ast
+    ast = @parser.parse_string("(test)")
+    assert_equal [[:test]], ast
   end
   
   test "should parse symbol with trailing exclamation mark" do
-    ast = @parser.parse_string("test!")
-    assert_equal [:test!], ast
+    ast = @parser.parse_string("(test!)")
+    assert_equal [[:test!]], ast
   end
   
   test "should parse symbol with trailing question mark" do
-    ast = @parser.parse_string("test?")
-    assert_equal [:test?], ast
+    ast = @parser.parse_string("(test?)")
+    assert_equal [[:test?]], ast
   end
   
   test "should parse symbol containing underscores" do
-    ast = @parser.parse_string("te__st")
-    assert_equal [:te__st], ast
+    ast = @parser.parse_string("(te__st)")
+    assert_equal [[:te__st]], ast
   end
   
   test "should parse symbol with leading underscores" do
-    ast = @parser.parse_string("__test")
-    assert_equal [:__test], ast
+    ast = @parser.parse_string("(__test)")
+    assert_equal [[:__test]], ast
   end
   
   test "should parse symbol with trailing underscores" do
-    ast = @parser.parse_string("test__")
-    assert_equal [:test__], ast
+    ast = @parser.parse_string("(test__)")
+    assert_equal [[:test__]], ast
   end
     
   test "should parse CamelCase symbol" do
-    ast = @parser.parse_string("TestSymbol")
-    assert_equal [:TestSymbol], ast
+    ast = @parser.parse_string("(TestSymbol)")
+    assert_equal [[:TestSymbol]], ast
   end
   
   test "should parse complex symbol" do
-    ast = @parser.parse_string("__TestSymbol_TEST__?")
-    assert_equal [:__TestSymbol_TEST__?], ast
+    ast = @parser.parse_string("(__TestSymbol_TEST__?)")
+    assert_equal [[:__TestSymbol_TEST__?]], ast
   end
   
   test "should parse symbol containing addition operators" do
-    ast = @parser.parse_string("+")
-    assert_equal [:+], ast
+    ast = @parser.parse_string("(+)")
+    assert_equal [[:+]], ast
   end
   
   test "should parse symbol containing multiplication operators" do
-    ast = @parser.parse_string("*")
-    assert_equal [:*], ast
+    ast = @parser.parse_string("(*)")
+    assert_equal [[:*]], ast
   end
   
   test "should parse symbol containing subtraction operators" do
-    ast = @parser.parse_string("-")
-    assert_equal [:-], ast
+    ast = @parser.parse_string("(-)")
+    assert_equal [[:-]], ast
   end
   
   test "should parse symbol containing division operators" do
-    ast = @parser.parse_string("/")
-    assert_equal [:"/"], ast
+    ast = @parser.parse_string("(/)")
+    assert_equal [[:"/"]], ast
   end
   
   test "should parse symbol containing any character except single and double quotes, backquote, parentheses and comma" do
-    ast = @parser.parse_string("~1!2@3#4$%5^6&7*890-_+=|\]}[{poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP:;/?><")
-    assert_equal [:"~1!2@3#4$%5^6&7*890-_+=|\]}[{poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP:;/?><"], ast
+    ast = @parser.parse_string("(~1!2@3#4$%5^6&7*890-_+=|\]}[{poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP:;/?><)")
+    assert_equal [[:"~1!2@3#4$%5^6&7*890-_+=|\]}[{poiuytrewqasdfghjklmnbvcxzZXCVBNMLKJHGFDSAQWERTYUIOP:;/?><"]], ast
   end
     
 end

data/test/unit/to_sexp_test.rb

@@ -18,10 +18,10 @@ class ToSexpTest < Test::Unit::TestCase
     assert_equal "(String! (1 (2 Other string.)))", sexp
   end
   
-  test "should output true and false using scheme notation" do
+  test "should not output true and false using scheme notation when scheme compat is off" do
     ast = [true, [false, [true, false]]]
     sexp = @parser.to_sexp(ast)
-    assert_equal "(#t (#f (#t #f)))", sexp
+    assert_equal "(true (false (true false)))", sexp
   end
   
   test "when not passed array to_sexp should print value (integer)" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Aaron Gough
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-11 00:00:00 -04:00
+date: 2010-10-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - VERSION
 - lib/sexpistol.rb
 - lib/sexpistol/sexpistol.rb
+- lib/sexpistol/sexpistol_parser.rb
 - sexpistol.gemspec
 - test/performance/benchmark_test.rb
 - test/setup/test_unit_extensions.rb