json-ld 1.0.5 → 1.0.6

data/lib/json/ld/compact.rb

@@ -133,7 +133,7 @@ module JSON::LD
                   compacted_item[key] = expanded_item['@index']
                 end
               else
-                raise ProcessingError::CompactionToListOfLists,
+                raise JsonLdError::CompactionToListOfLists,
                       "key cannot have more than one list value" if result.has_key?(item_active_property)
               end
             end

data/lib/json/ld/context.rb

@@ -116,16 +116,19 @@ module JSON::LD
     # @return [Context] A context provided to us that we can use without re-serializing XXX
     attr_accessor :provided_context
 
-    # @!attribute [r] remote_contexts
-    # @return [Array<String>] The list of remote contexts already processed
-    attr_accessor :remote_contexts
-
     # @!attribute [r] namer
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
     ##
     # Create new evaluation context
+    # @param [Hash] options
+    # @option options [String, #to_s] :base
+    #   The Base IRI to use when expanding the document. This overrides the value of `input` if it is a _IRI_. If not specified and `input` is not an _IRI_, the base IRI defaults to the current document IRI if in a browser context, or the empty string if there is no document context.
+    # @option options [Proc] :documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts. If specified, it must be used to retrieve remote documents and contexts; otherwise, if not specified, the processor's built-in loader must be used. See {API.documentLoader} for the method signature.
+    # @option options [Hash{Symbol => String}] :prefixes
+    #   See `RDF::Reader#initialize`
     # @yield [ec]
     # @yieldparam [Context]
     # @return [Context]
@@ -136,12 +139,12 @@ module JSON::LD
         @doc_base.fragment = nil
         @doc_base.query = nil
       end
+      options[:documentLoader] ||= JSON::LD::API.method(:documentLoader)
       @term_definitions = {}
       @iri_to_term = {
         RDF.to_uri.to_s => "rdf",
         RDF::XSD.to_uri.to_s => "xsd"
       }
-      @remote_contexts = []
       @namer = BlankNodeMapper.new("t")
 
       @options = options
@@ -151,7 +154,7 @@ module JSON::LD
         @iri_to_term[v.to_s] = k unless k.nil?
       end
 
-      debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
+      #debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
       
       yield(self) if block_given?
     end
@@ -159,12 +162,12 @@ module JSON::LD
     # @param [String] value must be an absolute IRI
     def base=(value)
       if value
-        raise InvalidContext::InvalidBaseIRI, "@base must be a string: #{value.inspect}" unless value.is_a?(String) || value.is_a?(RDF::URI)
+        raise JsonLdError::InvalidBaseIRI, "@base must be a string: #{value.inspect}" unless value.is_a?(String) || value.is_a?(RDF::URI)
         @base = RDF::URI(value)
         @base.canonicalize!
         @base.fragment = nil
         @base.query = nil
-        raise InvalidContext::InvalidBaseIRI, "@base must be an absolute IRI: #{value.inspect}" unless @base.absolute?
+        raise JsonLdError::InvalidBaseIRI, "@base must be an absolute IRI: #{value.inspect}" unless @base.absolute?
         @base
       else
         @base = nil
@@ -175,7 +178,7 @@ module JSON::LD
     # @param [String] value
     def default_language=(value)
       @default_language = if value
-        raise InvalidContext::InvalidDefaultLanguage, "@language must be a string: #{value.inspect}" unless value.is_a?(String)
+        raise JsonLdError::InvalidDefaultLanguage, "@language must be a string: #{value.inspect}" unless value.is_a?(String)
         value.downcase
       else
         nil
@@ -189,12 +192,12 @@ module JSON::LD
         value
       when String
         v = as_resource(value)
-        raise InvalidContext::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative?
+        raise JsonLdError::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative?
         v
       when nil
         nil
       else
