edn 0.0.0 → 0.9.0

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.rspec
 README.html
 Gemfile.lock
 InstalledFiles

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Clinton R. Nixon
+Copyright (c) 2012 Relevance Inc & Clinton N. Dreisbach
 
 MIT License
 
@@ -19,4 +19,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,5 +1,7 @@
 # edn-ruby
 
+© 2012 Relevance Inc and Clinton N. Dreisbach
+
 **edn-ruby** is a Ruby library to read and write [edn][edn] (extensible data notation), a subset of Clojure used for transferring data between applications, much like JSON, YAML, or XML.
 
 ## Installation
@@ -21,7 +23,7 @@ Or install it yourself as:
 To read a string of **edn**:
 
 ```ruby
-EDN.read("[1 2 {:foo \"bar\"}]")
+EDN.read('[1 2 {:foo "bar"}]')
 ```
 
 To convert a data structure to an **edn** string:
@@ -32,6 +34,20 @@ data.to_edn
 
 By default, this will work for strings, symbols, numbers, arrays, hashes, sets, nil, Time, and boolean values.
 
+### Value Translations
+
+**edn** has some different terminology, and some types that do not map cleanly to Ruby.
+
+**NOTE**: Comments requested on the following.
+
+In **edn**, you have _keywords_, which look like Ruby symbols and have the same meaning and purpose. These are converted to Ruby symbols. 
+
+You have **edn** _symbols_, which generally reflect variable names, but have several purposes. We parse these and return `EDN::Type::Symbol` values for them, as they are not directly portable into Ruby. 
+
+You have _vectors_, which map to Ruby arrays, and _lists_, which are linked lists in Clojure. We map these to `EDN::Type::List` values, which are type-compatible with arrays.
+
+**edn** has character types, but Ruby does not. These are converted into one-character strings.
+
 ### Tagged Values
 
 The interesting part of **edn** is the _extensible_ part. Data can be be _tagged_ to coerce interpretation of it to a particular data type. An example of a tagged data element:
@@ -44,9 +60,9 @@ The tag (`#wolf/pack`) will tell any consumers of this data to use a data type r
 
 The rules for tags from the [**edn** README][README] should be followed. In short, custom tags should have a prefix (the part before the `/`) designating the user that created them or context they are used in. Non-prefixed tags are reserved for built-in tags.
 
-There are two tags built in by default: `#uuid`, used for UUIDs, and `#inst`, used for an instant in time. In `edn-ruby`, `#inst` is converted to a Time, and Time values are tagged as `#inst`. There is not a UUID data type built into Ruby, so `#uuid` is converted to a string, but if you require `edn/uuid`, `#uuid` values are converted to an instance of `EDN::UUID`.
+There are two tags built in by default: `#uuid`, used for UUIDs, and `#inst`, used for an instant in time. In `edn-ruby`, `#inst` is converted to a Time, and Time values are tagged as `#inst`. There is not a UUID data type built into Ruby, so `#uuid` is converted to an instance of `EDN::Type::UUID`.
 
-Tags that are not registered are converted as their base data type and a warning will be shown.
+Tags that are not registered generate a struct of the type `EDN::Type::Unknown` with the methods `tag` and `value`.
 
 ### Registering a New Tag For Reading
 
@@ -106,6 +122,5 @@ This method calls `.to_edn` on the second argument and joins the arguments appro
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-
 [edn]: https://github.com/richhickey/edn
 [README]: https://github.com/richhickey/edn/blob/master/README.md

data/Rakefile

@@ -1,2 +1,7 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/edn.gemspec

@@ -14,4 +14,9 @@ Gem::Specification.new do |gem|
   gem.name          = "edn"
   gem.require_paths = ["lib"]
   gem.version       = EDN::VERSION
+
+  gem.add_dependency 'parslet'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rantly'
 end

data/lib/edn.rb

@@ -1,5 +1,54 @@
+$:.push(File.dirname(__FILE__))
 require "edn/version"
+require "edn/core_ext"
+require "edn/parser"
+require "edn/transform"
 
 module EDN
