json-ld 1.0.5 → 1.0.6

data/lib/json/ld/extensions.rb

@@ -38,29 +38,6 @@ module RDF
       Node.new(id + value.to_s)
     end
   end
-
-  class Literal
-    class Double
-      ##
-      # Converts this literal into its canonical lexical representation.
-      # Update to use %.15E to avoid precision problems
-      def canonicalize!
-        @string = case
-          when @object.nan?      then 'NaN'
-          when @object.infinite? then @object.to_s[0...-'inity'.length].upcase
-          when @object.zero?     then '0.0E0'
-          else
-            i, f, e = ('%.15E' % @object.to_f).split(/[\.E]/)
-            f.sub!(/0*$/, '')           # remove any trailing zeroes
-            f = '0' if f.empty?         # ...but there must be a digit to the right of the decimal point
-            e.sub!(/^\+?0+(\d)$/, '\1') # remove the optional leading '+' sign and any extra leading zeroes
-            "#{i}.#{f}E#{e}"
-        end
-        @object = Float(@string) unless @object.nil?
-        self
-      end
-    end
-  end
 end
 
 class Array

data/lib/json/ld/flatten.rb

@@ -114,7 +114,7 @@ module JSON::LD
 
             # If element has an @index member, set the @index member of node to its value. If node has already an @index member with a different value, a conflicting indexes error has been detected and processing is aborted. Otherwise, continue by removing the @index member from element.
             if element.has_key?('@index')
-              raise ProcessingError::ConflictingIndexesError,
+              raise JsonLdError::ConflictingIndexes,
                     "Element already has index #{node['@index']} dfferent from #{element['@index']}" if
                     node['@index'] && node['@index'] != element['@index']
               node['@index'] = element.delete('@index')

data/lib/json/ld/reader.rb

@@ -20,7 +20,7 @@ module JSON::LD
     #
     # @param  [IO, File, String]       input
     # @param  [Hash{Symbol => Object}] options
-    #   any additional options (see `RDF::Reader#initialize`)
+    #   any additional options (see `RDF::Reader#initialize` and {JSON::LD::API.initialize})
     # @yield  [reader] `self`
     # @yieldparam  [RDF::Reader] reader
     # @yieldreturn [void] ignored
@@ -49,7 +49,7 @@ module JSON::LD
     # @private
     # @see   RDF::Reader#each_statement
     def each_statement(&block)
-      JSON::LD::API.toRDF(@doc, @options[:context], @options).each do |statement|
+      JSON::LD::API.toRDF(@doc, @options).each do |statement|
         # If RDF version is 1.0, fold literals with xsd:string to be just simple literals
         statement.object.datatype = nil if
           RDF::VERSION.to_s < "1.1" &&

data/lib/json/ld/resource.rb

@@ -128,7 +128,7 @@ module JSON::LD
       end
 
       compacted = nil
-      JSON::LD::API.expand(node_definition, @context) do |expanded|
+      JSON::LD::API.expand(node_definition, :expandContext => @context) do |expanded|
         compacted = JSON::LD::API.compact(expanded, @context)
       end
       compacted.delete_if {|k, v| k == '@context'}

data/spec/api_spec.rb

@@ -18,7 +18,9 @@ describe JSON::LD::API do
       
       context test do
         it "expands" do
-          jld = JSON::LD::API.expand(File.open(filename), (File.open(context) if context), :debug => @debug)
+          options = {:debug => @debug}
+          options[:expandContext] = File.open(context) if context
+          jld = JSON::LD::API.expand(File.open(filename), options)
           jld.should produce(JSON.load(File.open(expanded)), @debug)
         end if File.exist?(expanded)
         

data/spec/compact_spec.rb

@@ -378,8 +378,10 @@ describe JSON::LD::API do
     end
 
     context "context as reference" do
+      let(:remote_doc) do
+        JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({"@context": {"b": "http://example.com/b"}}))
+      end
       it "uses referenced context" do
-        ctx = StringIO.new(%q({"@context": {"b": "http://example.com/b"}}))
         input = {
           "http://example.com/b" => "c"
         }
@@ -387,7 +389,7 @@ describe JSON::LD::API do
           "@context" => "http://example.com/context",
           "b" => "c"
         }
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(ctx)
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
         jld = JSON::LD::API.compact(input, "http://example.com/context", :debug => @debug, :validate => true)
         jld.should produce(expected, @debug)
       end
