edn 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 264ff1a11e92aaba18083680eb6504c5d6b24236
-  data.tar.gz: 9381907dfe329aa6d6048b49eb6288b85b97050f
+  metadata.gz: 972dc5d81c03165a6a51a6e3ea561f63dc38afaa
+  data.tar.gz: 8e55935d4bd465c787920bddd99083db37ab5d07
 SHA512:
-  metadata.gz: 4a94597575dcca3006dd2bd20d79d69ebc3e1bae05484f459a4620f87e2d76f90562450aec24adc61a2df6a88762e8e5ae571a1ed3683b73d7b583f263ee8517
-  data.tar.gz: 9d6dce5fa89864ad64ce89ee8f9f57ed98328c7a42accfcf7725f29bb545af11dbbdf636c7c5d445c9052dd79f8abc21942bd872a2e602a6283130fcdd2ade40
+  metadata.gz: f7902d652632b1553a746a62a54e6d602281f6f1d6f45f50e9234ba9e2c04321fa8a86d5e587f141ddd8ad0f90cb2b54604adfa11aac9c174716a45d3f061d56
+  data.tar.gz: 247a8609a0d39f19165640e659351444fedbeebfdb518e7c9eeb055c9225f59aac309d1441736cea7bbf2a509bde5684a997a2e0624c56e669d1ce1454132397

data/README.md

@@ -5,7 +5,7 @@
 
 © 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.
+**edn-ruby** is a Ruby library to read and write EDN (extensible data notation), a subset of Clojure used for transferring data between applications, much like JSON, YAML, or XML.
 
 ## Installation
 
@@ -23,30 +23,68 @@ Or install it yourself as:
 
 ## Usage
 
-To read a string of **edn**:
+To read a string of EDN:
 
 ```ruby
 EDN.read('[1 2 {:foo "bar"}]')
 ```
 
-To convert a data structure to an **edn** string:
+Alternatively you can pass in an IO instance, for
+example an open file:
 
 ```ruby
-data.to_edn
+File.open("data.edn") do |f|
+  data = EDN.read(f)
+  # Do something with data
+end
 ```
 
-By default, this will work for strings, symbols, numbers, arrays, hashes, sets, nil, Time, and boolean values.
+By default EDN.read will throw an execption
+if you try to read past the end of the data:
+
+```ruby
+EDN.read("")   # Boom!
+```
+
+Alternatively, the `EDN.read` method takes an optional
+parameter, which is the value to return
+when it hits the end of data:
+
+```ruby
+EDN.read("", :nomore)
 
-### Multiple element reading
+#=> :nomore
+```
+
+There is no problem using `nil` as an eof value.
+
+### EDN::Reader
 
-If you have a string of **edn** that contains multiple forms, you can create an `EDN::Reader`, which extends `Enumerable`.
+You can also do things in a more object oriented way by
+creating instances of `EDN::Reader`:
 
 ```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.read #=> RuntimeError: Unexpected end of file
+```
+
+`EDN:Reader` will also take an IO instance:
+
+```ruby
+r = EDN::Reader.new(open("data.edn"))
+
+r.read  # Read the first form from the file.
+r.read  # Read the second form from the file.
+r.read  # Read the third from from the file.
+```
+
+You can also iterate through the forms with `each`:
+
+```ruby
+r = EDN::Reader.new('[1 2 3] {:a 1 :b 2}')
 
 r.each do |form|
   p form
@@ -54,35 +92,69 @@ end
 
 #=> [1, 2, 3]
 #=> {:a => 1, :b => 2}
+```
 
-r.count #=> 2
+Note that in contrast to earlier versions of this gem,
+EDN::Reader is no longer `Enumerable`.
+
+Like `EDN.read`, `Reader.read` also takes an optional
+parameter, which is returned when there is no more data:
+
+```ruby
+r = EDN::Reader.new('1 2 3')
+r.read(:eof)  # returns 1
+r.read(:eof)  # returns 2
+r.read(:eof)  # returns 3
+r.read(:eof)  # returns :eof
 ```
 
