edn 0.9.4 → 1.0.0

data/README.md

@@ -34,6 +34,27 @@ data.to_edn
 
 By default, this will work for strings, symbols, numbers, arrays, hashes, sets, nil, Time, and boolean values.
 
+### Multiple element reading
+
+If you have a string of **edn** that contains multiple forms, you can create an `EDN::Reader`, which extends `Enumerable`.
+
+```ruby
+r = EDN::Reader.new('[1 2 3] {:a 1 :b 2}')
+
+r.read #=> [1, 2, 3]
+r.read #=> {:a => 1, :b => 2}
+r.read #=> RuntimeError: EDN::Reader is out of string!
+
+r.each do |form|
+  p form
+end
+
+#=> [1, 2, 3]
+#=> {:a => 1, :b => 2}
+
+r.count #=> 2
+```
+
 ### Value Translations
 
 **edn** has some different terminology, and some types that do not map cleanly to Ruby.
@@ -114,6 +135,21 @@ end
 
 This method calls `.to_edn` on the second argument and joins the arguments appropriately.
 
+## Metadata
+
+Certain elements of **edn** can have *metadata*. Metadata is a map of values about the element, which must follow specific rules.
+
+* Only symbols, lists, vectors, maps, and sets can have metadata. Tagged elements *cannot* have metadata.
+* Metadata keys must be symbols, keywords, or strings.
+
+Metadata can be expressed in one of the following three ways:
+
+* Via a map. The element is prefixed with a map which has a caret (`^`) prefixed to it, like so: `^{:doc "This is my vector" :rel :temps} [98.6 99.7]`.
+* Via a keyword. The element is prefixed with a keyword, also prefixed by a caret: `^:awesome #{1 2 \c}`. This results in the key `:awesome` being set to `true`, as if the metadata was: `^{:awesome true} #{1 2 \c}`.
+* Via a symbol. The element is prefixed with a symbol, also prefixed by a caret: `^Boolean "true"`. This results in the key `:tag` being set to the symbol, as if the metadata was: `^{:tag Boolean} "true"`. This is used in Clojure to indicate the Java type of the element. In other **edn** implementations, it may be ignored or used differently.
+
+More than one piece of metadata can be applied to an element. Metadata is applied to the next element appearing after it, so in the case of `^:foo ^{:bar false} [1 2]`, the metadata would be, in total, `^{:foo true, :bar false}`. Note that `^:foo` is applied to the element `[1 2]` with the metadata `^{:bar false}` applied to it. Because of this, key collisions are resolved *right-to-left*.
+
 ## Contributors
 
 * Clinton N. Dreisbach (@crnixon)

data/lib/edn.rb

@@ -1,17 +1,33 @@
 $:.push(File.dirname(__FILE__))
 require 'edn/version'
-require 'edn/types'
 require 'edn/core_ext'
+require 'edn/types'
 require 'edn/parser'
 require 'edn/transform'
+require 'edn/reader'
 
 module EDN
+  class ParseFailed < StandardError
+    attr_reader :original_exception
+
+    def initialize(message, original_exception)
+      super(message)
+      @original_exception = original_exception
+    end
+  end
+
   @parser = EDN::Parser.new
   @transform = EDN::Transform.new
   @tags = Hash.new
 
   def self.read(edn)
-    @transform.apply(@parser.parse(edn))
+    begin
+      tree = @parser.parse(edn)
+    rescue Parslet::ParseFailed => error
+      message = "Invalid EDN, cannot parse: #{edn}"
+      raise ParseFailed.new(message, error)
+    end
+    @transform.apply(tree)
   end
 
   def self.register(tag, func = nil, &block)
@@ -32,17 +48,17 @@ module EDN
     @tags[tag] = nil
   end
 
-  def self.tagged_value(tag, value)
+  def self.tagged_element(tag, element)
     func = @tags[tag]
     if func
-      func.call(value)
+      func.call(element)
     else
-      EDN::Type::Unknown.new(tag, value)
+      EDN::Type::Unknown.new(tag, element)
     end
   end
 
