json-ld 0.3.2 → 0.9.0

data/lib/json/ld/utils.rb

@@ -36,7 +36,16 @@ module JSON::LD
     # @param [Object] value
     # @return [Boolean]
     def list?(value)
-      value.is_a?(Hash) && value.keys == %w(@list)
+      value.is_a?(Hash) && value.has_key?('@list')
+    end
+
+    ##
+    # Is value annotated?
+    #
+    # @param [Object] value
+    # @return [Boolean]
+    def annotation?(value)
+      value.is_a?(Hash) && value.has_key?('@annotation')
     end
 
     ##
@@ -76,30 +85,52 @@ module JSON::LD
   ##
   # Utility class for mapping old blank node identifiers, or unnamed blank
   # nodes to new identifiers
-  class BlankNodeNamer < Hash
+  class BlankNodeMapper < Hash
+    ##
+    # Just return a Blank Node based on `old`. Manufactures
+    # a node if `old` is nil or empty
+    # @param [String] old ("")
+    # @return [String]
+    def get_sym(old = "")
+      old = RDF::Node.new.to_s if old.to_s.empty?
+      old.to_s.sub(/_:/, '')
+    end
+
+    ##
+    # Get a new mapped name for `old`
+    #
+    # @param [String] old ("")
+    # @return [String]
+    def get_name(old = "")
+      "_:" + get_sym(old)
+    end
+  end
+
+  class BlankNodeNamer < BlankNodeMapper
     # @param [String] prefix
     def initialize(prefix)
-      @prefix = "_:#{prefix}0"
+      @prefix = prefix.to_s
+      @num = 0
       super
     end
-    
+
     ##
-    # Get a new mapped name for `old`
-    #
-    # @param [String] old
+    # Get a new symbol mapped from `old`
+    # @param [String] old ("")
     # @return [String]
-    def get_name(old)
+    def get_sym(old = "")
+      old = old.to_s.sub(/_:/, '')
       if old && self.has_key?(old)
         self[old]
-      elsif old
-        self[old] = @prefix.dup
-        @prefix.succ!
-        self[old]
+      elsif !old.empty?
+        @num += 1
+        #puts "allocate #{@prefix + (@num - 1).to_s} to #{old.inspect}"
+        self[old] = @prefix + (@num - 1).to_s
       else
         # Not referenced, just return a new unique value
-        cur = @prefix.dup
-        @prefix.succ!
-        cur
+        @num += 1
+        #puts "allocate #{@prefix + (@num - 1).to_s} to #{old.inspect}"
+        @prefix + (@num - 1).to_s
       end
     end
   end

data/spec/compact_spec.rb