-        raise InvalidContext::InvalidVocabMapping, "@value must be a string: #{value.inspect}"
+        raise JsonLdError::InvalidVocabMapping, "@value must be a string: #{value.inspect}"
       end
     end
 
@@ -208,7 +211,7 @@ module JSON::LD
     # 
     #
     # @param [String, #read, Array, Hash, Context] local_context
-    # @raise [InvalidContext]
+    # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @see http://json-ld.org/spec/latest/json-ld-api/index.html#context-processing-algorithm
     def parse(local_context, remote_contexts = [])
@@ -229,46 +232,57 @@ module JSON::LD
             # Load context document, if it is a string
             begin
               ctx = JSON.load(context)
-              raise JSON::LD::InvalidContext::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
+              raise JSON::LD::JsonLdError::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
               result = parse(ctx["@context"] ? ctx["@context"].dup : {})
               result.provided_context = ctx["@context"]
               result
             rescue JSON::ParserError => e
               debug("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
-              raise JSON::LD::InvalidContext::InvalidRemoteContext, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
+              raise JSON::LD::JsonLdError::InvalidRemoteContext, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
               self.dup
             end
-          when String
+          when String, RDF::URI
             debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
             # Load context document, if it is a string
-            begin
-              # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
-              context = RDF::URI(result.context_base || result.base).join(context)
+            # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
+            context = RDF::URI(result.context_base || result.base).join(context)
 
-              raise InvalidContext::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context)
-              @remote_contexts = @remote_contexts + [context]
+            raise JsonLdError::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context.to_s)
+            remote_contexts << context.to_s
 
-              context_no_base = self.dup
-              context_no_base.base = nil
-              context_no_base.provided_context = context
-              context_no_base.context_base = context
+            context_no_base = self.dup
+            context_no_base.base = nil
+            unless @options[:processingMode] == "json-ld-1.0"
+              context_no_base.provided_context = context.to_s
+            end
+            context_no_base.context_base = context.to_s
 
-              RDF::Util::File.open_file(context) do |f|
+            begin
+              @options[:documentLoader].call(context.to_s) do |remote_doc|
                 # 3.2.5) Dereference context. If the dereferenced document has no top-level JSON object with an @context member, an invalid remote context has been detected and processing is aborted; otherwise, set context to the value of that member.
-                jo = JSON.load(f)
-                raise InvalidContext::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
+                jo = case remote_doc.document
+                when String then JSON.parse(remote_doc.document)
+                else remote_doc.document
+                end
+                raise JsonLdError::InvalidRemoteContext, "#{context}" unless jo.is_a?(Hash) && jo.has_key?('@context')
                 context = jo['@context']
+                if @options[:processingMode] == "json-ld-1.0"
+                  context_no_base.provided_context = context.dup
+                end
               end
-
-              # 3.2.6) Set context to the result of recursively calling this algorithm, passing context no base for active context, context for local context, and remote contexts.
-              context = context_no_base.parse(context, remote_contexts.dup)
-              context.base = result.base unless result.base.nil?
-              result = context
-              debug("parse") {"=> provided_context: #{context.inspect}"}
+            rescue JsonLdError
+              raise
             rescue Exception => e
               debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise InvalidContext::InvalidRemoteContext, "#{context_no_base.context_base}", e.backtrace if @options[:validate]
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}", e.backtrace if @options[:validate]
             end