@@ -490,14 +492,14 @@ describe JSON::LD::API do
           :input => {
             "http://example.org/foo" => {"@list" => [{"@list" => ["baz"]}]}
           },
-          :exception => JSON::LD::ProcessingError::ListOfLists
+          :exception => JSON::LD::JsonLdError::ListOfLists
         },
         "@list containing @list (with coercion)" => {
           :input => {
             "@context" => {"http://example.org/foo" => {"@container" => "@list"}},
             "http://example.org/foo" => [{"@list" => ["baz"]}]
           },
-          :exception => JSON::LD::ProcessingError::ListOfLists
+          :exception => JSON::LD::JsonLdError::ListOfLists
         },
       }.each do |title, params|
         it title do

data/spec/context_spec.rb

@@ -25,38 +25,36 @@ end
 describe JSON::LD::Context do
   before(:each) {
     @debug = []
-    @ctx_json = %q({
+  }
+  let(:context) {JSON::LD::Context.new(:debug => @debug, :validate => true)}
+  let(:remote_doc) do
+    JSON::LD::API::RemoteDocument.new("http://example.com/context", %q({
       "@context": {
         "xsd": "http://www.w3.org/2001/XMLSchema#",
         "name": "http://xmlns.com/foaf/0.1/name",
         "homepage": {"@id": "http://xmlns.com/foaf/0.1/homepage", "@type": "@id"},
         "avatar": {"@id": "http://xmlns.com/foaf/0.1/avatar", "@type": "@id"}
       }
-    })
-  }
-  let(:context) {JSON::LD::Context.new(:debug => @debug, :validate => true)}
+    }))
+  end
   subject {context}
 
   describe "#parse" do
     context "remote" do