@@ -58,7 +58,7 @@ describe JSON::LD::API do
       "@id" => {
         :input => {"@id" => "http://example.org/test#example"},
         :context => {},
-        :output => {"@id" => "http://example.org/test#example"}
+        :output => {"@graph" => []}
       },
       "@id coercion" => {
         :input => {
@@ -280,7 +280,8 @@ describe JSON::LD::API do
         },
         "Uses subject alias" => {
           :input => [{
-            "@id" => "http://example.com/id1"
+            "@id" => "http://example.com/id1",
+            "http://example.com/id1" => {"@value" => "foo", "@language" => "de"}
           }],
           :context => {
             "id1" => "http://example.com/id1",
@@ -292,104 +293,8 @@ describe JSON::LD::API do
               "@language" => "de"
             },
             "@id" => "id1",
+            "id1" => "foo"
           }
-        },
-        "Allows IRI to be aliased to null, but still output term using IRI" => {
-          :context => {
-            "http://example.com/comment" => nil,
-            "comment_en" => {"@id" => "http://example.com/comment", "@language" => "en"}
-          },
-          :input => [{
-            "http://example.com/comment" => [
-               {"@value" => "comment in english", "@language" => "en"},
-               {"@value" => "commentar auf deutsch", "@language" => "de"},
-               {"@value" => "日本語でのコメント", "@language" => "ja"},
-             ]
-          }],
-          :output => {
-            "@context" => {
-              "http://example.com/comment" => nil,
-              "comment_en" => {"@id" => "http://example.com/comment", "@language" => "en"}
-            },
-            "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
@@ -467,6 +372,132 @@ describe JSON::LD::API do
       end
     end
 
+    context "language maps" do
+      {
+        "compact-0024" => {
+          :input => [
+            {
+              "@id" => "http://example.com/queen",
+              "http://example.com/vocab/label" => [
+                {"@value" => "The Queen", "@language" => "en"},
+                {"@value" => "Die Königin", "@language" => "de"},
+                {"@value" => "Ihre Majestät", "@language" => "de"}
+              ]
+            }
+          ],
+          :context => {
+            "vocab" => "http://example.com/vocab/",
+            "label" => {"@id" => "vocab:label", "@container" => "@language"}
+          },
+          :output => {
+            "@context" => {
+              "vocab" => "http://example.com/vocab/",
+              "label" => {"@id" => "vocab:label", "@container" => "@language"}
+            },
+            "@id" => "http://example.com/queen",
+            "label" => {
+              "en" => "The Queen",
+              "de" => ["Die Königin", "Ihre Majestät"]
+            }
+          }
+        },
+      }.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.should produce(params[:output], @debug)
+        end
+      end
+    end
+
     context "@graph" do
       {
         "Uses @graph given mutliple inputs" => {
@@ -483,20 +514,6 @@ describe JSON::LD::API do
             ]
           }
         },
-        "Uses expanded node definitions for node references" => {
-          :input => [
-            {"@id" => "http://example.com/foo"},
-            {"@id" => "http://example.com/bar"}
-          ],
-          :context => {"ex" => "http://example.com/"},
-          :output => {
-            "@context" => {"ex" => "http://example.com/"},
-            "@graph" => [
-              {"@id" => "ex:foo"},
-              {"@id" => "ex:bar"}
-            ]
-          }
-        },
       }.each_pair do |title, params|
         it title do
           jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)

data/spec/evaluation_context_spec.rb

@@ -45,9 +45,8 @@ describe JSON::LD::EvaluationContext do
         }, @debug)
       end
       
-      it "allows a non-existing @context" do
-        ec = subject.parse(StringIO.new("{}"))
-        ec.mappings.should produce({}, @debug)
+      it "notes non-existing @context" do
+        lambda {subject.parse(StringIO.new("{}"))}.should raise_error
       end
       
       it "parses a referenced context at a relative URI" do
@@ -204,6 +203,15 @@ describe JSON::LD::EvaluationContext do
           ]).vocab.should produce(nil, @debug)
         end
 
+        it "removes term if set to null with @vocab" do
+          subject.parse([
+            {
+              "@vocab" => "http://schema.org/",
+              "term" => nil
+            }
+          ]).mappings.should produce({"term" => nil}, @debug)
+        end
+
         it "loads initial context" do
           init_ec = JSON::LD::EvaluationContext.new
           nil_ec = subject.parse(nil)
@@ -218,6 +226,25 @@ 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
@@ -226,7 +253,8 @@ describe JSON::LD::EvaluationContext do
         "no @id, @type, or @container" => {"foo" => {}},
         "value as array" => {"foo" => []},
         "@id as object" => {"foo" => {"@id" => {}}},
-        "@id as array" => {"foo" => {"@id" => []}},
+        "@id as array of object" => {"foo" => {"@id" => [{}]}},
+        "@id as array of null" => {"foo" => {"@id" => [nil]}},
         "@type as object" => {"foo" => {"@type" => {}}},
         "@type as array" => {"foo" => {"@type" => []}},
         "@type as @list" => {"foo" => {"@type" => "@list"}},
@@ -333,6 +361,15 @@ describe JSON::LD::EvaluationContext do
       }, @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)
