edn 1.0.3 → 1.0.5

data/lib/edn/reader.rb

@@ -1,36 +1,23 @@
 module EDN
   class Reader
-    include Enumerable
 
-    def initialize(text)
-      @parser = Parser.new
-      @transform = Transform.new
-      @original_text = text
-      @text = text
+    def initialize(source)
+      @parser = Parser.new(source)
     end
 
-    def eof?
-      @text.nil? || @text.empty?
+    def read(eof_value = NOTHING)
+      result = @parser.read
+      if result == EOF 
+        raise "Unexpected end of file" if eof_value == NOTHING
+        return eof_value
+      end
+      result
     end
 
     def each
-      reset!
-      return enum_for(:select) unless block_given?
-
-      until eof?
-        yield read
+      until (result = @parser.read) == EOF
+        yield result
       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/version.rb

@@ -1,3 +1,3 @@
 module EDN
-  VERSION = "1.0.3"
+  VERSION = "1.0.5"
 end

data/spec/edn/char_stream_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe EDN::CharStream do
+  it "reads a stream in order" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.current.should == "a"
+    s.advance.should == "b"
+    s.advance.should == "c"
+    s.advance.should == :eof
+    s.current.should == :eof
+  end
+
+  it "keeps returning the current until your advance" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.current.should == "a"
+    s.current.should == "a"
+    s.advance.should == "b"
+  end
+
+  it "knows if the current char is a digit" do
+    s = EDN::CharStream.new(io_for("4f"))
+    s.digit?.should be_true
+    s.advance
+    s.digit?.should be_false
+  end
+
+  it "knows if the current char is an alpha" do
+    s = EDN::CharStream.new(io_for("a9"))
+    s.alpha?.should be_true
+    s.advance
+    s.alpha?.should be_false
+  end
+
+  it "knows if the current char is whitespace" do
+    s = EDN::CharStream.new(io_for("a b\nc\td,"))
+    s.ws?.should be_false # a
+
+    s.advance
+    s.ws?.should be_true # " "
+
+    s.advance
+    s.ws?.should be_false # b
+
+    s.advance
+    s.ws?.should be_true # \n
+
+    s.advance
+    s.ws?.should be_false # c
+
+    s.advance
+    s.ws?.should be_true # \t
+
+    s.advance
+    s.ws?.should be_false # d
+
+    s.advance
+    s.ws?.should be_true # ,
+  end
+
+  it "knows if the current char is a newline" do
+    s = EDN::CharStream.new(io_for("a\nb\rc"))
+    s.newline?.should be_false # a
+
+    s.advance
+    s.newline?.should be_true # \n
+
+    s.advance
+    s.newline?.should be_false # b
+
+    s.advance
+    s.newline?.should be_true # \r
+
+    s.advance
+    s.newline?.should be_false # c
+  end
+
+  it "knows if it is at the eof" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.eof?.should be_false # a
+    s.advance
+    s.eof?.should be_false # b
+    s.advance
+    s.eof?.should be_false # c
+    s.advance
+    s.eof?.should be_true
+  end
+
+  it "knows how to skip past a char" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.skip_past("a").should == "a"
+    s.current.should == "b"
+  end
+
+  it "knows how not to skip a char" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.skip_past("X").should be_nil
+  end
+
+  it "knows how skip to the end of a line" do
+    s = EDN::CharStream.new(io_for("abc\ndef"))
+    s.skip_to_eol
+    s.current.should == "\n"
+    s.advance.should == "d"
+  end
+
+  it "knows how skip whitespace" do
+    s = EDN::CharStream.new(io_for("  \n \t,,,,abc"))
+    s.skip_ws
+    s.current.should == "a"
+  end
+end

data/spec/edn/parser_spec.rb

@@ -7,60 +7,32 @@ describe EDN::Parser do
 
   it "can contain comments" do
     edn = ";; This is some sample data\n[1 2 ;; the first two values\n3]"
-    parser.should parse(edn)
-    parser.parse(edn).should ==
-      {:vector=>[{:integer=>"1", :precision=>nil},
-                 {:integer=>"2", :precision=>nil},
-                 {:integer=>"3", :precision=>nil}]}
+    EDN.read(edn).should == [1, 2, 3]
   end
 
   it "can discard using the discard reader macro" do