-  # Your code goes here...
+  @parser = EDN::Parser.new
+  @transform = EDN::Transform.new
+  @tags = Hash.new
+
+  def self.read(edn)
+    @transform.apply(@parser.parse(edn))
+  end
+
+  def self.register(tag, func = nil, &block)
+    if block_given?
+      func = block
+    end
+
+    raise "EDN.register requires a block or callable." if func.nil?
+
+    if func.is_a?(Class)
+      @tags[tag] = lambda { |*args| func.new(*args) }
+    else
+      @tags[tag] = func
+    end
+  end
+
+  def self.unregister(tag)
+    @tags[tag] = nil
+  end
+
+  def self.tag_value(tag, value)
+    func = @tags[tag]
+    if func
+      func.call(value)
+    else
+      EDN::Type::Unknown.new(tag, value)
+    end
+  end
+
+  def self.tagout(tag, value)
+    ["##{tag}", value.to_edn].join(" ")
+  end
+end
+
+EDN.register("inst") do |value|
+  Time.parse(value)
+end
+
+EDN.register("uuid") do |value|
+  EDN::Type::UUID.new(value)
 end

data/lib/edn/core_ext.rb

@@ -0,0 +1,64 @@
+require 'time'
+
+module EDN
+  module CoreExt
+    module Unquoted
+      def to_edn
+        self.to_s
+      end
+    end
+
+    module String
+      def to_edn
+        self.inspect
+      end
+    end
+
+    module Symbol
+      def to_edn
+        ":#{self.to_s}"
+      end
+    end
+
+    module Array
+      def to_edn
+        '[' + self.map(&:to_edn).join(" ") + ']'
+      end
+    end
+
+    module Hash
+      def to_edn
+        '{' + self.map { |k, v| [k, v].map(&:to_edn).join(" ") }.join(", ") + '}'
+      end
+    end
+
+    module Set
+      def to_edn
+        '#{' + self.to_a.map(&:to_edn).join(" ") + '}'
+      end
+    end
+
+    module NilClass
+      def to_edn
+        "nil"
+      end
+    end
+
+    module Time
+      def to_edn
+        EDN.tagout("inst", self.xmlschema)
+      end
+    end
+  end
+end
+
+Numeric.send(:include, EDN::CoreExt::Unquoted)
+TrueClass.send(:include, EDN::CoreExt::Unquoted)
+FalseClass.send(:include, EDN::CoreExt::Unquoted)
+NilClass.send(:include, EDN::CoreExt::NilClass)
+String.send(:include, EDN::CoreExt::String)
+Symbol.send(:include, EDN::CoreExt::Symbol)
+Array.send(:include, EDN::CoreExt::Array)
+Hash.send(:include, EDN::CoreExt::Hash)
+Set.send(:include, EDN::CoreExt::Set)
+Time.send(:include, EDN::CoreExt::Time)

data/lib/edn/parser.rb

@@ -0,0 +1,140 @@
+require 'parslet'
+
+module EDN
+  class Parser < Parslet::Parser
+    root(:top)
+
+    rule(:top) {
+      space? >> value >> space?
+    }
+
+    rule(:value) {
+      tagged_value | base_value
+    }
+
+    rule(:base_value) {
+      vector |
+      list |
+      set |
+      map |
+      boolean |
+      str('nil').as(:nil) |
+      keyword |
+      string |
+      character |
+      float |
+      integer |
+      symbol
+    }
+
+    rule(:tagged_value) {
+      (tag >> space >> base_value.as(:value)).as(:tagged_value)
+    }
+
+    # Collections
+
+    rule(:vector) {
+      str('[') >>
+      top.repeat.as(:vector) >>
+      space? >>
+      str(']')
+    }
+
+    rule(:list) {
+      str('(') >>
+      top.repeat.as(:list) >>
+      space? >>
+      str(')')
+    }
+
+    rule(:set) {
+      str('#{') >>
+      top.repeat.as(:set) >>
+      space? >>
+      str('}')
+    }
+
+    rule(:map) {
+      str('{') >>
+      (top.as(:key) >> top.as(:value)).repeat.as(:map) >>
+      space? >>
+      str('}')
+    }
+
+    # Primitives
+
+    rule(:integer) {
+      (str('-').maybe >>
+       (str('0') | match('[1-9]') >> digit.repeat)).as(:integer) >>
+      str('N').maybe
+    }
+
+    rule(:float) {
+      (str('-').maybe >>
+       (str('0') | (match('[1-9]') >> digit.repeat)) >>
+       str('.') >> digit.repeat(1) >>
+       (match('[eE]') >> match('[\-+]').maybe >> digit.repeat).maybe).as(:float) >>
+      str('M').maybe
+    }
+
+    rule(:string) {
+      str('"') >>
+      (str('\\') >> any | str('"').absent? >> any).repeat.as(:string) >>
+      str('"')
+    }
+
+    rule(:character) {
+      str("\\") >>
+      (str('newline') | str('space') | str('tab') |
+       match['[:graph:]']).as(:character)
+    }
+
+    rule(:keyword) {
+      str(':') >> symbol.as(:keyword)
+    }
+
+    rule(:symbol) {
+      (symbol_chars >> (str('/') >> symbol_chars).maybe |
+       str('/')).as(:symbol)
+    }
+
+    rule(:boolean) {
+      str('true').as(:true) | str('false').as(:false)
+    }
+
+    # Parts
+
+    rule(:tag) {
+      (str('#') >> symbol).as(:tag)
+    }
+
+    rule(:symbol_chars) {
+      (symbol_first_char >>
+       valid_chars.repeat) |
+      match['\-\.']
+    }
+
+    rule(:symbol_first_char) {
+      (match['\-\.'] >> match['0-9'].absent? |
+       match['\#\:0-9'].absent?) >> valid_chars
+    }
+
+    rule(:valid_chars) {
+      match['[:alnum:]'] | sym_punct
+    }
+
+    rule(:sym_punct) {
+      match['\.\*\+\!\-\?\:\#\_']
+    }
+
+    rule(:digit) {
+      match['0-9']
+    }
+
+    rule(:space) {
+      match('[\s,]').repeat(1)
+    }
+
+    rule(:space?) { space.maybe }
+  end
+end

