edn 0.9.0 → 0.9.1

data/README.md

@@ -1,6 +1,6 @@
 # edn-ruby
 
-© 2012 Relevance Inc and Clinton N. Dreisbach
+© 2012 Relevance Inc
 
 **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.
 
@@ -114,6 +114,10 @@ end
 
 This method calls `.to_edn` on the second argument and joins the arguments appropriately.
 
+## Contributors
+
+* Clinton N. Dreisbach
+
 ## Contributing
 
 1. Fork it

data/edn.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
   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'
+  gem.add_dependency 'parslet', '~> 1.4.0'
+  gem.add_development_dependency 'pry', '~> 0.9.10'
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
+  gem.add_development_dependency 'rantly', '~> 0.3.1'
 end

data/lib/edn.rb

@@ -46,7 +46,7 @@ module EDN
 end
 
 EDN.register("inst") do |value|
-  Time.parse(value)
+  DateTime.parse(value)
 end
 
 EDN.register("uuid") do |value|

data/lib/edn/core_ext.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'bigdecimal'
 
 module EDN
   module CoreExt
@@ -8,6 +9,18 @@ module EDN
       end
     end
 
+    module Bignum
+      def to_edn
+        self.to_s + 'M'
+      end
+    end
+
+    module BigDecimal
+      def to_edn
+        self.to_s('F') + 'M'
+      end
+    end
+
     module String
       def to_edn
         self.inspect
@@ -44,6 +57,12 @@ module EDN
       end
     end
 
+    module DateTime
+      def to_edn
+        EDN.tagout("inst", self.rfc3339)
+      end
+    end
+
     module Time
       def to_edn
         EDN.tagout("inst", self.xmlschema)
@@ -53,6 +72,8 @@ module EDN
 end
 
 Numeric.send(:include, EDN::CoreExt::Unquoted)
+Bignum.send(:include, EDN::CoreExt::Bignum)
+BigDecimal.send(:include, EDN::CoreExt::BigDecimal)
 TrueClass.send(:include, EDN::CoreExt::Unquoted)
 FalseClass.send(:include, EDN::CoreExt::Unquoted)
 NilClass.send(:include, EDN::CoreExt::NilClass)
@@ -61,4 +82,5 @@ Symbol.send(:include, EDN::CoreExt::Symbol)
 Array.send(:include, EDN::CoreExt::Array)
 Hash.send(:include, EDN::CoreExt::Hash)
 Set.send(:include, EDN::CoreExt::Set)
+DateTime.send(:include, EDN::CoreExt::DateTime)
 Time.send(:include, EDN::CoreExt::Time)

data/lib/edn/parser.rb

@@ -28,7 +28,7 @@ module EDN
     }
 
     rule(:tagged_value) {
-      (tag >> space >> base_value.as(:value)).as(:tagged_value)
+      tag >> space >> base_value.as(:value)
     }
 
     # Collections
@@ -66,7 +66,7 @@ module EDN
     rule(:integer) {
       (str('-').maybe >>
        (str('0') | match('[1-9]') >> digit.repeat)).as(:integer) >>
-      str('N').maybe
+      str('N').maybe.as(:precision)
     }
 
     rule(:float) {
@@ -74,7 +74,7 @@ module EDN
        (str('0') | (match('[1-9]') >> digit.repeat)) >>
        str('.') >> digit.repeat(1) >>
        (match('[eE]') >> match('[\-+]').maybe >> digit.repeat).maybe).as(:float) >>
-      str('M').maybe
+      str('M').maybe.as(:precision)
     }
 
     rule(:string) {
@@ -105,7 +105,7 @@ module EDN
     # Parts
 
     rule(:tag) {
-      (str('#') >> symbol).as(:tag)
+      str('#') >> symbol.as(:tag)
     }
 
     rule(:symbol_chars) {

data/lib/edn/transform.rb

@@ -1,5 +1,6 @@
 require 'edn/string_transformer'
 require 'edn/types'
+require 'bigdecimal'
 
 module EDN
   class Transform < Parslet::Transform
@@ -7,8 +8,16 @@ module EDN
     rule(:false => simple(:x)) { false }
     rule(:nil => simple(:x)) { nil }
 
-    rule(:integer => simple(:x)) { Integer(x) }
-    rule(:float => simple(:x)) { Float(x) }
+    rule(:integer => simple(:num), :precision => simple(:n)) {
+      Integer(num)
+    }
+    rule(:float => simple(:num), :precision => simple(:n)) {
+      if n
+        BigDecimal(num)
+      else
+        Float(num)
+      end
+    }
 
     rule(:string => simple(:x)) { EDN::StringTransformer.parse_string(x) }
     rule(:keyword => simple(:x)) { x.to_sym }
@@ -27,8 +36,8 @@ module EDN
     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])
