json-ld 0.1.4.2 → 0.1.5

data/VERSION

@@ -1 +1 @@
-0.1.4.2
+0.1.5

data/lib/json/ld.rb

@@ -47,6 +47,7 @@ module JSON
       @set
       @type
       @value
+      @vocab
     ).freeze
 
     # Regexp matching an NCName.

data/lib/json/ld/evaluation_context.rb

@@ -64,6 +64,14 @@ module JSON::LD
     # This adds a language to plain strings that aren't otherwise coerced
     # @attr [String]
     attr :default_language, true
+    
+    # Default vocabulary
+    #
+    #
+    # Sets the default vocabulary used for expanding terms which
+    # aren't otherwise absolute IRIs
+    # @attr [String]
+    attr :vocab, true
 
     # Global options used in generating IRIs
     # @attr [Hash] options
@@ -149,8 +157,22 @@ module JSON::LD
         ec
       when Hash
         new_ec = self.dup
-        new_ec.provided_context = context
-        
+        new_ec.provided_context = context.dup
+
+        {
+          '@language' => :default_language=,
+          '@vocab'    => :vocab=
+        }.each do |key, setter|
+          v = context.fetch(key, false)
+          if v.nil? || v.is_a?(String)
+            context.delete(key)
+            debug("parse") {"Hash[#{key}] = #{v.inspect}"}
+            new_ec.send(setter, v)
+          elsif v
+            raise InvalidContext::Syntax, "#{key.inspect} is invalid"
+            end
+        end
+
         num_updates = 1
         while num_updates > 0 do
           num_updates = 0
@@ -159,8 +181,9 @@ module JSON::LD
           context.each do |key, value|
             # Expand a string value, unless it matches a keyword
             debug("parse") {"Hash[#{key}] = #{value.inspect}"}
-            if key == '@language' && (value.nil? || value.is_a?(String))
-              new_ec.default_language = value
+
+            if KEYWORDS.include?(key)
+              raise InvalidContext::Syntax, "key #{key.inspect} must not be a keyword"
             elsif term_valid?(key)
               # Remove all coercion information for the property
               new_ec.set_coerce(key, nil)
@@ -172,9 +195,7 @@ module JSON::LD
               raise InvalidContext::Syntax, "unknown mapping for #{key.inspect} to #{value.class}" unless value.is_a?(String) || value.nil?
 
               iri = new_ec.expand_iri(value, :position => :predicate) if value.is_a?(String)
-              if iri && KEYWORDS.include?(key)
-                raise InvalidContext::Syntax, "key #{key.inspect} must not be a keyword"
-              elsif iri && new_ec.mappings.fetch(key, nil) != iri
+              if iri && new_ec.mappings.fetch(key, nil) != iri
                 # Record term definition
                 new_ec.set_mapping(key, iri)
                 num_updates += 1
@@ -254,6 +275,7 @@ module JSON::LD
           debug {"=> context: #{inspect}"}
           ctx = Hash.ordered
           ctx['@language'] = default_language.to_s if default_language
+          ctx['@vocab'] = vocab.to_s if vocab
 
           # Mappings
           mappings.keys.sort{|a, b| a.to_s <=> b.to_s}.each do |k|
@@ -453,7 +475,7 @@ module JSON::LD
       return iri unless iri.is_a?(String)
       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}"} unless options[:quiet]
+      debug("expand_iri") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{vocab.inspect}"} unless options[:quiet]
       base = self.base unless [:predicate, :datatype].include?(options[:position])
       prefix = prefix.to_s
       case
@@ -462,6 +484,7 @@ module JSON::LD
       when suffix.to_s[0,2] == '//'         then uri(iri)
       when mappings.has_key?(prefix)        then uri(mappings[prefix] + suffix.to_s)
       when base                             then base.join(iri)
+      when vocab                            then uri("#{vocab}#{iri}")
       else
         # Otherwise, it must be an absolute IRI
         u = uri(iri)
@@ -535,10 +558,20 @@ module JSON::LD
         least_distance = term_map.values.max
         terms = term_map.keys.select {|t| term_map[t] == least_distance}
 