@@ -545,6 +582,15 @@ describe JSON::LD::EvaluationContext do
       subject.expand_iri("_:a").should be_a(RDF::Node)
     end
 
+    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)
+        end
+      end
+    end
+
     context "relative IRI" do
       {
         :subject => true,
@@ -579,7 +625,7 @@ describe JSON::LD::EvaluationContext do
         {
           :subject => true,
           :predicate => false,
-          :type => false
+          :type => true
         }.each do |position, r|
           context "as #{position}" do
             before(:each) do
@@ -627,6 +673,23 @@ describe JSON::LD::EvaluationContext do
           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
 
@@ -651,14 +714,14 @@ describe JSON::LD::EvaluationContext do
         subject.compact_iri(input).should produce(result, @debug)
       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"],
+        "prefix:suffix" => ["ex:suffix",           "http://example.org/suffix"],
         "keyword" =>       ["@type",               "@type"],
         "empty" =>         [":suffix",             "http://empty/suffix"],
         "unmapped" =>      ["foo",                 "foo"],
@@ -668,6 +731,13 @@ describe JSON::LD::EvaluationContext do
           subject.compact_iri(input).should produce(result, @debug)
         end
       end
+
+      it "does not use @vocab if it would collide with a term" 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)
+      end
     end
 
     context "with value" do
@@ -695,24 +765,18 @@ describe JSON::LD::EvaluationContext do
           "setdouble" => {"@id" => "http://example.com/double", "@type" => "xsd:double", "@container" => "@set"},
           "setdate" => {"@id" => "http://example.com/date", "@type" => "xsd:date", "@container" => "@set"},
           "setid" => {"@id" => "http://example.com/id", "@type" => "@id", "@container" => "@set"},
+          "langmap" => {"@id" => "http://example.com/langmap", "@container" => "@language"},
         })
         @debug.clear
         c
       end
 
       {
-        "setplain"   => [
-          {"@value" => "foo"},
-          {"@value" => "de", "@language" => "de"},
-          {"@value" => "other dt", "@language" => "http://example.com/other-datatype"}
-        ],
-        "setlang" => [{"@value" => "en", "@language" => "en"}],
-        "setbool" => [{"@value" => true}, {"@value" => false}, {"@value" => "true", "@type" => RDF::XSD.boolean.to_s}],
-        "setinteger" => [{"@value" => 1}, {"@value" => "1", "@type" => RDF::XSD.integer.to_s}],
-        "setdouble" => [{"@value" => 1.1}, {"@value" => "1", "@type" => RDF::XSD.double.to_s}],
-        "setdate" => [{"@value" => "2012-04-17", "@type" => RDF::XSD.date.to_s}],
+        "langmap" => [{"@value" => "en", "@language" => "en"}],
+        "plain" => [{"@value" => "foo"}],
+        "setplain" => [{"@value" => "foo", "@language" => "pl"}] # looks like langmap
       }.each do |prop, values|
-        context "uses #{prop}", :pending => "does algorithm favor @set?" do
+        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)
@@ -725,6 +789,7 @@ describe JSON::LD::EvaluationContext do
         {
           "listplain"   => [
             [{"@value" => "foo"}],
+            [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => "baz"}],
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => 1}],
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => 1.1}],
             [{"@value" => "foo"}, {"@value" => "bar"}, {"@value" => true}],
@@ -748,6 +813,112 @@ describe JSON::LD::EvaluationContext do
       end
     end
 