+    rule(:tag => simple(:tag), :value => subtree(:value)) {
+      EDN.tag_value(tag.to_s, value)
     }
   end
 end

data/lib/edn/version.rb

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

data/spec/edn/parser_spec.rb

@@ -151,6 +151,14 @@ describe EDN::Parser do
   end
 
   context "tagged value" do
+    context "#inst" do
+      it "should consume #inst" do
+        rant(RantlyHelpers::INST).each do |value|
+          parser.tagged_value.should parse(value)
+        end
+      end
+    end
+
     it "should consume tagged values" do
       rant(RantlyHelpers::TAGGED_VALUE).each do |value|
         parser.tagged_value.should parse(value)

data/spec/edn/transform_spec.rb

@@ -3,13 +3,17 @@ require 'spec_helper'
 describe EDN::Transform do
   context "integer" do
     it "should emit an integer" do
-      subject.apply(:integer => "1").should == 1
+      subject.apply(:integer => "1", :precision => nil).should == 1
     end
   end
 
   context "float" do
     it "should emit an float" do
-      subject.apply(:float => "1.0").should == 1.0
+      subject.apply(:float => "1.0", :precision => nil).should == 1.0
+    end
+
+    it "should emit a BigDecimal if suffixed with M" do
+      subject.apply(:float => "1.0", :precision => "M").should == BigDecimal("1.0")
     end
   end
 
@@ -63,21 +67,21 @@ describe EDN::Transform do
   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]
+      subject.apply(:vector => [{:integer => "1", :precision => nil}, {:string => "abc"}]).should == [1, "abc"]
+      subject.apply(:vector => [{:vector => [{:integer => "1", :precision => nil}, {:string => "abc"}]}, {:float => "3.14", :precision => nil}]).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 == \
+      subject.apply(:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]).should == EDN::Type::List.new(1, "abc")
+      subject.apply(:list => [{:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]}, {:float => "3.14", :precision => nil}]).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"]
+      subject.apply(:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]).should == [1, "abc"]
     end
   end
 
@@ -91,8 +95,8 @@ describe EDN::Transform do
   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"}}
+        [ {:key=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1", :precision => nil}},
+          {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2", :precision => nil}}
         ]
       }
 
@@ -101,29 +105,52 @@ describe EDN::Transform do
 
     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=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1", :precision => nil}},
+          {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2", :precision => nil}},
           {:key=>
             {:map=>
-              [{:key=>{:keyword=>{:symbol=>"c"}}, :value=>{:integer=>"3"}}]},
-            :value=>{:integer=>"4"}}]}
+              [{:key=>{:keyword=>{:symbol=>"c"}}, :value=>{:integer=>"3", :precision => nil}}]},
+            :value=>{:integer=>"4", :precision => nil}}]}
       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")