-    edn = "[1 2 #_3 {:foo #_bar baz}]"
-    parser.should parse(edn)
-    parser.parse(edn).should ==
-      {:vector=>[{:integer=>"1", :precision=>nil},
-                 {:integer=>"2", :precision=>nil},
-                 {:map => [{:key=>{:keyword=>{:symbol=>"foo"}}, :value=>{:symbol=>"baz"}}]}]}
+    edn = "[1 2 #_3 {:foo #_bar :baz}]"
+    EDN.read(edn).should == [1, 2, {:foo => :baz}]
   end
 
   context "element" do
-    it "should consume nil" do
-      parser.element.should parse("nil")
-    end
-
     it "should consume metadata with the element" do
-      parser.element.should parse('^{:doc "test"} [1 2]')
-    end
-  end
-
-  context "comment" do
-    it "should consume and throw away comments" do
-      comment = "; this is a comment"
-      parser.comment.should parse(comment)
-      parser.comment.parse(comment).should == "; this is a comment"
-    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")
+      x = EDN.read('^{:doc "test"} [1 2]')
+      x.should == [1, 2]
+      x.metadata.should == {doc: "test"}
     end
   end
 
   context "integer" do
     it "should consume integers" do
       rant(RantlyHelpers::INTEGER).each do |int|
-        parser.integer.should parse(int)
+        (EDN.read int.to_s).should == int.to_i
       end
     end
 
     it "should consume integers prefixed with a +" do
       rant(RantlyHelpers::INTEGER).each do |int|
-        parser.integer.should parse("+#{int.to_i.abs.to_s}")
+        (EDN.read "+#{int.to_i.abs.to_s}").should == int.to_i.abs
       end
     end
   end
@@ -68,41 +40,35 @@ describe EDN::Parser do
   context "float" do
     it "should consume simple floats" do
       rant(RantlyHelpers::FLOAT).each do |float|
-        parser.float.should parse(float)
+        EDN.read(float.to_s).should == float.to_f
       end
     end
 
     it "should consume floats with exponents" do
       rant(RantlyHelpers::FLOAT_WITH_EXP).each do |float|
-        parser.float.should parse(float)
+        EDN.read(float.to_s).should == float.to_f
       end
     end
 
     it "should consume floats prefixed with a +" do
       rant(RantlyHelpers::FLOAT).each do |float|
-        parser.float.should parse("+#{float.to_f.abs.to_s}")
+        EDN.read("+#{float.to_f.abs.to_s}").should == float.to_f.abs
       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('/')
+        EDN.read('/').should == EDN::Type::Symbol.new(:"/")
       end
 
       it "should consume '.'" do
-        parser.symbol.should parse('.')
+        EDN.read('.').should == EDN::Type::Symbol.new(:".")
       end
 
       it "should consume '-'" do
-        parser.symbol.should parse('-')
+        EDN.read('-').should == EDN::Type::Symbol.new(:"-")
       end
     end
   end
@@ -110,84 +76,70 @@ describe EDN::Parser do
   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::TAG).each do |tag|
-        parser.tag.should parse(tag)
+        EDN.read(":#{symbol}").should == symbol.to_sym
       end
     end
   end
 
   context "string" do
     it "should consume any string" do
-      rant(RantlyHelpers::STRING).each do |string|
-        parser.string.should parse(string)
+      rant(RantlyHelpers::RUBY_STRING).each do |string|
+        EDN.read(string.to_edn).should == string
       end
     end
   end
 
   context "character" do
     it "should consume any character" do
-      rant(RantlyHelpers::CHARACTER).each do |char|
-        parser.character.should parse(char)
+      rant(RantlyHelpers::RUBY_CHAR).each do |char|
+        EDN.read(char.to_edn).should == char
       end
     end
   end
 
   context "vector" do
     it "should consume an empty vector" do
-      parser.vector.should parse('[]')
-      parser.vector.should parse('[  ]')
+      EDN.read('[]').should == []
+      EDN.read('[  ]').should == []
     end
 
     it "should consume vectors of mixed elements" do
       rant(RantlyHelpers::VECTOR).each do |vector|
-        parser.vector.should parse(vector)
+        expect { EDN.read(vector) }.to_not raise_error
       end
     end
   end
 
   context "list" do
     it "should consume an empty list" do
-      parser.list.should parse('()')
-      parser.list.should parse('( )')
+      EDN.read('()').should == []
+      EDN.read('( )').should == []
     end
 
     it "should consume lists of mixed elements" do
       rant(RantlyHelpers::LIST).each do |list|
-        parser.list.should parse(list)
+        expect { EDN.read(list) }.to_not raise_error
       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('#{ }')