+    context "compact-0018" do
+      let(:ctx) do
+        subject.parse(JSON.parse %({
+          "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"
+          },
+          "term3": {
+            "@id": "http://example.com/term",
+            "@container": "@list",
+            "@language": null
+          },
+          "term4": {
+            "@id": "http://example.com/term",
+            "@container": "@list",
+            "@type": "type1"
+          },
+          "term5": {
+            "@id": "http://example.com/term",
+            "@container": "@list",
+            "@type": "type2"
+          }
+        }))
+      end
+
+      {
+        "term" => [
+          '{ "@value": "v0.1", "@language": "de" }',
+          '{ "@value": "v0.2", "@language": "en" }',
+          '{ "@value": "v0.3"}',
+          '{ "@value": 4}',
+          '{ "@value": true}',
+          '{ "@value": false}'
+        ],
+        "term1" => %q({
+          "@list": [
+            { "@value": "v1.1", "@language": "de" },
+            { "@value": "v1.2", "@language": "en" },
+            { "@value": "v1.3"},
+            { "@value": 14},
+            { "@value": true},
+            { "@value": false}
+          ]
+        }),
+        "term2" => %q({
+          "@list": [
+            { "@value": "v2.1", "@language": "en" },
+            { "@value": "v2.2", "@language": "en" },
+            { "@value": "v2.3", "@language": "en" },
+            { "@value": "v2.4", "@language": "en" },
+            { "@value": "v2.5", "@language": "en" },
+            { "@value": "v2.6", "@language": "en" }
+          ]
+        }),
+        "term3" => %q({
+          "@list": [
+            { "@value": "v3.1"},
+            { "@value": "v3.2"},
+            { "@value": "v3.3"},
+            { "@value": "v3.4"},
+            { "@value": "v3.5"},
+            { "@value": "v3.6"}
+          ]
+        }),
+        "term4" => %q({
+          "@list": [
+            { "@value": "v4.1", "@type": "http://example.com/t1" },
+            { "@value": "v4.2", "@type": "http://example.com/t1" },
+            { "@value": "v4.3", "@type": "http://example.com/t1" },
+            { "@value": "v4.4", "@type": "http://example.com/t1" },
+            { "@value": "v4.5", "@type": "http://example.com/t1" },
+            { "@value": "v4.6", "@type": "http://example.com/t1" }
+          ]
+        }),
+        "term5" => %q({
+          "@list": [
+            { "@value": "v5.1", "@type": "http://example.com/t2" },
+            { "@value": "v5.2", "@type": "http://example.com/t2" },
+            { "@value": "v5.3", "@type": "http://example.com/t2" },
+            { "@value": "v5.4", "@type": "http://example.com/t2" },
+            { "@value": "v5.5", "@type": "http://example.com/t2" },
+            { "@value": "v5.6", "@type": "http://example.com/t2" }
+          ]
+        }),
+      }.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)).
+              should produce(term, @debug)
+          end
+        end
+      end
+    end
+
     context "compact-0020" do
       let(:ctx) do
         subject.parse({
@@ -773,6 +944,18 @@ describe JSON::LD::EvaluationContext do
           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"}})
+      end
+      it "Does not use @list with @annotation" do
+        ctx.compact_iri("http://example.com/property", :value => {
+          "@list" => ["one item"],
+          "@annotation" => "an annotation"
+        }).should produce("http://example.com/property", @debug)
+      end
+    end
   end
 
   describe "#term_rank" do
@@ -842,7 +1025,7 @@ describe JSON::LD::EvaluationContext do
         "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 => 3},
+        "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},
@@ -883,11 +1066,11 @@ describe JSON::LD::EvaluationContext do
           "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 => 0},
+          "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 => 3},
+          "lang"  => {:value => {"@value" => "apple", "@language" => "en"}, :rank => 2},
           "id"    => {:value => {"@id" => "http://example/id"}, :rank => 1},
-          "value string" => {:value => {"@value" => "foo"}, :rank => 0},
+          "value string" => {:value => {"@value" => "foo"}, :rank => 2},
           "null"  => {:value => nil, :rank => 3},
         },
         "boolean" => {
@@ -944,7 +1127,7 @@ describe JSON::LD::EvaluationContext do
           "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 => 3},
+          "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},
@@ -997,18 +1180,18 @@ describe JSON::LD::EvaluationContext do
           })
         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.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"}, 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],
+          "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, 3],
-          "v2.6" => [{"@value" => "v2.6", "@language" => "de"}, 3, 0],
+          "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
@@ -1033,6 +1216,7 @@ describe JSON::LD::EvaluationContext do
       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
