edn 1.0.3 → 1.0.5

data/spec/spec_helper.rb

@@ -1,12 +1,10 @@
 require 'rspec'
 require 'edn'
-require 'parslet/rig/rspec'
-require 'parslet/convenience'
 require 'rantly'
 require 'date'
 require 'time'
 
-REPEAT = (ENV["REPEAT"] || 100).to_i
+REPEAT = (ENV["REPEAT"] || 150).to_i
 
 RSpec.configure do |c|
   c.fail_fast = true
@@ -19,6 +17,10 @@ RSpec.configure do |c|
   c.run_all_when_everything_filtered = true
 end
 
+def io_for(s)
+  StringIO.new(s)
+end
+
 module RantlyHelpers
 
   KEYWORD = lambda { |_|
@@ -47,7 +49,9 @@ module RantlyHelpers
 
   STRING = lambda { |_| sized(range(1, 100)) { string.to_edn } }
 
-  FLOAT = lambda { |_| (float * range(-1000, 1000)).to_edn }
+  RUBY_STRING = lambda { |_| sized(range(1, 100)) { string } }
+
+  FLOAT = lambda { |_| (float * range(-4000, 5000)).to_edn }
 
   FLOAT_WITH_EXP = lambda { |_|
     # limited range because of Infinity
@@ -59,6 +63,14 @@ module RantlyHelpers
     join("")
   }
 
+  RUBY_CHAR = lambda { |_|
+    "\\" +
+    sized(1) {
+      freq([1, [:choose, "\n", "\r", " ", "\t"]],
+           [5, [:string, :graph]])
+    }
+  }
+
   CHARACTER = lambda { |_|
     "\\" +
     sized(1) {

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: edn
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.5
 platform: ruby
 authors:
-- Clinton N. Dreisbach
+- Clinton N. Dreisbach & Russ Olsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-17 00:00:00.000000000 Z
+date: 2014-06-20 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +68,7 @@ dependencies:
         version: 10.0.3
 description: "'edn implements a reader for Extensible Data Notation by Rich Hickey.'"
 email:
-- clinton@thinkrelevance.com
+- russ@russolsen.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -96,27 +82,26 @@ files:
 - Rakefile
 - edn.gemspec
 - lib/edn.rb
+- lib/edn/char_stream.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
 - lib/edn/type/symbol.rb
 - lib/edn/type/unknown.rb
 - lib/edn/type/uuid.rb
 - lib/edn/types.rb
 - lib/edn/version.rb
-- lib/parslet/ignore.rb
+- spec/edn/char_stream_spec.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
-homepage: ''
-licenses: []
+homepage: https://github.com/relevance/edn-ruby
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -134,14 +119,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: "'edn implements a reader for Extensible Data Notation by Rich Hickey.'"
 test_files:
+- spec/edn/char_stream_spec.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

data/lib/edn/string_transformer.rb

@@ -1,46 +0,0 @@
-module EDN
-  module StringTransformer
-    # Unescape characters in strings.
-    # Borrowed from json-pure gem.
-    UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
-    UNESCAPE_MAP.update({ ?"  => '"',
-                          ?\\ => '\\',
-                          ?/  => '/',
-                          #' Clear messed up syntax highlighting with Emacs.
-                          ?b  => "\b",
-                          ?f  => "\f",
-                          ?n  => "\n",
-                          ?r  => "\r",
-                          ?t  => "\t",
-                          ?u  => nil,
-                        })
-
-    EMPTY_8BIT_STRING = ''
-    if ::String.method_defined?(:encode)
-      EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
-    end
-
-    def self.parse_string(string)
-      string = string.to_s
-      return '' if string.empty?
-      string = string.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
-        #" Clear messed up syntax highlighting with Emacs.
-        if u = UNESCAPE_MAP[$&[1]]
-          u
-        else # \uXXXX
-          bytes = EMPTY_8BIT_STRING.dup
-          i = 0
-          while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
-            bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
-            i += 1
-          end
-          JSON.iconv('utf-8', 'utf-16be', bytes)
-        end
-      end
-      if string.respond_to?(:force_encoding)
-        string.force_encoding(::Encoding::UTF_8)
-      end
-      string
-    end
-  end
-end

data/lib/edn/transform.rb

@@ -1,59 +0,0 @@
-require 'edn/string_transformer'
-require 'edn/types'
-require 'edn/metadata'
-require 'bigdecimal'
-
-module EDN
-  class Transform < Parslet::Transform
-    rule(:true => simple(:x)) { true }
-    rule(:false => simple(:x)) { false }
-    rule(:nil => simple(:x)) { nil }
-
-    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 => []) { "" }
-    rule(:string => simple(:x)) { EDN::StringTransformer.parse_string(x) }
-    rule(:keyword => simple(:x)) { x.to_sym }
-    rule(:symbol => simple(:x)) { EDN::Type::Symbol.new(x) }
-    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
-      end
-    }
-
-    rule(:vector => subtree(:array)) { array }
-    rule(:list => subtree(:array)) { EDN::Type::List.new(*array) }
-    rule(:set => subtree(:array)) { Set.new(array) }
-    rule(:map => subtree(:array)) { Hash[array.map { |hash| [hash[:key], hash[: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/parslet/ignore.rb

@@ -1,24 +0,0 @@
-class IgnoreParslet < Parslet::Atoms::Base
-  def initialize(parslet)
-    @parslet = parslet
-  end
-  def to_s_inner(prec)
-    @parslet.to_s(prec)
-  end
-  def try(source, context)
-    success, value = result = @parslet.try(source, context)
-
-    return succ(nil) if success
-    return result
-  end
-end
-
-module IgnoreDSL
-  def ignore
-    IgnoreParslet.new(self)
-  end
-end
-
-class Parslet::Atoms::Base
-  include IgnoreDSL
-end

data/spec/edn/transform_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-describe EDN::Transform do
-  context "integer" do
-    it "should emit an integer" do
-      subject.apply(:integer => "1", :precision => nil).should == 1
-    end
-  end
-
-  context "float" do
-    it "should emit an float" do
-      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
-
-  context "string" do
-    it "should emit a string with control characters substituted" do
-      subject.apply(:string => 'hello\nworld').should == "hello\nworld"
-    end
-
-    it "should not evaluate interpolated Ruby code" do
-      subject.apply(:string => 'hello\n#{world}').should == "hello\n\#{world}"
-    end
-
-    it "should emit empty strings as strings" do
-      subject.apply(:string => []).should == ""
-    end
-  end
-
-  context "keyword" do
-    it "should emit a Ruby symbol" do
-      subject.apply(:keyword => "test").should == :test
-    end
-  end
-
-  context "symbol" do
-    it "should emit an EDN symbol" do
-      subject.apply(:symbol => "test").should == ~'test'
-    end
-  end
-
-  context "boolean" do
-    it "should emit true or false" do
-      subject.apply(:true => "true").should == true
-      subject.apply(:false => "false").should == false
-    end
-  end
-
-  context "nil" do
-    it "should emit nil" do
-      subject.apply(:nil => "nil").should == nil
-    end
-  end
-
-  context "character" do
-    it "should emit a string" do
-      subject.apply(:character => "&").should == "&"
-    end
-
-    it "should handle newline, space, and tab special cases" do
-      subject.apply(:character => "newline").should == "\n"
-      subject.apply(:character => "space").should == " "
-      subject.apply(:character => "tab").should == "\t"
-    end
-  end
-
-  context "vector" do
-    it "should emit an array" do
-      subject.apply(:vector => []).should == []
-      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.list
-      subject.apply(:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]).should == ~[1, "abc"]
-      subject.apply(:list => [{:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]}, {:float => "3.14", :precision => nil}]).should == \
-        ~[~[1, "abc"], 3.14]
-    end
-
-    it "should be type-compatible with arrays" do
-      subject.apply(:list => [{:integer => "1", :precision => nil}, {:string => "abc"}]).should == [1, "abc"]
-    end
-  end
-
-  context "set" do
-    it "should emit a set" do
-      subject.apply(:set => []).should == Set.new
-      subject.apply(:set => [1, "abc", 2]).should == Set.new([1, "abc", 2])
-    end
-  end
-
-  context "map" do
-    it "should emit a hash" do
-      map_tree = {:map=>
-        [ {:key=>{:keyword=>{:symbol=>"a"}}, :value=>{:integer=>"1", :precision => nil}},
-          {:key=>{:keyword=>{:symbol=>"b"}}, :value=>{:integer=>"2", :precision => nil}}
-        ]
-      }
-
-      subject.apply(map_tree).should == {:a => 1, :b => 2}
-    end
-
-    it "should work with nested maps" do
-      map_tree = {:map=>
-        [{: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", :precision => nil}}]},
-            :value=>{:integer=>"4", :precision => nil}}]}
-      subject.apply(map_tree).should == {:a => 1, :b => 2, {:c => 3} => 4}
-    end
-  end
-
-  context "tagged element" do
-    it "should emit a EDN::Type::Unknown if the tag is not registered" do
-      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 element if the tag is registered" do
-      EDN.register("uri", lambda { |uri| URI(uri) })
-      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 elements" do
-      tree = {
-        :tag=>{:symbol=>"cnd/awesome"},
-        :element=>
-        {: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
-
-  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