-        # If the list of found terms is empty, append a compact IRI for
-        # each term which is a prefix of iri which does not have
-        # @type coercion, @container coercion or @language coercion rules
-        # along with the iri itself.
+        # If terms is empty, and the active context has a @vocab which is a 
+        # prefix of iri where the resulting relative IRI is not a term in the 
+        # active context. The resulting relative IRI is the unmatched part of iri.
+        if vocab && terms.empty? && iri.to_s.index(vocab) == 0
+          terms << iri.to_s.sub(vocab, '')
+          debug("vocab") {"vocab: #{vocab}, rel: #{terms.first}"}
+        end
+
+        # If terms is empty, add a compact IRI representation of iri for each 
+        # term in the active context which maps to an IRI which is a prefix for 
+        # iri where the resulting compact IRI is not a term in the active 
+        # context. The resulting compact IRI is the term associated with the 
+        # partially matched IRI in the active context concatenated with a colon 
+        # (:) character and the unmatched part of iri.
         if terms.empty?
           debug("curies") {"mappings: #{mappings.inspect}"}
           curies = mappings.keys.map do |k|
@@ -566,20 +599,22 @@ module JSON::LD
           end
 
           debug("curies") {"selected #{terms.inspect}"}
+        end
 
-          # If we still don't have any terms and we're using standard_prefixes,
-          # try those, and add to mapping
-          if terms.empty? && @options[:standard_prefixes]
-            terms = RDF::Vocabulary.
-              select {|v| iri.index(v.to_uri.to_s) == 0}.
-              map do |v|
-                prefix = v.__name__.to_s.split('::').last.downcase
-                set_mapping(prefix, v.to_uri.to_s)
-                iri.sub(v.to_uri.to_s, "#{prefix}:").sub(/:$/, '')
-              end
-            debug("curies") {"using standard prefies: #{terms.inspect}"}
-          end
+        # If we still don't have any terms and we're using standard_prefixes,
+        # try those, and add to mapping
+        if terms.empty? && @options[:standard_prefixes]
+          terms = RDF::Vocabulary.
+            select {|v| iri.index(v.to_uri.to_s) == 0}.
+            map do |v|
+              prefix = v.__name__.to_s.split('::').last.downcase
+              set_mapping(prefix, v.to_uri.to_s)
+              iri.sub(v.to_uri.to_s, "#{prefix}:").sub(/:$/, '')
+            end
+          debug("curies") {"using standard prefies: #{terms.inspect}"}
+        end
 
+        if terms.empty?
           # If there is a mapping from the complete IRI to null, return null,
           # otherwise, return the complete IRI.
           if mappings.has_key?(iri.to_s) && !mapping(iri)
@@ -589,7 +624,7 @@ module JSON::LD
             terms << iri.to_s
           end
         end
-        
+
         # Get the first term based on distance and lexecographical order
         # Prefer terms that don't have @container @set over other terms, unless as set is true
         terms = terms.sort do |a, b|

data/spec/evaluation_context_spec.rb

@@ -86,6 +86,12 @@ describe JSON::LD::EvaluationContext do
         }).default_language.should produce("en", @debug)
       end
 
