json-ld 0.9.1 → 1.0.0

data/spec/compact_spec.rb

@@ -58,7 +58,7 @@ describe JSON::LD::API do
       "@id" => {
         :input => {"@id" => "http://example.org/test#example"},
         :context => {},
-        :output => {"@graph" => []}
+        :output => {}
       },
       "@id coercion" => {
         :input => {
@@ -136,18 +136,6 @@ describe JSON::LD::API do
           "b" => []
         }
       },
-      "empty term" => {
-        :input => {
-          "@id" => "http://example.com/",
-          "@type" => "#{RDF::RDFS.Resource}"
-        },
-        :context => {"" => "http://example.com/"},
-        :output => {
-          "@context" => {"" => "http://example.com/"},
-          "@id" => "",
-          "@type" => "#{RDF::RDFS.Resource}"
-        },
-      },
       "@type with string @id" => {
         :input => {
           "@id" => "http://example.com/",
@@ -191,7 +179,7 @@ describe JSON::LD::API do
       },
     }.each_pair do |title, params|
       it title do
-        jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+        jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
         jld.should produce(params[:output], @debug)
       end
     end
@@ -254,7 +242,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -264,7 +252,7 @@ describe JSON::LD::API do
       {
         "Uses term with nil language when two terms conflict on language" => {
           :input => [{
-            "http://example.com/term" => {"@value" => "v1", "@language" => nil}
+            "http://example.com/term" => {"@value" => "v1"}
           }],
           :context => {
             "term5" => {"@id" => "http://example.com/term","@language" => nil},
@@ -292,16 +280,80 @@ describe JSON::LD::API do
               "id1" => "http://example.com/id1",
               "@language" => "de"
             },
-            "@id" => "id1",
+            "@id" => "http://example.com/id1",
             "id1" => "foo"
           }
+        },
+        "compact-0007" => {
+          :input => ::JSON.parse(%(
+            {"http://example.org/vocab#contains": "this-is-not-an-IRI"}
+          )),
+          :context => ::JSON.parse(%({
+            "ex": "http://example.org/vocab#",
+            "ex:contains": {"@type": "@id"}
+          })),
+          :output => ::JSON.parse(%({
+            "@context": {
+              "ex": "http://example.org/vocab#",
+              "ex:contains": {"@type": "@id"}
+            },
+            "http://example.org/vocab#contains": "this-is-not-an-IRI"
+          }))
         }
       }.each_pair do |title, params|
         it title do
           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 = JSON::LD::API.compact(input, ctx, :debug => @debug)
+          jld.should produce(output, @debug)
+        end
+      end
+    end
+
+    context "@reverse" do
+      {
+        "compact-0033" => {
+          :input => %([
+            {
+              "@id": "http://example.com/people/markus",
+              "@reverse": {
+                "http://xmlns.com/foaf/0.1/knows": [
+                  {
+                    "@id": "http://example.com/people/dave",
+                    "http://xmlns.com/foaf/0.1/name": [ { "@value": "Dave Longley" } ]
+                  }
+                ]
+              },
+              "http://xmlns.com/foaf/0.1/name": [ { "@value": "Markus Lanthaler" } ]
+            }
+          ]),
+          :context => %({
+            "name": "http://xmlns.com/foaf/0.1/name",
+            "isKnownBy": { "@reverse": "http://xmlns.com/foaf/0.1/knows" }
+          }),
+          :output => %({
+            "@context": {
+              "name": "http://xmlns.com/foaf/0.1/name",
+              "isKnownBy": {
+                "@reverse": "http://xmlns.com/foaf/0.1/knows",
+                "@type": "@id"
+              }
+            },
+            "@id": "http://example.com/people/markus",
+            "name": "Markus Lanthaler",
+            "isKnownBy": {
+              "@id": "http://example.com/people/dave",
+              "name": "Dave Longley"
+            }
+          })
+        }
+      }.each_pair do |title, params|
+        it title do
+          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, :debug => @debug)
           jld.should produce(output, @debug)
         end
       end
@@ -321,7 +373,7 @@ describe JSON::LD::API do
           },
           "foo" => "bar"
         }
-        jld = JSON::LD::API.compact(input, ctx, nil, :debug => @debug, :validate => true)
+        jld = JSON::LD::API.compact(input, ctx, :debug => @debug, :validate => true)
         jld.should produce(expected, @debug)
       end
     end
@@ -337,7 +389,7 @@ describe JSON::LD::API do
           "b" => "c"
         }
         RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(ctx)
-        jld = JSON::LD::API.compact(input, "http://example.com/context", nil, :debug => @debug, :validate => true)
+        jld = JSON::LD::API.compact(input, "http://example.com/context", :debug => @debug, :validate => true)
         jld.should produce(expected, @debug)
       end
     end
@@ -366,7 +418,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -403,96 +455,7 @@ describe JSON::LD::API do
         },
       }.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 "property generators" do
-      {
-        "exactly matching" => {
-          :input => [{
-            "http://example.com/foo" => [{"@value" => "baz"}],
-            "http://example.com/bar"=> [{"@value" => "baz"}],
-          }],
-          :context => {
-            "foobar" => {"@id" => ["http://example.com/foo", "http://example.com/bar"]}
-          },
-          :output => {
-            "@context" => {
-              "foobar" => {"@id" => ["http://example.com/foo", "http://example.com/bar"]}
-            },
-            "foobar" => "baz"
-          }
-        },
-        "overlapping" => {
-          :input => [{
-            "http://example.com/foo" => [{"@value" => "baz"}, {"@value" => "baz1"}],
-            "http://example.com/bar"=> [{"@value" => "baz"}, {"@value" => "baz2"}],
-          }],
-          :context => {
-            "foobar" => {"@id" => ["http://example.com/foo", "http://example.com/bar"]}
-          },
-          :output => {
-            "@context" => {
-              "foobar" => {"@id" => ["http://example.com/foo", "http://example.com/bar"]}
-            },
-            "foobar" => "baz",
-            "http://example.com/foo" => "baz1",
-            "http://example.com/bar" => "baz2"
-          }
-        },
-        "compact-0031" => {
-          :input => JSON.parse(%q([{
-             "@id": "http://example.com/node/1",
-             "http://example.com/vocab/field_related": [{
-                "@id": "http://example.com/node/this-is-related-news"
-             }],
-             "http://schema.org/about": [{
-                "@id": "http://example.com/node/this-is-related-news"
-             }, {
-                "@id": "http://example.com/term/this-is-a-tag"
-             }],
-             "http://example.com/vocab/field_tags": [{
-                "@id": "http://example.com/term/this-is-a-tag"
-             }]
-          }])),
-          :context => JSON.parse(%q({
-            "site": "http://example.com/",
-            "field_tags": {
-              "@id": [ "site:vocab/field_tags", "http://schema.org/about" ],
-              "@container": "@set"
-            },
-            "field_related": {
-              "@id": [ "site:vocab/field_related", "http://schema.org/about" ]
-            }
-          })),
-          :output => JSON.parse(%q({
-            "@context": {
-              "site": "http://example.com/",
-              "field_tags": {
-                "@id": [
-                  "site:vocab/field_tags",
-                  "http://schema.org/about"
-                ],
-                "@container": "@set"
-              },
-              "field_related": {
-                "@id": [
-                  "site:vocab/field_related",
-                  "http://schema.org/about"
-                ]
-              }
-            },
-            "@id": "site:node/1",
-            "field_tags": [{"@id": "site:term/this-is-a-tag"}],
-            "field_related": {"@id": "site:node/this-is-related-news"}
-          })),
-        },
-      }.each_pair do |title, params|
-        it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -516,7 +479,7 @@ describe JSON::LD::API do
         },
       }.each_pair do |title, params|
         it title do
