ptolemy 0.0.1

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+  watch(%r{^lib/(.+)\.tt$})     { "spec" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Natansh Verma
+
+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.md

@@ -0,0 +1,5 @@
+![Ptolemy](https://raw.github.com/natansh/ptolemy/master/ptolemy.jpg)
+[![Build Status](https://travis-ci.org/natansh/ptolemy.png?branch=master)](https://travis-ci.org/natansh/ptolemy)
+=======
+
+Ptolemy is a simple TOML parser.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :test => :spec
+
+task :default => :spec

data/lib/ptolemy/exceptions.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+module Ptolemy
+
+  class ParseError < StandardError; end
+
+end

data/lib/ptolemy/nodes.rb

@@ -0,0 +1,142 @@
+# encoding: UTF-8
+
+require 'set'
+
+require 'ptolemy/exceptions'
+
+module Ptolemy
+module TOML
+
+  class Toml < Treetop:: Runtime::SyntaxNode
+    def to_value
+      result = {}
+      # Keep track of location under which all the key value pairs must be
+      # stored. It gets modified when a key group is encountered.
+      current = result
+      # Store all key groups detected so that duplicates can be discovered.
+      key_group_set = Set.new
+
+      list.elements.map do |item|
+        elem = item.elem
+        if elem.is_a? KeyGroup
+          # Reset current to root level. Key value groups always specify
+          # nesting from root
+          current = result
+          key_group = elem.to_value
+          if key_group_set.include? key_group
+            raise ParseError, "Already defined [#{key_group}] before."
+          end
+          key_group_set.add key_group
+          # If the key group is x.y.z.w, create the whole nested structure
+          # in case it doesn't exist already.
+          key_group.each do |key|
+            current[key] = {} if current[key].nil?
+            current = current[key]
+          end
+        else
+          key, value = elem.to_value
+          # Set value in hash, if it hasn't been set already.
+          if current[key].nil?
+            current[key] = value
+          else
+            raise ParseError, "Duplicate value for key:#{key}"
+          end
+        end
+      end
+      result
+    end
+  end
+
+  class KeyGroup < Treetop::Runtime::SyntaxNode
+    def to_value
+      result = [keys.key.to_value]
+      keys.remaining_keys.elements.each do |elem|
+        result << elem.key.to_value
+      end
+      result
+    end
+  end
+
+  class KeyValue < Treetop::Runtime::SyntaxNode
+    def to_value
+      [key.to_value, value.to_value]
+    end
+  end
+
+  class Key < Treetop::Runtime::SyntaxNode
+    def to_value
+      text_value
+    end
+  end
+
+  class Comment < Treetop::Runtime::SyntaxNode
+  end
+
+  class ArrayLiteral < Treetop::Runtime::SyntaxNode
+   def to_value
+      result = list.elements.map do|elem|
+        elem.item.to_value
+      end
+      unless last.empty?
+        result << last.item.to_value
+      end
+      result
+    end
+  end
+
+  class IntegerLiteral < Treetop::Runtime::SyntaxNode
+   def to_value
+      text_value.to_i
+    end
+  end
+
+  class FloatLiteral < Treetop::Runtime::SyntaxNode
+    def to_value
+      text_value.to_f
+    end
+  end
+
+  class BooleanLiteral < Treetop::Runtime::SyntaxNode
+    def to_value
+      text_value == 'true'
+    end
+  end
+
+  class StringLiteral < Treetop::Runtime::SyntaxNode
+
+    private
+
+    @@unescape = {
+      '\b' => "\b",
+      '\t' => "\t",
+      '\n' => "\n",
+      '\\' => "\\",
+      '\f' => "\f",
+      '\r' => "\r",
+      '\"' => "\"",
+      '\/' => "\/"
+    }
+
+    public
+
+    def to_value
+      elem = string.text_value
+      # Unescape unicode characters of the form \uXXXX
+      # Pack the XXXX string as hexadecimal ---> Unpack to array of integers
+      # ---> Pack back into unicode
+      elem.gsub!(/\\u([\da-fA-F]{4})/) {|m| [$1].pack("H*").unpack("n*").pack("U*")}
+      # Unescape known escape characters
+      elem.gsub!(/(\\[btn\\fr"\/])/) {|m| @@unescape[m]}
+      elem
+    end
+  end
+
+  class DateLiteral < Treetop::Runtime::SyntaxNode
+    def to_value
+      args = [year, month, day, hour, min, sec].map(&:text_value).map(&:to_i)
+      DateTime.new(*args)
+    end
+  end
+
+end
+end

data/lib/ptolemy/parser.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require 'treetop'
+
+require 'ptolemy/nodes'
+require 'ptolemy/exceptions'
+
+module Ptolemy
+
+  class Parser
+
+    # Load TOML grammar into Treetop
+    base_path = File.expand_path File.dirname(__FILE__)
+    Treetop.load File.join(base_path, 'toml.tt')
+
+    # Treetop would've generated a parser for TOML based on the grammar
+    @@parser = TOMLParser.new
+
+    def self.parse data
+      # Data should be a valid UTF-8 encoded string.
+      if data.encoding != Encoding::UTF_8
+        raise ParseError, "Input is not UTF-8 encoded"
+      end
+      unless data.valid_encoding?
+        raise ParseError, "Input contains invalid UTF-8 byte sequence"
+      end
+
+      tree = @@parser.parse data
+
+      if tree.nil?
+        raise ParseError, "Parse error at offset: #{@@parser.index}"
+      end
+
+      tree.to_value
+    end
+
+  end
+
+end

data/lib/ptolemy/toml.tt

@@ -0,0 +1,73 @@
+module Ptolemy
+
+grammar TOML
+
+  rule toml
+    list:((separator* elem:(key_group / key_value))*) separator* <Toml>
+  end
+
+  rule key_group
+    '[' keys:(key remaining_keys:('.' key)*) ']' <KeyGroup>
+  end
+
+  rule key_value
+    key space? '=' space? value <KeyValue>
+  end
+
+  rule key
+    [a-zA-Z_] [a-zA-Z0-9_?#!]* <Key>
+  end
+
+  rule value
+    (boolean / date / float / integer / string / array)
+  end
+
+  rule separator
+    comment / space / newline
+  end
+
+  rule newline
+    "\n" / "\r\n"
+  end
+
+  rule comment
+    '#' (!newline .)* <Comment>
+  end
+
+  rule array
+    '[' list:(separator* item:string separator* ',')* separator* last:(separator* item:string separator*)? ']' <ArrayLiteral> /
+    '[' list:(separator* item:date separator* ',')* separator* last:(separator* item:date separator*)? ']' <ArrayLiteral> /
+    '[' list:(separator* item:float separator* ',')* separator* last:(separator* item:float separator*)? ']' <ArrayLiteral> /
+    '[' list:(separator* item:integer separator* ',')* separator* last:(separator* item:integer separator*)? ']' <ArrayLiteral> /
+    '[' list:(separator* item:boolean separator* ',')* separator* last:(separator* item:boolean separator*)? ']' <ArrayLiteral> /
+    '[' list:(separator* item:array separator* ',')* separator* last:(separator* item:array separator*)? ']' <ArrayLiteral>
+  end
+
+  rule string
+    '"' string:([^"\\] / "\\" . )* '"' <StringLiteral>
+  end
+
+  rule date
+    year:([0-9] 4..4) '-' month:([0-9] 2..2) '-' day:([0-9] 2..2)
+    'T' hour:([0-9] 2..2) ':' min:([0-9] 2..2) ':' sec:([0-9] 2..2) 'Z' <DateLiteral>
+  end
+
+  rule float
+    ('+' / '-')? [0-9]+ ('.' [0-9]+) <FloatLiteral>
+  end
+
+  rule integer
+    ('+' / '-')? [0-9]+ <IntegerLiteral>
+  end
+
+  rule boolean
+    ('true' <BooleanLiteral> / 'false' <BooleanLiteral>)
+  end
+
+  rule space
+    [ \t]+
+  end
+
+end
+
+end

data/lib/ptolemy/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+
+module Ptolemy
+  VERSION = "0.0.1"
+end

data/lib/ptolemy.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require "ptolemy/version"
+require "ptolemy/parser"
+
+module Ptolemy
+
+  def self.parse data
+    Parser.parse data
+  end
+
+  def self.parse_file filename
+    File.open filename, 'r:utf-8' do |file|
+      # TODO: Should the check for valid UTF-8 be done over here?
+      return Parser.parse file.read
+    end
+  end
+
+end

data/ptolemy.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ptolemy/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Natansh Verma"]
+  gem.email         = ["natansh.verma@gmail.com"]
+  gem.description   = %q{Ptolemy is a TOML parser.}
+  gem.summary       = %q{Ptolemy is a TOML parser.}
+  gem.homepage      = "http://www.github.com/natansh/ptolemy"
+
+  gem.files         = `git ls-files`.split($\) - %w(.gitignore ptolemy.jpg)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "ptolemy"
+  gem.require_paths = ["lib"]
+  gem.version       = Ptolemy::VERSION
+
+  gem.required_ruby_version = ">= 1.9.3"
+
+  gem.add_dependency "treetop"
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "guard"
+  gem.add_development_dependency "guard-rspec"
+end

data/spec/example.toml

@@ -0,0 +1,36 @@
+# By Tom Preston-Werner (@mojombo)
+# This is a TOML document. Boom.
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+organization = "GitHub"
+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+  # You can indent as you please. Tabs or spaces. TOML don't care.
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ]
+
+# Line breaks are OK when inside arrays
+hosts = [
+  "alpha",
+  "omega"
+]

data/spec/hard_example.toml

@@ -0,0 +1,21 @@
+# Test file for TOML
+# Only this one tries to emulate a TOML file written by a user of the kind of parser writers probably hate
+# This part you'll really hate
+
+[the]
+test_string = "You'll hate me after this - #"          # " Annoying, isn't it?
+
+    [the.hard]
+    test_array = [ "] ", " # "]      # ] There you go, parse this!
+    test_array2 = [ "Test #11 ]proved that", "Experiment #9 was a success" ]
+    # You didn't think it'd as easy as chucking out the last #, did you?
+    another_test_string = " Same thing, but with a string #"
+    harder_test_string = " And when \"'s are in the string, along with # \""   # "and comments are there too"
+    # Things will get harder
+    
+        [the.hard.bit#]
+        what? = "You don't think some user won't do that?"
+        multi_line_array = [
+            "]",
+            # ] Oh yes I did
+            ]

data/spec/parser_spec.rb

@@ -0,0 +1,122 @@
+# encoding: UTF-8
+
+require_relative 'spec_helper'
+
+describe Ptolemy::Parser do
+
+  describe "#parse" do
+    describe 'Valid TOML input' do
+      it 'should parse TOML specification file' do
+        filename = 'example.toml'
+        path = File.expand_path(File.join(File.dirname(__FILE__), filename))
+        result = Ptolemy.parse_file(path)
+
+        result['title'].should eql('TOML Example')
+
+        owner = result['owner']
+        owner.should be_a_kind_of(Hash)
+        owner.should eql({
+          'name' => 'Tom Preston-Werner',
+          'organization' => 'GitHub',
+          'bio' => "GitHub Cofounder & CEO\nLikes tater tots and beer.",
+          # Test for Dates
+          'dob' => DateTime.parse('1979-05-27T07:32:00Z')
+        })
+
+        database = result['database']
+        database.should be_a_kind_of(Hash)
+        database['ports'].should be_a_kind_of(Array)
+        database.should eql({
+          'server' => "192.168.1.1",
+          'ports' => [ 8001, 8001, 8002 ],
+          'connection_max' => 5000,
+          'enabled' => true
+        })
+
+        servers = result['servers']
+        servers.should be_a_kind_of(Hash)
+        servers.keys.sort!.should eql ['alpha', 'beta']
+
+        alpha = servers['alpha']
+        alpha.should be_a_kind_of(Hash)
+
+        beta = servers['beta']
+        beta.should be_a_kind_of(Hash)
+
+        clients = result['clients']
+        clients['data'].should eql([["gamma", "delta"], [1, 2]])
+
+        hosts = clients['hosts']
+        hosts.should eql(["alpha", "omega"])
+      end
+
+      it 'should parse hard TOML example file' do
+        filename = 'hard_example.toml'
+        path = File.expand_path(File.join(File.dirname(__FILE__), filename))
+        result = Ptolemy.parse_file(path)
+
+        the = result['the']
+        the.should be_a_kind_of(Hash)
+        the['test_string'].should eql("You'll hate me after this - #")
+        hard = the['hard']
+        hard['test_array'].should eql(["] ", " # "])
+        hard['test_array2'].should eql([ "Test #11 ]proved that",
+                                        "Experiment #9 was a success" ])
+        hard['another_test_string'].should eql(" Same thing, but with a string #")
+        hard['harder_test_string'].should eql(
+          " And when \"'s are in the string, along with # \"")
+
+        bit = hard['bit#']
+        bit.should be_a_kind_of(Hash)
+        bit['what?'].should eql("You don't think some user won't do that?")
+        bit['multi_line_array'].should eql([ "]"])
+      end
+    end
+
+    describe 'Invalid TOML input' do
+      it 'should give error if anything other than tabs/space/nl/comment'\
+        'is present after key group on line' do
+        input = "[error]   if you didn't catch this, your parser is broken"
+        expect{Ptolemy.parse(input)}.to raise_error(Ptolemy::ParseError)
+      end
+
+      it 'should give error if anything other than tabs/space/nl/comment'\
+        'is present after key value pair on line' do
+        input = 'string = "Hello World!" Have fun'
+        expect{Ptolemy.parse(input)}.to raise_error(Ptolemy::ParseError)
+        input = "number = 3.14  pi <--again forgot the #"
+        expect{Ptolemy.parse(input)}.to raise_error(Ptolemy::ParseError)
+      end
+
+      it 'should give an error for a malformed multiline array' do
+        input = <<END
+array = [
+         "This might most likely happen in multiline arrays",
+         Like here,
+         "or here,
+         and here"
+]     End of array comment, forgot the #
+END
+        expect{Ptolemy.parse(input)}.to raise_error(Ptolemy::ParseError)
+      end
+    end
+
+    describe 'Encoding' do
+      it 'should give an error if input is not UTF-8 encoded' do
+        input = 'hello = "world"'
+        input.encode!(Encoding::ASCII)
+        input.encoding.name.should eql('US-ASCII')
+        expect{Ptolemy.parse(input)}.to \
+          raise_error(Ptolemy::ParseError, "Input is not UTF-8 encoded")
+      end
+
+      it 'should give an error if input has invalid byte sequence' do
+        input = "hello = 'hi \255'"
+        input.encoding.name.should eql('UTF-8')
+        expect{Ptolemy.parse(input)}.to \
+          raise_error(Ptolemy::ParseError, "Input contains invalid UTF-8 byte sequence")
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'rspec'
+
+require 'ptolemy'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}

data/spec/support/matchers/have_value.rb

@@ -0,0 +1,18 @@
+RSpec::Matchers.define :have_value do |expected|
+  match do |actual|
+    actual.respond_to?(:to_value) && actual.to_value == expected
+  end
+
+  failure_message_for_should do |actual|
+    "Expected that #{actual.class}(text value: #{actual.text_value}, value: #{actual.to_value}) should have value #{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "Expected that #{actual.class}(text value: #{actual.text_value}, value: #{actual.to_value}) should not have value #{expected}"
+  end
+
+  description do
+    "have the value #{expected}"
+  end
+end
+

data/spec/toml_parser_spec.rb

@@ -0,0 +1,235 @@
+# encoding: UTF-8
+
+require_relative 'spec_helper'
+
+describe Ptolemy::TOMLParser do
+
+  before :all do
+    @parser = Ptolemy::TOMLParser.new
+  end
+
+  describe 'Literals' do
+    describe 'String' do
+      it 'should parse an empty string' do
+        result = @parser.parse('""', root: :string)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::StringLiteral)
+        result.should have_value("")
+      end
+
+      it 'should parse a simple string' do
+        result = @parser.parse('"This is a string"', root: :string)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::StringLiteral)
+        result.should have_value("This is a string")
+      end
+
+      it 'should parse a string having escaped characters' do
+        result = @parser.parse('"This is an \n\t \bescaped string."', root: :string)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::StringLiteral)
+        result.should have_value("This is an \n\t \bescaped string.")
+      end
+
+      it 'should parse a string having unicode symbols' do
+        result = @parser.parse('"This is a string containing úƞĩƈōƌě symbols."', root: :string)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::StringLiteral)
+        result.should have_value( "This is a string containing úƞĩƈōƌě symbols.")
+      end
+
+      it 'should parse a string having escaped unicode characters' do
+        result = @parser.parse('"This is a unicode string containing linefeed as \u000A."', root: :string)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::StringLiteral)
+        result.should have_value( "This is a unicode string containing linefeed as \n.")
+      end
+
+      it 'should not parse a string with single quotes' do
+        result = @parser.parse("'Hello World!'", root: :string)
+        result.should be_nil
+      end
+    end
+
+    it 'should parse a correct float' do
+      ['-0.0', '1.4', '123.2', '+1.1', '+123.9' ].each do |float|
+        result = @parser.parse(float, root: :float)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::FloatLiteral)
+        result.should have_value(float.to_f)
+      end
+    end
+
+    it 'should parse a correct integers' do
+      ['-1', '1', '123', '+1', '+123' ].each do |integer|
+        result = @parser.parse(integer, root: :integer)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::IntegerLiteral)
+        result.should have_value(integer.to_i)
+      end
+    end
+
+    it 'should parse a correct boolean' do
+      ['true', 'false' ].each do |boolean|
+        result = @parser.parse(boolean, root: :boolean)
+        result.should_not be_nil
+        result.should be_a_kind_of(Ptolemy::TOML::BooleanLiteral)
+        result.should have_value((boolean == 'true'))
+      end
+    end
+
+    it 'should parse a correct date' do
+      result = @parser.parse('1979-05-27T07:32:00Z', root: :date)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::DateLiteral)
+      result.should have_value(DateTime.new(1979, 5, 27, 7, 32, 0))
+    end
+
+    it 'should not parse an incorrect date' do
+      result = @parser.parse('1979-05-27T07:32:00', root: :date)
+      result.should be_nil
+    end
+  end
+
+  describe 'Array' do
+    it 'should parse a simple array' do
+      array_string = '[1, 2, 3]'
+      result = @parser.parse(array_string, root: :array)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::ArrayLiteral)
+      result.should have_value([1, 2, 3])
+    end
+
+    it 'should parse a complex multi-line array' do
+        array_string = <<AS_END
+[ # Evil, must say
+1,
+
+     2        ,
+# Wait, you can put comments anywhere?
+
+4 ,
+# What the... is this right?
+]
+AS_END
+      array_string.chomp! #Heredoc introduces a newline at the end
+
+      result = @parser.parse(array_string, root: :array)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::ArrayLiteral)
+      result.should have_value([1, 2, 4])
+    end
+
+    it 'should parse a nested array' do
+      array_string = <<AS_END
+[
+  [1, 2,
+  # Nested comment, yeah!
+  3 ],
+  ["hello", "world"
+    # Now this is a doozy!
+  ]
+]
+AS_END
+      array_string.chomp! #Heredoc introduces a newline at the end
+
+      result = @parser.parse(array_string, root: :array)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::ArrayLiteral)
+      result.should have_value([[1, 2, 3], ["hello", "world"]])
+    end
+  end
+
+  describe 'comment' do
+    it 'should parse a correct comment' do
+      result = @parser.parse('# This is a comment', root: :comment)
+      result.should_not be_nil
+      result.text_value.should eql '# This is a comment'
+      result.should be_a_kind_of(Ptolemy::TOML::Comment)
+    end
+  end
+
+  describe 'Constructs' do
+    it 'should parse a key' do
+      result = @parser.parse('hello', root: :key)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::Key)
+    end
+
+    it 'should parse a value' do
+      examples = {
+        '"hello"' => [Ptolemy::TOML::StringLiteral, 'hello'],
+        '-1.0' => [Ptolemy::TOML::FloatLiteral, -1.0],
+        '1' => [Ptolemy::TOML::IntegerLiteral, 1],
+        'true' => [Ptolemy::TOML::BooleanLiteral, true],
+        '1979-05-27T07:32:00Z' => [Ptolemy::TOML::DateLiteral, DateTime.new(1979, 5, 27, 7, 32, 0)]
+      }
+
+      examples.each do |input, details|
+        klass, value = details
+        result = @parser.parse(input, root: :value)
+        result.should_not be_nil
+        result.should be_a_kind_of(klass)
+        result.should have_value(value)
+      end
+    end
+
+    it 'should parse a correct key value' do
+      examples = {
+        'string' => '"Hello"',
+        'date' => '1979-05-27T07:32:00Z',
+        'integer' => '114',
+        'float' => '1.0'
+      }
+      examples.each do |key, value|
+        result = @parser.parse("#{key} =    \t #{value}", root: :key_value)
+        result.should_not be_nil
+        result.key.text_value.should eql key
+        result.value.text_value.should eql value
+        result.should be_a_kind_of(Ptolemy::TOML::KeyValue)
+        result.should respond_to(:to_value)
+        result.to_value[0].should eql key
+      end
+    end
+
+    it 'should parse a correct key group' do
+      result = @parser.parse('[key.hello.while]', root: :key_group)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::KeyGroup)
+      result.should have_value(['key', 'hello', 'while'])
+    end
+
+    it 'should not parse a key group having empty key' do
+      result = @parser.parse('[key..while]', root: :key_group)
+      result.should be_nil
+    end
+
+    it 'should parse valid toml' do
+      toml_string = <<TS_END
+description = "This is valid TOML."
+[personal.details]
+name = "John Doe"
+height = 186
+date_of_birth = 1990-04-12T05:30:00Z
+favorites = ["sports", "gaming"]
+TS_END
+      result = @parser.parse(toml_string)
+      result.should_not be_nil
+      result.should be_a_kind_of(Ptolemy::TOML::Toml)
+      result.should respond_to(:to_value)
+
+      toml = result.to_value
+      toml['description'].should eql('This is valid TOML.')
+      toml['personal'].should be_a_kind_of(Hash)
+      details = toml['personal']['details']
+      details.should_not be_nil
+      details.should be_a_kind_of(Hash)
+      details['name'].should eql('John Doe')
+      details['height'].should eql(186)
+      details['date_of_birth'].should eql(DateTime.new(1990, 4, 12, 5, 30, 0))
+      details['favorites'].should be_a_kind_of(Array)
+      details['favorites'].should eql(["sports", "gaming"])
+    end
+  end
+
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: ptolemy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Natansh Verma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ptolemy is a TOML parser.
+email:
+- natansh.verma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/ptolemy.rb
+- lib/ptolemy/exceptions.rb
+- lib/ptolemy/nodes.rb
+- lib/ptolemy/parser.rb
+- lib/ptolemy/toml.tt
+- lib/ptolemy/version.rb
+- ptolemy.gemspec
+- spec/example.toml
+- spec/hard_example.toml
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/have_value.rb
+- spec/toml_parser_spec.rb
+homepage: http://www.github.com/natansh/ptolemy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1717741281203789886
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ptolemy is a TOML parser.
+test_files:
+- spec/example.toml
+- spec/hard_example.toml
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers/have_value.rb
+- spec/toml_parser_spec.rb