json-ld 0.1.5.1 → 0.1.5.2

data/VERSION

@@ -1 +1 @@
-0.1.5.1
+0.1.5.2

data/lib/json/ld/api.rb

@@ -288,7 +288,8 @@ module JSON::LD
     # @param [Proc] callback (&block)
     #   Alternative to using block, with same parameteres.
     # @param  [Hash{Symbol => Object}] options
-    # @option options [Boolean] :notType don't use @type for rdf:type
+    # @option options [Boolean] :useRdfType (false) use rdf:type instead of @type
+    # @option options [Boolean] :useNativeDatatypes FIXME
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form

data/lib/json/ld/evaluation_context.rb

@@ -13,6 +13,11 @@ module JSON::LD
     # @attr_reader [RDF::URI]
     attr_reader :base
 
+    # The base IRI of the context, if loaded remotely.
+    #
+    # @attr [RDF::URI]
+    attr :context_base, true
+
     # A list of current, in-scope mappings from term to IRI.
     #
     # @attr [Hash{String => String}]
@@ -132,18 +137,26 @@ module JSON::LD
           raise JSON::LD::InvalidContext::Syntax, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
           self.dup
         end
-      when String, nil
+      when nil
+        debug("parse") {"nil"}
+        # Load context document, if it is a string
+        ec = EvaluationContext.new(options)
+      when String
         debug("parse") {"remote: #{context}"}
         # Load context document, if it is a string
         ec = nil
         begin
-          RDF::Util::File.open_file(context.to_s) {|f| ec = parse(f)}
+          url = expand_iri(context, :base => context_base || base)
+          ecdup = self.dup
+          ecdup.context_base = url  # Set context_base for recursive remote contexts
+          RDF::Util::File.open_file(url) {|f| ec = ecdup.parse(f)}
           ec.provided_context = context
+          ec.context_base = url
           debug("parse") {"=> provided_context: #{context.inspect}"}
           ec
         rescue Exception => e
-          debug("parse") {"Failed to retrieve @context from remote document at #{context}: #{e.message}"}
-          raise JSON::LD::InvalidContext::LoadError, "Failed to parse remote context at #{context}: #{e.message}", e.backtrace if @options[:validate]
+          debug("parse") {"Failed to retrieve @context from remote document at #{context.inspect}: #{e.message}"}
+          raise JSON::LD::InvalidContext::LoadError, "Failed to retrieve remote context at #{context.inspect}: #{e.message}", e.backtrace if @options[:validate]
           self.dup
         end
       when Array
@@ -467,6 +480,8 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options
     # @option options [:subject, :predicate, :object, :datatype] position
     #   Useful when determining how to serialize.
+    # @option options [RDF::URI] base (self.base)
+    #   Base IRI to use when expanding relative IRIs.
     #
     # @return [RDF::URI, String] IRI or String, if it's a keyword
     # @raise [RDF::ReaderError] if the iri cannot be expanded
@@ -476,7 +491,7 @@ module JSON::LD
       prefix, suffix = iri.split(':', 2)
       return mapping(iri) if mapping(iri) # If it's an exact match
       debug("expand_iri") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{vocab.inspect}"} unless options[:quiet]
-      base = self.base unless [:predicate, :datatype].include?(options[:position])
+      base = options.fetch(:base, self.base) unless [:predicate, :datatype].include?(options[:position])
       prefix = prefix.to_s
       case
       when prefix == '_' && suffix          then bnode(suffix)
@@ -654,13 +669,13 @@ module JSON::LD
     # @param [Hash, String] value
     #   Value (literal or IRI) to be expanded
     # @param  [Hash{Symbol => Object}] options
-    # @option options [Boolean] :native (true) use native representations
+    # @option options [Boolean] :useNativeTypes (true) use native representations
     #
     # @return [Hash] Object representation of value
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-expansion
     def expand_value(property, value, options = {})
-      options = {:native => true}.merge(options)
+      options = {:useNativeTypes => true}.merge(options)
       depth(options) do
         debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}, coerce: #{coerce(property).inspect}"}
         value = RDF::Literal(value) if RDF::Literal(value).has_datatype?
@@ -681,7 +696,7 @@ module JSON::LD
           when RDF::XSD.double.to_s
             {"@value" => value.to_s, "@type" => RDF::XSD.double.to_s}
           else
-            if options[:native]
+            if options[:useNativeTypes]
               # Unless there's coercion, to not modify representation
               {"@value" => (value.is_a?(RDF::Literal::Boolean) ? value.object : value)}
             else
