edn2023 1.1.4

data/lib/edn/parser.rb

@@ -0,0 +1,92 @@
+require 'stringio'
+require 'set'
+
+
+module EDN
+  Parser = RubyEdnParser
+  @parser_class = RubyEdnParser
+
+  def self.parser=(p)
+    @parser_class = p
+  end
+
+  def self.new_parser(*args)
+    @parser_class.new(*args)
+  end
+
+  # 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
+end

data/lib/edn/reader.rb

@@ -0,0 +1,23 @@
+module EDN
+  class Reader
+
+    def initialize(source)
+      @parser = EDN.new_parser(source)
+    end
+
+    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
+      until (result = @parser.read) == EOF
+        yield result
+      end
+    end
+  end
+end

data/lib/edn/ruby_edn_parser.rb

@@ -0,0 +1,266 @@
+require 'stringio'
+require 'set'
+
+
+module EDN
+  class RubyEdnParser
+    def initialize(source, *extra)
+      io = source.instance_of?(String) ? StringIO.new(source) : source
+      @s = CharStream.new(io)
+    end
+
+    def read(return_nothing=false)
+      meta = read_meta
+      value = read_basic(return_nothing)
+      if meta && value != NOTHING
+        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(return_nothing=false)
+      @s.skip_ws
+      ch = @s.current
+      result = call_reader(READERS[ch])
+      while NOTHING.equal?(result) && !return_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
+
+      if @s.current == '.'
+        result += '.'
+        @s.advance
+        result = @s.digit? ? result + read_digits : result + '0'
+        #puts "aaa: #{result}"
+      end
+
+      if @s.current == 'e' || @s.current == 'E'
+        @s.advance
+        result = result + 'e' + read_digits
+        #puts "bbb: #{result}"
+      end
+      #puts result
+      result.to_f 
+    end
+
+    def read_number(leading='')
+      result = leading + read_digits
+
+      if %w{. e E}.include? @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
+
+      while true
+        @s.skip_ws
+        raise "Unexpected eof" if @s.eof?
+        break if @s.current == closing
+        next_value = read(true)
+        result << next_value unless next_value == NOTHING
+      end
+      @s.advance
+      result
+    end
+  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,39 @@
+module EDN
+  module Type
+    class Symbol
+      include EDN::CoreExt::AllowsMetadata
+
+      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

@@ -0,0 +1,3 @@
+module EDN
+  VERSION = "1.1.4"
+end

data/lib/edn.rb

@@ -0,0 +1,80 @@
+$:.push(File.dirname(__FILE__))
+require 'set'
+require 'edn/version'
+require 'edn/core_ext'
+require 'edn/types'
+require 'edn/metadata'
+require 'edn/char_stream'
+require 'edn/ruby_edn_parser'
+require 'edn/parser'
+require 'edn/reader'
+
+module EDN
+  @tags = Hash.new
+
+  def self.read(edn, eof_value=NOTHING)
+    EDN::Reader.new(edn).read(eof_value)
+  end
+
+  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
+
+  def self.tagout(tag, element)
+    ["##{tag}", element.to_edn].join(" ")
+  end
+
+  def self.symbol(text)
+    EDN::Type::Symbol.new(text)
+  end
+
+  def self.list(values)
+    EDN::Type::List.new(*values)
+  end
+
+  def self.set(*elems)
+    Set.new(*elems)
+  end
+
+  def self.rational(value)
+    Rational(value)
+  end
+  
+  def self.big_decimal(str)
+    BigDecimal(str)
+  end
+end
+
+EDN.register("inst") do |value|
+  DateTime.parse(value)
+end
+
+EDN.register("uuid") do |value|
+  EDN::Type::UUID.new(value)
+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_truthy
+    s.advance
+    s.digit?.should be_falsey
+  end
+
+  it "knows if the current char is an alpha" do
+    s = EDN::CharStream.new(io_for("a9"))
+    s.alpha?.should be_truthy
+    s.advance
+    s.alpha?.should be_falsey
+  end
+
+  it "knows if the current char is whitespace" do
+    s = EDN::CharStream.new(io_for("a b\nc\td,"))
+    s.ws?.should be_falsey # a
+
+    s.advance
+    s.ws?.should be_truthy # " "
+
+    s.advance
+    s.ws?.should be_falsey # b
+
+    s.advance
+    s.ws?.should be_truthy # \n
+
+    s.advance
+    s.ws?.should be_falsey # c
+
+    s.advance
+    s.ws?.should be_truthy # \t
+
+    s.advance
+    s.ws?.should be_falsey # d
+
+    s.advance
+    s.ws?.should be_truthy # ,
+  end
+
+  it "knows if the current char is a newline" do
+    s = EDN::CharStream.new(io_for("a\nb\rc"))
+    s.newline?.should be_falsey # a
+
+    s.advance
+    s.newline?.should be_truthy # \n
+
+    s.advance
+    s.newline?.should be_falsey # b
+
+    s.advance
+    s.newline?.should be_truthy # \r
+
+    s.advance
+    s.newline?.should be_falsey # c
+  end
+
+  it "knows if it is at the eof" do
+    s = EDN::CharStream.new(io_for("abc"))
+    s.eof?.should be_falsey # a
+    s.advance
+    s.eof?.should be_falsey # b
+    s.advance
+    s.eof?.should be_falsey # c
+    s.advance
+    s.eof?.should be_truthy
+  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/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