+      EDN.read('#{}').should == Set.new
+      EDN.read('#{ }').should == Set.new
     end
 
     it "should consume sets of mixed elements" do
       rant(RantlyHelpers::SET).each do |set|
-        parser.set.should parse(set)
+        EDN.read(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)
+        expect { EDN.read(map) }.not_to raise_error
       end
     end
   end
@@ -196,14 +148,14 @@ describe EDN::Parser do
     context "#inst" do
       it "should consume #inst" do
         rant(RantlyHelpers::INST).each do |element|
-          parser.tagged_element.should parse(element)
+          expect { EDN.read(element) }.not_to raise_error
         end
       end
     end
 
     it "should consume tagged elements" do
       rant(RantlyHelpers::TAGGED_ELEMENT).each do |element|
-        parser.tagged_element.should parse(element)
+        expect { EDN.read(element) }.not_to raise_error
       end
     end
   end

data/spec/edn/reader_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
 
 describe EDN::Reader do
-  let(:reader) { EDN::Reader.new("[1 2] 3 :a {:b c}") }
+  let(:reader) { EDN::Reader.new("[1 2] 3 :a {:b c} ") }
 
-  it "should respond to count" do
-    reader.count.should == 4
+  it "should read each value" do
+    reader.read.should == [1, 2]
+    reader.read.should == 3
+    reader.read.should == :a
+    reader.read.should == {:b => ~"c"}
   end
 
   it "should respond to each" do
@@ -13,11 +16,8 @@ describe EDN::Reader do
     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"}]
+  it "returns a special end of file value if asked" do
+    4.times { reader.read(:the_end).should_not == :the_end }
+    reader.read(:no_more).should == :no_more
   end
 end

data/spec/edn_spec.rb

@@ -1,9 +1,39 @@
 require 'spec_helper'
+require 'stringio'
 
 describe EDN do
   include RantlyHelpers
 
   context "#read" do
+    it "reads from a stream" do
+      io = StringIO.new("123")
+      EDN.read(io).should == 123
+    end
+
+    it "reads mutiple values from a stream" do
+      io = StringIO.new("123 456 789")
+      EDN.read(io).should == 123
+      EDN.read(io).should == 456
+      EDN.read(io).should == 789
+    end
+
+    it "raises an exception on eof by default" do
+      expect { EDN.read('') }.to raise_error
+    end
+
+    it "allows you to specify an eof value" do
+      io = StringIO.new("123 456")
+      EDN.read(io, :my_eof).should == 123
+      EDN.read(io, :my_eof).should == 456
+      EDN.read(io, :my_eof).should == :my_eof
+    end
+
+    it "allows you to specify nil as an eof value" do
+      EDN.read("", nil).should == nil
+    end
+  end
+
+  context "reading data" do
     it "reads single elements" do
       EDN.read(%q{""}).should == ""
       EDN.read("1").should == 1
@@ -20,24 +50,27 @@ describe EDN do
       EDN.read('\c').should == "c"
     end
 
-    it "should support M suffix without decimals" do
+    it "should support M suffix without decimals"  do
       EDN.read(123412341231212121241234.to_edn).should == 123412341231212121241234
       EDN.read("123412341231212121241234M").should == 123412341231212121241234
     end
 
-    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
-
     it "reads vectors" do
       EDN.read('[]').should == []
+      EDN.read('()').should be_a(Array)
       EDN.read('[1]').should == [1]
       EDN.read('["hello" 1 2]').should == ['hello', 1, 2]
       EDN.read('[[1 [:hi]]]').should == [[1, [:hi]]]
     end
 
+    it "reads tagged elements" do
+      EDN.read('#inst "2012-09-10T16:16:03-04:00"').should == DateTime.rfc3339("2012-09-10T16:16:03-04:00")
+      EDN.read('#uuid "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"').should == "f81d4fae-7dec-11d0-a765-00a0c91e6bf6"
+    end
+
     it "reads lists" do
       EDN.read('()').should == []
+      EDN.read('()').should be_a(EDN::Type::List)
       EDN.read('(1)').should == [1]
       EDN.read('("hello" 1 2)').should == ['hello', 1, 2]
       EDN.read('((1 (:hi)))').should == [[1, [:hi]]]
@@ -45,6 +78,7 @@ describe EDN do
 
     it "reads maps" do
       EDN.read('{}').should == {}
+      EDN.read('{}').should be_a(Hash)
       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}}