data/lib/edn/string_transformer.rb

@@ -0,0 +1,46 @@
+module EDN
+  module StringTransformer
+    # Unescape characters in strings.
+    # Borrowed from json-pure gem.
+    UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+    UNESCAPE_MAP.update({ ?"  => '"',
+                          ?\\ => '\\',
+                          ?/  => '/',
+                          #' Clear messed up syntax highlighting with Emacs.
+                          ?b  => "\b",
+                          ?f  => "\f",
+                          ?n  => "\n",
+                          ?r  => "\r",
+                          ?t  => "\t",
+                          ?u  => nil,
+                        })
+
+    EMPTY_8BIT_STRING = ''
+    if ::String.method_defined?(:encode)
+      EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+    end
+
+    def self.parse_string(string)
+      string = string.to_s
+      return '' if string.empty?
+      string = string.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+        #" Clear messed up syntax highlighting with Emacs.
+        if u = UNESCAPE_MAP[$&[1]]
+          u
+        else # \uXXXX
+          bytes = EMPTY_8BIT_STRING.dup
+          i = 0
+          while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
+            bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
+            i += 1
+          end
+          JSON.iconv('utf-8', 'utf-16be', bytes)
+        end
+      end
+      if string.respond_to?(:force_encoding)
+        string.force_encoding(::Encoding::UTF_8)
+      end
+      string
+    end
+  end
+end

data/lib/edn/transform.rb

@@ -0,0 +1,34 @@
+require 'edn/string_transformer'
+require 'edn/types'
+
+module EDN
+  class Transform < Parslet::Transform
+    rule(:true => simple(:x)) { true }
+    rule(:false => simple(:x)) { false }
+    rule(:nil => simple(:x)) { nil }
+
+    rule(:integer => simple(:x)) { Integer(x) }
+    rule(:float => simple(:x)) { Float(x) }
+
+    rule(:string => simple(:x)) { EDN::StringTransformer.parse_string(x) }
+    rule(:keyword => simple(:x)) { x.to_sym }
+    rule(:symbol => simple(:x)) { EDN::Type::Symbol.new(x) }
+    rule(:character => simple(:x)) {
+      case x
+      when "newline" then "\n"
+      when "tab" then "\t"
+      when "space" then " "
+      else x.to_s
+      end
+    }
+
+    rule(:vector => subtree(:array)) { array }
+    rule(:list => subtree(:array)) { EDN::Type::List.new(*array) }
+    rule(:set => subtree(:array)) { Set.new(array) }
+    rule(:map => subtree(:array)) { Hash[array.map { |hash| [hash[:key], hash[:value]] }] }
+
+    rule(:tagged_value => subtree(:x)) {
+      EDN.tag_value(x[:tag].to_s, x[:value])
+    }
+  end
+end

data/lib/edn/type/list.rb

