json-ld 0.1.6 → 0.1.6.1

data/History.markdown

@@ -1,3 +1,6 @@
+=== 0.1.6.1
+* Merge relative contexts from 0.1.5.2.
+
 === 0.1.6
 * Added flattening API, and updated algorithm.
 * Fixed framing issues using updated flattening.

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.6.1

data/lib/json/ld/api.rb

@@ -368,7 +368,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, :position => :subject)
+          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 = [:subject, :object].include?(options[:position]) ? self.base : nil
+      base = [:subject, :object].include?(options[:position]) ? options.fetch(:base, self.base) : nil
       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[:nodes][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)

metadata

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