@@ -695,7 +710,7 @@ module JSON::LD
             {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
           when RDF::XSD.integer.to_s, nil
             # Unless there's coercion, to not modify representation
-            if options[:native]
+            if options[:useNativeTypes]
               {"@value" => value.is_a?(RDF::Literal::Integer) ? value.object : value}
             else
               {"@value" => value.to_s, "@type" => RDF::XSD.integer.to_s}
@@ -714,7 +729,7 @@ module JSON::LD
           when RDF::XSD.double.to_s
             {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
           when nil
-            if options[:native]
+            if options[:useNativeTypes]
               # Unless there's coercion, to not modify representation
               {"@value" => value.is_a?(RDF::Literal::Double) ? value.object : value}
             else

data/lib/json/ld/from_rdf.rb

@@ -64,8 +64,8 @@ module JSON::LD
         value = graph[:subjects][subject] ||= {'@id' => subject}
 
         # If property is http://www.w3.org/1999/02/22-rdf-syntax-ns#type
-        # and the notType option is not true
-        if statement.predicate == RDF.type && !@options[:notType]
+        # and the useRdfType option is not true
+        if statement.predicate == RDF.type && !@options[:useRdfType]
           object = ec.expand_iri(statement.object).to_s
           debug("@type") { object.inspect}
           # append the string representation of object to the array value for the key @type, creating
@@ -78,10 +78,11 @@ module JSON::LD
           key = ec.expand_iri(statement.predicate).to_s
           (value[key] ||= []) << {"@list" => []}
         else
-          # Otherwise, let key be the string representation of predicate and let object representation
-          # be object represented in expanded form as described in Value Expansion.
+          # Otherwise, let key be the string representation of predicate and 
+          # let object representation be object represented in expanded form as 
+          # described in Value Expansion.
           key = ec.expand_iri(statement.predicate).to_s
-          object = ec.expand_value(key, statement.object, :native => false)
+          object = ec.expand_value(key, statement.object, @options)
           if blank_node?(object)
             # if object is an Unnamed Node, set as the head element in the listMap
             # entry for object

data/spec/evaluation_context_spec.rb

@@ -32,7 +32,7 @@ describe JSON::LD::EvaluationContext do
 
       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, /Failed to parse remote context/)
+        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::InvalidContext, /Failed to retrieve remote context/)
       end
 
       it "creates mappings" do
@@ -49,6 +49,18 @@ describe JSON::LD::EvaluationContext do
         ec = subject.parse(StringIO.new("{}"))
         ec.mappings.should produce({}, @debug)
       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)
+        ec = subject.parse("http://example.com/c1")
+        ec.mappings.should produce({
+          "name"     => "http://xmlns.com/foaf/0.1/name",
+          "homepage" => "http://xmlns.com/foaf/0.1/homepage",
+          "avatar"   => "http://xmlns.com/foaf/0.1/avatar"
+        }, @debug)
+      end
     end
 
     context "EvaluationContext" do

data/spec/from_rdf_spec.rb

@@ -65,6 +65,14 @@ describe JSON::LD::API do
         it "integer" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
           serialize(input).should produce([{
+            '@id'   => "http://example.com/a",
+            "http://example.com/b"    => [{"@value" => 1}]
+          }], @debug)
+        end
+
+        it "integer (non-native)" do
+          input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1 .)
+          serialize(input, :useNativeTypes => false).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1","@type" => "http://www.w3.org/2001/XMLSchema#integer"}]
           }], @debug)
@@ -73,6 +81,14 @@ describe JSON::LD::API do
         it "boolean" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
           serialize(input).should produce([{
+            '@id'   => "http://example.com/a",
+            "http://example.com/b"    => [{"@value" => true}]
+          }], @debug)
+        end
+
+        it "boolean (non-native)" do
+          input = %(@prefix ex: <http://example.com/> . ex:a ex:b true .)
+          serialize(input, :useNativeTypes => false).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "true","@type" => "http://www.w3.org/2001/XMLSchema#boolean"}]
           }], @debug)