+
+            # 3.2.6) Set context to the result of recursively calling this algorithm, passing context no base for active context, context for local context, and remote contexts.
+            context = context_no_base.parse(context, remote_contexts.dup)
+            context.provided_context = context_no_base.provided_context
+            context.base ||= result.base
+            result = context
+            debug("parse") {"=> provided_context: #{context.inspect}"}
           when Hash
             # 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.
             {
@@ -293,7 +307,7 @@ module JSON::LD
             end
           else
             # 3.3) If context is not a JSON object, an invalid local context error has been detected and processing is aborted.
-            raise InvalidContext::InvalidLocalContext
+            raise JsonLdError::InvalidLocalContext
           end
         end
       end
@@ -311,7 +325,7 @@ module JSON::LD
     # @param [Hash] local_context
     # @param [String] term
     # @param [Hash] defined
-    # @raise [InvalidContext]
+    # @raise [JsonLdError]
     #   Represents a cyclical term dependency
     # @see http://json-ld.org/spec/latest/json-ld-api/index.html#create-term-definition
     def create_term_definition(local_context, term, defined)
@@ -324,15 +338,15 @@ module JSON::LD
       when nil
         defined[term] = false
       else
-        raise InvalidContext::CyclicIRIMapping, "Cyclical term dependency found for #{term.inspect}"
+        raise JsonLdError::CyclicIRIMapping, "Cyclical term dependency found for #{term.inspect}"
       end
 
       # Since keywords cannot be overridden, term must not be a keyword. Otherwise, an invalid value has been detected, which is an error.
       if KEYWORDS.include?(term) && !%w(@vocab @language).include?(term)
-        raise InvalidContext::KeywordRedefinition, "term #{term.inspect} must not be a keyword" if
+        raise JsonLdError::KeywordRedefinition, "term #{term.inspect} must not be a keyword" if
           @options[:validate]
       elsif !term_valid?(term) && @options[:validate]
-        raise InvalidContext::InvalidTermDefinition, "term #{term.inspect} is invalid"
+        raise JsonLdError::InvalidTermDefinition, "term #{term.inspect} is invalid"
       end
 
       # Remove any existing term definition for term in active context.
@@ -356,16 +370,29 @@ module JSON::LD
         if value.has_key?('@type')
           type = value['@type']
           # SPEC FIXME: @type may be nil
-          raise InvalidContext::InvalidTypeMapping, "unknown mapping for '@type' to #{type.inspect}" unless type.is_a?(String) || type.nil?
-          type = expand_iri(type, :vocab => true, :documentRelative => true, :local_context => local_context, :defined => defined) if type.is_a?(String)
+          type = case type
+          when nil
+            type
+          when String
+            begin
+              expand_iri(type, :vocab => true, :documentRelative => false, :local_context => local_context, :defined => defined)
+            rescue JsonLdError::InvalidIRIMapping
+              raise JsonLdError::InvalidTypeMapping, "invalid mapping for '@type' to #{type.inspect}"
+            end
+          else
+            :error
+          end
+          unless %w(@id @vocab).include?(type) || type.is_a?(RDF::URI) && type.absolute?
+            raise JsonLdError::InvalidTypeMapping, "unknown mapping for '@type' to #{type.inspect}"
+          end
           debug("") {"type_mapping: #{type.inspect}"}
           definition.type_mapping = type
         end
 
         if value.has_key?('@reverse')
-          raise InvalidContext::InvalidReverseProperty, "unexpected key in #{value.inspect}" if
+          raise JsonLdError::InvalidReverseProperty, "unexpected key in #{value.inspect}" if
             value.keys.any? {|k| %w(@id).include?(k)}
-          raise InvalidContext::InvalidIRIMapping, "expected value of @reverse to be a string" unless
+          raise JsonLdError::InvalidIRIMapping, "expected value of @reverse to be a string" unless
             value['@reverse'].is_a?(String)
 
           # Otherwise, set the IRI mapping of definition to the result of using the IRI Expansion algorithm, passing active context, the value associated with the @reverse key for value, true for vocab, true for document relative, local context, and defined. If the result is not an absolute IRI, i.e., it contains no colon (:), an invalid IRI mapping error has been detected and processing is aborted.
@@ -374,25 +401,27 @@ module JSON::LD
                                       :documentRelative => true,
                                       :local_context => local_context,
                                       :defined => defined)