-### Value Translations
+### Converting Ruby data to EDN
 
-**edn** has some different terminology, and some types that do not map cleanly to Ruby.
+To convert a data structure to an EDN string:
+
+```ruby
+data.to_edn
+```
+
+By default, this will work for strings, symbols, numbers, arrays, hashes, sets, nil, Time, and boolean values.
+
+### Value Translations
 
-**NOTE**: Comments requested on the following.
+Note that EDN uses its own terminology for the types of objects it represents
+and in some cases those types not map cleanly to Ruby.
 
-In **edn**, you have _keywords_, which look like Ruby symbols and have the same meaning and purpose. These are converted to Ruby symbols.
+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. To create an **edn** symbol in Ruby, call `EDN::Type::Symbol.new` or `EDN.symbol` with a string argument, or use the convenience unary operator `~` like so: `~"elf/rings"`.
+You also 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 don't map to anything built into Ruby. To create an EDN symbol in Ruby,
+call `EDN::Type::Symbol.new` or `EDN.symbol` with a string argument, or use the
+convenience unary operator `~` like so: `~"elf/rings"`.
 
-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. To create an **edn** list in Ruby, call `EDN::Type::List.new` or `EDN.list` with all arguments to go in the list. If you have an array, you will use the splat operator, like so: `EDN.list(*[1, 2, 3])`. You can also use the `~` unary operator like so: `~[1, 2, 3]`.
+EDN also has _vectors_, which map to Ruby arrays, and _lists_, which are linked lists
+in Clojure. We map EDN lists to `EDN::Type::List` values, which are type-compatible with
+arrays. To create an EDN list in Ruby, call `EDN::Type::List.new` or `EDN.list`
+with all arguments to go in the list. If you have an array, you will use the splat
+operator, like so: `EDN.list(*[1, 2, 3])`. You can also use the `~` unary
+operator like so: `~[1, 2, 3]`.
 
-**edn** has character types, but Ruby does not. These are converted into one-character strings.
+EDN also 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:
+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:
 
 ```
 #wolf/pack {:alpha "Greybeard" :betas ["Frostpaw" "Blackwind" "Bloodjaw"]}
 ```
 
-The tag (`#wolf/pack`) will tell any consumers of this data to use a data type registered to handle `wolf/pack` to represent this data.
+The tag (`#wolf/pack`) will tell any consumers of this data
+to use a data type registered to handle `wolf/pack` to represent this data.
 
-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.
+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 an instance of `EDN::Type::UUID`.
 
@@ -156,7 +228,7 @@ end
 
 ## Metadata
 
-Certain elements of **edn** can have *metadata*. Metadata is a map of values about the element, which must follow specific rules.
+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.
@@ -165,7 +237,7 @@ 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.
+* 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*.
 
@@ -175,6 +247,7 @@ More than one piece of metadata can be applied to an element. Metadata is applie
 * Michael Ficarra (@michaelficarra)
 * Andrew Forward (@aforward)
 * Gabriel Horner (@cldwalker)
+* Russ Olsen (@russolsen)
 
 ## Contributing
 

data/Rakefile

@@ -5,3 +5,8 @@ require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+task :irb do
+  sh "irb -I lib -r edn"
+  sh "reset"
+end

data/edn.gemspec

@@ -2,11 +2,12 @@
 require File.expand_path('../lib/edn/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Clinton N. Dreisbach"]
-  gem.email         = ["clinton@thinkrelevance.com"]
+  gem.authors       = ["Clinton N. Dreisbach & Russ Olsen"]
+  gem.email         = ["russ@russolsen.com"]
   gem.description   = %q{'edn implements a reader for Extensible Data Notation by Rich Hickey.'}
   gem.summary       = gem.description
-  gem.homepage      = ""
+  gem.homepage      = "https://github.com/relevance/edn-ruby"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -15,7 +16,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = EDN::VERSION
 
-  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'

data/lib/edn.rb

@@ -2,32 +2,16 @@ $:.push(File.dirname(__FILE__))
 require 'edn/version'
 require 'edn/core_ext'
 require 'edn/types'
+require 'edn/metadata'
+require 'edn/char_stream'
 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)