@@ -0,0 +1,13 @@
+module EDN
+  module Type
+    class List < ::Array
+      def self.new(*values)
+        self.[](*values)
+      end
+
+      def to_edn
+        '(' + self.map(&:to_edn).join(" ") + ')'
+      end
+    end
+  end
+end

data/lib/edn/type/symbol.rb

@@ -0,0 +1,37 @@
+module EDN
+  module Type
+    class Symbol
+      attr_reader :symbol
+
+      def initialize(sym)
+        @symbol = sym.to_sym
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Symbol)
+        to_sym == other.to_sym
+      end
+
+      def eql?(other)
+        return false unless other.is_a?(Symbol)
+        to_sym == other.to_sym
+      end
+
+      def hash
+        @symbol.hash
+      end
+
+      def to_sym
+        @symbol
+      end
+
+      def to_s
+        @symbol.to_s
+      end
+
+      def to_edn
+        @symbol.to_s
+      end
+    end
+  end
+end

data/lib/edn/type/unknown.rb

@@ -0,0 +1,9 @@
+module EDN
+  module Type
+    class Unknown < Struct.new(:tag, :value)
+      def to_edn
+        EDN.tagout(tag, value)
+      end
+    end
+  end
+end

data/lib/edn/type/uuid.rb

@@ -0,0 +1,9 @@
+module EDN
+  module Type
+    class UUID < String
+      def to_edn
+        "#uuid #{self.inspect}"
+      end
+    end
+  end
+end

data/lib/edn/types.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), 'type', '*.rb')].each do |file|
+  require file
+end

data/lib/edn/version.rb

@@ -1,3 +1,3 @@
 module EDN
-  VERSION = "0.0.0"
+  VERSION = "0.9.0"
 end

data/spec/edn/parser_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe EDN::Parser do
+  include RantlyHelpers
+
+  let(:parser) { EDN::Parser.new }
+
+  context "value" do
+    it "should consume nil" do
+      parser.value.should parse("nil")
+    end
+  end
+
+  context "boolean" do
+    it "should consume true" do
+      parser.boolean.should parse("true")
+    end
+
+    it "should consume false" do
+      parser.boolean.should parse("false")
+    end
+  end
+
+  context "integer" do
+    it "should consume integers" do
+      rant(RantlyHelpers::INTEGER).each do |int|
+        parser.integer.should parse(int)
+      end
+    end
+  end
+
+  context "float" do
+    it "should consume simple floats" do
+      rant(RantlyHelpers::FLOAT).each do |float|
+        parser.float.should parse(float)
+      end
+    end
+
+    it "should consume floats with exponents" do
+      rant(RantlyHelpers::FLOAT_WITH_EXP).each do |float|
+        parser.float.should parse(float)
+      end
+    end
+  end
+
+  context "symbol" do
+    it "should consume any symbols" do
+      rant(RantlyHelpers::SYMBOL).each do |symbol|
+        parser.symbol.should parse("#{symbol}")
+      end
+    end
+
+    context "special cases" do
+      it "should consume '/'" do
+        parser.symbol.should parse('/')
+      end
+
+      it "should consume '.'" do
+        parser.symbol.should parse('.')
+      end
+
+      it "should consume '-'" do
+        parser.symbol.should parse('-')
+      end
+    end
+  end
+
+  context "keyword" do
+    it "should consume any keywords" do
+      rant(RantlyHelpers::SYMBOL).each do |symbol|
+        parser.keyword.should parse(":#{symbol}")
+      end
+    end
+  end
+
+  context "tag" do
+    it "should consume any tags" do
+      rant(RantlyHelpers::SYMBOL).each do |symbol|
+        parser.tag.should parse("##{symbol}")
+      end
+    end
+  end
+
+  context "string" do
+    it "should consume any string" do
+      rant(RantlyHelpers::STRING).each do |string|
+        parser.string.should parse(string)
+      end
+    end
+  end
+
+  context "character" do
+    it "should consume any character" do
+      rant(RantlyHelpers::CHARACTER).each do |char|
+        parser.character.should parse(char)
+      end
+    end
+  end
+
+  context "vector" do
+    it "should consume an empty vector" do
+      parser.vector.should parse('[]')
+      parser.vector.should parse('[  ]')
+    end
+
+    it "should consume vectors of mixed elements" do
+      rant(RantlyHelpers::VECTOR).each do |vector|
+        parser.vector.should parse(vector)
+      end
+    end
+  end
+
+  context "list" do
+    it "should consume an empty list" do
+      parser.list.should parse('()')
+      parser.list.should parse('( )')
+    end
+
+    it "should consume lists of mixed elements" do
+      rant(RantlyHelpers::LIST).each do |list|
+        parser.list.should parse(list)
+      end
+    end
+  end
+
+  context "set" do
+    it "should consume an empty set" do
+      parser.set.parse_with_debug('#{}')
+      parser.set.should parse('#{}')
+      parser.set.should parse('#{ }')
+    end
+
+    it "should consume sets of mixed elements" do
+      rant(RantlyHelpers::SET).each do |set|
+        parser.set.should parse(set)
+      end
+    end
+  end
+
+  context "map" do
+    it "should consume an empty map" do
+      parser.map.should parse('{}')
+      parser.map.should parse('{ }')
+    end
+
+    it "should consume maps of mixed elements" do
+      rant(RantlyHelpers::MAP).each do |map|
+        parser.map.should parse(map)
+      end
+    end
+  end
+
+  context "tagged value" do
+    it "should consume tagged values" do
+      rant(RantlyHelpers::TAGGED_VALUE).each do |value|
+        parser.tagged_value.should parse(value)
+      end
+    end
+  end
+end