-          raise InvalidContext::InvalidIRImapping, "non-absolute @reverse IRI: #{definition.id}" unless
-            definition.id.absolute?
+          raise JsonLdError::InvalidIRIMapping, "non-absolute @reverse IRI: #{definition.id}" unless
+            definition.id.is_a?(RDF::URI) && definition.id.absolute?
 
           # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, nor @index, nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
           if (container = value['@container'])
-            raise InvalidContext::InvalidReverseProperty,
+            raise JsonLdError::InvalidReverseProperty,
                   "unknown mapping for '@container' to #{container.inspect}" unless
                    ['@set', '@index', nil].include?(container)
             definition.container_mapping = container
           end
           definition.reverse_property = true
         elsif value.has_key?('@id') && value['@id'] != term
-          raise InvalidContext::InvalidIRIMapping, "expected value of @reverse to be a string" unless
+          raise JsonLdError::InvalidIRIMapping, "expected value of @id to be a string" unless
             value['@id'].is_a?(String)
           definition.id = expand_iri(value['@id'],
             :vocab => true,
             :documentRelative => true,
             :local_context => local_context,
             :defined => defined)
+          raise JsonLdError::InvalidKeywordAlias, "expected value of @id to not be @context" if
+            definition.id == '@context'
         elsif term.include?(':')
           # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
           prefix, suffix = term.split(':')
@@ -408,21 +437,21 @@ module JSON::LD
           debug("") {"=> #{definition.id}"}
         else
           # Otherwise, active context must have a vocabulary mapping, otherwise an invalid value has been detected, which is an error. Set the IRI mapping for definition to the result of concatenating the value associated with the vocabulary mapping and term.
-          raise InvalidContext::InvalidIRIMapping, "relative term definition without vocab" unless vocab
+          raise JsonLdError::InvalidIRIMapping, "relative term definition without vocab" unless vocab
           definition.id = vocab + term
           debug("") {"=> #{definition.id}"}
         end
 
         if value.has_key?('@container')
           container = value['@container']
-          raise InvalidContext::InvalidContainerMapping, "unknown mapping for '@container' to #{container.inspect}" unless %w(@list @set @language @index).include?(container)
+          raise JsonLdError::InvalidContainerMapping, "unknown mapping for '@container' to #{container.inspect}" unless %w(@list @set @language @index).include?(container)
           debug("") {"container_mapping: #{container.inspect}"}
           definition.container_mapping = container
         end
 
         if value.has_key?('@language')
           language = value['@language']
-          raise InvalidContext::InvalidLanguageMapping, "language must be null or a string, was #{language.inspect}}" unless language.nil? || (language || "").is_a?(String)
+          raise JsonLdError::InvalidLanguageMapping, "language must be null or a string, was #{language.inspect}}" unless language.nil? || (language || "").is_a?(String)
           language = language.downcase if language.is_a?(String)
           debug("") {"language_mapping: #{language.inspect}"}
           definition.language_mapping = language || false
@@ -431,7 +460,7 @@ module JSON::LD
         term_definitions[term] = definition
         defined[term] = true
       else
-        raise InvalidContext::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class}"
+        raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class}"
       end
     end
 
@@ -447,7 +476,7 @@ module JSON::LD
       depth(options) do
         # FIXME: not setting provided_context now
         use_context = case provided_context
-        when RDF::URI
+        when String, RDF::URI
           debug "serlialize: reuse context: #{provided_context.inspect}"
           provided_context.to_s
         when Hash, Array
@@ -462,7 +491,7 @@ module JSON::LD
           ctx['@vocab'] = vocab.to_s if vocab
 
           # Term Definitions
-          term_definitions.each do |term, definition|
+          term_definitions.dup.each do |term, definition|
             ctx[term] = definition.to_context_definition(self)
           end
 
@@ -611,7 +640,7 @@ module JSON::LD
     #   Used during Context Processing.
     # @return [RDF::URI, String]
     #   IRI or String, if it's a keyword