-    begin
-      tree = @parser.parse(edn)
-    rescue Parslet::ParseFailed => error
-      message = "Invalid EDN, cannot parse: #{edn}"
-      raise ParseFailed.new(message, error)
-    end
-    @transform.apply(tree)
+  def self.read(edn, eof_value=NOTHING)
+    EDN::Reader.new(edn).read(eof_value)
   end
 
   def self.register(tag, func = nil, &block)

data/lib/edn/char_stream.rb

@@ -0,0 +1,84 @@
+require 'stringio'
+require 'set'
+
+module EDN
+  class CharStream
+    def initialize(io=$stdin)
+      @io = io
+      @current = nil
+    end
+
+    def current
+      return @current if @current
+      advance
+    end
+
+    def advance
+      return @current if @current == :eof
+      @current = @io.getc || :eof
+    end
+
+    def digit?(c=current)
+      /[0-9]/ =~ c
+    end
+
+    def alpha?(c=current)
+      /[a-zA-Z]/ =~ c
+    end
+
+    def eof?(c=current)
+      c == :eof
+    end
+
+    def ws?(c=current)
+      /[ \t\n,]/ =~ c
+    end
+
+    def newline?(c=current)
+      /[\n\r]/ =~ c
+    end
+
+    def repeat(pattern, &block)
+      result = nil
+      while current =~ pattern
+        result ||= ''
+        result = block.call(result, current)
+      end
+      result
+    end
+
+    def gather(pattern)
+      repeat(pattern) do |result, ch|
+        result << ch
+      end
+    end
+
+    def skip_past(expected, error_message=nil)
+      if current == expected
+        advance
+        return expected
+      elsif error_message
+        raise error_message
+      end
+      nil
+    end
+
+    def skip_to_eol
+      until current == :eof || newline?
+        advance
+      end
+    end
+
+    def skip_ws
+      while current != :eof
+        if ws?(current)
+          advance
+        elsif current == ';'
+          skip_to_eol
+        else
+          break
+        end
+      end
+    end
+  end
+end

data/lib/edn/parser.rb

