bracer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8b71bbf9c678ae9d2e8a33ccc8dc54bb0a04683
+  data.tar.gz: 2d7f04f3b5cf21afefe7a3ea9855f6be80d28ea2
+SHA512:
+  metadata.gz: 58bea8f8543d81af5ecb11f3da3d2ca878ef75e99c3126f47bfaf19a129c7ccbe5c434cf52cca2410fa2de1fc005cccb332827c9c711f8bf034d4b8c2a991467
+  data.tar.gz: 749658b045ace5f741332ed8ee5d1f127a1db8e9b1e38a885964a5eeeb6b97909b6564825024526373059a9357512b238d990c13280b9b7a8915c9016d7a137d

data/.gitignore

@@ -0,0 +1 @@
+*.gem

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 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "sexpistol"
+    gemspec.summary = "An S-Expression Parser Library for Ruby"
+    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"]
+    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.7

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

@@ -0,0 +1,76 @@
+# 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 Bracer
+
+  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 = BracerParser.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)
+        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 BracerParser < StringScanner
+
+  def initialize(string)
+    unless(string.count('[') == string.count(']'))
+      raise Exception, "Missing closing braces"
+    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

@@ -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{bracer}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aaron Gough","The Trung"]
+  s.date = %q{2015-02-07}
+  s.description = %q{Brace is Sexpistol with braces, an easy-to-use S-Expression parser for Ruby. It is fast and has no dependencies.}
+  s.email = %q{aaron@aarongough.com, deulamco@gmail.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/thetrung/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 Braces S-Expression with 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 bracer" do
+    puts "\nRunning performance test...\n"
+    
+    parser = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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 = Bracer.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,81 @@
+--- !ruby/object:Gem::Specification
+name: bracer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Aaron Gough
+- The Trung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-07 00:00:00.000000000 Z
+dependencies: []
+description: Brace is Sexpistol with braces, an easy-to-use S-Expression parser for
+  Ruby. It is fast and has no dependencies.
+email: aaron@aarongough.com, deulamco@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- MIT-LICENSE
+- README.rdoc
+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
+homepage: http://github.com/thetrung/sexpistol
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+- "--line-numbers"
+- "--inline-source"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 3
+summary: An Braces S-Expression with Parser Library for Ruby
+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
+has_rdoc: