deil_sexpistol 0.0.8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Aaron Gough (http://thingsaaronmade.com/)
+
+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.rdoc

@@ -0,0 +1,89 @@
+= Sexpistol
+
+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
+
+  (define test (lambda () (
+    (print "Hello world!\n")
+    (print 1)
+    (print 9.01)
+    (print 2.0e10)
+    (print (+ 10 12 13))
+  )))
+  
+would be parsed by Sexpistol like so:
+
+  [:define, :test, [:lambda, [], [
+    [:print, "Hello world!\n"],
+    [:print, 1],
+    [:print, 9.01],
+    [:print, 2.0e10],
+    [:print, [:+, 10, 12, 13]]
+  ]]]
+  
+=== Type mappings
+
+Sexpistol supports all of the standard datatypes and converts them directly to their Ruby equivalents:
+
+* Lists (a b c)
+* Integers (1 2 3)
+* Floats (1.0 2.0 42.9 3e6 1.2e2)
+* Strings ("\t\"Hello world!\"\n")
+* Symbols (symbol Symbol ____symbol____ symbo_l symbol? symbol! + - / ++ a+ e$, etc...)
+
+Sexpistol also supports mapping the Ruby keyword literals (nil, true, false) to their native Ruby types, although this is disabled by default for compatibility. To enable it use `@parser.ruby_keyword_literals = true`, eg:
+  
+  @parser = Sexpistol.new
+  @parser.parse_string("nil false true")
+  #=> [:nil, :false, :true]
+  
+  @parser.ruby_keyword_literals = true
+  @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:
+
+  gem install sexpistol
+  
+=== Usage
+
+  # Create a new parser instance
+  @parser = Sexpistol.new
+  
+  # Parse a string
+  ast = @parser.parse_string("(string (to (parse)))")
+  #=> [:string, [:to, [:parse]]]
+  
+  # Change the representation
+  ast[1][0] = :is
+  ast[1][1][0] = :parsed
+  #=> [:string, [:is, [:parsed]]]
+  
+  # Turn the array structure back into an S-Expression
+  @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/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "deil_sexpistol"
+    gemspec.summary = "An S-Expression Parser Library for Ruby. Forked"
+    gemspec.description = "Sexpistol is an easy-to-use S-Expression parser for Ruby. It is fast and has no dependencies."
+    gemspec.email = "aaron@aarongough.com"
+    gemspec.homepage = "http://github.com/aarongough/sexpistol"
+    gemspec.authors = ["Aaron Gough", "Anton Kosyakin"]
+    gemspec.rdoc_options << '--line-numbers' << '--inline-source'
+    gemspec.extra_rdoc_files = ['README.rdoc', 'MIT-LICENSE']
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+
+desc 'Test sexpistol.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib/*.rb'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+
+desc 'Generate documentation for sexpistol.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Koi'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.8

data/deil_sexpistol.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{deil_sexpistol}
+  s.version = "0.0.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Gough", "Anton Kosyakin"]
+  s.date = %q{2011-09-14}
+  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 = [
+    "MIT-LICENSE",
+    "README.rdoc"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+    "README.rdoc",
+    "Rakefile",
+    "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",
+    "test/test_helper.rb",
+    "test/unit/float_literal_test.rb",
+    "test/unit/integer_literal_test.rb",
+    "test/unit/ruby_keyword_literals_test.rb",
+    "test/unit/scheme_compatability_test.rb",
+    "test/unit/string_literal_test.rb",
+    "test/unit/structure_test.rb",
+    "test/unit/symbol_test.rb",
+    "test/unit/to_sexp_test.rb"
+  ]
+  s.homepage = %q{http://github.com/aarongough/sexpistol}
+  s.rdoc_options = ["--line-numbers", "--inline-source"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{An S-Expression Parser Library for Ruby. Forked}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/sexpistol/sexpistol.rb

@@ -0,0 +1,78 @@
+# This class contains our logic for parsing
+# S-Expressions. They are turned into a 
+# native Ruby representation like:
+#   [:def, :something [:lambda, [:a], [:do_something]]]
+class Sexpistol
+
+  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)
+    tree = SexpistolParser.new(string).parse
+    return convert_ruby_keyword_literals(tree) if(@ruby_keyword_literals)
+    return tree
+  end
+
+  # 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
+    end
+  end
+  
+  # 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
+  end
+  
+  # Convert a set of nested arrays back into an S-Expression
+  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)
+        elsif item.is_a?(String)
+          "\"" + item + "\""
+        else
+          item.to_s
+        end
+      end
+      "(" + mapped.join(" ") + ")"
+    else
+      data.to_s
+    end
+  end
+  
+  private
+  
+    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

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/lib/sexpistol.rb