-      before(:each) do
-        @ctx = StringIO.new(@ctx_json)
-        def @ctx.content_type; "application/ld+json"; end
-      end
 
       it "retrieves and parses a remote context document" do
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(@ctx)
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         ec.provided_context.should produce("http://example.com/context", @debug)
       end
 
       it "fails given a missing remote @context" do
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_raise(IOError)
-        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::InvalidContext::InvalidRemoteContext, "http://example.com/context")
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_raise(IOError)
+        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::JsonLdError::LoadingRemoteContextFailed, %r{http://example.com/context})
       end
 
       it "creates mappings" do
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(@ctx)
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
         ec = subject.parse("http://example.com/context")
         ec.mappings.should produce({
           "xsd"      => "http://www.w3.org/2001/XMLSchema#",
@@ -71,9 +69,9 @@ describe JSON::LD::Context do
       end
       
       it "parses a referenced context at a relative URI" do
-        c1 = StringIO.new(%({"@context": "context"}))
-        RDF::Util::File.stub(:open_file).with("http://example.com/c1").and_yield(c1)
-        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(@ctx)
+        rd1 = JSON::LD::API::RemoteDocument.new("http://example.com/c1", %({"@context": "context"}))
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/c1").and_yield(rd1)
+        JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
         ec = subject.parse("http://example.com/c1")
         ec.mappings.should produce({
           "xsd"      => "http://www.w3.org/2001/XMLSchema#",
@@ -261,7 +259,7 @@ describe JSON::LD::Context do
           lambda {
             ec = subject.parse(context)
             ec.serialize.should produce({}, @debug)
-          }.should raise_error(JSON::LD::InvalidContext)
+          }.should raise_error(JSON::LD::JsonLdError)
         end
       end
       
@@ -270,24 +268,14 @@ describe JSON::LD::Context do
           lambda {
             ec = subject.parse({kw => "http://example.com/"})
             ec.serialize.should produce({}, @debug)
-          }.should raise_error(JSON::LD::InvalidContext)
+          }.should raise_error(JSON::LD::JsonLdError)
         end
 
         it "does not redefine #{kw} with an @id" do
           lambda {
             ec = subject.parse({kw => {"@id" => "http://example.com/"}})
             ec.serialize.should produce({}, @debug)
-          }.should raise_error(JSON::LD::InvalidContext)
-        end
-      end
-    end
-
-    describe "Load Errors" do
-      {
-        "fixme" => "FIXME",
-      }.each do |title, context|
-        it title do
-          lambda { subject.parse(context) }.should raise_error(JSON::LD::InvalidContext::InvalidRemoteContext)
+          }.should raise_error(JSON::LD::JsonLdError)
         end
       end
     end
@@ -295,10 +283,7 @@ describe JSON::LD::Context do
 
   describe "#serialize" do
     it "context document" do
-      ctx = StringIO.new(@ctx_json)
-      def ctx.content_type; "application/ld+json"; end
-
-      RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(ctx)
+      JSON::LD::API.stub(:documentLoader).with("http://example.com/context").and_yield(remote_doc)
       ec = subject.parse("http://example.com/context")
       ec.serialize.should produce({
         "@context" => "http://example.com/context"
@@ -994,10 +979,10 @@ describe JSON::LD::Context do
       "native date" =>    ["foo", Date.parse("2011-12-27Z"),      {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
       "native time" =>    ["foo", Time.parse("10:11:12Z"),        {"@value" => "10:11:12Z", "@type" => RDF::XSD.time.to_s}],
       "native dateTime" =>["foo", DateTime.parse("2011-12-27T10:11:12Z"), {"@value" => "2011-12-27T10:11:12Z", "@type" => RDF::XSD.dateTime.to_s}],
-      "rdf boolean" =>    ["foo", RDF::Literal(true),             {"@value" => true}],
-      "rdf integer" =>    ["foo", RDF::Literal(1),                {"@value" => 1}],
+      "rdf boolean" =>    ["foo", RDF::Literal(true),             {"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
+      "rdf integer" =>    ["foo", RDF::Literal(1),                {"@value" => "1", "@type" => RDF::XSD.integer.to_s}],
       "rdf decimal" =>    ["foo", RDF::Literal::Decimal.new(1.1), {"@value" => "1.1", "@type" => RDF::XSD.decimal.to_s}],
-      "rdf double" =>     ["foo", RDF::Literal::Double.new(1.1),  {"@value" => 1.1}],
+      "rdf double" =>     ["foo", RDF::Literal::Double.new(1.1),  {"@value" => "1.1E0", "@type" => RDF::XSD.double.to_s}],
       "rdf URI" =>        ["foo", RDF::URI("foo"),                {"@id" => "foo"}],
       "rdf date " =>      ["foo", RDF::Literal(Date.parse("2011-12-27Z")), {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
       "rdf nonNeg" =>     ["foo", RDF::Literal::NonNegativeInteger.new(1), {"@value" => "1", "@type" => RDF::XSD.nonNegativeInteger}],

data/spec/expand_spec.rb

@@ -67,7 +67,7 @@ describe JSON::LD::API do
       }
     }.each_pair do |title, params|
       it title do
-        jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+        jld = JSON::LD::API.expand(params[:input], :debug => @debug)
         jld.should produce(params[:output], @debug)
       end
     end
@@ -114,7 +114,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :base => "http://example.org/", :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :base => "http://example.org/", :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -173,7 +173,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -228,7 +228,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -256,7 +256,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -300,7 +300,7 @@ describe JSON::LD::API do
         }
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -328,7 +328,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -394,7 +394,7 @@ describe JSON::LD::API do
         }
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil,
+          jld = JSON::LD::API.expand(params[:input],
             :base => "http://foo/bar/",
             :debug => @debug)
           jld.should produce(params[:output], @debug)
@@ -451,7 +451,7 @@ describe JSON::LD::API do
         ]}
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug, :base => 'http://example/')
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug, :base => 'http://example/')
           jld.should produce(params[:output], @debug)
         end
       end
@@ -530,7 +530,7 @@ describe JSON::LD::API do
         }
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -583,7 +583,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -651,7 +651,7 @@ describe JSON::LD::API do
         }
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -748,7 +748,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -783,7 +783,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.expand(params[:input], nil, :debug => @debug)
+          jld = JSON::LD::API.expand(params[:input], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -793,43 +793,63 @@ describe JSON::LD::API do
       {
         "non-null @value and null @type" => {
           :input => {"http://example.com/foo" => {"@value" => "foo", "@type" => nil}},
-          :exception => JSON::LD::ProcessingError::InvalidTypeValue
+          :exception => JSON::LD::JsonLdError::InvalidTypeValue
         },
         "non-null @value and null @language" => {
           :input => {"http://example.com/foo" => {"@value" => "foo", "@language" => nil}},
-          :exception => JSON::LD::ProcessingError::InvalidLanguageTaggedString
+          :exception => JSON::LD::JsonLdError::InvalidLanguageTaggedString
         },
         "value with null language" => {
           :input => {
             "@context" => {"@language" => "en"},
             "http://example.org/nolang" => {"@value" => "no language", "@language" => nil}
           },
-          :exception => JSON::LD::ProcessingError::InvalidLanguageTaggedString
+          :exception => JSON::LD::JsonLdError::InvalidLanguageTaggedString
         },
         "@list containing @list" => {
           :input => {
             "http://example.com/foo" => {"@list" => [{"@list" => ["baz"]}]}
           },
-          :exception => JSON::LD::ProcessingError::ListOfLists
+          :exception => JSON::LD::JsonLdError::ListOfLists
         },
         "@list containing @list (with coercion)" => {
           :input => {
             "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
             "foo" => [{"@list" => ["baz"]}]
           },
-          :exception => JSON::LD::ProcessingError::ListOfLists
+          :exception => JSON::LD::JsonLdError::ListOfLists
         },
         "coerced @list containing an array" => {
           :input => {
             "@context" => {"foo" => {"@id" => "http://example.com/foo", "@container" => "@list"}},
             "foo" => [["baz"]]
           },
-          :exception => JSON::LD::ProcessingError::ListOfLists
+          :exception => JSON::LD::JsonLdError::ListOfLists
         },
+        "@reverse object with an @id property" => {
+          :input => JSON.parse(%({
+            "@id": "http://example/foo",
+            "@reverse": {
+              "@id": "http://example/bar"
+            }
+          })),
+          :exception => JSON::LD::JsonLdError::InvalidReversePropertyMap,
+        },
+        "colliding keywords" => {
+          :input => JSON.parse(%({
+            "@context": {
+              "id": "@id",
+              "ID": "@id"
+            },
+            "id": "http://example/foo",
+            "ID": "http://example/bar"
+          })),
+          :exception => JSON::LD::JsonLdError::CollidingKeywords,
+        }
       }.each do |title, params|
         it title do
-          #JSON::LD::API.expand(params[:input], nil, :debug => @debug).should produce([], @debug)
-          lambda {JSON::LD::API.expand(params[:input], nil)}.should raise_error(params[:exception])
+          #JSON::LD::API.expand(params[:input], :debug => @debug).should produce([], @debug)
+          lambda {JSON::LD::API.expand(params[:input])}.should raise_error(params[:exception])
         end
       end
     end

data/spec/frame_spec.rb

@@ -505,7 +505,7 @@ describe JSON::LD::API do
         begin
           jld = JSON::LD::API.frame(params[:input], params[:frame], :debug => @debug)
           jld.should produce(params[:output], @debug)
-        rescue JSON::LD::ProcessingError, JSON::LD::InvalidContext, JSON::LD::InvalidFrame => e
+        rescue JSON::LD::JsonLdError, JSON::LD::JsonLdError, JSON::LD::InvalidFrame => e
           fail("#{e.class}: #{e.message}\n" +
             "#{@debug.join("\n")}\n" +
             "Backtrace:\n#{e.backtrace.join("\n")}")

data/spec/from_rdf_spec.rb

@@ -69,7 +69,7 @@ describe JSON::LD::API do
 
         it "integer" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
-          serialize(input).should produce([{
+          serialize(input, :useNativeTypes => true).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1}]
           }], @debug)