-  def self.tagout(tag, value)
-    ["##{tag}", value.to_edn].join(" ")
+  def self.tagout(tag, element)
+    ["##{tag}", element.to_edn].join(" ")
   end
 
   def self.symbol(text)

data/lib/edn/core_ext.rb

@@ -10,6 +10,12 @@ module EDN
       end
     end
 
+    module AllowsMetadata
+      def allows_metadata?
+        true
+      end
+    end
+
     module Bignum
       def to_edn
         self.to_s + 'M'
@@ -93,3 +99,7 @@ Hash.send(:include, EDN::CoreExt::Hash)
 Set.send(:include, EDN::CoreExt::Set)
 DateTime.send(:include, EDN::CoreExt::DateTime)
 Time.send(:include, EDN::CoreExt::Time)
+
+[Array, Hash, Set].each do |klass|
+  klass.send(:include, EDN::CoreExt::AllowsMetadata)
+end

data/lib/edn/metadata.rb

@@ -0,0 +1,27 @@
+module EDN
+  module Metadata
+    def self.extended(base)
+      base.instance_eval do
+        alias :to_edn_without_metadata :to_edn
+        alias :to_edn :to_edn_with_metadata
+      end
+    end
+
+    attr_accessor :metadata
+
+    def has_metadata?
+      respond_to?(:allows_metadata?) and
+        allows_metadata? and
+        !metadata.nil? and
+        !metadata.empty?
+    end
+
+    def to_edn_with_metadata
+      if has_metadata?
+        '^' + metadata.to_edn + ' ' + to_edn_without_metadata
+      else
+        to_edn_without_metadata
+      end
+    end
+  end
+end

data/lib/edn/parser.rb

@@ -3,17 +3,52 @@ require 'parslet/ignore'
 
 module EDN
   class Parser < Parslet::Parser
+
+    def parse_prefix(str, options={})
+      source = Parslet::Source.new(str.to_s)
+      success, value = setup_and_apply(source, nil)
+
+      unless success
+        reporter = options[:reporter] || Parslet::ErrorReporter::Tree.new
+        success, value = setup_and_apply(source, reporter)
+
+        fail "Assertion failed: success was true when parsing with reporter" if success
+        value.raise
+      end
+
+      rest = nil
+      if !source.eof?
+        rest = source.consume(source.chars_left).to_s
+      end
+
+      return [flatten(value), rest]
+    end
+
     root(:top)
 
     rule(:top) {
-      space? >> value >> space?
+      space? >> element >> space?
+    }
+
+    rule(:element) {
+      base_element |
+      tagged_element |
+      metadata.maybe >> metadata_capable_element.as(:element)
+    }
+
+    rule(:metadata_capable_element) {
+      vector |
+      list |
+      set |
+      map |
+      symbol
     }
 
