parsr 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in parsr.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/parsr.rb

@@ -0,0 +1,91 @@
+require 'strscan'
+
+class Parsr
+
+  BASE_PATH = File.expand_path(File.join(File.dirname(__FILE__), 'parsr'))
+
+  autoload :ArrayRule,      "#{BASE_PATH}/array_rule"
+  autoload :FloatRule,      "#{BASE_PATH}/float_rule"
+  autoload :HashRule,       "#{BASE_PATH}/hash_rule"
+  autoload :IntegerRule,    "#{BASE_PATH}/integer_rule"
+  autoload :RawStringRule,  "#{BASE_PATH}/raw_string_rule"
+  autoload :StringRule,     "#{BASE_PATH}/string_rule"
+  autoload :SymbolRule,     "#{BASE_PATH}/symbol_rule"
+  autoload :Token,          "#{BASE_PATH}/token"
+  autoload :VERSION,        "#{BASE_PATH}/version"
+
+  Error = Class.new(Exception)
+  IllegalValue = Class.new(Error)
+
+  class SyntaxError < Error
+
+    attr_reader :scanner
+
+    def self.message(message=nil)
+      @message = "Syntax error, #{message}" if message
+      @message
+    end
+
+    def initialize(scanner)
+      @scanner = scanner
+      super(self.class.message % context)
+    end
+
+    protected
+    def context
+      if scanner.eos? || scanner.rest =~ /^\s*$/
+        rest = 'end of string'
+       else
+         scanner.rest.scan(/^\s*([^\s])/)
+         rest = $1
+       end
+      {:rest => rest}
+    end
+
+  end
+
+  class << self
+
+    def safe_literal_eval(string)
+      @safe_eval_parser ||= self.new(
+        ArrayRule,
+        HashRule,
+        SymbolRule,
+        FloatRule,
+        IntegerRule,
+        RawStringRule,
+        StringRule
+      )
+      @safe_eval_parser.parse(string)
+    end
+
+  end
+
+  attr_accessor :rules
+
+  def initialize(*rules)
+    @rules = [rules].flatten
+  end
+
+  def parse(string)
+    scanner = StringScanner.new(string)
+    token = parse_value(scanner)
+    raise IllegalValue unless token.is_a?(Parsr::Token)
+    token.value
+  end
+
+  protected
+  def parse_value(scanner)
+    trim_space(scanner)
+    rules.each do |rule|
+      token = rule.match(scanner){ parse_value(scanner) }
+      return token if token.is_a?(Parsr::Token)
+    end
+    nil
+  end
+
+  def trim_space(scanner)
+    scanner.scan(/\s+/)
+  end
+
+end

data/lib/parsr/array_rule.rb

@@ -0,0 +1,44 @@
+module Parsr::ArrayRule
+
+  class Unterminated < Parsr::SyntaxError
+    message "unexpected '%{rest}', expecting ']'"
+  end
+
+  class << self
+
+    def match(scanner, &block)
+      if scanner.scan(/\[\s*/)
+        array = []
+        begin
+          if scanner.scan(/[a-zA-Z_][0-9a-zA-Z_]*\:/)
+            token = Parsr::Token.new(scanner.matched.chomp(':').to_sym)
+            array << parse_unclosed_hash(scanner, token, &block)
+            break
+          end
+
+          token = yield 
+          if token.is_a?(Parsr::Token) && scanner.scan(/\s*=>\s*/)
+            array << parse_unclosed_hash(scanner, token, &block)
+            break
+          end
+          
+          array << token.value if token.is_a?(Parsr::Token)
+        end while scanner.scan(/\s*,\s*/)
+        raise Unterminated.new(scanner) unless scanner.scan(/\s*\]/)
+        Parsr::Token.new(array)
+      end
+    end
+
+    def parse_unclosed_hash(scanner, token, &block)
+      hash = []
+      while pair = Parsr::HashRule.parse_pair(scanner, token, &block)
+        token = nil
+        hash << pair
+        break unless scanner.scan(/\s*\,\s*/)
+      end
+      Hash[hash]
+    end
+
+  end
+
+end

data/lib/parsr/float_rule.rb

@@ -0,0 +1,15 @@
+module Parsr::FloatRule
+
+  PATTERN = /[\-\+]?\d*\.\d+/
+
+  class << self
+
+    def match(scanner)
+      if scanner.scan(PATTERN)
+        Parsr::Token.new(Float(scanner.matched))
+      end
+    end
+
+  end
+
+end