@@ -85,7 +85,7 @@ describe JSON::LD::API do
 
         it "boolean" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
-          serialize(input).should produce([{
+          serialize(input, :useNativeTypes => true).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => true}]
           }], @debug)
@@ -101,7 +101,7 @@ describe JSON::LD::API do
 
         it "decmal" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0 .)
-          serialize(input).should produce([{
+          serialize(input, :useNativeTypes => true).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0", "@type" => "http://www.w3.org/2001/XMLSchema#decimal"}]
           }], @debug)
@@ -109,7 +109,7 @@ describe JSON::LD::API do
 
         it "double" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
-          serialize(input).should produce([{
+          serialize(input, :useNativeTypes => true).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => 1.0E0}]
           }], @debug)
@@ -337,24 +337,6 @@ describe JSON::LD::API do
         end
       end
     end
-
-    context "useRdfType option" do
-      it "uses @type if set to false" do
-        input = %(@prefix ex: <http://example.com/> . ex:a a ex:b .)
-        serialize(input, :useRdfType => false).should produce([{
-          '@id'   => "http://example.com/a",
-          "@type"    => ["http://example.com/b"]
-        }], @debug)
-      end
-      
-      it "does not use @type if set to true" do
-        input = %(@prefix ex: <http://example.com/> . ex:a a ex:b .)
-        serialize(input, :useRdfType => true).should produce([{
-          '@id'   => "http://example.com/a",
-          '@type'    => ["http://example.com/b"]
-        }], @debug)
-      end
-    end
   
     context "problems" do
       {