@@ -0,0 +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/sexpistol.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sexpistol}
+  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-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 = [
+    "MIT-LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "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",
+     "test/test_helper.rb",
+     "test/unit/float_literal_test.rb",
+     "test/unit/integer_literal_test.rb",
+     "test/unit/ruby_keyword_literals_test.rb",
+     "test/unit/scheme_compatability_test.rb",
+     "test/unit/string_literal_test.rb",
+     "test/unit/structure_test.rb",
+     "test/unit/symbol_test.rb",
+     "test/unit/to_sexp_test.rb"
+  ]
+  s.homepage = %q{http://github.com/aarongough/sexpistol}
+  s.rdoc_options = ["--charset=UTF-8", "--line-numbers", "--inline-source"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{An S-Expression Parser Library for Ruby}
+  s.test_files = [
+    "test/performance/benchmark_test.rb",
+     "test/setup/test_unit_extensions.rb",
+     "test/test_helper.rb",
+     "test/unit/float_literal_test.rb",
+     "test/unit/integer_literal_test.rb",
+     "test/unit/ruby_keyword_literals_test.rb",
+     "test/unit/scheme_compatability_test.rb",
+     "test/unit/string_literal_test.rb",
+     "test/unit/structure_test.rb",
+     "test/unit/symbol_test.rb",
+     "test/unit/to_sexp_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/performance/benchmark_test.rb

@@ -0,0 +1,46 @@
+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("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.to_sexp(ast)
+        end
+      end
+    end
+    
+    puts
+  end    
+    
+end

data/test/setup/test_unit_extensions.rb

@@ -0,0 +1,21 @@
+module Test::Unit
+  # Used to fix a minor minitest/unit incompatibility in flexmock
+  AssertionFailedError = Class.new(StandardError)
+  
+  class TestCase
+   
+    def self.test(name, &block)
+      test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+      defined = instance_method(test_name) rescue false
+      raise "#{test_name} is already defined in #{self}" if defined
+      if block_given?
+        define_method(test_name, &block)
+      else
+        define_method(test_name) do
+          flunk "No implementation provided for #{name}"
+        end
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+
+require_files = []
+require_files << File.join(File.dirname(__FILE__), '..', 'lib', 'sexpistol.rb')
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'setup', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

data/test/unit/float_literal_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class FloatLiteralTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should parse sexp containing an implicitly positive float literal" do
+    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
+  end
+  
+  test "should parse sexp containing an explicitly negative float literal" do
+    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
+  end
+  
+  test "should parse sexp containing a float defined in scientific notation" do
+    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
+    
+    
+end

data/test/unit/integer_literal_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class IntegerLiteralTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should parse sexp containing an implicitly positive integer literal" do
+    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
+  end
+  
+  test "should parse sexp containing an explicitly negative integer literal" do
+    ast = @parser.parse_string("(-10)")
+    assert_equal [[-10]], ast
+  end
+    
+end

data/test/unit/ruby_keyword_literals_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class RubyKeywordLiteralsTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should parse nil as literal" do
+    @parser.ruby_keyword_literals = true
+    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
+  end
+  
+  test "should parse true as literal" do
+    @parser.ruby_keyword_literals = true
+    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
+  end
+  
+  test "should parse false as literal" do
+    @parser.ruby_keyword_literals = true
+    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
+  end
+    
+end

data/test/unit/scheme_compatability_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class SchemeCompatabilityTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+    @parser.scheme_compatability = true
+  end
+
+  test "should parse #t as symbol" do
+    ast = @parser.parse_string('(#t)')
+    assert_equal [[:"#t"]], ast
+  end
+  
+  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) 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
+  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

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class StringLiteralTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should parse empty string literal" do
+    ast = @parser.parse_string('("")')
+    assert_equal [[""]], ast
+  end
+
+  test "should parse string literal" do
+    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
+  end
+  
+  test "should parse string literal containing escaped characters" do
+    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
+  end
+  
+  test "should parse string literal containing newlines" do
+    ast = @parser.parse_string('("blah' + "\n" + 'foo")')
+    assert_equal [["blah\nfoo"]], ast
+  end
+    
+end

data/test/unit/structure_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class StructureTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+  
+  test "should create nested set of arrays from s-expression" do
+    ast = @parser.parse_string('(this (is (an (s_expression) (also) blah) foo) (test))')
+    assert_equal [[:this, [:is, [:an, [:s_expression], [:also], :blah], :foo], [:test]]], ast
+  end
+  
+  test "should create nested set of arrays from s-expression with string literals" do
+    ast = @parser.parse_string('(this (is (an ("s_expression"))))')
+    assert_equal [[:this, [:is, [:an, ["s_expression"]]]]], ast
+  end
+  
+  test "should raise error on broken s-expression" do
+    assert_raises Exception do
+      ast = @parser.parse_string('(this (is (an (s_expression) too)')
+    end
+  end
+  
+  test "should parser () as empty list" do
+    ast = @parser.parse_string('()')
+    assert_equal [[]], ast
+  end
+    
+end

data/test/unit/symbol_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class SymbolTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should parse simple symbol" do
+    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
+  end
+  
+  test "should parse symbol with trailing question mark" do
+    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
+  end
+  
+  test "should parse symbol with leading underscores" do
+    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
+  end
+    
+  test "should parse CamelCase symbol" do
+    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
+  end
+  
+  test "should parse symbol containing addition operators" do
+    ast = @parser.parse_string("(+)")
+    assert_equal [[:+]], ast
+  end
+  
+  test "should parse symbol containing multiplication operators" do
+    ast = @parser.parse_string("(*)")
+    assert_equal [[:*]], ast
+  end
+  
+  test "should parse symbol containing subtraction operators" do
+    ast = @parser.parse_string("(-)")
+    assert_equal [[:-]], ast
+  end
+  
+  test "should parse symbol containing division operators" do
+    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
+  end
+    
+end

data/test/unit/to_sexp_test.rb

@@ -0,0 +1,51 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper.rb'))
+
+class ToSexpTest < Test::Unit::TestCase
+
+  def setup
+    @parser = Sexpistol.new
+  end
+
+  test "should convert nested arrays back into an S-Expression" do
+    ast = [:string, [:is, [:parsed]]]
+    sexp = @parser.to_sexp(ast)
+    assert_equal "(string (is (parsed)))", sexp
+  end
+  
+  test "should structure containing integers and strings back into an S-Expression" do
+    ast = ["String!", [1, [2, "Other string."]]]
+    sexp = @parser.to_sexp(ast)
+    assert_equal "(String! (1 (2 Other string.)))", sexp
+  end
+  
+  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 "(true (false (true false)))", sexp
+  end
+  
+  test "when not passed array to_sexp should print value (integer)" do
+    ast = 1
+    sexp = @parser.to_sexp(ast)
+    assert_equal "1", sexp
+  end
+  
+  test "when not passed array to_sexp should print value (string)" do
+    ast = "test"
+    sexp = @parser.to_sexp(ast)
+    assert_equal "test", sexp
+  end
+  
+  test "when not passed array to_sexp should print value (symbol)" do
+    ast = :test
+    sexp = @parser.to_sexp(ast)
+    assert_equal "test", sexp
+  end
+  
+  test "lists passed to to_sexp should have not extraneous spaces" do
+    ast = [1, 2, 3]
+    sexp = @parser.to_sexp(ast)
+    assert_equal "(1 2 3)", sexp
+  end
+    
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: deil_sexpistol
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
+platform: ruby
+authors: 
+- Aaron Gough
+- Anton Kosyakin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-14 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: Sexpistol is an easy-to-use S-Expression parser for Ruby. It is fast and has no dependencies.
+email: aaron@aarongough.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- deil_sexpistol.gemspec
+- 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
+- test/test_helper.rb
+- test/unit/float_literal_test.rb
+- test/unit/integer_literal_test.rb
+- test/unit/ruby_keyword_literals_test.rb
+- test/unit/scheme_compatability_test.rb
+- test/unit/string_literal_test.rb
+- test/unit/structure_test.rb
+- test/unit/symbol_test.rb
+- test/unit/to_sexp_test.rb
+has_rdoc: true
+homepage: http://github.com/aarongough/sexpistol
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An S-Expression Parser Library for Ruby. Forked
+test_files: []
+