+      it "extracts @vocab" do
+        subject.parse({
+          "@vocab" => "http://schema.org/"
+        }).vocab.should produce("http://schema.org/", @debug)
+      end
+
       it "maps term with IRI value" do
         subject.parse({
           "foo" => "http://example.com/"
@@ -154,6 +160,15 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
+      it "expands terms using @vocab" do
+        subject.parse({
+          "foo" => "bar",
+          "@vocab" => "http://example.com/"
+        }).mappings.should produce({
+          "foo" => "http://example.com/bar"
+        }, @debug)
+      end
+
       context "with null" do
         it "removes @language if set to null" do
           subject.parse([
@@ -166,6 +181,17 @@ describe JSON::LD::EvaluationContext do
           ]).default_language.should produce(nil, @debug)
         end
 
+        it "removes @vocab if set to null" do
+          subject.parse([
+            {
+              "@vocab" => "http://schema.org/"
+            },
+            {
+              "@vocab" => nil
+            }
+          ]).vocab.should produce(nil, @debug)
+        end
+
         it "loads initial context" do
           init_ec = JSON::LD::EvaluationContext.new
           nil_ec = subject.parse(nil)
@@ -197,6 +223,7 @@ describe JSON::LD::EvaluationContext do
         "@container as array" => {"foo" => {"@container" => []}},
         "@container as string" => {"foo" => {"@container" => "true"}},
         "@language as @id" => {"@language" => {"@id" => "http://example.com/"}},
+        "@vocab as @id" => {"@vocab" => {"@id" => "http://example.com/"}},
       }.each do |title, context|
         it title do
           lambda {
@@ -206,15 +233,15 @@ describe JSON::LD::EvaluationContext do
         end
       end
       
-      (JSON::LD::KEYWORDS - %w(@language)).each do |kw|
-        it "does not redefined #{kw} as a string" do
+      (JSON::LD::KEYWORDS - %w(@language @vocab)).each do |kw|
+        it "does not redefine #{kw} as a string" do
           lambda {
             ec = subject.parse({kw => "http://example.com/"})
             ec.serialize.should produce({}, @debug)
           }.should raise_error(JSON::LD::InvalidContext::Syntax)
         end
 
-        it "does not redefined #{kw} with an @id" do
+        it "does not redefine #{kw} with an @id" do
           lambda {
             ec = subject.parse({kw => {"@id" => "http://example.com/"}})
             ec.serialize.should produce({}, @debug)
@@ -235,7 +262,7 @@ describe JSON::LD::EvaluationContext do
   end
 
   describe "#serialize" do
-    it "uses provided context document" do
+    it "context document" do
       ctx = StringIO.new(@ctx_json)
       def ctx.content_type; "application/ld+json"; end
 
@@ -246,7 +273,7 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
-    it "uses provided context array" do
+    it "context array" do
       ctx = [
         {"foo" => "http://example.com/"},
         {"baz" => "bob"}
@@ -258,7 +285,7 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
-    it "uses provided context hash" do
+    it "context hash" do
       ctx = {"foo" => "http://example.com/"}
 
       ec = subject.parse(ctx)
@@ -276,6 +303,15 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
+    it "@vocab" do
+      subject.vocab = "http://example.com/"
+      subject.serialize.should produce({
+        "@context" => {
+          "@vocab" => "http://example.com/"
+        }
+      }, @debug)
+    end
+
     it "term mappings" do
       subject.set_mapping("foo", "http://example.com/")
       subject.serialize.should produce({
@@ -458,6 +494,18 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
+    it "compacts IRIs using @vocab" do
+      subject.vocab = 'http://example.org/'
+      subject.set_mapping("term", 'http://example.org/term')
+      subject.set_coerce("term", "http://example.org/datatype")
+      subject.serialize.should produce({
+        "@context" => {
+          "@vocab" => 'http://example.org/',
+          "term" => {"@id" => "term", "@type" => "datatype"}
+        }
+      }, @debug)
+    end
+
     context "extra keys or values" do
       {
         "extra key" => {
@@ -544,6 +592,33 @@ describe JSON::LD::EvaluationContext do
         end
       end
     end
+    
+    context "@vocab" do
+      before(:each) { subject.vocab = "http://example.com/"}
+      {
+        :subject => false,
+        :predicate => true,
+        :object => false,
+        :datatype => true
+      }.each do |position, r|
+        context "as #{position}" do
+          {
+            "absolute IRI" =>  ["http://example.org/", "http://example.org/", true],
+            "term" =>          ["ex",                  "http://example.org/", true],
+            "prefix:suffix" => ["ex:suffix",           "http://example.org/suffix", true],
+            "keyword" =>       ["@type",               "@type", true],
+            "empty" =>         [":suffix",             "http://empty/suffix", true],
+            "unmapped" =>      ["foo",                 "http://example.com/foo", true],
+            "empty term" =>    ["",                    "http://empty/", true],
+          }.each do |title, (input,result,abs)|
+            result = nil unless r || abs
+            it title do
+              subject.expand_iri(input).should produce(result, @debug)
+            end
+          end
+        end
+      end
+    end
   end
 
   describe "#compact_iri" do
@@ -568,6 +643,24 @@ describe JSON::LD::EvaluationContext do
       end
     end
     
+    context "with @vocab" do
+      before(:each) { subject.vocab = "http://example.org/"}
+
+      {
+        "absolute IRI" =>  ["http://example.com/", "http://example.com/"],
+        "term" =>          ["ex",                  "http://example.org/"],
+        "prefix:suffix" => ["suffix",              "http://example.org/suffix"],
+        "keyword" =>       ["@type",               "@type"],
+        "empty" =>         [":suffix",             "http://empty/suffix"],
+        "unmapped" =>      ["foo",                 "foo"],
+        "bnode" =>         ["_:a",                 RDF::Node("a")],
+      }.each do |title, (result, input)|
+        it title do
+          subject.compact_iri(input).should produce(result, @debug)
+        end
+      end
+    end
+
     context "with value" do
       let(:ctx) do
         c = subject.parse({

metadata

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