-    rule(:value) {
-      tagged_value | base_value
+    rule(:tagged_element) {
+      tag >> space? >> base_element.as(:element)
     }
 
-    rule(:base_value) {
+    rule(:base_element) {
       vector |
       list |
       set |
@@ -28,15 +63,10 @@ module EDN
       symbol
     }
 
-    rule(:tagged_value) {
-      tag >> space? >> base_value.as(:value)
-    }
-
     # Collections
 
     rule(:vector) {
       str('[') >>
-      space? >>
       top.repeat.as(:vector) >>
       space? >>
       str(']')
@@ -106,6 +136,25 @@ module EDN
 
     # Parts
 
+    rule(:metadata) {
+      ((metadata_map | metadata_symbol | metadata_keyword) >> space?).repeat.as(:metadata)
+    }
+
+    rule(:metadata_map) {
+      str('^{') >>
+      ((keyword | symbol | string).as(:key) >> top.as(:value)).repeat.as(:map) >>
+      space? >>
+      str('}')
+    }
+
+    rule(:metadata_symbol) {
+      str('^') >> symbol
+    }
+
+    rule(:metadata_keyword) {
+      str('^') >> keyword
+    }
+
     rule(:tag) {
       str('#') >> match['[:alpha:]'].present? >> symbol.as(:tag)
     }
@@ -140,7 +189,7 @@ module EDN
     }
 
     rule(:discard) {
-      str('#_') >> space? >> (tagged_value | base_value).ignore
+      str('#_') >> space? >> (tagged_element | base_element).ignore
     }
 
     rule(:space) {

data/lib/edn/reader.rb

@@ -0,0 +1,36 @@
+module EDN
+  class Reader
+    include Enumerable
+
+    def initialize(text)
+      @parser = Parser.new
+      @transform = Transform.new
+      @original_text = text
+      @text = text
+    end
+
+    def eof?
+      @text.nil? || @text.empty?
+    end
+
+    def each
+      reset!
+      return enum_for(:select) unless block_given?
+
+      until eof?
+        yield read
+      end
+    end
+
+    def reset!
+      @text = @original_text
+    end
+
+    def read
+      raise "EDN::Reader is out of string!" if eof?
+      element, rest = @parser.parse_prefix(@text)
+      @text = rest
+      @transform.apply(element)
+    end
+  end
+end

data/lib/edn/transform.rb

@@ -1,5 +1,6 @@
 require 'edn/string_transformer'
 require 'edn/types'
+require 'edn/metadata'
 require 'bigdecimal'
 
 module EDN
@@ -25,6 +26,7 @@ module EDN
     rule(:character => simple(:x)) {
       case x
       when "newline" then "\n"
+      when "return" then "\r"
       when "tab" then "\t"
       when "space" then " "
       else x.to_s
@@ -36,8 +38,21 @@ module EDN
     rule(:set => subtree(:array)) { Set.new(array) }
     rule(:map => subtree(:array)) { Hash[array.map { |hash| [hash[:key], hash[:value]] }] }
 
-    rule(:tag => simple(:tag), :value => subtree(:value)) {
-      EDN.tagged_value(tag.to_s, value)
+    rule(:tag => simple(:tag), :element => subtree(:element)) {
+      EDN.tagged_element(tag.to_s, element)
+    }
+
+    rule(:metadata => subtree(:raw_metadata), :element => subtree(:element)) {
+      metadata = raw_metadata.reverse.reduce({}) do |acc, m|
+        case m
+        when Symbol then acc.merge(m => true)
+        when EDN::Type::Symbol then acc.merge(:tag => m)
+        else acc.merge(m)
+        end
+      end
+      element.extend EDN::Metadata
+      element.metadata = metadata
+      element
     }
   end
 end

data/lib/edn/type/list.rb

@@ -1,5 +1,7 @@
 module EDN
   module Type
+    include EDN::CoreExt::AllowsMetadata
+
     class List < ::Array
       def self.new(*values)
         self.[](*values)

data/lib/edn/type/symbol.rb

@@ -1,6 +1,8 @@
 module EDN
   module Type
     class Symbol
+      include EDN::CoreExt::AllowsMetadata
+
       attr_reader :symbol
 
       def initialize(sym)

data/lib/edn/version.rb

@@ -1,3 +1,3 @@
 module EDN
-  VERSION = "0.9.4"
+  VERSION = "1.0.0"
 end

data/spec/edn/metadata_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe EDN do
+  describe "metadata" do
+    it "reads metadata, which does not change the element's equality" do
+      EDN.read('[1 2 3]').should == EDN.read('^{:doc "My vec"} [1 2 3]')
+    end
+
+    it "reads metadata recursively from right to left" do
+      element = EDN.read('^String ^:foo ^{:foo false :tag Boolean :bar 2} [1 2]')
+      element.should == [1, 2]
+      element.metadata.should == {:tag => ~"String", :foo => true, :bar => 2}
+    end
+
+    it "writes metadata" do
+      element = EDN.read('^{:doc "My vec"} [1 2 3]')
+      element.to_edn.should == '^{:doc "My vec"} [1 2 3]'
+    end
+
+    it "only writes metadata for elements that can have it" do
+      apply_metadata = lambda { |o|
+        o.extend(EDN::Metadata)
+        o.metadata = {:foo => 1}
+        o
+      }
+
+      apply_metadata[[1, 2]].to_edn.should == '^{:foo 1} [1 2]'
+      apply_metadata[~[1, 2]].to_edn.should == '^{:foo 1} (1 2)'
+      apply_metadata[{1 => 2}].to_edn.should == '^{:foo 1} {1 2}'
+      apply_metadata[Set.new([1, 2])].to_edn.should == '^{:foo 1} #{1 2}'
+      apply_metadata[~"bar"].to_edn.should == '^{:foo 1} bar'
+
+      apply_metadata["bar"].to_edn.should == '"bar"'
+
+      # Cannot extend symbols, booleans, and nil, so no test for them.
+    end
+  end
+end

data/spec/edn/parser_spec.rb

@@ -23,9 +23,13 @@ describe EDN::Parser do
                  {:map => [{:key=>{:keyword=>{:symbol=>"foo"}}, :value=>{:symbol=>"baz"}}]}]}
   end
 
-  context "value" do
+  context "element" do
     it "should consume nil" do
-      parser.value.should parse("nil")
+      parser.element.should parse("nil")
+    end
+
+    it "should consume metadata with the element" do
+      parser.element.should parse('^{:doc "test"} [1 2]')
     end
   end
 
@@ -188,18 +192,18 @@ describe EDN::Parser do
     end
   end
 
-  context "tagged value" do
+  context "tagged element" do
     context "#inst" do
       it "should consume #inst" do
-        rant(RantlyHelpers::INST).each do |value|
-          parser.tagged_value.should parse(value)
+        rant(RantlyHelpers::INST).each do |element|
+          parser.tagged_element.should parse(element)
         end
       end
     end
 
-    it "should consume tagged values" do
-      rant(RantlyHelpers::TAGGED_VALUE).each do |value|
-        parser.tagged_value.should parse(value)
+    it "should consume tagged elements" do
+      rant(RantlyHelpers::TAGGED_ELEMENT).each do |element|
+        parser.tagged_element.should parse(element)
       end
     end
   end

data/spec/edn/reader_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe EDN::Reader do
+  let(:reader) { EDN::Reader.new("[1 2] 3 :a {:b c}") }
+
+  it "should respond to count" do
+    reader.count.should == 4
+  end
+
+  it "should respond to each" do
+    reader.each do |element|
+      element.should_not be_nil
+    end
+  end
+
+  it "should return an Enumerator from each if no block given" do
+    reader.each.should be_a(Enumerator)
+  end
+
+  it "should respond to map" do
+    reader.map { |x| x }.should == [[1, 2], 3, :a, {:b => ~"c"}]
+  end
+end

data/spec/edn/transform_spec.rb

@@ -115,21 +115,21 @@ describe EDN::Transform do
     end
   end
 
-  context "tagged value" do
+  context "tagged element" do
     it "should emit a EDN::Type::Unknown if the tag is not registered" do
-      subject.apply({:tag => {:symbol => 'uri'}, :value => {:string => 'http://google.com'}}).should == EDN::Type::Unknown.new("uri", "http://google.com")
+      subject.apply({:tag => {:symbol => 'uri'}, :element => {: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
+    it "should emit the transformed element if the tag is registered" do
       EDN.register("uri", lambda { |uri| URI(uri) })
-      subject.apply({:tag => {:symbol => 'uri'}, :value => {:string => 'http://google.com'}}).should == URI("http://google.com")
+      subject.apply({:tag => {:symbol => 'uri'}, :element => {:string => 'http://google.com'}}).should == URI("http://google.com")
       EDN.unregister("uri") # cleanup
     end
 
-    it "should work with nested values" do
+    it "should work with nested elements" do
       tree = {
         :tag=>{:symbol=>"cnd/awesome"},
-        :value=>
+        :element=>
         {:vector=>
           [{:keyword=>{:symbol=>"a"}},
             {:list=>
@@ -153,4 +153,20 @@ describe EDN::Transform do
       subject.apply(tree).should == expected
     end
   end
+
+  context "element with metadata" do
+    it "should tag the element with metadata" do
+      tree = {
+        :metadata =>
+          [:map =>
+            [
+              {:key=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1", :precision => nil}},
+              {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2", :precision => nil}}]],
+        :element => {:vector => [{:integer => "1", :precision => nil}, {:string => "abc"}]}}
+
+      element = subject.apply(tree)
+      element.should == [1, "abc"]
+      element.metadata.should == {:a => 1, :b => 2}
+    end
+  end
 end

data/spec/edn_spec.rb

@@ -4,22 +4,22 @@ describe EDN do
   include RantlyHelpers
 
   context "#read" do
-    it "reads single values" do
+    it "reads single elements" do
       EDN.read("1").should == 1
       EDN.read("3.14").should == 3.14
       EDN.read("3.14M").should == BigDecimal("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 == ~'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
+    it "reads #inst tagged elements" do
       EDN.read('#inst "2012-09-10T16:16:03-04:00"').should == DateTime.new(2012, 9, 10, 16, 16, 3, '-04:00')
     end
 
@@ -51,17 +51,17 @@ describe EDN do
       EDN.read('#{1 #{:abc}}').should == Set[1, Set[:abc]]
     end
 
-    it "reads any valid value" do
-      values = rant(RantlyHelpers::VALUE)
-      values.each do |value|
+    it "reads any valid element" do
+      elements = rant(RantlyHelpers::ELEMENT)
+      elements.each do |element|
         begin
-          if value == "nil"
-            EDN.read(value).should be_nil
+          if element == "nil"
+            EDN.read(element).should be_nil
           else
-            EDN.read(value).should_not be_nil
+            EDN.read(element).should_not be_nil
           end
         rescue Exception => ex
-          puts "Bad value: #{value}"
+          puts "Bad element: #{element}"
           raise ex
         end
       end
@@ -69,14 +69,14 @@ describe EDN do
   end
 
   context "writing" do
-    it "writes any valid value" do
-      values = rant(RantlyHelpers::VALUE)
-      values.each do |value|
+    it "writes any valid element" do
+      elements = rant(RantlyHelpers::ELEMENT)
+      elements.each do |element|
         expect {
           begin
-            EDN.read(value).to_edn
+            EDN.read(element).to_edn
           rescue Exception => ex
-            puts "Bad value: #{value}"
+            puts "Bad element: #{element}"
             raise ex
           end
         }.to_not raise_error
@@ -84,10 +84,13 @@ describe EDN do
     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)
+      elements = rant(RantlyHelpers::ELEMENT)
+      elements.each do |element|
+        ruby_element = EDN.read(element)
+        ruby_element.should == EDN.read(ruby_element.to_edn)
+        if ruby_element.respond_to?(:metadata)
+          ruby_element.metadata.should == EDN.read(ruby_element.to_edn).metadata
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -27,7 +27,6 @@ module RantlyHelpers
   PLAIN_SYMBOL = lambda { |_|
     sized(range(1, 100)) {
       s = string(/[[:alnum:]]|[\.\*\+\!\-\?\$_%&=:#]/)
-#      guard s =~ /^[A-Za-z\.\*\+\!\-\?\$_%&=:#]/
       guard s !~ /^[0-9]/
       guard s !~ /^[\+\-\.][0-9]/
       guard s !~ /^[\:\#]/
@@ -58,7 +57,7 @@ module RantlyHelpers
   CHARACTER = lambda { |_|
     "\\" +
     sized(1) {
-      freq([1, [:choose, "newline", "space", "tab"]],
+      freq([1, [:choose, "newline", "return", "space", "tab"]],
            [5, [:string, :graph]])
     }
   }
@@ -68,36 +67,37 @@ module RantlyHelpers
   }
 
   ARRAY = lambda { |_|
-    array(range(0, 10)) { call(VALUE) }
+    array(range(1, 10)) { call(ELEMENT) }
   }
 
   VECTOR = lambda { |_|
-    call(ARRAY).to_edn
+    '[' + call(ARRAY).join(', ') + ']'
   }
 
   LIST = lambda { |_|
-    EDN::Type::List.new(*call(ARRAY)).to_edn
+    '(' + call(ARRAY).join(', ') + ')'
   }
 
   SET = lambda { |_|
-    Set.new(call(ARRAY)).to_edn
+    '#{' + call(ARRAY).join(', ') + '}'
   }
 
   MAP = lambda { |_|
     size = range(0, 10)
-    keys = array(size) { call(VALUE) }
-    values = array(size) { call(VALUE) }
-    arrays = keys.zip(values)
+    keys = array(size) { call(ELEMENT) }
+    elements = array(size) { call(ELEMENT) }
+    arrays = keys.zip(elements)
     '{' + arrays.map { |array| array.join(" ") }.join(", ") + '}'
   }
 
-  VALUE = lambda { |_|
-    freq([10, BASIC_VALUE],
+  ELEMENT = lambda { |_|
+    freq([8, BASIC_ELEMENT],
+         [2, ELEMENT_WITH_METADATA],
          [1, INST],
-         [1, TAGGED_VALUE])
+         [1, TAGGED_ELEMENT])
   }
 
-  BASIC_VALUE = lambda { |_|
+  BASIC_ELEMENT = lambda { |_|
     branch(INTEGER,
            FLOAT,
            FLOAT_WITH_EXP,
@@ -112,14 +112,26 @@ module RantlyHelpers
            MAP)
   }
 
+  METADATA = lambda { |_|
+    size = range(1, 4)
+    keys = array(size) { branch(KEYWORD, SYMBOL, STRING) }
+    elements = array(size) { call(ELEMENT) }
+    arrays = keys.zip(elements)
+    '^{' + arrays.map { |array| array.join(" ") }.join(", ") + '}'
+  }
+
+  ELEMENT_WITH_METADATA = lambda { |_|
+    [call(METADATA), branch(SYMBOL, VECTOR, LIST, SET, MAP)].join(" ")
+  }
+
   TAG = lambda { |_|
     tag = call(SYMBOL)
     guard tag =~ /^[A-Za-z]/
     "##{tag}"
   }
 
-  TAGGED_VALUE = lambda { |_|
-    [call(TAG), call(BASIC_VALUE)].join(" ")
+  TAGGED_ELEMENT = lambda { |_|
+    [call(TAG), call(BASIC_ELEMENT)].join(" ")
   }
 
   INST = lambda { |_|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edn
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-18 00:00:00.000000000 Z
+date: 2012-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -91,7 +91,9 @@ files:
 - edn.gemspec
 - lib/edn.rb
 - lib/edn/core_ext.rb
+- lib/edn/metadata.rb
 - lib/edn/parser.rb
+- lib/edn/reader.rb
 - lib/edn/string_transformer.rb
 - lib/edn/transform.rb
 - lib/edn/type/list.rb
@@ -101,7 +103,9 @@ files:
 - lib/edn/types.rb
 - lib/edn/version.rb
 - lib/parslet/ignore.rb
+- spec/edn/metadata_spec.rb
 - spec/edn/parser_spec.rb
+- spec/edn/reader_spec.rb
 - spec/edn/transform_spec.rb
 - spec/edn_spec.rb
 - spec/spec_helper.rb
@@ -119,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3816899269916079900
+      hash: -2141916682632630907
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -128,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3816899269916079900
+      hash: -2141916682632630907
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -136,7 +140,9 @@ signing_key:
 specification_version: 3
 summary: ! '''edn implements a reader for Extensible Data Notation by Rich Hickey.'''
 test_files:
+- spec/edn/metadata_spec.rb
 - spec/edn/parser_spec.rb
+- spec/edn/reader_spec.rb
 - spec/edn/transform_spec.rb
 - spec/edn_spec.rb
 - spec/spec_helper.rb