json-ld 0.3.2 → 0.9.0

data/README.markdown

@@ -220,8 +220,8 @@ Full documentation available on [RubyDoc](http://rubydoc.info/gems/json-ld/file/
 
 ## Dependencies
 * [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
-* [JSON](https://rubygems.org/gems/json) (>= 1.5.1)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0)
+* [JSON](https://rubygems.org/gems/json) (>= 1.5)
 
 ## Installation
 The recommended installation method is via [RubyGems](http://rubygems.org/).

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.9.0

data/lib/json/ld.rb

@@ -89,6 +89,9 @@ module JSON
       # A list containing another list was detected.
       LIST_OF_LISTS_DETECTED = 3
       
+      # When processing a language map, a value not a 
+      ILLEGAL_LANGUAGE_MAP_DETECTED = 4
+      
       attr_reader :code
       
       class Lossy < ProcessingError
@@ -105,6 +108,13 @@ module JSON
         end
       end
 
+      class LanguageMap < ProcessingError
+        def initialize(*args)
+          super
+          @code = ILLEGAL_LANGUAGE_MAP_DETECTED
+        end
+      end
+
       class ListOfLists < ProcessingError
         def initialize(*args)
           super

data/lib/json/ld/api.rb

@@ -28,9 +28,22 @@ module JSON::LD
     OPEN_OPTS = {
       :headers => %w(Accept: application/ld+json, application/json)
     }
+
+    # Current input
+    # @!attribute [rw] input
+    # @return [String, #read, Hash, Array]
     attr_accessor :value
+
+    # Input evaluation context
+    # @!attribute [rw] context
+    # @return [JSON::LD::EvaluationContext]
     attr_accessor :context
 
+    # Current Blank Node Namer
+    # @!attribute [r] namer
+    # @return [JSON::LD::BlankNodeNamer]
+    attr_reader :namer
+
     ##
     # Initialize the API, reading in any document and setting global options
     #
@@ -49,13 +62,18 @@ module JSON::LD
     # @option options [Boolean] :optimize (false)
     #   If set to `true`, the JSON-LD processor is allowed to optimize the output of the Compaction Algorithm to produce even compacter representations. The algorithm for compaction optimization is beyond the scope of this specification and thus not defined. Consequently, different implementations *MAY* implement different optimization algorithms.
     #   (Presently, this is a noop).
-    # @option options [Boolean] :useNativeDatatypes (true)
-    # If set to `true`, the JSON-LD processor will use the expanded `rdf:type` IRI as the property instead of `@type` when converting from RDF.
-    # @option options [Boolean] :useRdfType (false) If set to `true`, the JSON-LD processor will try to convert datatyped literals to JSON native types instead of using the expanded object form when converting from RDF. `xsd:boolean` values will be converted to `true` or `false`. `xsd:integer` and `xsd:double` values will be converted to JSON numbers.
+    # @option options [Boolean] :useNativeTypes (true)
+    #   If set to `true`, the JSON-LD processor will use native datatypes for expression xsd:integer, xsd:boolean, and xsd:double values, otherwise, it will use the expanded form.
+    # @option options [Boolean] :useRdfType (false)
+    #   If set to `true`, the JSON-LD processor will try to convert datatyped literals to JSON native types instead of using the expanded object form when converting from RDF. `xsd:boolean` values will be converted to `true` or `false`. `xsd:integer` and `xsd:double` values will be converted to JSON numbers.
+    # @option options [Boolean] :rename_bnodes (true)
+    #   Rename bnodes as part of expansion, or keep them the same.
     # @yield [api]
     # @yieldparam [API]
     def initialize(input, context, options = {}, &block)
       @options = {:compactArrays => true}.merge(options)
+      options = {:rename_bnodes => true}.merge(options)
+      @namer = options[:rename_bnodes] ? BlankNodeNamer.new("t") : BlankNodeMapper.new
       @value = case input
       when Array, Hash then input.dup
       when IO, StringIO then JSON.parse(input.read)
@@ -110,7 +128,7 @@ module JSON::LD
       result = result['@graph'] if result.is_a?(Hash) && result.keys == %w(@graph)
 
       # Finally, if element is a JSON object, it is wrapped into an array.
-      result = [result] unless result.is_a?(Array)
+      result = [result].compact unless result.is_a?(Array)
       callback.call(result) if callback
       yield result if block_given?
       result
@@ -207,18 +225,14 @@ module JSON::LD
 
         # Generate _nodeMap_
         node_map = Hash.ordered
-        self.generate_node_map(value,
-          node_map,
-          (graph.to_s == '@merged' ? '@merged' : '@default'),
-          nil,
-          BlankNodeNamer.new("t"))
+        self.generate_node_map(value, node_map, (graph.to_s == '@merged' ? '@merged' : '@default'))
         
         result = []
 
         # If nodeMap has no property graph, return result, otherwise set definitions to its value.
         definitions = node_map.fetch(graph.to_s, {})
         
-        # Foreach property and valud of definitions
+        # Foreach property and value of definitions
         definitions.keys.sort.each do |prop|
           value = definitions[prop]
           result << value
@@ -304,11 +318,7 @@ module JSON::LD
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         all_nodes = Hash.ordered
         depth do
-          generate_node_map(value,
-            all_nodes,
-            '@merged',
-            nil,
-            BlankNodeNamer.new("t"))
+          generate_node_map(value, all_nodes, '@merged')
         end
         @node_map = all_nodes['@merged']
         debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"}
@@ -350,20 +360,27 @@ module JSON::LD
     #   See options in {JSON::LD::API#initialize}
     #   Options passed to {JSON::LD::API.expand}
     # @raise [InvalidContext]
+    # @return [Array<RDF::Statement>] if no block given
     # @yield statement
     # @yieldparam [RDF::Statement] statement
-    def self.toRDF(input, context = nil, callback = nil, options = {})
-      # 1) Perform the Expansion Algorithm on the JSON-LD input.
-      #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded = expand(input, context, nil, options)
+    def self.toRDF(input, context = nil, callback = nil, options = {}, &block)
+      API.new(input, context, options) do |api|
+        # 1) Perform the Expansion Algorithm on the JSON-LD input.
+        #    This removes any existing context to allow the given context to be cleanly applied.
+        result = api.expand(api.value, nil, api.context)
 
-      API.new(expanded, nil, options) do
-        debug(".expand") {"expanded input: #{value.to_json(JSON_STATE)}"}
+        api.send(:debug, ".expand") {"expanded input: #{result.to_json(JSON_STATE)}"}
         # Start generating statements
-        statements("", value, nil, nil, nil) do |statement|
-          callback.call(statement) if callback
-          yield statement if block_given?
+        results = []
+        api.statements("", result, nil, nil, nil) do |statement|
+          callback ||= block if block_given?
+          if callback
+            callback.call(statement)
+          else
+            results << statement
+          end
         end
+        results
       end
     end
     
@@ -384,7 +401,7 @@ module JSON::LD
     #   The JSON-LD document in expanded form
     # @return [Array<Hash>]
     #   The JSON-LD document in expanded form
-    def self.fromRDF(input, callback = nil, options = {})
+    def self.fromRDF(input, callback = nil, options = {}, &block)
       options = {:useNativeTypes => true}.merge(options)
       result = nil
 
@@ -392,8 +409,8 @@ module JSON::LD
         result = api.from_statements(input)
       end
 
+      callback ||= block if block_given?
       callback.call(result) if callback
-      yield result if block_given?
       result
     end
   end

data/lib/json/ld/compact.rb

@@ -21,7 +21,7 @@ module JSON::LD
         #    active property.
         debug("compact") {"Array #{element.inspect}"}
         result = depth {element.map {|v| compact(v, property)}}
-        
+
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
         # member; otherwise the compacted value is element
@@ -35,36 +35,92 @@ module JSON::LD
       when Hash
         # 2) Otherwise, if element is an object:
         result = {}
-        
+
         if k = %w(@list @set @value).detect {|container| element.has_key?(container)}
           debug("compact") {"#{k}: container(#{property}) = #{context.container(property)}"}
         end
 
         k ||= '@id' if element.keys == ['@id']
-        
+
         case k
         when '@value', '@id'
           # If element has an @value property or element is a node reference, return the result of performing Value Compaction on element using active property.
           v = context.compact_value(property, element, :depth => @depth)
-          debug("compact") {"value optimization, return as #{v.inspect}"}
+          debug("compact") {"value optimization for #{property}, return as #{v.inspect}"}
           return v
         when '@list'
           # Otherwise, if the active property has a @container mapping to @list and element has a corresponding @list property, recursively compact that property's value passing a copy of the active context and the active property ensuring that the result is an array with all null values removed.
-          
+
           # If there already exists a value for active property in element and the full IRI of property is also coerced to @list, return an error.
           # FIXME: check for full-iri list coercion
 
           # Otherwise store the resulting array as value of active property if empty or property otherwise.
-          compacted_key = context.compact_iri(k, :position => :predicate, :depth => @depth)
+          compacted_key = context.compact_iri('@list', :position => :predicate, :depth => @depth)
           v = depth { compact(element[k], property) }
-          
+
           # Return either the result as an array, as an object with a key of @list (or appropriate alias from active context
           v = [v].compact unless v.is_a?(Array)
-          v = {compacted_key => v} unless context.container(property) == k
+          unless context.container(property) == '@list'
+            v = {compacted_key => v}
+            if element['@annotation']
+              compacted_key = context.compact_iri('@annotation', :position => :predicate, :depth => @depth)
+              v[compacted_key] = element['@annotation']
+            end
+          end
           debug("compact") {"@list result, return as #{v.inspect}"}
           return v
         end
 
+        # Check for property generators before continuing with other elements
+        # For each term pg in the active context which is a property generator
+        # Select property generator terms by shortest term
+        context.mappings.keys.sort.each do |term|
+          next unless context.mapping(term).is_a?(Array)
+          # Using the first expanded IRI p associated with the property generator
+          expanded_iris = context.mapping(term).map(&:to_s)
+          p = expanded_iris.first.to_s
+
+          # Skip to the next property generator term unless p is a property of element
+          next unless element.has_key?(p)
+
+          debug("compact") {"check pg #{term}: #{expanded_iris}"}
+
+          # For each node n which is a value of p in element
+          node_values = []
+          element[p].dup.each do |n|
+            # For each expanded IRI pi associated with the property generator other than p
+            next unless expanded_iris[1..-1].all? do |pi|
+              debug("compact") {"check #{pi} for (#{n.inspect})"}
+              element.has_key?(pi) && element[pi].any? do |ni|
+                nodesEquivalent?(n, ni)
+              end
+            end
+
+            # Remove n as a value of all p and pi in element
+            debug("compact") {"removed matched value #{n.inspect} from #{expanded_iris.inspect}"}
+            expanded_iris.each do |pi|
+              # FIXME: This removes all values equivalent to n, not just the first
+              element[pi] = element[pi].reject {|ni| nodesEquivalent?(n, ni)}
+            end
+
+            # Add the result of performing the compaction algorithm on n to pg to output
+            node_values << n
+          end
+
+          # If there are node_values, or all the values from expanded_iris are empty, add node_values to result, and remove the expanded_iris as keys from element
+          if node_values.length > 0 || expanded_iris.all? {|pi| element.has_key?(pi) && element[pi].empty?}
+            debug("compact") {"compact extracted pg values"}
+            result[term] = depth { compact(node_values, term)}
+            result[term] = [result[term]] if !result[term].is_a?(Array) && context.container(term) == '@set'
+
+            debug("compact") {"remove empty pg keys from element"}
+            expanded_iris.each do |pi|
+              debug(" =>") {"#{pi}? #{element.fetch(pi, []).empty?}"}
+              element.delete(pi) if element.fetch(pi, []).empty?
+            end
+          end
+        end
+
         # Otherwise, for each property and value in element:
         element.each do |key, value|
           debug("compact") {"#{key}: #{value.inspect}"}
@@ -80,48 +136,63 @@ module JSON::LD
               context.compact_iri(value, :position => position, :depth => @depth)
             when Array
               # Otherwise, value must be an array. Perform IRI Compaction on every entry of value. If value contains just one entry, value is set to that entry
-              compacted_value = value.map {|v| context.compact_iri(v, :position => position, :depth => @depth)}
+              compacted_value = value.map {|v2| context.compact_iri(v2, :position => position, :depth => @depth)}
               debug {" => compacted value(#{key}): #{compacted_value.inspect}"}
               compacted_value = compacted_value.first if compacted_value.length == 1 && @options[:compactArrays]
               compacted_value
             end
+          elsif key == '@annotation' && context.container(property) == '@annotation'
+            # Skip the annotation key if annotations being applied
+            next
           else
             if value.empty?
               # Make sure that an empty array is preserved
               compacted_key = context.compact_iri(key, :position => :predicate, :depth => @depth)
               next if compacted_key.nil?
               result[compacted_key] = value
+              next
             end
 
             # For each item in value:
-            raise ProcessingError, "found #{value.inspect} for #{key} if #{element.inspect}" unless value.is_a?(Array)
+            value = [value] if key == '@annotation' && value.is_a?(String)
+            raise ProcessingError, "found #{value.inspect} for #{key} of #{element.inspect}" unless value.is_a?(Array)
             value.each do |item|
               compacted_key = context.compact_iri(key, :position => :predicate, :value => item, :depth => @depth)
+
+              # Result for this item, typically the output object itself
+              item_result = result
+              item_key = compacted_key
               debug {" => compacted key: #{compacted_key.inspect} for #{item.inspect}"}
               next if compacted_key.nil?
 
+              # Language maps and annotations
+              if field = %w(@language @annotation).detect {|kk| context.container(compacted_key) == kk}
+                item_result = result[compacted_key] ||= Hash.new
+                item_key = item[field]
+              end
+
               compacted_item = depth {self.compact(item, compacted_key)}
               debug {" => compacted value: #{compacted_value.inspect}"}
-            
-              case result[compacted_key]
+
+              case item_result[item_key]
               when Array
-                result[compacted_key] << compacted_item
+                item_result[item_key] << compacted_item
               when nil
                 if !compacted_value.is_a?(Array) && context.container(compacted_key) == '@set'
                   compacted_item = [compacted_item].compact
                   debug {" => as @set: #{compacted_item.inspect}"}
                 end
-                result[compacted_key] = compacted_item
+                item_result[item_key] = compacted_item
               else
-                result[compacted_key] = [result[compacted_key], compacted_item]
+                item_result[item_key] = [item_result[item_key], compacted_item]
               end
             end
           end
         end
-        
+
         # Re-order result keys
         r = Hash.ordered
-        result.keys.sort.each {|k| r[k] = result[k]}
+        result.keys.kw_sort.each {|kk| r[kk] = result[kk]}
         r
       else
         # For other types, the compacted value is the element value
@@ -129,5 +200,36 @@ module JSON::LD
         element
       end
     end
+
+    private
+
+    # Determines if two nodes are equivalent.
+    # * Value nodes are equivalent using a deep comparison
+    # * Arrays are equivalent if they have the same number of elements and each element is equivalent to the matching element
+    # * Node Defintions/References are equivalent IFF the have the same @id
+    def nodesEquivalent?(n1, n2)
+      depth do
+        r = if n1.is_a?(Array) && n2.is_a?(Array) && n1.length == n2.length
+          equiv = true
+          n1.each_with_index do |v1, i|
+            equiv &&= nodesEquivalent?(v1, n2[i]) if equiv
+          end
+          equiv
+        elsif value?(n1) && value?(n2)
+          n1 == n2
+        elsif list?(n1)
+          list?(n2) &&
+            n1.fetch('@annotation', true) == n2.fetch('@annotation', true) &&
+            nodesEquivalent?(n1['@list'], n2['@list'])
+        elsif (node?(n1) || node_reference?(n2))
+          (node?(n2) || node_reference?(n2)) && n1['@id'] == n2['@id']
+        else
+          false
+        end
+
+        debug("nodesEquivalent?(#{n1.inspect}, #{n2.inspect}): #{r.inspect}")
+        r
+      end
+    end
   end
 end

data/lib/json/ld/evaluation_context.rb

@@ -75,6 +75,10 @@ module JSON::LD
     # @return [EvaluationContext] A context provided to us that we can use without re-serializing
     attr_accessor :provided_context
 
+    # @!attribute [r] remote_contexts
+    # @return [Array<String>] The list of remote contexts already processed
+    attr_accessor :remote_contexts
+
     ##
     # Create new evaluation context
     # @yield [ec]
@@ -91,6 +95,7 @@ module JSON::LD
         RDF.to_uri.to_s => "rdf",
         RDF::XSD.to_uri.to_s => "xsd"
       }
+      @remote_contexts = []
 
       @options = options
 
@@ -121,6 +126,7 @@ module JSON::LD
         # Load context document, if it is a string
         begin
           ctx = JSON.load(context)
+          raise JSON::LD::InvalidContext::LoadError, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
           parse(ctx["@context"] || {})
         rescue JSON::ParserError => e
           debug("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
@@ -137,6 +143,8 @@ module JSON::LD
         ec = nil
         begin
           url = expand_iri(context, :base => context_base || base, :position => :subject)
+          raise JSON::LD::InvalidContext::LoadError if remote_contexts.include?(url)
+          @remote_contexts = @remote_contexts + [url]
           ecdup = self.dup
           ecdup.context_base = url  # Set context_base for recursive remote contexts
           RDF::Util::File.open_file(url) {|f| ec = ecdup.parse(f)}
@@ -162,6 +170,7 @@ module JSON::LD
         new_ec = self.dup
         new_ec.provided_context = context.dup
 
+        # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
         {
           '@language' => :default_language=,
           '@vocab'    => :vocab=
@@ -171,7 +180,7 @@ module JSON::LD
             context.delete(key)
             debug("parse") {"Set #{key} to #{v.inspect}"}
             new_ec.send(setter, v)
-          elsif v
+          elsif v && @options[:validate]
             raise InvalidContext::Syntax, "#{key.inspect} is invalid"
           end
         end
@@ -186,26 +195,48 @@ module JSON::LD
             debug("parse") {"Hash[#{key}] = #{value.inspect}"}
 
             if KEYWORDS.include?(key)
-              raise InvalidContext::Syntax, "key #{key.inspect} must not be a keyword"
+              raise InvalidContext::Syntax, "key #{key.inspect} must not be a keyword" if @options[:validate]
+              next
             elsif term_valid?(key)
               # Remove all coercion information for the property
               new_ec.set_coerce(key, nil)
               new_ec.set_container(key, nil)
               @languages.delete(key)
 
-              # Extract IRI mapping. This is complicated, as @id may have been aliased
-              value = value.fetch('@id', nil) if value.is_a?(Hash)
-              raise InvalidContext::Syntax, "unknown mapping for #{key.inspect} to #{value.class}" unless value.is_a?(String) || value.nil?
+              # Extract IRI mapping. This is complicated, as @id may have been aliased. Also, if @id is explicitly set to nil, it inhibits and automatic mapping, so treat it as false, to distinguish from no mapping at all.
+              value = case value
+              when Hash
+                value.has_key?('@id') && value['@id'].nil? ? false : value.fetch('@id', nil)
+              when nil
+                false
+              else
+                value
+              end
+
+              # Explicitly say this is not mapped
+              if value == false
+                debug("parse") {"Map #{key} to nil"}
+                new_ec.set_mapping(key, nil)
+                next
+              end
+
+              iri = if value.is_a?(Array)
+                # expand each item according the IRI Expansion algorithm. If an item does not expand to a valid absolute IRI, raise an INVALID_PROPERTY_GENERATOR error; otherwise sort val and store it as IRI mapping in definition.
+                value.map do |v|
+                  raise InvalidContext::Syntax, "unknown mapping for #{key.inspect} to #{v.inspect}" unless v.is_a?(String)
+                  new_ec.expand_iri(v, :position => :predicate)
+                end.sort
+              elsif value
+                raise InvalidContext::Syntax, "unknown mapping for #{key.inspect} to #{value.inspect}" unless value.is_a?(String)
+                new_ec.expand_iri(value, :position => :predicate)
+              end
 
-              iri = new_ec.expand_iri(value, :position => :predicate) if value.is_a?(String)
               if iri && new_ec.mappings.fetch(key, nil) != iri
                 # Record term definition
                 new_ec.set_mapping(key, iri)
                 num_updates += 1
-              elsif value.nil?
-                new_ec.set_mapping(key, nil)
               end
-            else
+            elsif @options[:validate]
               raise InvalidContext::Syntax, "key #{key.inspect} is invalid"
             end
           end
@@ -223,14 +254,18 @@ module JSON::LD
               iri = new_ec.expand_iri(value2, :position => :predicate) if value2.is_a?(String)
               case key2
               when '@type'
-                raise InvalidContext::Syntax, "unknown mapping for '@type' to #{value2.class}" unless value2.is_a?(String) || value2.nil?
+                raise InvalidContext::Syntax, "unknown mapping for '@type' to #{value2.inspect}" unless value2.is_a?(String) || value2.nil?
                 if new_ec.coerce(key) != iri
-                  raise InvalidContext::Syntax, "unknown mapping for '@type' to #{iri.inspect}" unless RDF::URI(iri).absolute? || iri == '@id'
+                  case iri
+                  when '@id', /_:/, RDF::Node
+                  else
+                    raise InvalidContext::Syntax, "unknown mapping for '@type' to #{iri.inspect}" unless (RDF::URI(iri).absolute? rescue false)
+                  end
                   # Record term coercion
                   new_ec.set_coerce(key, iri)
                 end
               when '@container'
-                raise InvalidContext::Syntax, "unknown mapping for '@container' to #{value2.class}" unless %w(@list @set).include?(value2)
+                raise InvalidContext::Syntax, "unknown mapping for '@container' to #{value2.inspect}" unless %w(@list @set @language @annotation).include?(value2)
                 if new_ec.container(key) != value2
                   debug("parse") {"container #{key.inspect} as #{value2.inspect}"}
                   new_ec.set_container(key, value2)
@@ -281,10 +316,10 @@ module JSON::LD
           ctx['@vocab'] = vocab.to_s if vocab
 
           # Mappings
-          mappings.keys.sort{|a, b| a.to_s <=> b.to_s}.each do |k|
+          mappings.keys.kw_sort{|a, b| a.to_s <=> b.to_s}.each do |k|
             next unless term_valid?(k.to_s)
             debug {"=> mappings[#{k}] => #{mappings[k]}"}
-            ctx[k] = mappings[k].to_s
+            ctx[k] = mappings[k]
           end
 
           unless coercions.empty? && containers.empty? && languages.empty?
@@ -310,7 +345,7 @@ module JSON::LD
               end
 
               debug {"=> container(#{k}) => #{container(k)}"}
-              if %w(@list @set).include?(container(k))
+              if %w(@list @set @language @annotation).include?(container(k))
                 ctx[k]["@container"] = container(k)
                 debug {"=> container[#{k}] => #{container(k).inspect}"}
               end
@@ -344,14 +379,14 @@ module JSON::LD
     #
     # @return [RDF::URI, String]
     def mapping(term)
-      @mappings.fetch(term.to_s, nil)
+      @mappings.fetch(term.to_s, false)
     end
 
     ##
     # Set term mapping
     #
     # @param [#to_s] term
-    # @param [RDF::URI, String] value
+    # @param [RDF::URI, String, nil] value
     #
     # @return [RDF::URI, String]
     def set_mapping(term, value)
@@ -388,8 +423,8 @@ module JSON::LD
     # @return [RDF::URI, '@id']
     def coerce(property)
       # Map property, if it's not an RDF::Value
-      # @type and @graph always is an IRI
-      return '@id' if [RDF.type, '@type', '@graph'].include?(property)
+      # @type is always is an IRI
+      return '@id' if [RDF.type, '@type'].include?(property)
       @coercions.fetch(property, nil)
     end
 
@@ -415,6 +450,7 @@ module JSON::LD
     # @param [String] property in unexpanded form
     # @return [String]
     def container(property)
+      return '@set' if property == '@graph'
       @containers.fetch(property.to_s, nil)
     end
 
@@ -472,33 +508,60 @@ module JSON::LD
     #   Useful when determining how to serialize.
     # @option options [RDF::URI] base (self.base)
     #   Base IRI to use when expanding relative IRIs.
-    #
-    # @return [RDF::URI, String] IRI or String, if it's a keyword
+    # @option options [Array<String>] path ([])
+    #   Array of looked up iris, used to find cycles
+    # @option options [BlankNodeNamer] namer
+    #   Blank Node namer to use for renaming Blank Nodes
+    #
+    # @return [RDF::Term, String, Array<RDF::URI>]
+    #   IRI or String, if it's a keyword, or array of IRI, if it matches
+    #   a property generator
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#iri-expansion
     def expand_iri(iri, options = {})
       return iri unless iri.is_a?(String)
+
       prefix, suffix = iri.split(':', 2)
-      return mapping(iri) if mapping(iri) # If it's an exact match
+      unless (m = mapping(iri)) == false
+        # It's an exact match
+        debug("expand_iri") {"match: #{iri.inspect} to #{m.inspect}"} unless options[:quiet]
+        return case m
+        when nil
+          nil
+        when Array
+          # Return array of IRIs, if it's a property generator
+          m.map {|mm| uri(mm.to_s, options[:namer])}
+        else
+          uri(m.to_s, options[:namer])
+        end
+      end
       debug("expand_iri") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{vocab.inspect}"} unless options[:quiet]
-      base = [:subject].include?(options[:position]) ? options.fetch(:base, self.base) : nil
+      base = [:subject, :type].include?(options[:position]) ? options.fetch(:base, self.base) : nil
       prefix = prefix.to_s
       case
-      when prefix == '_' && suffix          then bnode(suffix)
+      when prefix == '_' && suffix          then uri(bnode(suffix), options[:namer])
       when iri.to_s[0,1] == "@"             then iri
       when suffix.to_s[0,2] == '//'         then uri(iri)
-      when mappings.fetch(prefix, false)    then uri(mappings[prefix] + suffix.to_s)
+      when (mapping = mapping(prefix)) != false
+        debug("expand_iri") {"mapping: #{mapping(prefix).inspect}"} unless options[:quiet]
+        case mapping
+        when Array
+          # Return array of IRIs, if it's a property generator
+          mapping.map {|m| uri(m.to_s + suffix.to_s, options[:namer])}
+        else
+          uri(mapping.to_s + suffix.to_s, options[:namer])
+        end
       when base                             then base.join(iri)
       when vocab                            then uri("#{vocab}#{iri}")
       else
         # Otherwise, it must be an absolute IRI
         u = uri(iri)
-        u if u.absolute? || [:subject].include?(options[:position])
+        u if u.absolute? || [:subject, :type].include?(options[:position])
       end
     end
 
     ##
-    # Compact an IRI
+    # Compacts an absolute IRI to the shortest matching term or compact IRI
     #
     # @param [RDF::URI] iri
     # @param  [Hash{Symbol => Object}] options ({})
@@ -524,10 +587,9 @@ module JSON::LD
         # Create an empty list of terms _terms_ that will be populated with terms that are ranked according to how closely they match value. Initialize highest rank to 0, and set a flag list container to false.
         terms = {}
 
-        # If value is a @list add a term rank for each
-        # term mapping to iri which has @container @list.
-        debug("compact_iri", "#{value.inspect} is a list? #{list?(value).inspect}")
-        if list?(value)
+        # If value is a @list select terms that match every item equivalently.
+        debug("compact_iri", "#{value.inspect} is a list? #{list?(value).inspect}") if value
+        if list?(value) && !annotation?(value)
           list_terms = matched_terms.select {|t| container(t) == '@list'}
             
           terms = list_terms.inject({}) do |memo, t|
@@ -563,13 +625,6 @@ module JSON::LD
         least_distance = terms.values.max
         terms = terms.keys.select {|t| terms[t] == least_distance}
 
-        # If terms is empty, and the active context has a @vocab which is a  prefix of iri where the resulting relative IRI is not a term in the  active context. The resulting relative IRI is the unmatched part of iri.
-        if vocab && terms.empty? && iri.to_s.index(vocab) == 0 &&
-           [:predicate, :type].include?(options[:position])
-          terms << iri.to_s.sub(vocab, '')
-          debug("vocab") {"vocab: #{vocab}, rel: #{terms.first}"}
-        end
-
         # If terms is empty, add a compact IRI representation of iri for each 
         # term in the active context which maps to an IRI which is a prefix for 
         # iri where the resulting compact IRI is not a term in the active 
@@ -605,6 +660,15 @@ module JSON::LD
           debug("curies") {"selected #{terms.inspect}"}
         end
 
+        # If terms is empty, and the active context has a @vocab which is a  prefix of iri where the resulting relative IRI is not a term in the  active context. The resulting relative IRI is the unmatched part of iri.
+        # Don't use vocab, if the result would collide with a term
+        if vocab && terms.empty? && iri.to_s.index(vocab) == 0 &&
+          !mapping(iri.to_s.sub(vocab, '')) &&
+           [:predicate, :type].include?(options[:position])
+          terms << iri.to_s.sub(vocab, '')
+          debug("vocab") {"vocab: #{vocab}, rel: #{terms.first}"}
+        end
+
         # If we still don't have any terms and we're using standard_prefixes,
         # try those, and add to mapping
         if terms.empty? && @options[:standard_prefixes]
@@ -650,8 +714,8 @@ module JSON::LD
     ##
     # Expand a value from compacted to expanded form making the context
     # unnecessary. This method is used as part of more general expansion
-    # and operates on RHS values, using a supplied key to determine @type and @container
-    # coercion rules.
+    # and operates on RHS values, using a supplied key to determine @type and
+    # @container coercion rules.
     #
     # @param [String] property
     #   Associated property used to find coercion rules
@@ -659,6 +723,8 @@ module JSON::LD
     #   Value (literal or IRI) to be expanded
     # @param  [Hash{Symbol => Object}] options
     # @option options [Boolean] :useNativeTypes (true) use native representations
+    # @option options [BlankNodeNamer] namer
+    #   Blank Node namer to use for renaming Blank Nodes
     #
     # @return [Hash] Object representation of value
     # @raise [RDF::ReaderError] if the iri cannot be expanded
@@ -667,95 +733,40 @@ module JSON::LD
       options = {:useNativeTypes => true}.merge(options)
       depth(options) do
         debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}, coerce: #{coerce(property).inspect}"}
-        value = RDF::Literal(value) if RDF::Literal(value).has_datatype?
-        dt = case value
-        when RDF::Literal
-          case value.datatype
-          when RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double then value.datatype
-          else value
-          end
-        when RDF::Term then value.class.name
-        else value
-        end
 
-        result = case dt
-        when RDF::XSD.boolean
-          debug("xsd:boolean")
-          case coerce(property)
-          when RDF::XSD.double.to_s
-            {"@value" => value.to_s, "@type" => RDF::XSD.double.to_s}
-          else
-            if options[:useNativeTypes]
-              # Unless there's coercion, to not modify representation
-              {"@value" => (value.is_a?(RDF::Literal::Boolean) ? value.object : value)}
-            else
-              {"@value" => value.to_s, "@type" => RDF::XSD.boolean.to_s}
-            end
-          end
-        when RDF::XSD.integer
-          debug("xsd:integer")
-          case coerce(property)
-          when RDF::XSD.double.to_s
-            {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
-          when RDF::XSD.integer.to_s, nil
-            # Unless there's coercion, to not modify representation
-            if options[:useNativeTypes]
-              {"@value" => value.is_a?(RDF::Literal::Integer) ? value.object : value}
-            else
-              {"@value" => value.to_s, "@type" => RDF::XSD.integer.to_s}
-            end
-          else
-            res = Hash.ordered
-            res['@value'] = value.to_s
-            res['@type'] = coerce(property)
-            res
-          end
-        when RDF::XSD.double
-          debug("xsd:double")
-          case coerce(property)
-          when RDF::XSD.integer.to_s
-            {"@value" => value.to_int.to_s, "@type" => RDF::XSD.integer.to_s}
-          when RDF::XSD.double.to_s
-            {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
-          when nil
-            if options[:useNativeTypes]
-              # Unless there's coercion, to not modify representation
-              {"@value" => value.is_a?(RDF::Literal::Double) ? value.object : value}
-            else
-              {"@value" => RDF::Literal::Double.new(value, :canonicalize => true).to_s, "@type" => RDF::XSD.double.to_s}
-            end
-          else
-            res = Hash.ordered
-            res['@value'] = value.to_s
-            res['@type'] = coerce(property)
-            res
-          end
-        when "RDF::URI", "RDF::Node"
+        value = if value.is_a?(RDF::Value)
+          value
+        elsif coerce(property) == '@id'
+          expand_iri(value, :position => :subject, :namer => options[:namer])
+        else
+          RDF::Literal(value)
+        end
+        debug("expand_value") {"normalized: #{value.inspect}"}
+        
+        result = case value
+        when RDF::URI, RDF::Node
           debug("URI | BNode") { value.to_s }
           {'@id' => value.to_s}
         when RDF::Literal
-          debug("Literal")
+          debug("Literal") {"datatype: #{value.datatype.inspect}"}
           res = Hash.ordered
-          res['@value'] = value.to_s
-          res['@type'] = value.datatype.to_s if value.has_datatype?
-          res['@language'] = value.language.to_s if value.has_language?
-          res
-        else
-          debug("else")
-          case coerce(property)
-          when '@id'
-            {'@id' => expand_iri(value, :position => :subject).to_s}
-          when nil
-            debug("expand value") {"lang(prop): #{language(property).inspect}, def: #{default_language.inspect}"}
-            language(property) ? {"@value" => value.to_s, "@language" => language(property)} : {"@value" => value.to_s}
+          if options[:useNativeTypes] && [RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double].include?(value.datatype)
+            res['@value'] = value.object
+            res['@type'] = uri(coerce(property), options[:namer]) if coerce(property)
           else
-            res = Hash.ordered
+            value.canonicalize! if value.datatype == RDF::XSD.double
             res['@value'] = value.to_s
-            res['@type'] = coerce(property).to_s
-            res
+            if coerce(property)
+              res['@type'] = uri(coerce(property), options[:namer]).to_s
+            elsif value.has_datatype?
+              res['@type'] = uri(value.datatype, options[:namer]).to_s
+            elsif value.has_language? || language(property)
+              res['@language'] = (value.language || language(property)).to_s
+            end
           end
+          res
         end
-        
+
         debug {"=> #{result.inspect}"}
         result
       end
@@ -780,12 +791,14 @@ module JSON::LD
       depth(options) do
         debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}, coerce: #{coerce(property).inspect}"}
 
+        # Remove @annotation if property has annotation
+        value.delete('@annotation') if container(property) == '@annotation'
+
         result = case
-          #when %w(boolean integer double).any? {|t| expand_iri(value['@type'], :position => :type) == RDF::XSD[t]}
-        #  # Compact native type
-        #  debug {" (native)"}
-        #  l = RDF::Literal(value['@value'], :datatype => expand_iri(value['@type'], :position => :type))
-        #  l.canonicalize.object
+        when value.has_key?('@annotation')
+          # Don't compact the value
+          debug {" (@annotation without container @annotation)"}
+          value
         when coerce(property) == '@id' && value.has_key?('@id')
           # Compact an @id coercion
           debug {" (@id & coerce)"}
@@ -799,11 +812,11 @@ module JSON::LD
           value[self.alias('@id')] = compact_iri(value['@id'], :position => :subject)
           debug {" (#{self.alias('@id')} => #{value['@id']})"}
           value
-        when value['@language'] && value['@language'] == language(property)
+        when value['@language'] && (value['@language'] == language(property) || container(property) == '@language')
           # Compact language
           debug {" (@language) == #{language(property).inspect}"}
           value['@value']
-        when value['@value'] && !value['@value'].is_a?(String)
+        when !value.fetch('@value', "").is_a?(String)
           # Compact simple literal to string
           debug {" (@value not string)"}
           value['@value']
@@ -853,27 +866,36 @@ module JSON::LD
     
     def dup
       # Also duplicate mappings, coerce and list
+      that = self
       ec = super
-      ec.mappings = mappings.dup
-      ec.coercions = coercions.dup
-      ec.containers = containers.dup
-      ec.languages = languages.dup
-      ec.default_language = default_language
-      ec.options = options
-      ec.iri_to_term = iri_to_term.dup
-      ec.iri_to_curie = iri_to_curie.dup
+      ec.instance_eval do
+        @mappings = that.mappings.dup
+        @coerceions = that.coercions.dup
+        @containers = that.containers.dup
+        @languages = that.languages.dup
+        @default_language = that.default_language
+        @options = that.options
+        @iri_to_term = that.iri_to_term.dup
+        @iri_to_curie = that.iri_to_curie.dup
+      end
       ec
     end
 
     private
 
-    def uri(value, append = nil)
-      value = RDF::URI.new(value)
-      value = value.join(append) if append
-      value.validate! if @options[:validate]
-      value.canonicalize! if @options[:canonicalize]
-      value = RDF::URI.intern(value) if @options[:intern]
-      value
+    def uri(value, namer = nil)
+      case value.to_s
+      when /^_:(.*)$/
+        # Map BlankNodes if a namer is given
+        debug "uri(bnode)#{value}: #{$1}"
+        bnode(namer ? namer.get_sym($1) : $1)
+      else
+        value = RDF::URI.new(value)
+        value.validate! if @options[:validate]
+        value.canonicalize! if @options[:canonicalize]
+        value = RDF::URI.intern(value) if @options[:intern]
+        value
+      end
     end
 
     # Keep track of allocated BNodes
@@ -910,25 +932,42 @@ module JSON::LD
       elsif list?(value)
         if value['@list'].empty?
           # If the @list property is an empty array, if term has @container set to @list, term rank is 1, otherwise 0.
+          debug("term rank") { "empty list"}
           container(term) == '@list' ? 1 : 0
         else
-          # Otherwise, return the sum of the term ranks for every entry in the list.
-          depth {value['@list'].inject(0) {|memo, v| memo + term_rank(term, v)}}
+          debug("term rank") { "non-empty list"}
+          # Otherwise, return the most specific term, for which the term has some match against every value.
+          depth {value['@list'].map {|v| term_rank(term, v)}}.min
         end
       elsif value?(value)
         val_type = value.fetch('@type', nil)
         val_lang = value['@language'] || false if value.has_key?('@language')
         debug("term rank") {"@val_type: #{val_type.inspect}, val_lang: #{val_lang.inspect}"}
         if val_type
+          debug("term rank") { "typed value"}
           coerce(term) == val_type ? 3 :  (default_term ? 1 : 0)
         elsif !value['@value'].is_a?(String)
+          debug("term rank") { "native value"}
           default_term ? 2 : 1
         elsif val_lang.nil?
           debug("val_lang.nil") {"#{language(term).inspect} && #{coerce(term).inspect}"}
-          language(term) == false || (default_term && default_language.nil?) ? 3 : 0
+          if language(term) == false || (default_term && default_language.nil?)
+            # Value has no language, and there is no default language and the term has no language
+            3
+          elsif default_term
+            # The term has no language (or type), but it's different than the default
+            2
+          else
+            0
+          end
         else
-          if val_lang == language(term) || (default_term && default_language == val_lang)
+          debug("val_lang") {"#{language(term).inspect} && #{coerce(term).inspect}"}
+          if val_lang && container(term) == '@language'
             3
+          elsif val_lang == language(term) || (default_term && default_language == val_lang)
+            2
+          elsif default_term && container(term) == '@set'
+            2 # Choose a set term before a non-set term, if there's a language
           elsif default_term
             1
           else
@@ -936,6 +975,7 @@ module JSON::LD
           end
         end
       else # node definition/reference
+        debug("node dev/ref")
         coerce(term) == '@id' ? 3 : (default_term ? 1 : 0)
       end