-    # @raise [JSON::LD::InvalidContext::InvalidIRIMapping] if the value cannot be expanded
+    # @raise [JSON::LD::JsonLdError::InvalidIRIMapping] if the value cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#iri-expansion
     def expand_iri(value, options = {})
       return value unless value.is_a?(String)
@@ -668,7 +697,7 @@ module JSON::LD
           RDF::URI(base).join(value)
         elsif local_context && RDF::URI(value).relative?
           # If local context is not null and value is not an absolute IRI, an invalid IRI mapping error has been detected and processing is aborted.
-          raise JSON::LD::InvalidContext::InvalidIRIMapping, "not an absolute IRI: #{value}"
+          raise JSON::LD::JsonLdError::InvalidIRIMapping, "not an absolute IRI: #{value}"
         else
           RDF::URI(value)
         end
@@ -813,7 +842,7 @@ module JSON::LD
         # try those, and add to mapping
         if @options[:standard_prefixes]
           candidates = RDF::Vocabulary.
-            select {|v| iri.start_with?(v.to_uri.to_s)}.
+            select {|v| iri.start_with?(v.to_uri.to_s) && iri != v.to_uri.to_s}.
             map do |v|
               prefix = v.__name__.to_s.split('::').last.downcase
               set_mapping(prefix, v.to_uri.to_s)
@@ -854,7 +883,7 @@ module JSON::LD
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-expansion
     def expand_value(property, value, options = {})
-      options = {:useNativeTypes => true}.merge(options)
+      options = {:useNativeTypes => false}.merge(options)
       depth(options) do
         debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
@@ -928,7 +957,7 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options
     #
     # @return [Hash] Object representation of value
-    # @raise [ProcessingError] if the iri cannot be expanded
+    # @raise [JsonLdError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-compaction
     # FIXME: revisit the specification version of this.
     def compact_value(property, value, options = {})