+      subject.apply({:tag => {:symbol => '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")
+      subject.apply({:tag => {:symbol => 'uri'}, :value => {:string => 'http://google.com'}}).should == URI("http://google.com")
       EDN.unregister("uri") # cleanup
     end
+
+    it "should work with nested values" do
+      tree = {
+        :tag=>{:symbol=>"cnd/awesome"},
+        :value=>
+        {:vector=>
+          [{:keyword=>{:symbol=>"a"}},
+            {:list=>
+              [{:integer=>"1", :precision=>nil},
+                {:list=>
+                  [{:integer=>"2", :precision=>nil},
+                    {:integer=>"3", :precision=>nil}]}]},
+            {:keyword=>{:symbol=>"b"}},
+            {:keyword=>{:symbol=>"c"}},
+            {:set=>
+              [{:integer=>"1", :precision=>nil},
+                {:integer=>"2", :precision=>nil},
+                {:integer=>"3", :precision=>nil}]},
+            {:vector=>
+              [{:vector=>
+                  [{:vector=>[{:integer=>"42", :precision=>nil}]},
+                    {:integer=>"42", :precision=>nil}]}]}]}}
+      expected = EDN::Type::Unknown.new('cnd/awesome',
+                                    [:a, [1, [2, 3]], :b, :c,
+                                          Set.new([1, 2, 3]), [[[42], 42]]])
+      subject.apply(tree).should == expected
+    end
   end
 end

data/spec/edn_spec.rb

@@ -7,6 +7,7 @@ describe EDN do
     it "reads single values" 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"
@@ -19,7 +20,7 @@ describe EDN do
     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')
+      EDN.read('#inst "2012-09-10T16:16:03-04:00"').should == DateTime.new(2012, 9, 10, 16, 16, 3, '-04:00')
     end
 
     it "reads vectors" do

data/spec/spec_helper.rb

@@ -12,6 +12,10 @@ end
 
 module RantlyHelpers
 
+  KEYWORD = lambda { |_|
+    call(SYMBOL).to_sym.to_edn
+  }
+
   SYMBOL = lambda { |_|
     branch(PLAIN_SYMBOL, NAMESPACED_SYMBOL)
   }
@@ -30,11 +34,11 @@ module RantlyHelpers
     [call(PLAIN_SYMBOL), call(PLAIN_SYMBOL)].join("/")
   }
 
-  INTEGER = lambda { |_| integer.to_s }
+  INTEGER = lambda { |_| integer.to_edn }
 
-  STRING = lambda { |_| sized(range(1, 100)) { string.inspect } }
+  STRING = lambda { |_| sized(range(1, 100)) { string.to_edn } }
 
-  FLOAT = lambda { |_| (float * range(-1000, 1000)).to_s }
+  FLOAT = lambda { |_| (float * range(-1000, 1000)).to_edn }
 
   FLOAT_WITH_EXP = lambda { |_|
     # limited range because of Infinity
@@ -60,15 +64,15 @@ module RantlyHelpers
   }
 
   VECTOR = lambda { |_|
-    "[" + call(ARRAY).join(" ") + "]"
+    call(ARRAY).to_edn
   }
 
   LIST = lambda { |_|
-    "(" + call(ARRAY).join(" ") + ")"
+    EDN::Type::List.new(*call(ARRAY)).to_edn
   }
 
   SET = lambda { |_|
-    '#{' + call(ARRAY).join(" ") + '}'
+    Set.new(call(ARRAY)).to_edn
   }
 
   MAP = lambda { |_|
@@ -81,6 +85,7 @@ module RantlyHelpers
 
   VALUE = lambda { |_|
     freq([10, BASIC_VALUE],
+         [1, INST],
          [1, TAGGED_VALUE])
   }
 
@@ -89,6 +94,7 @@ module RantlyHelpers
            FLOAT,
            FLOAT_WITH_EXP,
            STRING,
+           KEYWORD,
            SYMBOL,
            CHARACTER,
            BOOL_OR_NIL,
@@ -102,6 +108,10 @@ module RantlyHelpers
     "#" + [call(SYMBOL), call(BASIC_VALUE)].join(" ")
   }
 
+  INST = lambda { |_|
+    DateTime.new(range(0, 2500), range(1, 12), range(1, 28), range(0, 23), range(0, 59), range(0, 59), "#{range(-12,12)}").to_edn
+  }
+
   def rant(fun, count = REPEAT)
     Rantly(count) { call(fun) }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edn
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,72 +9,72 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000 Z
+date: 2012-09-11 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'
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.10
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.11.0
 - !ruby/object:Gem::Dependency
   name: rantly
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.1
 description: ! '''edn implements a reader for Extensible Data Notation by Rich Hickey.'''
 email:
 - clinton@thinkrelevance.com
@@ -115,12 +115,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -981297228036091023
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -981297228036091023
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23