@@ -1,205 +1,337 @@
-require 'parslet'
-require 'parslet/ignore'
+require 'stringio'
+require 'set'
+require 'pry'
+
 
 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? >> 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(:tagged_element) {
-      tag >> space? >> base_element.as(:element)
-    }
-
-    rule(:base_element) {
-      vector |
-      list |
-      set |
-      map |
-      boolean |
-      _nil |
-      keyword |
-      string |
-      character |
-      float |
-      integer |
-      symbol
-    }
-
-    # 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) {
-      (match['\-\+'].maybe >>
-       (str('0') | match('[1-9]') >> digit.repeat)).as(:integer) >>
-      (str('N') | str("M") ).maybe.as(:precision)
-    }
-
-    rule(:float) {
-      (match['\-\+'].maybe >>
-       (str('0') | (match('[1-9]') >> digit.repeat)) >>
-       str('.') >> digit.repeat(1) >>
-       (match('[eE]') >> match('[\-+]').maybe >> digit.repeat).maybe).as(:float) >>
-      str('M').maybe.as(:precision)
-    }
-
-    rule(:string) {
-      str('"') >>
-      (str('\\') >> any | str('"').absent? >> any).repeat.as(:string) >>
-      str('"')
-    }
-
-    rule(:character) {
-      str("\\") >>
-      (str('newline') | str('space') | str('tab') | str('return') |
-       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)) >> valid_chars.absent?
-    }
-
-    rule(:_nil) {
-      str('nil').as(:nil) >> valid_chars.absent?
-    }
-
-    # 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)
-    }
-
-    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(:newline) { str("\r").maybe >> str("\n") }
-
-    rule(:comment) {
-      str(';') >> (newline.absent? >> any).repeat
-    }
-
-    rule(:discard) {
-      str('#_') >> space? >> (tagged_element | base_element).ignore
-    }
-
-    rule(:space) {
-      (discard | comment | match['\s,']).repeat(1)
-    }
-
-    rule(:space?) { space.maybe }
+
+  # Object returned when there is nothing to return
+
+  NOTHING = Object.new
+
+  # Object to return when we hit end of file. Cant be nil or :eof
+  # because either of those could be something in the EDN data.
+
+  EOF = Object.new
+
+  # Reader table
+
+  READERS = {}
+  SYMBOL_INTERIOR_CHARS =
+    Set.new(%w{. # * ! - _ + ? $ % & = < > :} + ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a)
+
+  SYMBOL_INTERIOR_CHARS.each {|n| READERS[n.to_s] = :read_symbol}
+
+  DIGITS = Set.new(('0'..'9').to_a)
+
+  DIGITS.each {|n| READERS[n.to_s] = :read_number}
+
+  READERS.default = :unknown
+
+  READERS['{'] = :read_map
+  READERS['['] = :read_vector
+  READERS['('] = :read_list
+  READERS['\\'] = :read_char
+  READERS['"'] = :read_string
+  READERS['.'] = :read_number_or_symbol
+  READERS['+'] = :read_number_or_symbol
+  READERS['-'] = :read_number_or_symbol
+  READERS[''] = :read_number_or_symbol
+  READERS['/'] = :read_slash
+  READERS[':'] = :read_keyword
+  READERS['#'] = :read_extension
+  READERS[:eof] = :read_eof
+
+  def self.register_reader(ch, handler=nil, &block)
+    if handler
+      READERS[ch] = handler
+    else
+      READERS[ch] = block
+    end
+  end
+
+  TAGS = {}
+
+  def self.register(tag, func = nil, &block)
+    if block_given?
+      func = block
+    end
+
+    if func.nil?
+      func = lambda { |x| x }
+    end
+
+    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.tagged_element(tag, element)
+    func = TAGS[tag]
+    if func
+      func.call(element)
+    else
+      EDN::Type::Unknown.new(tag, element)
+    end
+  end
+
+  class Parser
+    def initialize(source, *extra)
+      io = source.instance_of?(String) ? StringIO.new(source) : source
+      @s = CharStream.new(io)
+    end
+
+    def read
+      meta = read_meta
+      value = read_basic
+      if meta
+        value.extend EDN::Metadata
+        value.metadata = meta
+      end
+      value
+    end
+
+    def eof?
+      @s.eof?
+    end
+
+    def unknown
+      raise "Don't know what to do with #{@s.current} #{@s.current.class}"
+    end
+
+    def read_eof
+      EOF
+    end
+
+    def read_char
+      result = @s.advance
+      @s.advance
+      until @s.eof?
+        break unless @s.digit? || @s.alpha?
+        result += @s.current
+        @s.advance
+      end
+
+      return result if result.size == 1
+
+      case result
+      when 'newline'
+        "\n"
+      when 'return'
+        "\r"
+      when 'tab'
+        "\t"
+      when 'space'
+        " "
+      else
+        raise "Unknown char #{result}"
+      end
+    end
+
+    def read_slash
+      @s.advance
+      Type::Symbol.new('/')
+    end
+
+    def read_number_or_symbol
+      leading = @s.current
+      @s.advance
+      return read_number(leading) if @s.digit?
+      read_symbol(leading)
+    end
+
+    def read_symbol_chars
+      result = ''
+
+      ch = @s.current
+      while SYMBOL_INTERIOR_CHARS.include?(ch)
+        result << ch
+        ch = @s.advance
+      end
+      return result unless @s.skip_past('/')
+
+      result << '/'
+      ch = @s.current
+      while SYMBOL_INTERIOR_CHARS.include?(ch)
+        result << ch
+        ch = @s.advance
+      end
+
+      result
+    end
+
+    def read_extension
+      @s.advance
+      if @s.current == '{'
+        @s.advance
+        read_collection(Set, '}')
+      elsif @s.current == "_"
+        @s.advance
+        x = read
+        NOTHING
+      else
+        tag = read_symbol_chars
+        value = read
+        EDN.tagged_element(tag, value)
+      end
+    end
+
+    def read_symbol(leading='')
+      token = leading + read_symbol_chars
+      return true if token == "true"
+      return false if token == "false"
+      return nil if token == "nil"
+      Type::Symbol.new(token)
+    end
+
+    def read_keyword
+      @s.advance
+      read_symbol_chars.to_sym
+    end
+
+    def escape_char(ch)
+      return '\\' if ch == '\\'
+      return "\n" if ch == 'n'
+      return "\t" if ch == 't'
+      return "\r" if ch == 'r'
+      ch
+    end
+
+    def read_string
+      @s.advance
+
+      result = ''
+      until @s.current == '"'
+        raise "Unexpected eof" if @s.eof?
+        if @s.current == '\\'
+          @s.advance
+          result << escape_char(@s.current)
+        else
+          result << @s.current
+        end
+        @s.advance
+      end
+      @s.advance
+      result
+    end
+
+    def call_reader(reader)
+      if reader.instance_of? Symbol
+        self.send(reader)
+      else
+        self.instance_exec(&reader)
+      end
+    end
+
+    def read_basic
+      @s.skip_ws
+      ch = @s.current
+      result = call_reader(READERS[ch])
+      while result == NOTHING
+        @s.skip_ws
+        result = call_reader(READERS[@s.current])
+      end
+      result
+    end
+  
+    def read_digits(min_digits=0)
+      result = ''
+
+      if @s.current == '+' || @s.current == '-'
+        result << @s.current
+        @s.advance
+      end
+ 
+      n_digits = 0
+      while @s.current =~ /[0-9]/
+        n_digits += 1
+        result << @s.current
+        @s.advance
+      end
+
+      raise "Expected at least #{min_digits} digits, found #{result}" unless n_digits >= min_digits
+      result
+    end
+
+    def finish_float(whole_part)
+      result = whole_part
+      result += @s.skip_past('.', 'Expected .')
+      result += read_digits(1)
+      if @s.current == 'e' || @s.current == 'E'
+        @s.advance
+        result = result + 'e' + read_digits
+      end
+      result.to_f 
+    end
+
+    def read_number(leading='')
+      result = leading + read_digits
+
+      if @s.current == '.'
+        return finish_float(result)
+      elsif @s.skip_past('M') || @s.skip_past('N')
+        result.to_i
+      else
+        result.to_i
+      end
+    end
+
+    def read_meta
+      raw_metadata = []
+      @s.skip_ws
+      while @s.current == '^'
+        @s.advance
+        raw_metadata << read_basic
+        @s.skip_ws
+      end
+
+      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
+      metadata.empty? ? nil : metadata
+    end
+
+    def read_list
+      @s.advance
+      read_collection(EDN::Type::List, ')')
+    end
+
+    def read_vector
+      @s.advance
+      read_collection(Array, ']')
+    end
+
+    def read_map
+      @s.advance
+      array = read_collection(Array, '}')
+      raise "Need an even number of items for a map" unless array.count.even?
+      Hash[*array]
+    end
+
+    def read_collection(clazz, closing)
+      result = clazz.new
+
+      @s.skip_ws
+
+      ch = @s.current
+      while ch != closing
+        raise "Unexpected eof" if ch == :eof
+        result << read
+        @s.skip_ws
+        ch = @s.current
+      end
+      @s.advance
+      result
+    end
   end
 end