-          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld = JSON::LD::API.compact(params[:input], params[:context], :debug => @debug)
           jld.should produce(params[:output], @debug)
         end
       end
@@ -539,7 +502,7 @@ describe JSON::LD::API do
         },
       }.each do |title, params|
         it title do
-          lambda {JSON::LD::API.compact(params[:input], {}, nil)}.should raise_error(params[:exception])
+          lambda {JSON::LD::API.compact(params[:input], {})}.should raise_error(params[:exception])
         end
       end
     end

data/spec/{evaluation_context_spec.rb → context_spec.rb}

@@ -4,20 +4,40 @@ require 'spec_helper'
 require 'rdf/xsd'
 require 'rdf/spec/reader'
 
-describe JSON::LD::EvaluationContext do
+# Add for testing
+class JSON::LD::Context
+  # Retrieve type mappings
+  def coercions
+    term_definitions.inject({}) do |memo, (t,td)|
+      memo[t] = td.type_mapping
+      memo
+    end
+  end
+
+  def containers
+    term_definitions.inject({}) do |memo, (t,td)|
+      memo[t] = td.container_mapping
+      memo
+    end
+  end
+end
+
+describe JSON::LD::Context do
   before(:each) {
     @debug = []
     @ctx_json = %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"}
       }
     })
   }
-  subject { JSON::LD::EvaluationContext.new(:debug => @debug, :validate => true)}
+  let(:context) {JSON::LD::Context.new(:debug => @debug, :validate => true)}
+  subject {context}
 
-  describe "#parse", :pending => "Major update" do
+  describe "#parse" do
     context "remote" do
       before(:each) do
         @ctx = StringIO.new(@ctx_json)