@@ -994,6 +1023,7 @@ module JSON::LD
 
     def inspect
       v = %w([Context)
+      v << "base=#{base}" if base
       v << "vocab=#{vocab}" if vocab
       v << "def_language=#{default_language}" if default_language
       v << "term_definitions[#{term_definitions.length}]=#{term_definitions}"

data/lib/json/ld/expand.rb

@@ -24,7 +24,7 @@ module JSON::LD
             v = expand(v, active_property, context, options)
 
             # If the active property is @list or its container mapping is set to @list, the expanded item must not be an array or a list object, otherwise a list of lists error has been detected and processing is aborted.
-            raise ProcessingError::ListOfLists,
+            raise JsonLdError::ListOfLists,
                   "A list may not contain another list" if
                   is_list && (v.is_a?(Array) || list?(v))
             v
@@ -60,17 +60,17 @@ module JSON::LD
 
             if KEYWORDS.include?(expanded_property)
               # If active property equals @reverse, an invalid reverse property map error has been detected and processing is aborted.
-              raise ProcessingError::InvalidReversePropertyMap,
+              raise JsonLdError::InvalidReversePropertyMap,
                     "@reverse not appropriate at this point" if active_property == '@reverse'
 
               # If result has already an expanded property member, an colliding keywords error has been detected and processing is aborted.
-              raise ProcessingError::CollidingKeywords,
+              raise JsonLdError::CollidingKeywords,
                     "#{expanded_property} already exists in result" if output_object.has_key?(expanded_property)
 
               expanded_value = case expanded_property
               when '@id'
                 # If expanded property is @id and value is not a string, an invalid @id value error has been detected and processing is aborted
-                raise ProcessingError::InvalidIdValue,
+                raise JsonLdError::InvalidIdValue,
                       "value of @id must be a string: #{value.inspect}" unless value.is_a?(String)
 
                 # Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
@@ -82,7 +82,7 @@ module JSON::LD
                 when Array
                   depth do
                     value.map do |v|
-                      raise ProcessingError::InvalidTypeValue,
+                      raise JsonLdError::InvalidTypeValue,
                             "@type value must be a string or array of strings: #{v.inspect}" unless v.is_a?(String)
                       context.expand_iri(v, :vocab => true, :documentRelative => true, :quiet => true, :depth => @depth).to_s
                     end
@@ -91,11 +91,11 @@ module JSON::LD
                   context.expand_iri(value, :vocab => true, :documentRelative => true, :quiet => true, :depth => @depth).to_s
                 when Hash
                   # For framing
-                  raise ProcessingError::InvalidTypeValue,
+                  raise JsonLdError::InvalidTypeValue,
                         "@type value must be a an empty object for framing: #{value.inspect}" unless
                         value.empty?
                 else
-                  raise ProcessingError::InvalidTypeValue,
+                  raise JsonLdError::InvalidTypeValue,
                         "@type value must be a string or array of strings: #{value.inspect}"
                 end
               when '@graph'
@@ -103,7 +103,7 @@ module JSON::LD
                 depth { expand(value, '@graph', context, options) }
               when '@value'
                 # If expanded property is @value and value is not a scalar or null, an invalid value object value error has been detected and processing is aborted. Otherwise, set expanded value to value. If expanded value is null, set the @value member of result to null and continue with the next key from element. Null values need to be preserved in this case as the meaning of an @type member depends on the existence of an @value member.
-                raise ProcessingError::InvalidValueObjectValue,
+                raise JsonLdError::InvalidValueObjectValue,
                       "Value of #{expanded_property} must be a scalar or null: #{value.inspect}" if value.is_a?(Hash) || value.is_a?(Array)
                 if value.nil?
                   output_object['@value'] = nil
@@ -112,12 +112,12 @@ module JSON::LD
                 value
               when '@language'
                 # If expanded property is @language and value is not a string, an invalid language-tagged string error has been detected and processing is aborted. Otherwise, set expanded value to lowercased value.
-                raise ProcessingError::InvalidLanguageTaggedString,
+                raise JsonLdError::InvalidLanguageTaggedString,
                       "Value of #{expanded_property} must be a string: #{value.inspect}" unless value.is_a?(String)
                 value.downcase
               when '@index'
                 # If expanded property is @index and value is not a string, an invalid @index value error has been detected and processing is aborted. Otherwise, set expanded value to value.
-                raise ProcessingError::InvalidIndexValue,
+                raise JsonLdError::InvalidIndexValue,
                       "Value of @index is not a string: #{value.inspect}" unless value.is_a?(String)
                 value
               when '@list'
@@ -134,7 +134,7 @@ module JSON::LD
 
                 # If expanded value is a list object, a list of lists error has been detected and processing is aborted.
                 # Spec FIXME: Also look at each object if result is an array
-                raise ProcessingError::ListOfLists,
+                raise JsonLdError::ListOfLists,
                       "A list may not contain another list" if value.any? {|v| list?(v)}
 
                 value
@@ -143,7 +143,7 @@ module JSON::LD
                 depth { expand(value, active_property, context, options) }
               when '@reverse'
                 # If expanded property is @reverse and value is not a JSON object, an invalid @reverse value error has been detected and processing is aborted.
-                raise ProcessingError::InvalidReverseValueError,
+                raise JsonLdError::InvalidReverseValue,
                       "@reverse value must be an object: #{value.inspect}" unless value.is_a?(Hash)
 
                 # Otherwise
@@ -168,8 +168,8 @@ module JSON::LD
                     next if property == '@reverse'
                     items.each do |item|
                       if value?(item) || list?(item)
-                        raise ProcessingError::InvalidReversePropertyValue,
-                              "invalid reverse property value: #{item.inspect}"
+                        raise JsonLdError::InvalidReversePropertyValue,
+                              item.inspect
                       end
                       merge_value(reverse_map, property, item)
                     end
@@ -202,7 +202,7 @@ module JSON::LD
               value.keys.sort.each do |k|
                 [value[k]].flatten.each do |item|
                   # item must be a string, otherwise an invalid language map value error has been detected and processing is aborted.
-                  raise ProcessingError::InvalidLanguageMapValue,
+                  raise JsonLdError::InvalidLanguageMapValue,
                         "Expected #{item.inspect} to be a string" unless item.is_a?(String)
 
                   # Append a JSON object to expanded value that consists of two key-value pairs: (@value-item) and (@language-lowercased language).
@@ -256,8 +256,8 @@ module JSON::LD
               reverse_map = output_object['@reverse'] ||= {}
               [expanded_value].flatten.each do |item|
                 # If item is a value object or list object, an invalid reverse property value has been detected and processing is aborted.
-                raise ProcessingError::InvalidReversePropertyValue,
-                      "invalid reverse property value: #{item.inspect}" if value?(item) || list?(item)
+                raise JsonLdError::InvalidReversePropertyValue,
+                      item.inspect if value?(item) || list?(item)
 
                 # If reverse map has no expanded property member, create one and initialize its value to an empty array.
                 # Append item to the value of the expanded property member of reverse map.
@@ -274,9 +274,10 @@ module JSON::LD
 
           # If result contains the key @value:
           if value?(output_object)
-            unless (output_object.keys - %w(@value @language @type @index)).empty?
+            unless (output_object.keys - %w(@value @language @type @index)).empty? &&
+                   (output_object.keys & %w(@language @type)).length < 2
               # The result must not contain any keys other than @value, @language, @type, and @index. It must not contain both the @language key and the @type key. Otherwise, an invalid value object error has been detected and processing is aborted.
-              raise ProcessingError::InvalidValueObjectError,
+              raise JsonLdError::InvalidValueObject,
               "value object has unknown keys: #{output_object.inspect}"
             end
 
@@ -288,12 +289,13 @@ module JSON::LD
 
             if !output_object['@value'].is_a?(String) && output_object.has_key?('@language')
               # Otherwise, if the value of result's @value member is not a string and result contains the key @language, an invalid language-tagged value error has been detected (only strings can be language-tagged) and processing is aborted.
-              raise ProcessingError::InvalidLanguageTaggedValue,
+              raise JsonLdError::InvalidLanguageTaggedValue,
                     "when @language is used, @value must be a string: #{@value.inspect}"
-            elsif !output_object.fetch('@type', "").is_a?(String)
-              # Otherwise, if the result has a @type member and its value is not a string, an invalid typed value error has been detected and processing is aborted.
-              raise ProcessingError::InvalidTypedValue,
-                    "value of @type must be a string: #{output_object['@type'].inspect}"
+            elsif !output_object.fetch('@type', "").is_a?(String) ||
+                  !context.expand_iri(output_object.fetch('@type', ""), :vocab => true, :depth => @depth).is_a?(RDF::URI)
+              # Otherwise, if the result has a @type member and its value is not an IRI, an invalid typed value error has been detected and processing is aborted.
+              raise JsonLdError::InvalidTypedValue,
+                    "value of @type must be an IRI: #{output_object['@type'].inspect}"
             end
           elsif !output_object.fetch('@type', []).is_a?(Array)
             # Otherwise, if result contains the key @type and its associated value is not an array, set it to an array containing only the associated value.
@@ -301,7 +303,7 @@ module JSON::LD
           elsif output_object.keys.any? {|k| %w(@set @list).include?(k)}
             # Otherwise, if result contains the key @set or @list:
             # The result must contain at most one other key and that key must be @index. Otherwise, an invalid set or list object error has been detected and processing is aborted.
-            raise ProcessingError::InvalidSetOrListObject,
+            raise JsonLdError::InvalidSetOrListObject,
                   "@set or @list may only contain @index: #{output_object.keys.inspect}" unless
                   (output_object.keys - %w(@set @list @index)).empty?