@@ -1091,18 +1275,18 @@ describe JSON::LD::EvaluationContext do
     context "coercion" do
       before(:each) {subject.default_language = "en"}
       {
-        "boolean-boolean" => ["ex:boolean", true,   {"@value" => true}],
-        "boolean-double"  => ["ex:double",  true,   {"@value" => "true", "@type" => RDF::XSD.double.to_s}],
-        "boolean-int"     => ["foaf:age",   true,   {"@value" => true}],
-        "double-boolean"  => ["ex:boolean", 1.1,    {"@value" => "1.1", "@type" => RDF::XSD.boolean.to_s}],
-        "double-double"   => ["ex:double",  1.1,    {"@value" => "1.1E0", "@type" => RDF::XSD.double.to_s}],
-        "double-int"      => ["foaf:age",   1.1,    {"@value" => "1", "@type" => RDF::XSD.integer.to_s}],
-        "int-boolean"     => ["ex:boolean", 1,      {"@value" => "1", "@type" => RDF::XSD.boolean.to_s}],
-        "int-double"      => ["ex:double",  1,      {"@value" => "1.0E0", "@type" => RDF::XSD.double.to_s}],
-        "int-int"         => ["foaf:age",   1,      {"@value" => 1}],
+        "boolean-boolean" => ["ex:boolean", true,   {"@value" => true, "@type" => RDF::XSD.boolean.to_s}],
+        "boolean-integer" => ["ex:integer", true,   {"@value" => true, "@type" => RDF::XSD.integer.to_s}],
+        "boolean-double"  => ["ex:double",  true,   {"@value" => true, "@type" => RDF::XSD.double.to_s}],
+        "double-boolean"  => ["ex:boolean", 1.1,    {"@value" => 1.1, "@type" => RDF::XSD.boolean.to_s}],
+        "double-double"   => ["ex:double",  1.1,    {"@value" => 1.1, "@type" => RDF::XSD.double.to_s}],
+        "double-integer"  => ["foaf:age",   1.1,    {"@value" => 1.1, "@type" => RDF::XSD.integer.to_s}],
+        "integer-boolean" => ["ex:boolean", 1,      {"@value" => 1, "@type" => RDF::XSD.boolean.to_s}],
+        "integer-double"  => ["ex:double",  1,      {"@value" => 1, "@type" => RDF::XSD.double.to_s}],
+        "integer-integer" => ["foaf:age",   1,      {"@value" => 1, "@type" => RDF::XSD.integer.to_s}],
         "string-boolean"  => ["ex:boolean", "foo",  {"@value" => "foo", "@type" => RDF::XSD.boolean.to_s}],
         "string-double"   => ["ex:double",  "foo",  {"@value" => "foo", "@type" => RDF::XSD.double.to_s}],
-        "string-int"      => ["foaf:age",   "foo",  {"@value" => "foo", "@type" => RDF::XSD.integer.to_s}],
+        "string-integer"  => ["foaf:age",   "foo",  {"@value" => "foo", "@type" => RDF::XSD.integer.to_s}],
       }.each do |title, (key, compacted, expanded)|
         it title do
           subject.expand_value(key, compacted).should produce(expanded, @debug)
@@ -1124,6 +1308,8 @@ describe JSON::LD::EvaluationContext do
       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")
     end
 
     {
@@ -1158,6 +1344,7 @@ describe JSON::LD::EvaluationContext do
         "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"}],
+        "langmap"                        => ["langmap", "en",                                         {"@value" => "en", "@language" => "en"}],
         "no lang with @type coercion"    => ["dc:created", {"@value" => "foo"},                       {"@value" => "foo"}],
         "no lang with @id coercion"      => ["foaf:knows", {"@value" => "foo"},                       {"@value" => "foo"}],
         "no lang with @language=null"    => ["nolang", "string",                                      {"@value" => "string"}],