data/spec/edn/transform_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe EDN::Transform do
+  context "integer" do
+    it "should emit an integer" do
+      subject.apply(:integer => "1").should == 1
+    end
+  end
+
+  context "float" do
+    it "should emit an float" do
+      subject.apply(:float => "1.0").should == 1.0
+    end
+  end
+
+  context "string" do
+    it "should emit a string with control characters substituted" do
+      subject.apply(:string => 'hello\nworld').should == "hello\nworld"
+    end
+
+    it "should not evaluate interpolated Ruby code" do
+      subject.apply(:string => 'hello\n#{world}').should == "hello\n\#{world}"
+    end
+  end
+
+  context "keyword" do
+    it "should emit a Ruby symbol" do
+      subject.apply(:keyword => "test").should == :test
+    end
+  end
+
+  context "symbol" do
+    it "should emit an EDN symbol" do
+      subject.apply(:symbol => "test").should == EDN::Type::Symbol.new('test')
+    end
+  end
+
+  context "boolean" do
+    it "should emit true or false" do
+      subject.apply(:true => "true").should == true
+      subject.apply(:false => "false").should == false
+    end
+  end
+
+  context "nil" do
+    it "should emit nil" do
+      subject.apply(:nil => "nil").should == nil
+    end
+  end
+
+  context "character" do
+    it "should emit a string" do
+      subject.apply(:character => "&").should == "&"
+    end
+
+    it "should handle newline, space, and tab special cases" do
+      subject.apply(:character => "newline").should == "\n"
+      subject.apply(:character => "space").should == " "
+      subject.apply(:character => "tab").should == "\t"
+    end
+  end
+
+  context "vector" do
+    it "should emit an array" do
+      subject.apply(:vector => []).should == []
+      subject.apply(:vector => [{:integer => "1"}, {:string => "abc"}]).should == [1, "abc"]
+      subject.apply(:vector => [{:vector => [{:integer => "1"}, {:string => "abc"}]}, {:float => "3.14"}]).should == [[1, "abc"], 3.14]
+    end
+  end
+
+  context "list" do
+    it "should emit a list" do
+      subject.apply(:list => []).should == EDN::Type::List.new
+      subject.apply(:list => [{:integer => "1"}, {:string => "abc"}]).should == EDN::Type::List.new(1, "abc")
+      subject.apply(:list => [{:list => [{:integer => "1"}, {:string => "abc"}]}, {:float => "3.14"}]).should == \
+        EDN::Type::List.new(EDN::Type::List.new(1, "abc"), 3.14)
+    end
+
+    it "should be type-compatible with arrays" do
+      subject.apply(:list => [{:integer => "1"}, {:string => "abc"}]).should == [1, "abc"]
+    end
+  end
+
+  context "set" do
+    it "should emit a set" do
+      subject.apply(:set => []).should == Set.new
+      subject.apply(:set => [1, "abc", 2]).should == Set.new([1, "abc", 2])
+    end
+  end
+
+  context "map" do
+    it "should emit a hash" do
+      map_tree = {:map=>
+        [ {:key=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1"}},
+          {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2"}}
+        ]
+      }
+
+      subject.apply(map_tree).should == {:a => 1, :b => 2}
+    end
+
+    it "should work with nested maps" do
+      map_tree = {:map=>
+        [{:key=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1"}},
+          {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2"}},
+          {:key=>
+            {:map=>
+              [{:key=>{:keyword=>{:symbol=>"c"}}, :value=>{:integer=>"3"}}]},
+            :value=>{:integer=>"4"}}]}
+      subject.apply(map_tree).should == {:a => 1, :b => 2, {:c => 3} => 4}
+    end
+  end
+
+  context "tagged value" do
+    it "should emit a EDN::Type::Unknown if the tag is not registered" do
+      subject.apply(:tagged_value => {
+                      :tag => 'uri', :value => {:string => 'http://google.com'}
+                    }).should == EDN::Type::Unknown.new("uri", "http://google.com")
+    end
+
+    it "should emit the transformed value if the tag is registered" do
+      EDN.register("uri", lambda { |uri| URI(uri) })
+      subject.apply(:tagged_value => {
+                      :tag => 'uri', :value => {:string => 'http://google.com'}
+                    }).should == URI("http://google.com")
+      EDN.unregister("uri") # cleanup
+    end
+  end
+end

data/spec/edn_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe EDN do
+  include RantlyHelpers
+
+  context "#read" do
+    it "reads single values" do
+      EDN.read("1").should == 1
+      EDN.read("3.14").should == 3.14
+      EDN.read('"hello\nworld"').should == "hello\nworld"
+      EDN.read(':hello').should == :hello
+      EDN.read(':hello/world').should == :"hello/world"
+      EDN.read('hello').should == EDN::Type::Symbol.new('hello')
+      EDN.read('hello/world').should == EDN::Type::Symbol.new('hello/world')
+      EDN.read('true').should == true
+      EDN.read('false').should == false
+      EDN.read('nil').should == nil
+      EDN.read('\c').should == "c"
+    end
+
+    it "reads #inst tagged values" do
+      EDN.read('#inst "2012-09-10T16:16:03-04:00"').should == Time.new(2012, 9, 10, 16, 16, 3, '-04:00')
+    end
+
+    it "reads vectors" do
+      EDN.read('[]').should == []
+      EDN.read('[1]').should == [1]
+      EDN.read('["hello" 1 2]').should == ['hello', 1, 2]
+      EDN.read('[[1 [:hi]]]').should == [[1, [:hi]]]
+    end
+
+    it "reads lists" do
+      EDN.read('()').should == []
+      EDN.read('(1)').should == [1]
+      EDN.read('("hello" 1 2)').should == ['hello', 1, 2]
+      EDN.read('((1 (:hi)))').should == [[1, [:hi]]]
+    end
+
+    it "reads maps" do
+      EDN.read('{}').should == {}
+      EDN.read('{:a :b}').should == {:a => :b}
+      EDN.read('{:a 1, :b 2}').should == {:a => 1, :b => 2}
+      EDN.read('{:a {:b :c}}').should == {:a => {:b => :c}}
+    end
+
+    it "reads sets" do
+      EDN.read('#{}').should == Set.new
+      EDN.read('#{1}').should == Set[1]
+      EDN.read('#{1 "abc"}').should == Set[1, "abc"]
+      EDN.read('#{1 #{:abc}}').should == Set[1, Set[:abc]]
+    end
+
+    it "reads any valid value" do
+      values = rant(RantlyHelpers::VALUE)
+      values.each do |value|
+        if value == "nil"
+          EDN.read(value).should be_nil
+        else
+          EDN.read(value).should_not be_nil
+        end
+      end
+    end
+  end
+
+  context "writing" do
+    it "writes any valid value" do
+      values = rant(RantlyHelpers::VALUE)
+      values.each do |value|
+        expect {
+          EDN.read(value).to_edn
+        }.to_not raise_error
+      end
+    end
+
+    it "writes equivalent edn to what it reads" do
+      values = rant(RantlyHelpers::VALUE)
+      values.each do |value|
+        ruby_value = EDN.read(value)
+        ruby_value.should == EDN.read(ruby_value.to_edn)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,108 @@
+require 'rspec'
+require 'edn'
+require 'parslet/rig/rspec'
+require 'parslet/convenience'
+require 'rantly'
+
+REPEAT = (ENV["REPEAT"] || 100).to_i
+
+RSpec.configure do |c|
+  c.fail_fast = true
+end
+
+module RantlyHelpers
+
+  SYMBOL = lambda { |_|
+    branch(PLAIN_SYMBOL, NAMESPACED_SYMBOL)
+  }
+
+  PLAIN_SYMBOL = lambda { |_|
+    sized(range(1, 100)) {
+      s = string(/[[:alnum:]]|[\-\.\.\*\+\!\-\?\:\#\_]/)
+      guard s =~ /^[A-Za-z\-\.\.\*\+\!\-\?\:\#\_]/
+      guard s !~ /^[\-\.][0-9]/
+      guard s !~ /^[\:\#]/
+      s
+    }
+  }
+
+  NAMESPACED_SYMBOL = lambda { |_|
+    [call(PLAIN_SYMBOL), call(PLAIN_SYMBOL)].join("/")
+  }
+
+  INTEGER = lambda { |_| integer.to_s }
+
+  STRING = lambda { |_| sized(range(1, 100)) { string.inspect } }
+
+  FLOAT = lambda { |_| (float * range(-1000, 1000)).to_s }
+
+  FLOAT_WITH_EXP = lambda { |_|
+    # limited range because of Infinity
+    [float, choose("e", "E", "e+", "E+", "e-", "e+"), range(1, 100)].
+    map(&:to_s).
+    join("")
+  }
+
+  CHARACTER = lambda { |_|
+    "\\" +
+    sized(1) {
+      freq([1, [:choose, "newline", "space", "tab"]],
+           [5, [:string, :graph]])
+    }
+  }
+
+  BOOL_OR_NIL = lambda { |_|
+    choose("true", "false", "nil")
+  }
+
+  ARRAY = lambda { |_|
+    array(range(0, 10)) { call(VALUE) }
+  }
+
+  VECTOR = lambda { |_|
+    "[" + call(ARRAY).join(" ") + "]"
+  }
+
+  LIST = lambda { |_|
+    "(" + call(ARRAY).join(" ") + ")"
+  }
+
+  SET = lambda { |_|
+    '#{' + call(ARRAY).join(" ") + '}'
+  }
+
+  MAP = lambda { |_|
+    size = range(0, 10)
+    keys = array(size) { call(VALUE) }
+    values = array(size) { call(VALUE) }
+    arrays = keys.zip(values)
+    '{' + arrays.map { |array| array.join(" ") }.join(", ") + '}'
+  }
+
+  VALUE = lambda { |_|
+    freq([10, BASIC_VALUE],
+         [1, TAGGED_VALUE])
+  }
+
+  BASIC_VALUE = lambda { |_|
+    branch(INTEGER,
+           FLOAT,
+           FLOAT_WITH_EXP,
+           STRING,
+           SYMBOL,
+           CHARACTER,
+           BOOL_OR_NIL,
+           VECTOR,
+           LIST,
+           SET,
+           MAP)
+  }
+
+  TAGGED_VALUE = lambda { |_|
+    "#" + [call(SYMBOL), call(BASIC_VALUE)].join(" ")
+  }
+
+  def rant(fun, count = REPEAT)
+    Rantly(count) { call(fun) }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edn
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,72 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-07 00:00:00.000000000 Z
-dependencies: []
+date: 2012-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  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: pry
+  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: 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: rantly
+  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: ! '''edn implements a reader for Extensible Data Notation by Rich Hickey.'''
 email:
 - clinton@thinkrelevance.com
@@ -25,7 +89,20 @@ files:
 - Rakefile
 - edn.gemspec
 - lib/edn.rb
+- lib/edn/core_ext.rb
+- lib/edn/parser.rb
+- lib/edn/string_transformer.rb
+- lib/edn/transform.rb
+- lib/edn/type/list.rb
+- lib/edn/type/symbol.rb
+- lib/edn/type/unknown.rb
+- lib/edn/type/uuid.rb
+- lib/edn/types.rb
 - lib/edn/version.rb
+- spec/edn/parser_spec.rb
+- spec/edn/transform_spec.rb
+- spec/edn_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -50,4 +127,8 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: ! '''edn implements a reader for Extensible Data Notation by Rich Hickey.'''
-test_files: []
+test_files:
+- spec/edn/parser_spec.rb
+- spec/edn/transform_spec.rb
+- spec/edn_spec.rb
+- spec/spec_helper.rb