@@ -32,13 +52,14 @@ 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 retrieve remote context/)
+        lambda {subject.parse("http://example.com/context")}.should raise_error(JSON::LD::InvalidContext::InvalidRemoteContext, "http://example.com/context")
       end
 
       it "creates mappings" do
         RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(@ctx)
         ec = subject.parse("http://example.com/context")
         ec.mappings.should produce({
+          "xsd"      => "http://www.w3.org/2001/XMLSchema#",
           "name"     => "http://xmlns.com/foaf/0.1/name",
           "homepage" => "http://xmlns.com/foaf/0.1/homepage",
           "avatar"   => "http://xmlns.com/foaf/0.1/avatar"
@@ -55,17 +76,7 @@ describe JSON::LD::EvaluationContext do
         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
-      it "uses a duplicate of that provided" do
-        ec = subject.parse(StringIO.new(@ctx_json))
-        ec.mappings.should produce({
+          "xsd"      => "http://www.w3.org/2001/XMLSchema#",
           "name"     => "http://xmlns.com/foaf/0.1/name",
           "homepage" => "http://xmlns.com/foaf/0.1/homepage",
           "avatar"   => "http://xmlns.com/foaf/0.1/avatar"
@@ -119,7 +130,7 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
-      it "associates @list coercion with predicate" do
+      it "associates @list container mapping with predicate" do
         subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@list"}
         }).containers.should produce({
@@ -127,7 +138,7 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
-      it "associates @set coercion with predicate" do
+      it "associates @set container mapping with predicate" do
         subject.parse({
           "foo" => {"@id" => "http://example.com/", "@container" => "@set"}
         }).containers.should produce({
@@ -135,7 +146,7 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
-      it "associates @id coercion with predicate" do
+      it "associates @id container mapping with predicate" do
         subject.parse({
           "foo" => {"@id" => "http://example.com/", "@type" => "@id"}
         }).coercions.should produce({
@@ -143,7 +154,7 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
-      it "associates datatype coercion with predicate" do
+      it "associates type mapping with predicate" do
         subject.parse({
           "foo" => {"@id" => "http://example.com/", "@type" => RDF::XSD.string.to_s}
         }).coercions.should produce({
@@ -151,7 +162,7 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
 
-      it "associates language coercion with predicate" do
+      it "associates language mapping with predicate" do
         subject.parse({
           "foo" => {"@id" => "http://example.com/", "@language" => "en"}
         }).languages.should produce({
@@ -213,7 +224,7 @@ describe JSON::LD::EvaluationContext do
         end
 
         it "loads initial context" do
-          init_ec = JSON::LD::EvaluationContext.new
+          init_ec = JSON::LD::Context.new
           nil_ec = subject.parse(nil)
           nil_ec.default_language.should == init_ec.default_language
           nil_ec.languages.should == init_ec.languages
@@ -226,25 +237,6 @@ describe JSON::LD::EvaluationContext do
           subject.parse({"name" => nil}).mapping("name").should be_nil
         end
       end
-
-      context "property generator" do
-        {
-          "empty" => [
-            {"term" => {"@id" => []}},
-            []
-          ],
-          "single" => [
-            {"term" => {"@id" => ["http://example.com/"]}},
-            ["http://example.com/"]
-          ],
-          "multiple" => [
-            {"term" => {"@id" => ["http://example.com/", "http://example.org/"]}},
-            ["http://example.com/", "http://example.org/"]
-          ],
-        }.each do |title, (input, result)|
-          specify(title) {subject.parse(input).mapping("term").should produce(result, @debug)}
-        end
-      end
     end
 
     describe "Syntax Errors" do
@@ -269,23 +261,23 @@ describe JSON::LD::EvaluationContext do
           lambda {
             ec = subject.parse(context)
             ec.serialize.should produce({}, @debug)
-          }.should raise_error(JSON::LD::InvalidContext::Syntax)
+          }.should raise_error(JSON::LD::InvalidContext)
         end
       end
       
-      (JSON::LD::KEYWORDS - %w(@language @vocab)).each do |kw|
+      (JSON::LD::KEYWORDS - %w(@base @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)
+          }.should raise_error(JSON::LD::InvalidContext)
         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::Syntax)
+          }.should raise_error(JSON::LD::InvalidContext)
         end
       end
     end
@@ -295,7 +287,7 @@ describe JSON::LD::EvaluationContext do
         "fixme" => "FIXME",
       }.each do |title, context|
         it title do
-          lambda { subject.parse(context) }.should raise_error(JSON::LD::InvalidContext::LoadError)
+          lambda { subject.parse(context) }.should raise_error(JSON::LD::InvalidContext::InvalidRemoteContext)
         end
       end
     end
@@ -313,18 +305,6 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
-    it "context array", :pending => "Major update" do
-      ctx = [
-        {"foo" => "http://example.com/"},
-        {"baz" => "bob"}
-      ]
-
-      ec = subject.parse(ctx)
-      ec.serialize.should produce({
-        "@context" => ctx
-      }, @debug)
-    end
-
     it "context hash" do
       ctx = {"foo" => "http://example.com/"}
 
@@ -353,28 +333,22 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "term mappings" do
-      subject.set_mapping("foo", "http://example.com/")
-      subject.serialize.should produce({
+      subject.
+        parse({'foo' => "http://example.com/"}).send(:clear_provided_context).
+        serialize.should produce({
         "@context" => {
           "foo" => "http://example.com/"
         }
       }, @debug)
     end
 
-    it "property generator" do
-      subject.set_mapping("foo", ["http://example.com/", "http://example.org/"])
-      subject.serialize.should produce({
-        "@context" => {
-          "foo" => ["http://example.com/", "http://example.org/"]
-        }
-      }, @debug)
-    end
-
     it "@type with dependent prefixes in a single context" do
-      subject.set_mapping("xsd", RDF::XSD.to_uri.to_s)
-      subject.set_mapping("homepage", RDF::FOAF.homepage.to_s)
-      subject.set_coerce("homepage", "@id")
-      subject.serialize.should produce({
+      subject.parse({
+        'xsd' => "http://www.w3.org/2001/XMLSchema#",
+        'homepage' => {'@id' => RDF::FOAF.homepage.to_s, '@type' => '@id'}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "xsd" => RDF::XSD.to_uri,
           "homepage" => {"@id" => RDF::FOAF.homepage.to_s, "@type" => "@id"}
@@ -383,9 +357,11 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "@list with @id definition in a single context" do
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_container("knows", '@list')
-      subject.serialize.should produce({
+      subject.parse({
+        'knows' => {'@id' => RDF::FOAF.knows.to_s, '@container' => '@list'}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@list"}
         }
@@ -393,9 +369,11 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "@set with @id definition in a single context" do
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_container("knows", '@set')
-      subject.serialize.should produce({
+      subject.parse({
+        "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@set"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@set"}
         }
@@ -403,9 +381,11 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "@language with @id definition in a single context" do
-      subject.set_mapping("name", RDF::FOAF.name.to_s)
-      subject.set_language("name", 'en')
-      subject.serialize.should produce({
+      subject.parse({
+        "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => "en"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => "en"}
         }
@@ -413,22 +393,26 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "@language with @id definition in a single context and equivalent default" do
-      subject.set_mapping("name", RDF::FOAF.name.to_s)
-      subject.default_language = 'en'
-      subject.set_language("name", 'en')
-      subject.serialize.should produce({
+      subject.parse({
+        "@language" => 'en',
+        "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => 'en'}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "@language" => 'en',
-          "name" => {"@id" => RDF::FOAF.name.to_s}
+          "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => 'en'}
         }
       }, @debug)
     end
 
     it "@language with @id definition in a single context and different default" do
-      subject.set_mapping("name", RDF::FOAF.name.to_s)
-      subject.default_language = 'en'
-      subject.set_language("name", 'de')
-      subject.serialize.should produce({
+      subject.parse({
+        "@language" => 'en',
+        "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => "de"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "@language" => 'en',
           "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => "de"}
@@ -437,10 +421,12 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "null @language with @id definition in a single context and default" do
-      subject.set_mapping("name", RDF::FOAF.name.to_s)
-      subject.default_language = 'en'
-      subject.set_language("name", nil)
-      subject.serialize.should produce({
+      subject.parse({
+        "@language" => 'en',
+        "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => nil}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "@language" => 'en',
           "name" => {"@id" => RDF::FOAF.name.to_s, "@language" => nil}
@@ -449,10 +435,11 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "prefix with @type and @list" do
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_coerce("knows", "@id")
-      subject.set_container("knows", '@list')
-      subject.serialize.should produce({
+      subject.parse({
+        "knows" => {"@id" => RDF::FOAF.knows.to_s, "@type" => "@id", "@container" => "@list"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@type" => "@id", "@container" => "@list"}
         }
@@ -460,10 +447,11 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "prefix with @type and @set" do
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_coerce("knows", "@id")
-      subject.set_container("knows", '@set')
-      subject.serialize.should produce({
+      subject.parse({
+        "knows" => {"@id" => RDF::FOAF.knows.to_s, "@type" => "@id", "@container" => "@set"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@type" => "@id", "@container" => "@set"}
         }
@@ -471,21 +459,31 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "CURIE with @type" do
-      subject.set_mapping("foaf", RDF::FOAF.to_uri.to_s)
-      subject.set_container("foaf:knows", '@list')
-      subject.serialize.should produce({
+      subject.parse({
+        "foaf" => RDF::FOAF.to_uri.to_s,
+        "foaf:knows" => {
+          "@id" => RDF::FOAF.knows.to_s,
+          "@container" => "@list"
+        }
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
-          "foaf" => RDF::FOAF.to_uri,
-          "foaf:knows" => {"@container" => "@list"}
+          "foaf" => RDF::FOAF.to_uri.to_s,
+          "foaf:knows" => {
+            "@container" => "@list"
+          }
         }
       }, @debug)
     end
 
     it "does not use aliased @id in key position" do
-      subject.set_mapping("id", '@id')
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_container("knows", '@list')
-      subject.serialize.should produce({
+      subject.parse({
+        "id" => "@id",
+        "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@list"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "id" => "@id",
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@list"}
@@ -494,23 +492,34 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "does not use aliased @id in value position" do
-      subject.set_mapping("id", "@id")
-      subject.set_mapping("foaf", RDF::FOAF.to_uri.to_s)
-      subject.set_coerce("foaf:homepage", "@id")
-      subject.serialize.should produce({
+      subject.parse({
+        "foaf" => RDF::FOAF.to_uri.to_s,
+        "id" => "@id",
+        "foaf:homepage" => {
+          "@id" => RDF::FOAF.homepage.to_s,
+          "@type" => "@id"
+        }
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "foaf" => RDF::FOAF.to_uri.to_s,
           "id" => "@id",
-          "foaf:homepage" => {"@type" => "@id"}
+          "foaf:homepage" => {
+            "@type" => "@id"
+          }
         }
       }, @debug)
     end
 
     it "does not use aliased @type" do
-      subject.set_mapping("type", "@type")
-      subject.set_mapping("foaf", RDF::FOAF.to_uri.to_s)
-      subject.set_coerce("foaf:homepage", "@id")
-      subject.serialize.should produce({
+      subject.parse({
+        "foaf" => RDF::FOAF.to_uri.to_s,
+        "type" => "@type",
+        "foaf:homepage" => {"@type" => "@id"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "foaf" => RDF::FOAF.to_uri.to_s,
           "type" => "@type",
@@ -520,10 +529,12 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "does not use aliased @container" do
-      subject.set_mapping("container", '@container')
-      subject.set_mapping("knows", RDF::FOAF.knows.to_s)
-      subject.set_container("knows", '@list')
-      subject.serialize.should produce({
+      subject.parse({
+        "container" => "@container",
+        "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@list"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "container" => "@container",
           "knows" => {"@id" => RDF::FOAF.knows.to_s, "@container" => "@list"}
@@ -532,10 +543,12 @@ describe JSON::LD::EvaluationContext do
     end
 
     it "compacts IRIs to CURIEs" do
-      subject.set_mapping("ex", 'http://example.org/')
-      subject.set_mapping("term", 'http://example.org/term')
-      subject.set_coerce("term", "http://example.org/datatype")
-      subject.serialize.should produce({
+      subject.parse({
+        "ex" => 'http://example.org/',
+        "term" => {"@id" => "ex:term", "@type" => "ex:datatype"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "ex" => 'http://example.org/',
           "term" => {"@id" => "ex:term", "@type" => "ex:datatype"}
@@ -544,10 +557,12 @@ describe JSON::LD::EvaluationContext do
     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({
+      subject.parse({
+        "@vocab" => 'http://example.org/',
+        "term" => {"@id" => "http://example.org/term", "@type" => "datatype"}
+      }).
+      send(:clear_provided_context).
+      serialize.should produce({
         "@context" => {
           "@vocab" => 'http://example.org/',
           "term" => {"@id" => "http://example.org/term", "@type" => "datatype"}
@@ -555,11 +570,11 @@ describe JSON::LD::EvaluationContext do
       }, @debug)
     end
 
-    context "extra keys or values", :pending => "Major update" do
+    context "extra keys or values" do
       {
         "extra key" => {
           :input => {"foo" => {"@id" => "http://example.com/foo", "@baz" => "foobar"}},
-          :result => {"@context" => {"foo" => {"@id" => "http://example.com/foo", "@baz" => "foobar"}}}
+          :result => {"@context" => {"foo" => "http://example.com/foo"}}
         }
       }.each do |title, params|
         it title do
@@ -572,163 +587,156 @@ describe JSON::LD::EvaluationContext do
   end
 
   describe "#expand_iri" do
-    before(:each) do
-      subject.set_mapping("ex", "http://example.org/")
-      subject.set_mapping("", "http://empty/")
-      subject.set_mapping("_", "http://underscore/")
-    end
+    subject {
+      context.parse({
+        '@base' => 'http://base/',
+        '@vocab' => 'http://vocab/',
+        'ex' => 'http://example.org/',
+        '' => 'http://empty/',
+        '_' => 'http://underscore/'
+      })
+    }
 
     it "bnode" do
       subject.expand_iri("_:a").should be_a(RDF::Node)
     end
 
-    context "keywords", :pending => "Major update" do
+    context "keywords" do
       %w(id type).each do |kw|
         it "expands #{kw} to @#{kw}" do
           subject.set_mapping(kw, "@#{kw}")
-          subject.expand_iri(kw).should produce("@#{kw}", @debug)
+          subject.expand_iri(kw, :vocab => true).should produce("@#{kw}", @debug)
         end
       end
     end
 
-    context "relative IRI", :pending => "Major update" do
-      {
-        :subject => true,
-        :predicate => false,
-        :type => false
-      }.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",                 "foo", false],
-            "empty term" =>    ["",                    "http://empty/", true],
-            "another abs IRI"=>["ex://foo",            "ex://foo", true],
-            "absolute IRI looking like a curie" =>
-                               ["foo:bar",             "foo:bar", true],
-            "bnode" =>         ["_:foo",               RDF::Node("foo"), true],
-            "_" =>             ["_",                   "http://underscore/", true],
-          }.each do |title, (input,result,abs)|
-            result = nil unless r || abs
-            result = nil if title == 'unmapped'
-            it title do
-              subject.expand_iri(input).should produce(result, @debug)
-            end
+    context "relative IRI" do
+      context "with no options" do
+        {
+          "absolute IRI" =>  ["http://example.org/", RDF::URI("http://example.org/")],
+          "term" =>          ["ex",                  RDF::URI("ex")],
+          "prefix:suffix" => ["ex:suffix",           RDF::URI("http://example.org/suffix")],
+          "keyword" =>       ["@type",               "@type"],
+          "empty" =>         [":suffix",             RDF::URI("http://empty/suffix")],
+          "unmapped" =>      ["foo",                 RDF::URI("foo")],
+          "empty term" =>    ["",                    RDF::URI("")],
+          "another abs IRI"=>["ex://foo",            RDF::URI("ex://foo")],
+          "absolute IRI looking like a curie" =>
+                             ["foo:bar",             RDF::URI("foo:bar")],
+          "bnode" =>         ["_:t0",                RDF::Node("t0")],
+          "_" =>             ["_",                   RDF::URI("_")],
+        }.each do |title, (input, result)|
+          it title do
+            subject.expand_iri(input).should produce(result, @debug)
           end
         end
       end
 
       context "with base IRI" do
         {
-          :subject => true,
-          :predicate => false,
-          :type => true
-        }.each do |position, r|
-          context "as #{position}" do
-            before(:each) do
-              subject.instance_variable_set(:@base, RDF::URI("http://example.org/"))
-              subject.mappings.delete("")
-            end
-
-            {
-              "base" =>     ["",            RDF::URI("http://example.org/")],
-              "relative" => ["a/b",         RDF::URI("http://example.org/a/b")],
-              "hash" =>     ["#a",          RDF::URI("http://example.org/#a")],
-              "absolute" => ["http://foo/", RDF::URI("http://foo/")]
-            }.each do |title, (input,result)|
-              result = nil unless r || title == 'absolute'
-              it title do
-                subject.expand_iri(input, :position => position).should produce(result, @debug)
-              end
-            end
+          "absolute IRI" =>  ["http://example.org/", RDF::URI("http://example.org/")],
+          "term" =>          ["ex",                  RDF::URI("http://base/ex")],
+          "prefix:suffix" => ["ex:suffix",           RDF::URI("http://example.org/suffix")],
+          "keyword" =>       ["@type",               "@type"],
+          "empty" =>         [":suffix",             RDF::URI("http://empty/suffix")],
+          "unmapped" =>      ["foo",                 RDF::URI("http://base/foo")],
+          "empty term" =>    ["",                    RDF::URI("http://base/")],
+          "another abs IRI"=>["ex://foo",            RDF::URI("ex://foo")],
+          "absolute IRI looking like a curie" =>
+                             ["foo:bar",             RDF::URI("foo:bar")],
+          "bnode" =>         ["_:t0",                RDF::Node("t0")],
+          "_" =>             ["_",                   RDF::URI("http://base/_")],
+        }.each do |title, (input, result)|
+          it title do
+            subject.expand_iri(input, :documentRelative => true).should produce(result, @debug)
           end
         end
       end
-    end
     
-    context "@vocab" do
-      before(:each) { subject.vocab = "http://example.com/"}
-      {
-        :subject => false,
-        :predicate => true,
-        :type => 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
+      context "@vocab" do
+        {
+          "absolute IRI" =>  ["http://example.org/", RDF::URI("http://example.org/")],
+          "term" =>          ["ex",                  RDF::URI("http://example.org/")],
+          "prefix:suffix" => ["ex:suffix",           RDF::URI("http://example.org/suffix")],
+          "keyword" =>       ["@type",               "@type"],
+          "empty" =>         [":suffix",             RDF::URI("http://empty/suffix")],
+          "unmapped" =>      ["foo",                 RDF::URI("http://vocab/foo")],
+          "empty term" =>    ["",                    RDF::URI("http://empty/")],
+          "another abs IRI"=>["ex://foo",            RDF::URI("ex://foo")],
+          "absolute IRI looking like a curie" =>
+                             ["foo:bar",             RDF::URI("foo:bar")],
+          "bnode" =>         ["_:t0",                RDF::Node("t0")],
+          "_" =>             ["_",                   RDF::URI("http://underscore/")],
+        }.each do |title, (input, result)|
+          it title do
+            subject.expand_iri(input, :vocab => true).should produce(result, @debug)
           end
         end
       end
-      
-      it "removes term if set to null with @vocab" do
-        subject.set_mapping("term", nil)
-        subject.expand_iri("term").should produce(nil, @debug)
-      end
-    end
-    
-    context "property generator" do
-      before(:each) {subject.set_mapping("pg", ["http://a/", "http://b/"])}
-      {
-        "term" =>          ["pg",                  ["http://a/", "http://b/"]],
-        "prefix:suffix" => ["pg:suffix",           ["http://a/suffix", "http://b/suffix"]],
-      }.each do |title, (input,result)|
-        it title do
-          subject.expand_iri(input).should produce(result, @debug)
-        end
-      end
     end
   end
 
   describe "#compact_iri" do
-    before(:each) do
-      subject.set_mapping("ex", "http://example.org/")
-      subject.set_mapping("", "http://empty/")
-      subject.set_mapping("http://example.com/null", nil)
-    end
+    subject {
+      c = context.parse({
+        '@base' => 'http://base/',
+        "xsd"   => "http://www.w3.org/2001/XMLSchema#",
+        'ex'    => 'http://example.org/',
+        ''      => 'http://empty/',
+        '_'     => 'http://underscore/',
+        'rex'   => {'@reverse' => "ex"},
+        'lex'   => {'@id' => 'ex', '@language' => 'en'},
+        'tex'   => {'@id' => 'ex', '@type' => 'xsd:string'}
+      })
+      @debug.clear
+      c
+    }
 
     {
-      "absolute IRI" =>  ["http://example.com/", "http://example.com/"],
-      "term" =>          ["ex",                  "http://example.org/"],
+      "nil" => [nil, nil],
+      "absolute IRI"  => ["http://example.com/", "http://example.com/"],
       "prefix:suffix" => ["ex:suffix",           "http://example.org/suffix"],
-      "keyword" =>       ["@type",               "@type"],
-      "empty" =>         [":suffix",             "http://empty/suffix"],
-      "unmapped" =>      ["foo",                 "foo"],
-      "bnode" =>         ["_:a",                 RDF::Node("a")],
-      "null IRI" =>      [nil,                   "http://example.com/null"],
+      "keyword"       => ["@type",               "@type"],
+      "empty"         => [":suffix",             "http://empty/suffix"],
+      "unmapped"      => ["foo",                 "foo"],
+      "bnode"         => ["_:a",                 RDF::Node("a")],
+      "relative"      => ["foo/bar",             "http://base/foo/bar"]
     }.each do |title, (result, input)|
       it title do
         subject.compact_iri(input).should produce(result, @debug)
       end
     end
 
+    context "with :vocab option" do
+      {
+        "absolute IRI"  => ["http://example.com/", "http://example.com/"],
+        "prefix:suffix" => ["ex:suffix",           "http://example.org/suffix"],
+        "keyword"       => ["@type",               "@type"],
+        "empty"         => [":suffix",             "http://empty/suffix"],
+        "unmapped"      => ["foo",                 "foo"],
+        "bnode"         => ["_:a",                 RDF::Node("a")],
+        "relative"      => ["http://base/foo/bar", "http://base/foo/bar"]
+      }.each do |title, (result, input)|
+        it title do
+          subject.compact_iri(input, :vocab => true).should produce(result, @debug)
+        end
+      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" => ["ex:suffix",           "http://example.org/suffix"],
-        "keyword" =>       ["@type",               "@type"],
-        "empty" =>         [":suffix",             "http://empty/suffix"],
-        "unmapped" =>      ["foo",                 "foo"],
-        "bnode" =>         ["_:a",                 RDF::Node("a")],
+        "absolute IRI"  => ["http://example.com/", "http://example.com/"],
+        "prefix:suffix" => ["suffix",              "http://example.org/suffix"],
+        "keyword"       => ["@type",               "@type"],
+        "empty"         => [":suffix",             "http://empty/suffix"],
+        "unmapped"      => ["foo",                 "foo"],
+        "bnode"         => ["_:a",                 RDF::Node("a")],
+        "relative"      => ["http://base/foo/bar", "http://base/foo/bar"]
       }.each do |title, (result, input)|
         it title do
-          subject.compact_iri(input).should produce(result, @debug)
+          subject.compact_iri(input, :vocab => true).should produce(result, @debug)
         end
       end
 
@@ -736,11 +744,11 @@ describe JSON::LD::EvaluationContext do
         subject.set_mapping("name", "http://xmlns.com/foaf/0.1/name")
         subject.set_mapping("ex", nil)
         subject.compact_iri("http://example.org/name", :position => :predicate).
-          should produce("http://example.org/name", @debug)
+          should produce("lex:name", @debug)
       end
     end
 
-    context "with value", :pending => "Major update" do
+    context "with value" do
       let(:ctx) do
         c = subject.parse({
           "xsd" => RDF::XSD.to_s,
@@ -773,13 +781,13 @@ describe JSON::LD::EvaluationContext do
 
       {
         "langmap" => [{"@value" => "en", "@language" => "en"}],
-        "plain" => [{"@value" => "foo"}],
-        "setplain" => [{"@value" => "foo", "@language" => "pl"}] # looks like langmap
+        #"plain" => [{"@value" => "foo"}],
+        "setplain" => [{"@value" => "foo", "@language" => "pl"}]
       }.each do |prop, values|
         context "uses #{prop}" do
           values.each do |value|
             it "for #{value.inspect}" do
-              ctx.compact_iri("http://example.com/#{prop.sub('set', '')}", :value => value).should produce(prop, @debug)
+              ctx.compact_iri("http://example.com/#{prop.sub('set', '')}", :value => value, :vocab => true).should produce(prop, @debug)
             end
           end
         end
@@ -795,17 +803,19 @@ describe JSON::LD::EvaluationContext do
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => true}],
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => 1}],
             [{"@value" => "de", "@language" => "de"}, {"@value" => "jp", "@language" => "jp"}],
+            [{"@value" => true}], [{"@value" => false}], 
+            [[{"@value" => 1}], [{"@value" => 1.1}], 
           ],
           "listlang" => [[{"@value" => "en", "@language" => "en"}]],
-          "listbool" => [[{"@value" => true}], [{"@value" => false}], [{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}]],
-          "listinteger" => [[{"@value" => 1}], [{"@value" => "1", "@type" => RDF::XSD.integer.to_s}]],
-          "listdouble" => [[{"@value" => 1.1}], [{"@value" => "1", "@type" => RDF::XSD.double.to_s}]],
+          "listbool" => [[{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}]],
+          "listinteger" => [{"@value" => "1", "@type" => RDF::XSD.integer.to_s}]],
+          "listdouble" => [[{"@value" => "1", "@type" => RDF::XSD.double.to_s}]],
           "listdate" => [[{"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}]],
         }.each do |prop, values|
           context "uses #{prop}" do
             values.each do |value|
               it "for #{{"@list" => value}.inspect}" do
-                ctx.compact_iri("http://example.com/#{prop.sub('list', '')}", :value => {"@list" => value}).should produce(prop, @debug)
+                ctx.compact_iri("http://example.com/#{prop.sub('list', '')}", :value => {"@list" => value}, :vocab => true).should produce(prop, @debug)
               end
             end
           end
@@ -813,7 +823,7 @@ describe JSON::LD::EvaluationContext do
       end
     end
 
-    context "compact-0018", :pending => "Major update" do
+    context "compact-0018" do
       let(:ctx) do
         subject.parse(JSON.parse %({
           "id1": "http://example.com/id1",
@@ -912,7 +922,7 @@ describe JSON::LD::EvaluationContext do
       }.each do |term, value|
         [value].flatten.each do |v|
           it "Uses #{term} for #{v}" do
-            ctx.compact_iri("http://example.com/term", :value => JSON.parse(v)).
+            ctx.compact_iri("http://example.com/term", :value => JSON.parse(v), :vocab => true).
               should produce(term, @debug)
           end
         end
@@ -932,19 +942,6 @@ describe JSON::LD::EvaluationContext do
       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
-
     context "compact-0041" do
       let(:ctx) do
         subject.parse({"name" => {"@id" => "http://example.com/property", "@container" => "@list"}})
@@ -958,268 +955,23 @@ describe JSON::LD::EvaluationContext do
     end
   end
 
-  describe "#term_rank", :pending => "Major update" do
-    {
-      "no coercions" => {
-        :defn => {},
-        "boolean value" => {:value => {"@value" => true}, :rank => 2},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 2},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 2},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 3},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 1},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 1},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 1},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "boolean" => {
-        :defn => {"@type" => RDF::XSD.boolean.to_s},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-        "value boolean" => {:value => {"@value" => "true", "@type" => RDF::XSD.boolean.to_s}, :rank => 3},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "integer" => {
-        :defn => {"@type" => RDF::XSD.integer.to_s},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-        "value integer" => {:value => {"@value" => "1", "@type" => RDF::XSD.integer.to_s}, :rank => 3},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "double" => {
-        :defn => {"@type" => RDF::XSD.double.to_s},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-        "value double" => {:value => {"@value" => "1.1", "@type" => RDF::XSD.double.to_s}, :rank => 3},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "date" => {
-        :defn => {"@type" => RDF::XSD.date.to_s},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 3},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "lang" => {
-        :defn => {"@language" => "en"},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 2},
-        "other lang" => {:value => {"@value" => "apple", "@language" => "de"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-        "null"  => {:value => nil, :rank => 3},
-      },
-      "id" => {
-        :defn => {"@type" => "@id"},
-        "boolean value" => {:value => {"@value" => true}, :rank => 1},
-        "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-        "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-        "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-        "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-        "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-        "other lang" => {:value => {"@value" => "apple", "@language" => "de"}, :rank => 0},
-        "id"    => {:value => {"@id" => "http://example/id"}, :rank => 3},
-        "null"  => {:value => nil, :rank => 3},
-      },
-    }.each do |title, properties|
-      context title do
-        let(:ctx) do
-          subject.parse({
-            "term" => properties[:defn].merge("@id" => "http://example.org/term")
-          })
-        end
-        properties.each do |type, defn|
-          next unless type.is_a?(String)
-          it "returns #{defn[:rank]} for #{type}" do
-            ctx.send(:term_rank, "term", defn[:value]).should produce(defn[:rank], @debug)
-          end
-        end
-      end
-    end
-    
-    context "with default language" do
-      before(:each) {subject.default_language = "en"}
-      {
-        "no coercions" => {
-          :defn => {},
-          "boolean value" => {:value => {"@value" => true}, :rank => 2},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 2},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 2},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 2},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 1},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 2},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 1},
-          "value string" => {:value => {"@value" => "foo"}, :rank => 2},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "boolean" => {
-          :defn => {"@type" => RDF::XSD.boolean.to_s},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "value boolean" => {:value => {"@value" => "true", "@type" => RDF::XSD.boolean.to_s}, :rank => 3},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "integer" => {
-          :defn => {"@type" => RDF::XSD.integer.to_s},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "value integer" => {:value => {"@value" => "1", "@type" => RDF::XSD.integer.to_s}, :rank => 3},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "double" => {
-          :defn => {"@type" => RDF::XSD.double.to_s},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "value double" => {:value => {"@value" => "1.1", "@type" => RDF::XSD.double.to_s}, :rank => 3},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "date" => {
-          :defn => {"@type" => RDF::XSD.date.to_s},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 3},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "lang" => {
-          :defn => {"@language" => "en"},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 2},
-          "other lang" => {:value => {"@value" => "apple", "@language" => "de"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "null lang" => {
-          :defn => {"@language" => nil},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string value" => {:value => {"@value" => "foo"}, :rank => 3},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 0},
-          "null"  => {:value => nil, :rank => 3},
-        },
-        "id" => {
-          :defn => {"@type" => "@id"},
-          "boolean value" => {:value => {"@value" => true}, :rank => 1},
-          "integer value"    => {:value => {"@value" => 1}, :rank => 1},
-          "double value" => {:value => {"@value" => 1.1}, :rank => 1},
-          "string" => {:value => {"@value" => "foo"}, :rank => 0},
-          "date"  => {:value => {"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}, :rank => 0},
-          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 0},
-          "other lang" => {:value => {"@value" => "apple", "@language" => "de"}, :rank => 0},
-          "id"    => {:value => {"@id" => "http://example/id"}, :rank => 3},
-          "null"  => {:value => nil, :rank => 3},
-        },
-      }.each do |title, properties|
-        context title do
-          let(:ctx) do
-            subject.parse({
-              "term" => properties[:defn].merge("@id" => "http://example.org/term")
-            })
-          end
-          properties.each do |type, defn|
-            next unless type.is_a?(String)
-            it "returns #{defn[:rank]} for #{type}" do
-              ctx.send(:term_rank, "term", defn[:value]).should produce(defn[:rank], @debug)
-            end
-          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"}, 2, 0],
-          "v1.2" => [{"@value" => "v1.2", "@language" => "de"}, 2, 0],
-          "v1.3" => [{"@value" => "v1.3", "@language" => "de"}, 2, 0],
-          "v1.4" => [{"@value" => 4},                           2, 1],
-          "v1.5" => [{"@value" => "v1.5", "@language" => "de"}, 2, 0],
-          "v1.6" => [{"@value" => "v1.6", "@language" => "en"}, 1, 2],
-          "v2.1" => [{"@value" => "v2.1", "@language" => "en"}, 1, 2],
-          "v2.2" => [{"@value" => "v2.2", "@language" => "en"}, 1, 2],
-          "v2.3" => [{"@value" => "v2.3", "@language" => "en"}, 1, 2],
-          "v2.4" => [{"@value" => 4},                           2, 1],
-          "v2.5" => [{"@value" => "v2.5", "@language" => "en"}, 1, 2],
-          "v2.6" => [{"@value" => "v2.6", "@language" => "de"}, 2, 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
-
   describe "#expand_value" do
-    before(:each) do
-      subject.set_mapping("dc", RDF::DC.to_uri.to_s)
-      subject.set_mapping("ex", "http://example.org/")
-      subject.set_mapping("foaf", RDF::FOAF.to_uri.to_s)
-      subject.set_mapping("xsd", RDF::XSD.to_uri.to_s)
-      subject.set_coerce("foaf:age", RDF::XSD.integer.to_s)
-      subject.set_coerce("foaf:knows", "@id")
-      subject.set_coerce("dc:created", RDF::XSD.date.to_s)
-      subject.set_coerce("ex:integer", RDF::XSD.integer.to_s)
-      subject.set_coerce("ex:double", RDF::XSD.double.to_s)
-      subject.set_coerce("ex:boolean", RDF::XSD.boolean.to_s)
-    end
+    subject {
+      ctx = context.parse({
+        "dc" => RDF::DC.to_uri.to_s,
+        "ex" => "http://example.org/",
+        "foaf" => RDF::FOAF.to_uri.to_s,
+        "xsd" => "http://www.w3.org/2001/XMLSchema#",
+        "foaf:age" => {"@type" => "xsd:integer"},
+        "foaf:knows" => {"@type" => "@id"},
+        "dc:created" => {"@type" => "xsd:date"},
+        "ex:integer" => {"@type" => "xsd:integer"},
+        "ex:double" => {"@type" => "xsd:double"},
+        "ex:boolean" => {"@type" => "xsd:boolean"},
+      })
+      @debug.clear
+      ctx
+    }
 
     %w(boolean integer string dateTime date time).each do |dt|
       it "expands datatype xsd:#{dt}" do
@@ -1229,7 +981,7 @@ describe JSON::LD::EvaluationContext do
 
     {
       "absolute IRI" =>   ["foaf:knows",  "http://example.com/",  {"@id" => "http://example.com/"}],
-      "term" =>           ["foaf:knows",  "ex",                   {"@id" => "http://example.org/"}],
+      "term" =>           ["foaf:knows",  "ex",                   {"@id" => "ex"}],
       "prefix:suffix" =>  ["foaf:knows",  "ex:suffix",            {"@id" => "http://example.org/suffix"}],
       "no IRI" =>         ["foo",         "http://example.com/",  {"@value" => "http://example.com/"}],
       "no term" =>        ["foo",         "ex",                   {"@value" => "ex"}],
@@ -1296,34 +1048,34 @@ describe JSON::LD::EvaluationContext do
   end
 
   describe "compact_value" do
-    before(:each) do
-      subject.set_mapping("dc", RDF::DC.to_uri.to_s)
-      subject.set_mapping("ex", "http://example.org/")
-      subject.set_mapping("foaf", RDF::FOAF.to_uri.to_s)
-      subject.set_mapping("xsd", RDF::XSD.to_uri.to_s)
-      subject.set_mapping("list", "http://example.org/list")
-      subject.set_mapping("nolang", "http://example.org/nolang")
-      subject.set_coerce("foaf:age", RDF::XSD.integer.to_s)
-      subject.set_coerce("foaf:knows", "@id")
-      subject.set_coerce("dc:created", RDF::XSD.date.to_s)
-      subject.set_container("list", "@list")
-      subject.set_language("nolang", nil)
-      subject.set_mapping("langmap", "http://example.org/langmap")
-      subject.set_container("langmap", "@language")
+    let(:ctx) do
+      c = context.parse({
+        "dc"         => RDF::DC.to_uri.to_s,
+        "ex"         => "http://example.org/",
+        "foaf"       => RDF::FOAF.to_uri.to_s,
+        "xsd"        => RDF::XSD.to_s,
+        "langmap"    => {"@id" => "http://example.com/langmap", "@container" => "@language"},
+        "list"       => {"@id" => "http://example.org/list", "@container" => "@list"},
+        "nolang"     => {"@id" => "http://example.org/nolang", "@language" => nil},
+        "dc:created" => {"@type" => RDF::XSD.date.to_s},
+        "foaf:age"   => {"@type" => RDF::XSD.integer.to_s},
+        "foaf:knows" => {"@type" => "@id"},
+      })
+      @debug.clear
+      c
     end
+    subject {ctx}
 
     {
       "absolute IRI" =>   ["foaf:knows",  "http://example.com/",  {"@id" => "http://example.com/"}],
-      "term" =>           ["foaf:knows",  "ex",                   {"@id" => "http://example.org/"}],
       "prefix:suffix" =>  ["foaf:knows",  "ex:suffix",            {"@id" => "http://example.org/suffix"}],
       "integer" =>        ["foaf:age",    "54",                   {"@value" => "54", "@type" => RDF::XSD.integer.to_s}],
       "date " =>          ["dc:created",  "2011-12-27Z",          {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
       "no IRI" =>         ["foo", {"@id" =>"http://example.com/"},{"@id" => "http://example.com/"}],
-      "no IRI (term)" =>  ["foo", {"@id" => "ex"},                {"@id" => "http://example.org/"}],
-      "no IRI (CURIE)" => ["foo", {"@id" => "foaf:Person"},       {"@id" => RDF::FOAF.Person.to_s}],
-      "no boolean" =>     ["foo", {"@value" => "true", "@type" => "xsd:boolean"},{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
-      "no integer" =>     ["foo", {"@value" => "54", "@type" => "xsd:integer"},{"@value" => "54", "@type" => RDF::XSD.integer.to_s}],
-      "no date " =>       ["foo", {"@value" => "2011-12-27Z", "@type" => "xsd:date"}, {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
+      "no IRI (CURIE)" => ["foo", {"@id" => RDF::FOAF.Person.to_s},       {"@id" => RDF::FOAF.Person.to_s}],
+      "no boolean" =>     ["foo", {"@value" => "true", "@type" => RDF::XSD.boolean.to_s},{"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
+      "no integer" =>     ["foo", {"@value" => "54", "@type" => RDF::XSD.integer.to_s},{"@value" => "54", "@type" => RDF::XSD.integer.to_s}],
+      "no date " =>       ["foo", {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}, {"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
       "no string " =>     ["foo", "string",                       {"@value" => "string"}],
       "no lang " =>       ["nolang", "string",                    {"@value" => "string"}],
       "native boolean" => ["foo", true,                           {"@value" => true}],
@@ -1339,8 +1091,8 @@ describe JSON::LD::EvaluationContext do
     context "@language" do
       {
         "@id"                            => ["foo", {"@id" => "foo"},                                 {"@id" => "foo"}],
-        "integer"                        => ["foo", {"@value" => "54", "@type" => "xsd:integer"},     {"@value" => "54", "@type" => "xsd:integer"}],
-        "date"                           => ["foo", {"@value" => "2011-12-27Z","@type" => "xsd:date"},{"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
+        "integer"                        => ["foo", {"@value" => "54", "@type" => RDF::XSD.integer.to_s},     {"@value" => "54", "@type" => RDF::XSD.integer.to_s}],
+        "date"                           => ["foo", {"@value" => "2011-12-27Z","@type" => RDF::XSD.date.to_s},{"@value" => "2011-12-27Z", "@type" => RDF::XSD.date.to_s}],
         "no lang"                        => ["foo", {"@value" => "foo"  },                            {"@value" => "foo"}],
         "same lang"                      => ["foo", "foo",                                            {"@value" => "foo", "@language" => "en"}],
         "other lang"                     => ["foo",  {"@value" => "foo", "@language" => "bar"},       {"@value" => "foo", "@language" => "bar"}],
@@ -1364,12 +1116,6 @@ describe JSON::LD::EvaluationContext do
       end
     end
 
-    [[], true, false, 1, 1.1, "string"].each do |v|
-      it "raises error given #{v.class}" do
-        lambda {subject.compact_value("foo", v)}.should raise_error(JSON::LD::ProcessingError::Lossy)
-      end
-    end
-
     context "keywords" do
       before(:each) do
         subject.set_mapping("id", "@id")
@@ -1385,8 +1131,6 @@ describe JSON::LD::EvaluationContext do
         "@type" =>    [{"literal" => "foo", "type" => "http://example.com/"},
                                                                     {"@value" => "foo", "@type" => "http://example.com/"}],
         "@value" =>   [{"literal" => "foo", "language" => "bar"},   {"@value" => "foo", "@language" => "bar"}],
-        "@list" =>    [{"list" => ["foo"]},                         {"@list" => ["foo"]  }],
-        "@set" =>     [{"set" => ["foo"]},                         {"@set" => ["foo"]  }],
       }.each do |title, (compacted, expanded)|
         it title do
           subject.compact_value("foo", expanded).should produce(compacted, @debug)