data/lib/parsr/hash_rule.rb

@@ -0,0 +1,46 @@
+module Parsr::HashRule
+
+  class MissingValue < Parsr::SyntaxError
+    message "unexpected '%{rest}'"
+  end
+
+  class MissingSeparator < Parsr::SyntaxError
+    message "unexpected '%{rest}', expecting '=>'"
+  end
+
+  class Unterminated < Parsr::SyntaxError
+    message "unexpected '%{rest}', expecting '}'"
+  end
+
+  class << self
+
+    def match(scanner, &block)
+      if scanner.scan(/\{\s*/)
+        hash = []
+        while pair = parse_pair(scanner, &block)
+          hash << pair
+          break unless scanner.scan(/\s*\,\s*/)
+        end
+        raise Unterminated.new(scanner) unless scanner.scan(/\s*\}\s*/)
+        Parsr::Token.new(Hash[hash])
+      end
+    end
+
+    def parse_pair(scanner, key=nil)
+      unless key.is_a?(Parsr::Token)
+        if scanner.scan(/[a-zA-Z_][0-9a-zA-Z_]*\:/)
+          key = Parsr::Token.new(scanner.matched.chomp(':').to_sym)
+        elsif key = yield and key.is_a?(Parsr::Token)
+          raise MissingSeparator.new(scanner) unless scanner.scan(/\s*=>\s*/)
+        else
+          return false
+        end
+      end
+      value = yield
+      raise MissingValue.new(scanner) unless value && value.is_a?(Parsr::Token)
+      [key, value].map(&:value)
+    end
+
+  end
+
+end

data/lib/parsr/integer_rule.rb

@@ -0,0 +1,15 @@
+module Parsr::IntegerRule
+
+  PATTERN = /[\-\+]?\d+/
+
+  class << self
+
+    def match(scanner)
+      if scanner.scan(PATTERN)
+        Parsr::Token.new(Integer(scanner.matched))
+      end
+    end
+
+  end
+
+end

data/lib/parsr/raw_string_rule.rb