@@ -89,13 +105,21 @@ describe JSON::LD::API do
         it "double" do
           input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
           serialize(input).should produce([{
+            '@id'   => "http://example.com/a",
+            "http://example.com/b"    => [{"@value" => 1.0E0}]
+          }], @debug)
+        end
+
+        it "double (non-native)" do
+          input = %(@prefix ex: <http://example.com/> . ex:a ex:b 1.0e0 .)
+          serialize(input, :useNativeTypes => false).should produce([{
             '@id'   => "http://example.com/a",
             "http://example.com/b"    => [{"@value" => "1.0E0","@type" => "http://www.w3.org/2001/XMLSchema#double"}]
           }], @debug)
         end
       end
 
-      context "datatyped" do
+      context "datatyped (non-native)" do
         {
           :integer            => 1,
           :unsignedInteger    => 1,
@@ -110,7 +134,7 @@ describe JSON::LD::API do
               @prefix ex: <http://example.com/> .
               ex:a ex:b "#{v}"^^xsd:#{t} .
             )
-            serialize(input).should produce([{
+            serialize(input, :useNativeTypes => false).should produce([{
               '@id'   => "http://example.com/a",
               "http://example.com/b"    => [{"@value" => "#{v}","@type" => "http://www.w3.org/2001/XMLSchema##{t}"}]
             }], @debug)
@@ -307,10 +331,10 @@ describe JSON::LD::API do
       end
     end
 
-    context "notType option" do
+    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, :notType => false).should produce([{
+        serialize(input, :useRdfType => false).should produce([{
           '@id'   => "http://example.com/a",
           "@type"    => ["http://example.com/b"]
         }], @debug)
@@ -318,7 +342,7 @@ describe JSON::LD::API do
       
       it "does not use @type if set to true" do
         input = %(@prefix ex: <http://example.com/> . ex:a a ex:b .)
-        serialize(input, :notType => true).should produce([{
+        serialize(input, :useRdfType => true).should produce([{
           '@id'   => "http://example.com/a",
           RDF.type.to_s    => [{"@id" => "http://example.com/b"}]
         }], @debug)

data/spec/suite_helper.rb

@@ -26,27 +26,32 @@ module RDF::Util
         path = filename_or_url[5..-1]
         Kernel.open(path.to_s, &block)
       when /^#{REMOTE_PATH}/
-        #puts "attempt to open #{filename_or_url} locally"
-        if response = ::File.open(filename_or_url.to_s.sub(REMOTE_PATH, LOCAL_PATH))
-          #puts "use #{filename_or_url} locally"
-          case filename_or_url.to_s
-          when /\.jsonld$/
-            def response.content_type; 'application/ld+json'; end
-          when /\.sparql$/
-            def response.content_type; 'application/sparql-query'; end
-          end
+        begin
+          #puts "attempt to open #{filename_or_url} locally"
+          if response = ::File.open(filename_or_url.to_s.sub(REMOTE_PATH, LOCAL_PATH))
+            #puts "use #{filename_or_url} locally"
+            case filename_or_url.to_s
+            when /\.jsonld$/
+              def response.content_type; 'application/ld+json'; end
+            when /\.sparql$/
+              def response.content_type; 'application/sparql-query'; end
+            end
 
-          if block_given?
-            begin
-              yield response
-            ensure
-              response.close
+            if block_given?
+              begin
+                yield response
+              ensure
+                response.close
+              end
+            else
+              response
             end
           else
-            response
+            Kernel.open(filename_or_url.to_s, &block)
           end
-        else
-          Kernel.open(filename_or_url.to_s, &block)
+        rescue Errno::ENOENT
+          # Not there, don't run tests
+          StringIO.new("")
         end
       else
       end

data/spec/suite_spec.rb

@@ -6,61 +6,62 @@ describe JSON::LD do
   describe "test suite" do
     require 'suite_helper'
     
-    m = Fixtures::JSONLDTest::Manifest.each.to_a.first
-    describe m.name do
-      m.entries.each do |m2|
-        describe m2.name do
-          m2.entries.each do |t|
-            next if t.is_a?(Fixtures::JSONLDTest::NormalizeTest)
-            specify "#{File.basename(t.inputDocument.to_s)}: #{t.name}" do
-              begin
-                t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
-                case t
-                when Fixtures::JSONLDTest::CompactTest
-                  t.debug << "context: #{t.extra.read}" if t.extraDocument
-                  result = JSON::LD::API.compact(t.input, t.extra, nil,
-                                                :base => t.base_uri,
-                                                :debug => t.debug)
-                  expected = JSON.load(t.expect)
-                  result.should produce(expected, t.debug)
-                when Fixtures::JSONLDTest::ExpandTest
-                  t.debug << "context: #{t.extra.read}" if t.extraDocument
-                  result = JSON::LD::API.expand(t.input, nil, nil,
-                                                :base => t.base_uri,
-                                                :debug => t.debug)
-                  expected = JSON.load(t.expect)
-                  result.should produce(expected, t.debug)
-                when Fixtures::JSONLDTest::FrameTest
-                  t.debug << "frame: #{t.extra.read}" if t.extraDocument
-                  result = JSON::LD::API.frame(t.input, t.extra, nil, 
-                                                :base => t.inputDocument,
-                                                :debug => t.debug)
-                  expected = JSON.load(t.expect)
-                  result.should produce(expected, t.debug)
-                when Fixtures::JSONLDTest::FromRDFTest
-                  repo = RDF::Repository.load(t.inputDocument)
-                  result = JSON::LD::API.fromRDF(repo.each_statement.to_a, nil,
-                                                :debug => t.debug)
-                  expected = JSON.load(t.expect)
-                  result.should produce(expected, t.debug)
-                when Fixtures::JSONLDTest::ToRDFTest
-                  quads = []
-                  JSON::LD::API.toRDF(t.input, nil, nil,
-                                      :base => t.inputDocument,
-                                      :debug => t.debug) do |statement|
-                    quads << to_quad(statement)
-                  end
+    if m = Fixtures::JSONLDTest::Manifest.each.to_a.first
+      describe m.name do
+        m.entries.each do |m2|
+          describe m2.name do
+            m2.entries.each do |t|
+              next if t.is_a?(Fixtures::JSONLDTest::NormalizeTest)
+              specify "#{File.basename(t.inputDocument.to_s)}: #{t.name}" do
+                begin
+                  t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+                  case t
+                  when Fixtures::JSONLDTest::CompactTest
+                    t.debug << "context: #{t.extra.read}" if t.extraDocument
+                    result = JSON::LD::API.compact(t.input, t.extra, nil,
+                                                  :base => t.base_uri,
+                                                  :debug => t.debug)
+                    expected = JSON.load(t.expect)
+                    result.should produce(expected, t.debug)
+                  when Fixtures::JSONLDTest::ExpandTest
+                    t.debug << "context: #{t.extra.read}" if t.extraDocument
+                    result = JSON::LD::API.expand(t.input, nil, nil,
+                                                  :base => t.base_uri,
+                                                  :debug => t.debug)
+                    expected = JSON.load(t.expect)
+                    result.should produce(expected, t.debug)
+                  when Fixtures::JSONLDTest::FrameTest
+                    t.debug << "frame: #{t.extra.read}" if t.extraDocument
+                    result = JSON::LD::API.frame(t.input, t.extra, nil, 
+                                                  :base => t.inputDocument,
+                                                  :debug => t.debug)
+                    expected = JSON.load(t.expect)
+                    result.should produce(expected, t.debug)
+                  when Fixtures::JSONLDTest::FromRDFTest
+                    repo = RDF::Repository.load(t.inputDocument)
+                    result = JSON::LD::API.fromRDF(repo.each_statement.to_a, nil,
+                                                  :debug => t.debug)
+                    expected = JSON.load(t.expect)
+                    result.should produce(expected, t.debug)
+                  when Fixtures::JSONLDTest::ToRDFTest
+                    quads = []
+                    JSON::LD::API.toRDF(t.input, nil, nil,
+                                        :base => t.inputDocument,
+                                        :debug => t.debug) do |statement|
+                      quads << to_quad(statement)
+                    end
 
-                  quads.sort.join("").should produce(t.expect.read, t.debug)
-                else
-                  pending("unkown test type #{t.inspect}")
+                    quads.sort.join("").should produce(t.expect.read, t.debug)
+                  else
+                    pending("unkown test type #{t.inspect}")
+                  end
+                rescue JSON::LD::ProcessingError => e
+                  fail("Processing error: #{e.message}")
+                rescue JSON::LD::InvalidContext => e
+                  fail("Invalid Context: #{e.message}")
+                rescue JSON::LD::InvalidFrame => e
+                  fail("Invalid Frame: #{e.message}")
                 end
-              rescue JSON::LD::ProcessingError => e
-                fail("Processing error: #{e.message}")
-              rescue JSON::LD::InvalidContext => e
-                fail("Invalid Context: #{e.message}")
-              rescue JSON::LD::InvalidFrame => e
-                fail("Invalid Frame: #{e.message}")
               end
             end
           end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-ld
 version: !ruby/object:Gem::Version
-  version: 0.1.5.1
+  version: 0.1.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-07 00:00:00.000000000 Z
+date: 2012-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf