json-ld 0.1.6.1 → 0.3.0

data/lib/json/ld/to_rdf.rb

@@ -47,7 +47,7 @@ module JSON::LD
           active_subject = if element.fetch('@id', nil).is_a?(String)
             # 1.5 Subject
             # 1.5.1 Set active object (subject)
-            context.expand_iri(element['@id'], :quite => true)
+            context.expand_iri(element['@id'], :quiet => true)
           else
             # 1.6) Generate a blank node identifier and set it as the active subject.
             node
@@ -73,7 +73,7 @@ module JSON::LD
             else
               # 1.7.1) If a key that is not @id, @graph, or @type, set the active property by
               # performing Property Processing on the key.
-              context.expand_iri(key, :quite => true)
+              context.expand_iri(key, :quiet => true)
             end
 
             debug("statements[Step 1.7.4]")
@@ -171,7 +171,7 @@ module JSON::LD
     # @yieldparam [RDF::Statement] :statement
     def add_quad(path, subject, predicate, object, name)
       predicate = RDF.type if predicate == '@type'
-      object = RDF::URI(object.to_s) if object.literal? && predicate == RDF.type
+      object = context.expand_iri(object.to_s, :quiet => true) if object.literal? && predicate == RDF.type
       statement = RDF::Statement.new(subject, predicate, object, :context => name)
       debug(path) {"statement: #{statement.to_nquads}"}
       yield statement

data/spec/compact_spec.rb