@@ -0,0 +1,38 @@
+module Parsr::RawStringRule
+
+  class Unterminated < Parsr::SyntaxError
+    message 'unterminated string meets end of file'
+  end
+
+  class << self
+
+    def match(scanner)
+      if scanner.scan(/'/)
+        buffer = ''
+        while chunk = (parse_content(scanner) || parse_escape(scanner))
+          buffer << chunk
+        end
+        raise Unterminated.new(scanner) unless terminated?(scanner)
+        return Parsr::Token.new(buffer)
+      end
+      nil
+    end
+
+    protected
+    def parse_content(scanner)
+      scanner.matched if scanner.scan(/[^\\']+/)
+    end
+
+    def parse_escape(scanner)
+      return %q{'} if scanner.scan(/\\'/)
+      return %q{\\} if scanner.scan(/\\\\/)
+      return scanner.matched if scanner.scan(%r{\\[^'\\/]})
+    end
+
+    def terminated?(scanner)
+      scanner.scan(/'/)
+    end
+
+  end
+
+end

data/lib/parsr/string_rule.rb

@@ -0,0 +1,40 @@
+module Parsr::StringRule
+
+  ESCAPED_CHARS = {'\n' => "\n", '\b' => "\b", '\f' => "\f", '\r' => "\r", '\t' => "\t"}
+  
+  class Unterminated < Parsr::SyntaxError
+    message 'unterminated string meets end of file'
+  end
+
+  class << self
+
+    def match(scanner)
+      if scanner.scan(/"/)
+        buffer = ''
+        while chunk = (parse_content(scanner) || parse_escape(scanner))
+          buffer << chunk
+        end
+        raise Unterminated.new(scanner) unless terminated?(scanner)
+        return Parsr::Token.new(buffer)
+      end
+      nil
+    end
+
+    protected
+    def parse_content(scanner)
+      scanner.matched if scanner.scan(/[^\\"]+/)
+    end
+
+    def parse_escape(scanner)
+      return %q{"} if scanner.scan(/\\"/)
+      return %q{\\} if scanner.scan(/\\\\/)
+      return ESCAPED_CHARS[scanner.matched] if scanner.scan(/\\[bfnrt]/)
+      return [Integer("0x#{scanner.matched[2..-1]}")].pack('U') if scanner.scan(/\\u[0-9a-fA-F]{4}/)
+    end
+
+    def terminated?(scanner)
+      scanner.scan(/"/)
+    end
+
+  end
+end

data/lib/parsr/symbol_rule.rb

@@ -0,0 +1,15 @@
+module Parsr::SymbolRule
+
+  PATTERN = /\:[a-zA-Z_][0-9a-zA-Z_]*/
+
+  class << self
+
+    def match(scanner)
+      if scanner.scan(PATTERN)
+        Parsr::Token.new(scanner.matched[1..-1].to_sym)
+      end
+    end
+
+  end
+
+end

data/lib/parsr/token.rb

@@ -0,0 +1,9 @@
+class Parsr::Token
+
+  attr_reader :value
+
+  def initialize(value)
+    @value = value
+  end
+
+end

data/lib/parsr/version.rb

@@ -0,0 +1,3 @@
+class Parsr
+  VERSION = "0.0.1"
+end

data/parsr.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "parsr"
+
+Gem::Specification.new do |s|
+  s.name        = "parsr"
+  s.version     = Parsr::VERSION
+  s.authors     = ["Jean Boussier"]
+  s.email       = ["jean.boussier@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple parser to safe eval ruby literals}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/spec/parsr/array_rule_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Parsr::ArrayRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should be able to parse an empty array' do
+      match('[]').value.should be == []
+    end
+
+    it 'should yield to get its content values' do
+      values = [3, 2, 1]
+
+      result = match('[1,2,3]') do |scanner|
+        val = values.pop
+        scanner.scan(Regexp.new(val.to_s))
+        Parsr::Token.new(val)
+      end
+      
+      result.value.should be == [1, 2, 3]
+    end
+
+    it 'should not be disturbed by a trailing comma' do
+      values = [3, 2, 1]
+
+      result = match('[1,2,3,]') do |scanner|
+        val = values.pop
+        scanner.scan(Regexp.new(val.to_s))
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == [1, 2, 3]
+    end
+
+    it 'should not be disturbed by spaces around commas' do
+      values = [3, 2, 1]
+
+      result = match("[ 1   ,\t2\r\n, 3  ]") do |scanner|
+        val = values.pop
+        scanner.scan(Regexp.new(val.to_s))
+        Parsr::Token.new(val)
+      end
+      
+      result.value.should be == [1, 2, 3]
+    end
+
+    it 'should be able to parse a final unenclosed Hash' do
+      values = [6, 5, 4, 3, 2, 1]
+
+      result = match("[1, 2, 3 => 4, 5=>6]") do |scanner|
+        val = values.pop
+        scanner.scan(Regexp.new(val.to_s))
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == [1, 2, {3 => 4, 5 => 6}]
+    end
+
+    it 'should be able to parse a final unenclosed Ruby1.9 Hash' do
+      values = [6, 5, 4, 2, 1]
+
+      result = match("[1, 2, foo: 4, 5=>6]") do |scanner|
+        val = values.pop
+        scanner.scan(/\s*/)
+        scanner.scan(Regexp.new(val.to_s))
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == [1, 2, {:foo => 4, 5 => 6}]
+    end
+
+  end
+
+end

data/spec/parsr/float_rule_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Parsr::FloatRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should not match integers' do
+      match('42').should be_nil
+    end
+
+    it 'should match a simple float' do
+      match('42.42').value.should be == 42.42
+    end
+
+    it 'should match positive signed floats' do
+      match('+42.42').value.should be == 42.42
+    end
+
+    it 'should match negative signed floats' do
+      match('-42.42').value.should be == -42.42
+    end
+
+    it 'should match floats with a implicit 0 unit' do
+      match('.42').value.should be == 0.42
+    end
+
+    it 'should match positive signed floats with a implicit 0 unit' do
+      match('+.42').value.should be == 0.42
+    end
+
+    it 'should match negative signed floats with a implicit 0 unit' do
+      match('-.42').value.should be == -0.42
+    end
+
+  end
+
+end

data/spec/parsr/hash_rule_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Parsr::HashRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should be able to parse an empty hash' do
+      match('{}').value.should be == {}
+    end
+
+    it 'should yield to get its content values' do
+      values = [1, 2, 3, 4]
+
+      result = match("{1 => 2, 3 => 4}") do |scanner|
+        val = values.shift
+        scanner.scan(Regexp.new(Regexp.escape(val.inspect)))
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == {1 => 2, 3 => 4}
+    end
+
+    it 'should not be disturbed by a trailing comma' do
+      values = [1, 2, 3, 4]
+
+      result = match("{1 => 2, 3 => 4, }") do |scanner|
+        val = values.shift
+        scanner.scan(/\s*/)
+        scanner.scan(Regexp.new(Regexp.escape(val.inspect)))
+        scanner.scan(/\s*/)
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == {1 => 2, 3 => 4}
+    end
+
+    it 'should not be disturbed by spaces around commas' do
+      values = [1, 2, 3, 4]
+
+      result = match("{1\t=>\n\r     2,    3 => 4, }") do |scanner|
+        val = values.shift
+        scanner.scan(/\s*/)
+        scanner.scan(Regexp.new(Regexp.escape(val.inspect)))
+        scanner.scan(/\s*/)
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == {1 => 2, 3 => 4}
+    end
+
+    it 'should support Ruby 1.9 hash syntax' do
+      values = [1, 2, 4]
+
+      result = match("{1 => 2, foo: 4}") do |scanner|
+        val = values.shift
+        scanner.scan(/\s*/)
+        scanner.scan(Regexp.new(val.inspect))
+        Parsr::Token.new(val) if val
+      end
+      
+      result.value.should be == {1 => 2, :foo => 4}
+    end
+
+  end
+
+end

data/spec/parsr/integer_rule_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Parsr::IntegerRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should match digits' do
+      result = match('42')
+      result.should be_a(Parsr::Token)
+      result.value.should be == 42
+    end
+
+    it 'should match only digits' do
+      result = match('42abcd')
+      result.should be_a(Parsr::Token)
+      result.value.should be == 42
+    end
+
+    it 'should also match prepended sign' do
+      result = match('+42')
+      result.should be_a(Parsr::Token)
+      result.value.should be == 42
+      
+      result = match('-42')
+      result.should be_a(Parsr::Token)
+      result.value.should be == -42
+    end
+
+    it 'should not return a Token if it does not match' do
+      result = match('AZIJjkdjfs42|')
+      result.should_not be_a(Parsr::Token)
+    end
+
+  end
+
+end

data/spec/parsr/raw_string_rule_spec.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe Parsr::RawStringRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should match an empty string' do
+      match(%q{''}).value.should be == ''
+    end
+
+    it 'should match a simple word' do
+      match(%q{'foo'}).value.should be == 'foo'
+    end
+
+    it 'should match a simple sentence' do
+      match(%q{'foo bar'}).value.should be == 'foo bar'
+    end
+
+    it 'should match a simple sentence with punctuation' do
+      match(%q{'foo bar.,;$?!'}).value.should be == 'foo bar.,;$?!'
+    end
+
+    it 'should match a simple string with unicode characters' do
+      match(%q{'éùäüûꀢ©◊√'}).value.should be == 'éùäüûꀢ©◊√'
+    end
+
+    it 'should match a string containing double quotes' do
+      match(%q{'"'}).value.should be == '"'
+    end
+
+    it 'should match a string containing a backslash' do
+      match(%q{'\n'}).value.should be == '\n'
+    end
+
+    it 'should match a string containing an escaped backslash' do
+      match(%q{'\\\\'}).value.should be == '\\'
+    end
+
+    it 'should match a string containing an escaped single quote' do
+      match(%q{'\\''}).value.should be == "'"
+    end
+
+    it 'should raise an Parsr::RawStringRule::Unterminated if raw string is not terminated' do
+      expect{
+        match(%q{'bryan\\'s kitchen})
+      }.to raise_error(Parsr::RawStringRule::Unterminated)
+    end
+
+  end
+
+end

data/spec/parsr/string_rule_spec.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe Parsr::StringRule do
+  include_context 'rule'
+
+  describe '.match' do
+
+    it 'should match an empty string' do
+      match(%q{""}).value.should be == ""
+    end
+
+    it 'should match a simple word' do
+      match(%q{"foo"}).value.should be == "foo"
+    end
+
+    it 'should match a simple sentence' do
+      match(%q{"foo bar"}).value.should be == "foo bar"
+    end
+
+    it 'should match a simple sentence with punctuation' do
+      match(%q{"foo bar.,;$?!"}).value.should be == "foo bar.,;$?!"
+    end
+
+    it 'should match a simple string with unicode characters' do
+      match(%{"éùäüûꀢ©◊√"}).value.should be == "éùäüûꀢ©◊√"
+    end
+
+    it 'should match a string containing a simple quotes' do
+      match(%q{"'"}).value.should be == "'"
+    end
+
+    it 'should match a string containing a backslash' do
+      match(%q{"\n"}).value.should be == "\n"
+    end
+
+    it 'should match a string containing an escaped backslash' do
+      match(%q{"\\\\"}).value.should be == "\\"
+    end
+
+    it 'should match a string containing an escaped double quote' do
+      match('"\\""').value.should be == '"'
+    end
+
+    it 'should raise an Parsr::RawStringRule::Unterminated if raw string is not terminated' do
+      expect{
+        match(%q{"bryan\\"s kitchen})
+      }.to raise_error
+    end
+
+  end
+
+end

data/spec/parsr/symbol_rule_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Parsr::SymbolRule do
+  include_context 'rule'
+
+  it 'should match identifiers' do
+    match(':_').value.should be == :_
+    match(':foo').value.should be == :foo
+    match(':bar42').value.should be == :bar42
+  end
+
+  it 'should not match invalid identitifers' do
+    match(':42').should be_nil
+    match(':-').should be_nil
+  end
+
+end

data/spec/parsr_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Parsr do
+
+  it 'should have a VERSION' do
+    Parsr::VERSION.should be_a(String)
+  end
+
+  describe '#parse' do
+
+    let(:first_rule) { mock(:rule) }
+
+    let(:second_rule) { mock(:rule) }
+
+    let(:rules) { [first_rule, second_rule] }
+
+    subject{ Parsr.new(*rules) }
+
+    context 'call #match on all its rules' do
+
+      it 'should raise an IllegalValue if none of theses return a token' do
+        first_rule.should_receive(:match).and_return(true)
+        second_rule.should_receive(:match).and_return(false)
+        expect{
+          subject.parse('foo')
+        }.to raise_error(Parsr::IllegalValue)
+      end
+
+      it 'should return first matched token value' do
+        first_rule.should_receive(:match).and_return(true)
+        second_rule.should_receive(:match).and_return(Parsr::Token.new(42))
+        subject.parse('foo').should be == 42
+      end
+
+    end
+
+  end
+
+  describe '.safe_literal_eval' do
+
+    it 'should be able to parse some complexes literals' do
+      Parsr::safe_literal_eval(%q{
+        [1, "2", foo: {egg: 'spam', 'bar,' => 'plop'}, 3 => 4.2]
+      }).should be == [1, "2", {:foo => {:egg => 'spam', 'bar,' => 'plop'}, 3 => 4.2}]
+    end
+
+    it 'should be able to parse an array included in another array' do
+      Parsr::safe_literal_eval(%q{
+        [1, [2], 3]
+      }).should be == [1, [2], 3]
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/../lib/parsr'
+require 'rspec'
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each{ |f| require f }

data/spec/support/rule_shared_context.rb

@@ -0,0 +1,8 @@
+shared_context 'rule' do
+
+  def match(string)
+    scanner = StringScanner.new(string)
+    described_class.match(scanner) { yield scanner if block_given? }
+  end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: parsr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jean Boussier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70315696184660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70315696184660
+description: 
+email:
+- jean.boussier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- lib/parsr.rb
+- lib/parsr/array_rule.rb
+- lib/parsr/float_rule.rb
+- lib/parsr/hash_rule.rb
+- lib/parsr/integer_rule.rb
+- lib/parsr/raw_string_rule.rb
+- lib/parsr/string_rule.rb
+- lib/parsr/symbol_rule.rb
+- lib/parsr/token.rb
+- lib/parsr/version.rb
+- parsr.gemspec
+- spec/parsr/array_rule_spec.rb
+- spec/parsr/float_rule_spec.rb
+- spec/parsr/hash_rule_spec.rb
+- spec/parsr/integer_rule_spec.rb
+- spec/parsr/raw_string_rule_spec.rb
+- spec/parsr/string_rule_spec.rb
+- spec/parsr/symbol_rule_spec.rb
+- spec/parsr_spec.rb
+- spec/spec_helper.rb
+- spec/support/rule_shared_context.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Simple parser to safe eval ruby literals
+test_files:
+- spec/parsr/array_rule_spec.rb
+- spec/parsr/float_rule_spec.rb
+- spec/parsr/hash_rule_spec.rb
+- spec/parsr/integer_rule_spec.rb
+- spec/parsr/raw_string_rule_spec.rb
+- spec/parsr/string_rule_spec.rb
+- spec/parsr/symbol_rule_spec.rb
+- spec/parsr_spec.rb
+- spec/spec_helper.rb
+- spec/support/rule_shared_context.rb