sexpistol 0.0.1

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,71 @@
+= 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.
+
+=== Example
+
+  (define test (lambda () (
+    (print "blah")
+    (print 1)
+    (print 9.01)
+    (print (+ 10 12 13))
+  )))
+  
+would be parsed by Sexpistol like so:
+
+  [:define, :test, [:lambda, [], [
+    [:print, "blah"],
+    [:print, 1],
+    [:print, 9.01],
+    [: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)
+* Strings ("\t\"Hello world!\"\n")
+* Symbols (symbol Symbol __symbol__ symbo_l symbol? symbol!)
+
+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]
+  
+=== 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 ) ) )"
+  
+=== Author & Credits
+
+Author:: {Aaron Gough}[mailto:aaron@aarongough.com]
+
+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 = "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.1

data/lib/sexpistol/sexpistol.rb

@@ -0,0 +1,137 @@
+# 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
+
+  def initialize
+    @ruby_keyword_literals = false
+  end
+
+  # Parse a string containing an S-Expression into a
+  # nested set of Ruby arrays
+  def parse_string( string )
+    string.gsub!("(", " ( ")
+    string.gsub!(")", " ) ")
+    string_array = string.split
+    tokens = process_tokens( string_array )
+    check_tokens( tokens )
+    structure( tokens )
+  end
+  
+  # Check and array of tokens to make sure that the number
+  # of open and closing parentheses match
+  def check_tokens( tokens )
+    unless( (tokens.reject {|x| x == "("}).length == (tokens.reject {|x| x == ")"}).length)
+      raise Exception, "Invalid S-Expression. The number of opening and closing parentheses do not match."
+    end
+  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(is_nil?(t))
+        tokens << true and next if(is_true?(t))
+        tokens << false and next if(is_false?(t))
+      end
+      tokens << t and next if(is_paren?(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_identifier?(t) || 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] == ")" )
+        break  
+      else
+        program << token_array[offset]
+      end
+      offset += 1
+    end
+    if(internal)
+      return [offset, program]
+    else
+      return program
+    end
+  end
+
+  # Test to see whether or not a string represents the 'nil' literal
+  def is_nil?( string )
+    true if(string == "nil")
+  end
+  
+  # Test to see whether or not a string represents the 'true' literal
+  def is_true?( string )
+    true if(string == "true")
+  end
+  
+  # Test to see whether or not a string represents the 'false' literal
+  def is_false?( string )
+    true if(string == "false")
+  end
+
+  # Test to see whether a string represents a parentheses
+  def is_paren?( string )
+    is_match?( string, /[\(\)]+/ )
+  end
+
+  # Test to see whether or not a string represents an integer
+  def is_integer?( string )
+    is_match?( string, /[\-\+]?[0-9]+/ )
+  end
+  
+  # Test to see whether or not a string represents a float
+  def is_float?( string )
+    is_match?( string, /[\-\+]?[0-9]+\.[0-9]+/ )
+  end
+
+  # Test to see whether or not a string represents an identifier
+  def is_identifier?( string )
+    is_match?( string, /_*[a-zA-Z]+[a-zA-Z0-9_]*\??\!?/ )
+  end
+  
+  # Test to see whether or not a string represents a string literal
+  def is_string_literal?( string )
+    is_match?( string, /".*"/)
+  end
+
+  # Test to see whether or not a string represents a symbol
+  def is_symbol?( string )
+    is_match?( string, /[\!\*\^=\/\+\-]+/ )
+  end
+  
+  # Convert a set of nested arrays back into an S-Expression
+  def to_sexp( data )
+    mapped = data.map do |item|
+      if( item.is_a?(Array))
+        to_sexp(item)
+      else
+        item.to_s
+      end
+    end
+    "( " + mapped.join(" ") + " )"
+  end
+
+  private
+
+    def is_match?( string, pattern )
+      match = string.match(pattern)
+      return false unless match
+      match[0].length == string.length
+    end
+end

data/lib/sexpistol.rb

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

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,30 @@
+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
+    
+    
+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/string_literal_test.rb

@@ -0,0 +1,29 @@
+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
+    
+end

data/test/unit/structure_test.rb

@@ -0,0 +1,20 @@
+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 create nested set of arrays from s-expression" 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
+    
+end

data/test/unit/symbol_test.rb

@@ -0,0 +1,49 @@
+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
+    
+end

data/test/unit/to_sexp_test.rb

@@ -0,0 +1,15 @@
+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
+    
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: sexpistol
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aaron Gough
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-02 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
+- lib/sexpistol.rb
+- lib/sexpistol/sexpistol.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/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: 
+- --charset=UTF-8
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      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
+test_files: 
+- 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/string_literal_test.rb
+- test/unit/structure_test.rb
+- test/unit/symbol_test.rb
+- test/unit/to_sexp_test.rb