@@ -262,22 +262,22 @@ describe JSON::LD::API do
 
     context "term selection" do
       {
-        #"Uses term with nil language when two terms conflict on language" => {
-        #  :input => [{
-        #    "http://example.com/term" => {"@value" => "v1", "@language" => nil}
-        #  }],
-        #  :context => {
-        #    "term5" => {"@id" => "http://example.com/term","@language" => nil},
-        #    "@language" => "de"
-        #  },
-        #  :output => {
-        #    "@context" => {
-        #      "term5" => {"@id" => "http://example.com/term","@language" => nil},
-        #      "@language" => "de"
-        #    },
-        #    "term5" => "v1",
-        #  }
-        #},
+        "Uses term with nil language when two terms conflict on language" => {
+          :input => [{
+            "http://example.com/term" => {"@value" => "v1", "@language" => nil}
+          }],
+          :context => {
+            "term5" => {"@id" => "http://example.com/term","@language" => nil},
+            "@language" => "de"
+          },
+          :output => {
+            "@context" => {
+              "term5" => {"@id" => "http://example.com/term","@language" => nil},
+              "@language" => "de"
+            },
+            "term5" => "v1",
+          }
+        },
         "Uses subject alias" => {
           :input => [{
             "@id" => "http://example.com/id1"
@@ -314,10 +314,90 @@ describe JSON::LD::API do
             "comment_en" => "comment in english",
           }
         },
+        "compact-0018" => {
+          :context => %{{
+            "id1": "http://example.com/id1",
+            "type1": "http://example.com/t1",
+            "type2": "http://example.com/t2",
+            "@language": "de",
+            "term": { "@id": "http://example.com/term" },
+            "term1": { "@id": "http://example.com/term", "@container": "@list" },
+            "term2": { "@id": "http://example.com/term", "@container": "@list", "@language": "en" }
+          }},
+          :input => %{{
+            "http://example.com/term": [
+              {
+                "@list": [
+                  { "@value": "v1.1", "@language": "de" },
+                  { "@value": "v1.2", "@language": "de" },
+                  { "@value": "v1.3", "@language": "de" },
+                  4,
+                  { "@value": "v1.5", "@language": "de" },
+                  { "@value": "v1.6", "@language": "en" }
+                ]
+              },
+              {
+                "@list": [
+                  { "@value": "v2.1", "@language": "en" },
+                  { "@value": "v2.2", "@language": "en" },
+                  { "@value": "v2.3", "@language": "en" },
+                  4,
+                  { "@value": "v2.5", "@language": "en" },
+                  { "@value": "v2.6", "@language": "de" }
+                ]
+              }
+            ]
+          }},
+          :output => %q{{
+            "@context": {
+              "id1": "http://example.com/id1",
+              "type1": "http://example.com/t1",
+              "type2": "http://example.com/t2",
+              "@language": "de",
+              "term": {
+                "@id": "http://example.com/term"
+              },
+              "term1": {
+                "@id": "http://example.com/term",
+                "@container": "@list"
+              },
+              "term2": {
+                "@id": "http://example.com/term",
+                "@container": "@list",
+                "@language": "en"
+              }
+            },
+            "term1": [
+              "v1.1",
+              "v1.2",
+              "v1.3",
+              4,
+              "v1.5",
+              {
+                "@value": "v1.6",
+                "@language": "en"
+              }
+            ],
+            "term2": [
+              "v2.1",
+              "v2.2",
+              "v2.3",
+              4,
+              "v2.5",
+              {
+                "@value": "v2.6",
+                "@language": "de"
+              }
+            ]
+          }}
+        }
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
-          jld.should produce(params[:output], @debug)
+          input = params[:input].is_a?(String) ? JSON.parse(params[:input]) : params[:input]
+          ctx = params[:context].is_a?(String) ? JSON.parse(params[:context]) : params[:context]
+          output = params[:output].is_a?(String) ? JSON.parse(params[:output]) : params[:output]
+          jld = JSON::LD::API.compact(input, ctx, nil, :debug => @debug)
+          jld.should produce(output, @debug)
         end
       end
     end
@@ -357,6 +437,36 @@ describe JSON::LD::API do
       end
     end
 
+    context "@list" do
+      {
+        "1 term 2 lists 2 languages" => {
+          :input => [{
+            "http://example.com/foo" => [
+              {"@list" => [{"@value" => "en", "@language" => "en"}]},
+              {"@list" => [{"@value" => "de", "@language" => "de"}]}
+            ]
+          }],
+          :context => {
+            "foo_en" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "en"},
+            "foo_de" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "de"}
+          },
+          :output => {
+            "@context" => {
+              "foo_en" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "en"},
+              "foo_de" => {"@id" => "http://example.com/foo", "@container" => "@list", "@language" => "de"}
+            },
+            "foo_en" => ["en"],
+            "foo_de" => ["de"]
+          }
+        },
+      }.each_pair do |title, params|
+        it title do
+          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        end
+      end
+    end
+
     context "@graph" do
       {
         "Uses @graph given mutliple inputs" => {

data/spec/evaluation_context_spec.rb

@@ -513,7 +513,7 @@ describe JSON::LD::EvaluationContext do
       subject.serialize.should produce({
         "@context" => {
           "@vocab" => 'http://example.org/',
-          "term" => {"@id" => "term", "@type" => "datatype"}
+          "term" => {"@id" => "http://example.org/term", "@type" => "datatype"}
         }
       }, @debug)
     end
@@ -549,8 +549,7 @@ describe JSON::LD::EvaluationContext do
       {
         :subject => true,
         :predicate => false,
-        :object => true,
-        :datatype => false
+        :type => false
       }.each do |position, r|
         context "as #{position}" do
           {
@@ -580,8 +579,7 @@ describe JSON::LD::EvaluationContext do
         {
           :subject => true,
           :predicate => false,
-          :object => true,
-          :datatype => false
+          :type => false
         }.each do |position, r|
           context "as #{position}" do
             before(:each) do
@@ -610,8 +608,7 @@ describe JSON::LD::EvaluationContext do
       {
         :subject => false,
         :predicate => true,
-        :object => false,
-        :datatype => true
+        :type => true
       }.each do |position, r|
         context "as #{position}" do
           {
@@ -661,7 +658,7 @@ describe JSON::LD::EvaluationContext do
       {
         "absolute IRI" =>  ["http://example.com/", "http://example.com/"],
         "term" =>          ["ex",                  "http://example.org/"],
-        "prefix:suffix" => ["suffix",              "http://example.org/suffix"],
+        "prefix:suffix" => ["ex:suffix",              "http://example.org/suffix"],
         "keyword" =>       ["@type",               "@type"],
         "empty" =>         [":suffix",             "http://empty/suffix"],
         "unmapped" =>      ["foo",                 "foo"],
@@ -750,6 +747,32 @@ describe JSON::LD::EvaluationContext do
         end
       end
     end
+
+    context "compact-0020" do
+      let(:ctx) do
+        subject.parse({
+          "ex" => "http://example.org/ns#",
+          "ex:property" => {"@container" => "@list"}
+        })
+      end
+      it "Compact @id that is a property IRI when @container is @list" do
+        ctx.compact_iri("http://example.org/ns#property", :position => :subject).
+          should produce("ex:property", @debug)
+      end
+    end
+
+    context "compact-0021" do
+      let(:ctx) do
+        subject.parse({
+          "@vocab" => "http://example.com/",
+          "sub" => "http://example.com/subdir/"
+        })
+      end
+      it "Compact properties and types using @vocab" do
+        ctx.compact_iri("http://example.com/subdir/id/1", :position => :subject).
+          should produce("sub:id/1", @debug)
+      end
+    end
   end
 
   describe "#term_rank" do
@@ -964,6 +987,40 @@ describe JSON::LD::EvaluationContext do
           end
         end
       end
+      
+      context "compact-0018" do
+        let(:ctx) do
+          subject.parse({
+            "@language" => "de",
+            "term1" => {"@id" => "http://example/term"},
+            "term2" => {"@id" => "http://example/term", "@language" => "en"}
+          })
+        end
+        {
+          "v1.1" => [{"@value" => "v1.1", "@language" => "de"}, 3, 0],
+          "v1.2" => [{"@value" => "v1.2", "@language" => "de"}, 3, 0],
+          "v1.3" => [{"@value" => "v1.3", "@language" => "de"}, 3, 0],
+          "v1.4" => [{"@value" => 4},                           2, 1],
+          "v1.5" => [{"@value" => "v1.5", "@language" => "de"}, 3, 0],
+          "v1.6" => [{"@value" => "v1.6", "@language" => "en"}, 1, 3],
+          "v2.1" => [{"@value" => "v2.1", "@language" => "en"}, 1, 3],
+          "v2.2" => [{"@value" => "v2.2", "@language" => "en"}, 1, 3],
+          "v2.3" => [{"@value" => "v2.3", "@language" => "en"}, 1, 3],
+          "v2.4" => [{"@value" => 4},                           2, 1],
+          "v2.5" => [{"@value" => "v2.5", "@language" => "en"}, 1, 3],
+          "v2.6" => [{"@value" => "v2.6", "@language" => "de"}, 3, 0],
+        }.each do |label, (val, r1, r2)|
+          context label do
+            it "has rank #{r1} for term1" do
+              ctx.send(:term_rank, "term1", val).should produce(r1, @debug)
+            end
+
+            it "has rank #{r2} for term2" do
+              ctx.send(:term_rank, "term2", val).should produce(r2, @debug)
+            end
+          end
+        end
+      end
     end
   end
 

data/spec/resource_spec.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD::Resource do
+  it "is pending"
+end

data/spec/suite_compact_spec.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open('http://json-ld.org/test-suite/tests/compact-manifest.jsonld')
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('input')}: #{t.name}" do
+          begin
+            pending("resolution of term rank in compact-0018") if t.property('input') == 'compact-0018-in.jsonld'
+            t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+            t.debug << "context: #{t.context.read}" if t.property('context')
+            result = JSON::LD::API.compact(t.input, t.context, nil,
+                                          :base => t.base,
+                                          :debug => t.debug)
+            expected = JSON.load(t.expect)
+            result.should produce(expected, t.debug)
+          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
+    end
+  end
+end unless ENV['CI']

data/spec/suite_expand_spec.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open('http://json-ld.org/test-suite/tests/expand-manifest.jsonld')
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('input')}: #{t.name}" do
+          begin
+            case t.property('input')
+            when /expand-0029/
+              pending("resolution of @type resolution in expand-0029")
+            when /expand-0030/
+              pending("implementation of language maps")
+            end
+            t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+            t.debug << "context: #{t.context.read}" if t.property('context')
+            result = JSON::LD::API.expand(t.input, nil, nil,
+                                          :base => t.base,
+                                          :debug => t.debug)
+            expected = JSON.load(t.expect)
+            result.should produce(expected, t.debug)
+          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
+    end
+  end
+end unless ENV['CI']

data/spec/suite_frame_spec.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open('http://json-ld.org/test-suite/tests/frame-manifest.jsonld')
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('input')}: #{t.name}" do
+          begin
+            t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+            t.debug << "frame: #{t.frame.read}" if t.property('frame')
+            result = JSON::LD::API.frame(t.input, t.frame, nil, 
+                                          :base => t.base,
+                                          :debug => t.debug)
+            expected = JSON.load(t.expect)
+            result.should produce(expected, t.debug)
+          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
+    end
+  end
+end unless ENV['CI']

data/spec/suite_from_rdf_spec.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD do
+  describe "test suite" do
+    require 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open('http://json-ld.org/test-suite/tests/fromRdf-manifest.jsonld')
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('input')}: #{t.name}" do
+          begin
+            t.debug = ["test: #{t.inspect}", "source: #{t.input.read}"]
+            t.input.rewind
+            t.debug << "result: #{t.expect.read}"
+            repo = RDF::Repository.load(t.base)
+            t.debug << "repo: #{repo.dump(:trig)}"
+            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)
+          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
+    end
+  end
+end unless ENV['CI']