json-ld 3.1.3 → 3.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9799c8872d44570fe8213d9f9f54067ced632dcbfc593cb84f4223889f2530d
-  data.tar.gz: 9854ae82f3e53cb08ce4e5c8f8223d8def8c3bf86cac7ab95a6abbf08a448003
+  metadata.gz: 4755155aaabbcf15c3f29429eb085ac5e54c0785df8a84ebb42d8dbbb840c9b3
+  data.tar.gz: e8f5a6fc936ee33473f8f54ae9ee1587816b3146f4c94e179eebb2ebaa85feea
 SHA512:
-  metadata.gz: 4fb50a75c8d031026e97635ad5305d9318d455af2786b84e5ca42d0f0546ba1f1175dd5dbc05a884798145051aa352a8f1688fdb6a5ad593d057d3900d9c6f21
-  data.tar.gz: a844a733d4f292988638dc2da6be301a78d3294b3a64533398effb0b41b802bf7f48834d5e2754d3d65a6f2f69b802bcfc0ecbc44a159fdf2389ea16ae49bbad
+  metadata.gz: 8ebbbad6fde10f4ce69d8485292a580d2d9dc9cf1ffafcd878efb03a3c47bdfcd2188f1f50ec3a4d96b1a3cf7718d5926118f0283204f7420765e691d5782b78
+  data.tar.gz: bb86cdff64bceb60c574e5a72448394c9882817990b4a734e29ab1f6bc2f177fabf2fb0437bfa5c312ca87a1f7be10123cae1bc45db8722fb1029701cb38f16c

data/README.md

@@ -19,6 +19,12 @@ JSON::LD can now be used to create a _context_ from an RDFS/OWL definition, and
 
 Install with `gem install json-ld`
 
+### JSON-LD Streaming Profile
+This gem implements an optimized streaming reader used for generating RDF from large dataset dumps formatted as JSON-LD. Such documents must correspond to the [JSON-LD Streaming Profile](https://w3c.github.io/json-ld-streaming/):
+
+* Keys in JSON objects must be ordered with any of `@context`, and/or `@type` coming before any other keys, in that order. This includes aliases of those keys. It is strongly encouraged that `@id` be present, and come immediately after.
+* JSON-LD documents can be signaled or requested in [streaming document form](https://w3c.github.io/json-ld-streaming/#dfn-streaming-document-form). The profile URI identifying the [streaming document form](https://w3c.github.io/json-ld-streaming/#dfn-streaming-document-form) is `http://www.w3.org/ns/json-ld#streaming`.
+
 ### MultiJson parser
 The [MultiJson](https://rubygems.org/gems/multi_json) gem is used for parsing JSON; this defaults to the native JSON parser, but will use a more performant parser if one is available. A specific parser can be specified by adding the `:adapter` option to any API call. See [MultiJson](https://rubygems.org/gems/multi_json) for more information.
 
@@ -230,7 +236,7 @@ In some cases, the built-in document loader {JSON::LD::API.documentLoader} is in
 
 All entries into the {JSON::LD::API} accept a `:documentLoader` option, which can be used to provide an alternative method to use when loading remote documents. For example:
 ```ruby
-def load_document_local(url, options={}, &block)
+load_document_local = Proc.new do |url, **options, &block|
   if RDF::URI(url, canonicalize: true) == RDF::URI('http://schema.org/')
     remote_document = JSON::LD::API::RemoteDocument.new(url, File.read("etc/schema.org.jsonld"))
     return block_given? ? yield(remote_document) : remote_document

data/VERSION

@@ -1 +1 @@
-3.1.3
+3.1.4

data/lib/json/ld.rb

@@ -34,6 +34,8 @@ module JSON
     autoload :Normalize,          'json/ld/normalize'
     autoload :Reader,             'json/ld/reader'
     autoload :Resource,           'json/ld/resource'
+    autoload :StreamingReader,    'json/ld/streaming_reader'
+    autoload :StreamingWriter,    'json/ld/streaming_writer'
     autoload :VERSION,            'json/ld/version'
     autoload :Writer,             'json/ld/writer'
 
@@ -143,6 +145,7 @@ module JSON
       class InvalidScopedContext < JsonLdError; @code = "invalid scoped context"; end
       class InvalidScriptElement < JsonLdError; @code = "invalid script element"; end
       class InvalidSetOrListObject < JsonLdError; @code = "invalid set or list object"; end
+      class InvalidStreamingKeyOrder < JsonLdError; @code = 'invalid streaming key order' end
       class InvalidTermDefinition < JsonLdError; @code = "invalid term definition"; end
       class InvalidBaseDirection < JsonLdError; @code = "invalid base direction"; end
       class InvalidTypedValue < JsonLdError; @code = "invalid typed value"; end

data/lib/json/ld/api.rb

@@ -66,7 +66,7 @@ module JSON::LD
     # @param [String, #read, Hash, Array, JSON::LD::Context] context
     #   An external context to use additionally to the context embedded in input when expanding the input.
     # @param  [Hash{Symbol => Object}] options
-    # @option options [String, #to_s] :base
+    # @option options [RDF::URI, 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. If not specified, and a base IRI is found from `input`, options[:base] will be modified with this value.
     # @option options [Boolean] :compactArrays (true)
     #   If set to `true`, the JSON-LD processor replaces arrays with just one element with that element during compaction. If set to `false`, all arrays will remain arrays even if they have just one element.
@@ -108,6 +108,7 @@ module JSON::LD
       }.merge(options)
       @namer = unique_bnodes ? BlankNodeUniqer.new : (rename_bnodes ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
+      @options[:base] = RDF::URI(@options[:base]) if @options[:base] && !@options[:base].is_a?(RDF::URI)
       # For context via Link header
       _, context_ref = nil, nil
 
@@ -117,7 +118,7 @@ module JSON::LD
         remote_doc = self.class.loadRemoteDocument(input, **@options)
 
         context_ref = remote_doc.contextUrl
-        @options[:base] = remote_doc.documentUrl if remote_doc.documentUrl && !@options[:no_default_base]
+        @options[:base] = RDF::URI(remote_doc.documentUrl) if remote_doc.documentUrl && !@options[:no_default_base]
 
         case remote_doc.document
         when String
@@ -130,7 +131,7 @@ module JSON::LD
 
       # If not provided, first use context from document, or from a Link header
       context ||= context_ref || {}
-      @context = Context.parse(context || {}, **@options)
+      @context = Context.parse(context, **@options)
 
       if block_given?
         case block.arity
@@ -163,10 +164,9 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     # @see https://www.w3.org/TR/json-ld11-api/#expansion-algorithm
     def self.expand(input, framing: false, **options, &block)
-      result, doc_base = nil
+      result = doc_base = nil
       API.new(input, options[:expandContext], **options) do
         result = self.expand(self.value, nil, self.context,
-          ordered: @options[:ordered],
           framing: framing)
         doc_base = @options[:base]
       end
@@ -218,21 +218,21 @@ module JSON::LD
       # 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_input = expanded ? input : API.expand(input, ordered: false, **options) do |res, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         res
       end
 
       API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
-        result = compact(value, ordered: @options[:ordered])
+        result = compact(value)
 
         # xxx) Add the given context to the output
-        ctx = self.context.serialize
+        ctx = self.context.serialize(provided_context: context)
         if result.is_a?(Array)
           kwgraph = self.context.compact_iri('@graph', vocab: true)
           result = result.empty? ? {} : {kwgraph => result}
         end
-        result = ctx.merge(result) unless ctx.empty?
+        result = ctx.merge(result) unless ctx.fetch('@context', {}).empty?
       end
       block_given? ? yield(result) : result
     end
@@ -265,7 +265,7 @@ module JSON::LD
 
       # Expand input to simplify processing
       expanded_input = expanded ? input : API.expand(input, **options) do |result, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         result
       end
 
@@ -294,9 +294,11 @@ module JSON::LD
 
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
-          compacted = as_array(compact(flattened, ordered: @options[:ordered]))
+          compacted = as_array(compact(flattened))
           kwgraph = self.context.compact_iri('@graph')
-          flattened = self.context.serialize.merge(kwgraph => compacted)
+          flattened = self.context.
+            serialize(provided_context: context).
+            merge(kwgraph => compacted)
         end
       end
 
@@ -335,7 +337,7 @@ module JSON::LD
     def self.frame(input, frame, expanded: false, **options)
       result = nil
       options = {
-        base:                       (input if input.is_a?(String)),
+        base:                       (RDF::URI(input) if input.is_a?(String)),
         compactArrays:              true,
         compactToRelative:          true,
         embed:                      '@once',
@@ -369,7 +371,7 @@ module JSON::LD
 
       # Expand input to simplify processing
       expanded_input = expanded ? input : API.expand(input, ordered: false, **options) do |res, base_iri|
-        options[:base] ||= base_iri if options[:compactToRelative]
+        options[:base] ||= RDF::URI(base_iri) if base_iri && options[:compactToRelative]
         res
       end
 
@@ -426,7 +428,7 @@ module JSON::LD
         log_debug(".frame") {"expanded result: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Compact result
-        compacted = compact(result, ordered: @options[:ordered])
+        compacted = compact(result)
 
         # @replace `@null` with nil, compacting arrays
         compacted = cleanup_null(compacted)
@@ -434,11 +436,14 @@ module JSON::LD
 
         # Add the given context to the output
         result = if !compacted.is_a?(Array)
-          context.serialize.merge(compacted)
+          compacted
         else
           kwgraph = context.compact_iri('@graph')
-          context.serialize.merge({kwgraph => compacted})
+          {kwgraph => compacted}
         end
+        # Only add context if one was provided
+        result = context.serialize(provided_context: frame).merge(result) if frame['@context']
+        
         log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         result
       end
@@ -521,8 +526,7 @@ module JSON::LD
       API.new(nil, nil, **options) do
         result = from_statements(input,
           useRdfType: useRdfType,
-          useNativeTypes: useNativeTypes,
-          ordered: @options[:ordered])
+          useNativeTypes: useNativeTypes)
       end
 
       block_given? ? yield(result) : result
@@ -532,16 +536,18 @@ module JSON::LD
     # Uses built-in or provided documentLoader to retrieve a parsed document.
     #
     # @param [RDF::URI, String] url
+    # @param [String, RDF::URI] base
+    #   Location to use as documentUrl instead of `url`.
+    # @option options [Proc] :documentLoader
+    #   The callback of the loader to be used to retrieve remote documents and contexts.
     # @param [Boolean] extractAllScripts
     #   If set to `true`, when extracting JSON-LD script elements from HTML, unless a specific fragment identifier is targeted, extracts all encountered JSON-LD script elements using an array form, if necessary.
     # @param [String] profile
     #   When the resulting `contentType` is `text/html` or `application/xhtml+xml`, this option determines the profile to use for selecting a JSON-LD script elements.
     # @param [String] requestProfile
     #   One or more IRIs to use in the request as a profile parameter.
-    # @param [Boolean] validate
+    # @param [Boolean] validate (false)
     #   Allow only appropriate content types
-    # @param [String, RDF::URI] base
-    #   Location to use as documentUrl instead of `url`.
     # @param [Hash<Symbol => Object>] options
     # @yield remote_document
     # @yieldparam [RemoteDocumentRemoteDocument, RDF::Util::File::RemoteDocument] remote_document
@@ -550,13 +556,14 @@ module JSON::LD
     #   If a block is given, the result of evaluating the block is returned, otherwise, the retrieved remote document and context information unless block given
     # @raise [JsonLdError]
     def self.loadRemoteDocument(url,
+                                base: nil,
+                                documentLoader: nil,
                                 extractAllScripts: false,
                                 profile: nil,
                                 requestProfile: nil,
                                 validate: false,
-                                base: nil,
                                 **options)
-      documentLoader = options.fetch(:documentLoader, self.method(:documentLoader))
+      documentLoader ||= self.method(:documentLoader)
       options = OPEN_OPTS.merge(options)
       if requestProfile
         # Add any request profile

data/lib/json/ld/compact.rb

@@ -12,11 +12,14 @@ module JSON::LD
     # This algorithm compacts a JSON-LD document, such that the given context is applied. This must result in shortening any applicable IRIs to terms or compact IRIs, any applicable keywords to keyword aliases, and any applicable JSON-LD values expressed in expanded form to simple values such as strings or numbers.
     #
     # @param [Array, Hash] element
-    # @param [String] property (nil)
-    # @param [Boolean] ordered (true)
+    # @param [String, RDF::URI] base (nil)
     #   Ensure output objects have keys ordered properly
+    # @param [String] property (nil)
+    #   Extra validatation
     # @return [Array, Hash]
-    def compact(element, property: nil, ordered: false)
+    def compact(element,
+                base: nil,
+                property: nil)
       #if property.nil?
       #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
       #else
@@ -29,7 +32,9 @@ module JSON::LD
       case element
       when Array
         #log_debug("") {"Array #{element.inspect}"}
-        result = element.map {|item| compact(item, property: property, ordered: ordered)}.compact
+        result = element.map do |item|
+          compact(item, base: base, property: property)
+        end.compact
 
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
@@ -55,10 +60,13 @@ module JSON::LD
 
         # Look up term definintions from property using the original type-scoped context, if it exists, but apply them to the now current previous context
         td = input_context.term_definitions[property] if property
-        self.context = context.parse(td.context, override_protected: true) if td && td.context
+        if td && !td.context.nil?
+          self.context = context.parse(td.context,
+            override_protected: true)
+        end
 
         if element.key?('@id') || element.key?('@value')
-          result = context.compact_value(property, element, log_depth: @options[:log_depth])
+          result = context.compact_value(property, element, base: @options[:base])
           if !result.is_a?(Hash) || context.coerce(property) == '@json'
             #log_debug("") {"=> scalar result: #{result.inspect}"}
             return result
@@ -67,7 +75,8 @@ module JSON::LD
 
         # If expanded property is @list and we're contained within a list container, recursively compact this item to an array
         if list?(element) && context.container(property).include?('@list')
-          return compact(element['@list'], property: property, ordered: ordered)
+          return compact(element['@list'], base: base,
+                         property: property)
         end
 
         inside_reverse = property == '@reverse'
@@ -80,15 +89,17 @@ module JSON::LD
           sort.
           each do |term|
           term_context = input_context.term_definitions[term].context if input_context.term_definitions[term]
-          self.context = context.parse(term_context, propagate: false) if term_context
+          self.context = context.parse(term_context, propagate: false) unless term_context.nil?
         end
 
-        element.keys.opt_sort(ordered: ordered).each do |expanded_property|
+        element.keys.opt_sort(ordered: @options[:ordered]).each do |expanded_property|
           expanded_value = element[expanded_property]
           #log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if expanded_property == '@id'
-            compacted_value = Array(expanded_value).map {|expanded_id| context.compact_iri(expanded_id)}
+            compacted_value = Array(expanded_value).map do |expanded_id|
+              context.compact_iri(expanded_id, base: @options[:base])
+            end
 
             kw_alias = context.compact_iri('@id', vocab: true)
             as_array = compacted_value.length > 1
@@ -98,7 +109,9 @@ module JSON::LD
           end
 
           if expanded_property == '@type'
-            compacted_value = Array(expanded_value).map {|expanded_type| input_context.compact_iri(expanded_type, vocab: true)}
+            compacted_value = Array(expanded_value).map do |expanded_type|
+              input_context.compact_iri(expanded_type, vocab: true)
+            end
 
             kw_alias = context.compact_iri('@type', vocab: true)
             as_array = compacted_value.length > 1 ||
@@ -110,7 +123,8 @@ module JSON::LD
           end
 
           if expanded_property == '@reverse'
-            compacted_value = compact(expanded_value, property: '@reverse', ordered: ordered)
+            compacted_value = compact(expanded_value, base: base,
+                                      property: '@reverse')
             #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             # handle double-reversed properties
             compacted_value.each do |prop, value|
@@ -131,7 +145,8 @@ module JSON::LD
 
           if expanded_property == '@preserve'
             # Compact using `property`
-            compacted_value = compact(expanded_value, property: property, ordered: ordered)
+            compacted_value = compact(expanded_value, base: base,
+                                      property: property)
             #log_debug("@preserve") {"compacted_value: #{compacted_value.inspect}"}
 
             unless compacted_value.is_a?(Array) && compacted_value.empty?
@@ -158,8 +173,7 @@ module JSON::LD
               context.compact_iri(expanded_property,
                                   value: expanded_value,
                                   vocab: true,
-                                  reverse: inside_reverse,
-                                  log_depth: @options[:log_depth])
+                                  reverse: inside_reverse)
 
             if nest_prop = context.nest(item_active_property)
               result[nest_prop] ||= {}
@@ -177,8 +191,7 @@ module JSON::LD
               context.compact_iri(expanded_property,
                                   value: expanded_item,
                                   vocab: true,
-                                  reverse: inside_reverse,
-                                  log_depth: @options[:log_depth])
+                                  reverse: inside_reverse)
 
 
             nest_result = if nest_prop = context.nest(item_active_property)
@@ -197,7 +210,8 @@ module JSON::LD
             else expanded_item
             end
 
-            compacted_item = compact(value, property: item_active_property, ordered: ordered)
+            compacted_item = compact(value, base: base,
+                                     property: item_active_property)
             #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             # handle @list
@@ -225,9 +239,9 @@ module JSON::LD
                 map_object = nest_result[item_active_property] ||= {}
                 # If there is no @id, create a blank node identifier to use as an index
                 map_key = if container.include?('@id') && expanded_item['@id']
-                  context.compact_iri(expanded_item['@id'])
+                  context.compact_iri(expanded_item['@id'], base: @options[:base])
                 elsif container.include?('@index') && expanded_item['@index']
-                  context.compact_iri(expanded_item['@index'])
+                  context.compact_iri(expanded_item['@index'], vocab: true)
                 else
                   context.compact_iri('@none', vocab: true)
                 end
@@ -299,7 +313,9 @@ module JSON::LD
 
                 # if compacted_item contains a single entry who's key maps to @id, then recompact the item without @type
                 if compacted_item.keys.length == 1 && expanded_item.keys.include?('@id')
-                  compacted_item = compact({'@id' => expanded_item['@id']}, property: item_active_property)
+                  compacted_item = compact({'@id' => expanded_item['@id']},
+                                           base: base,
+                                           property: item_active_property)
                 end
                 compacted_item
               end

data/lib/json/ld/context.rb

@@ -3,6 +3,8 @@
 require 'json'
 require 'bigdecimal'
 require 'set'
+require 'rdf/util/cache'
+
 begin
   # Attempt to load this to avoid unnecessary context fetches
   require 'json-ld-preloaded'
@@ -21,10 +23,13 @@ module JSON::LD
     # @return [Hash{Symbol => Context}]
     PRELOADED = {}
 
+    # Initial contexts, defined on first access
+    INITIAL_CONTEXTS = {}
+
     ##
     # Defines the maximum number of interned URI references that can be held
     # cached in memory at any one time.
-    CACHE_SIZE = -1 # unlimited by default
+    CACHE_SIZE = 100 # unlimited by default
 
     class << self
       ##
@@ -45,242 +50,11 @@ module JSON::LD
       end
     end
 
-    # Term Definitions specify how properties and values have to be interpreted as well as the current vocabulary mapping and the default language
-    class TermDefinition
-      # @return [RDF::URI] IRI map
-      attr_accessor :id
-
-      # @return [String] term name
-      attr_accessor :term
-
-      # @return [String] Type mapping
-      attr_accessor :type_mapping
-
-      # Base container mapping, without @set
-      # @return [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] Container mapping
-      attr_reader :container_mapping
-
-      # @return [String] Term used for nest properties
-      attr_accessor :nest
-
-      # Language mapping of term, `false` is used if there is an explicit language mapping for this term.
-      # @return [String] Language mapping
-      attr_accessor :language_mapping
-
-      # Direction of term, `false` is used if there is explicit direction mapping mapping for this term.
-      # @return ["ltr", "rtl"] direction_mapping
-      attr_accessor :direction_mapping
-
-      # @return [Boolean] Reverse Property
-      attr_accessor :reverse_property
-
-      # This is a simple term definition, not an expanded term definition
-      # @return [Boolean]
-      attr_accessor :simple
-
-      # Property used for data indexing; defaults to @index
-      # @return [Boolean]
-      attr_accessor :index
-
-      # Indicate that term may be used as a prefix
-      attr_writer :prefix
-
-      # Term-specific context
-      # @return [Hash{String => Object}]
-      attr_accessor :context
-
-      # Term is protected.
-      # @return [Boolean]
-      attr_writer :protected
-
-      # This is a simple term definition, not an expanded term definition
-      # @return [Boolean] simple
-      def simple?; simple; end
-
-      # This is an appropriate term to use as the prefix of a compact IRI
-      # @return [Boolean] simple
-      def prefix?; @prefix; end
-
-      # Create a new Term Mapping with an ID
-      # @param [String] term
-      # @param [String] id
-      # @param [String] type_mapping Type mapping
-      # @param [Set<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
-      # @param [String] language_mapping
-      #   Language mapping of term, `false` is used if there is an explicit language mapping for this term
-      # @param ["ltr", "rtl"] direction_mapping
-      #   Direction mapping of term, `false` is used if there is an explicit direction mapping for this term
-      # @param [Boolean] reverse_property
-      # @param [Boolean] protected
-      # @param [String] nest term used for nest properties
-      # @param [Boolean] simple
-      #   This is a simple term definition, not an expanded term definition
-      # @param [Boolean] prefix
-      #   Term may be used as a prefix
-      def initialize(term,
-                    id: nil,
-                    index: nil,
-                    type_mapping: nil,
-                    container_mapping: nil,
-                    language_mapping: nil,
-                    direction_mapping: nil,
-                    reverse_property: false,
-                    nest: nil,
-                    protected: nil,
-                    simple: false,
-                    prefix: nil,
-                    context: nil)
-        @term                   = term
-        @id                     = id.to_s           unless id.nil?
-        @index                  = index.to_s        unless index.nil?
-        @type_mapping           = type_mapping.to_s unless type_mapping.nil?
-        self.container_mapping  = container_mapping
-        @language_mapping       = language_mapping  unless language_mapping.nil?
-        @direction_mapping      = direction_mapping unless direction_mapping.nil?
-        @reverse_property       = reverse_property
-        @protected              = protected
-        @nest                   = nest              unless nest.nil?
-        @simple                 = simple
-        @prefix                 = prefix            unless prefix.nil?
-        @context                = context           unless context.nil?
-      end
-
-      # Term is protected.
-      # @return [Boolean]
-      def protected?; !!@protected; end
-
-      # Set container mapping, from an array which may include @set
-      def container_mapping=(mapping)
-        mapping = case mapping
-        when Set then mapping
-        when Array then Set.new(mapping)
-        when String then Set[mapping]
-        when nil then Set.new
-        else
-          raise "Shouldn't happen with #{mapping.inspect}"
-        end
-        if @as_set = mapping.include?('@set')
-          mapping = mapping.dup
-          mapping.delete('@set')
-        end
-        @container_mapping = mapping
-        @index ||= '@index' if mapping.include?('@index')
-      end
-
-      ##
-      # Output Hash or String definition for this definition considering @language and @vocab
-      #
-      # @param [Context] context
-      # @return [String, Hash{String => Array[String], String}]
-      def to_context_definition(context)
-        cid = if context.vocab && id.start_with?(context.vocab)
-          # Nothing to return unless it's the same as the vocab
-          id == context.vocab ? context.vocab : id.to_s[context.vocab.length..-1]
-        else
-          # Find a term to act as a prefix
-          iri, prefix = context.iri_to_term.detect {|i,p| id.to_s.start_with?(i.to_s)}
-          iri && iri != id ? "#{prefix}:#{id.to_s[iri.length..-1]}" : id
-        end
-
-        if simple?
-           cid.to_s unless cid == term && context.vocab
-        else
-          defn = {}
-          defn[reverse_property ? '@reverse' : '@id'] = cid.to_s unless cid == term && !reverse_property
-          if type_mapping
-            defn['@type'] = if KEYWORDS.include?(type_mapping)
-              type_mapping
-            else
-              context.compact_iri(type_mapping, vocab: true)
-            end
-          end
-
-          cm = Array(container_mapping)
-          cm << "@set" if as_set? && !cm.include?("@set")
-          cm = cm.first if cm.length == 1
-          defn['@container'] = cm unless cm.empty?
-          # Language set as false to be output as null
-          defn['@language'] = (@language_mapping ? @language_mapping : nil) unless @language_mapping.nil?
-          defn['@context'] = @context if @context
-          defn['@nest'] = @nest if @nest
-          defn['@index'] = @index if @index
-          defn['@prefix'] = @prefix unless @prefix.nil?
-          defn
-        end
-      end
-
-      ##
-      # Turn this into a source for a new instantiation
-      # FIXME: context serialization
-      # @return [String]
-      def to_rb
-        defn = [%(TermDefinition.new\(#{term.inspect})]
-        %w(id index type_mapping container_mapping language_mapping direction_mapping reverse_property nest simple prefix context protected).each do |acc|
-          v = instance_variable_get("@#{acc}".to_sym)
-          v = v.to_s if v.is_a?(RDF::Term)
-          if acc == 'container_mapping'
-            v = v.to_a
-            v << '@set' if as_set?
-            v = v.first if v.length <= 1
-          end
-          defn << "#{acc}: #{v.inspect}" if v
-        end
-        defn.join(', ') + ")"
-      end
-
-      # If container mapping was defined along with @set
-      # @return [Boolean]
-      def as_set?; @as_set || false; end
-
-      # Check if term definitions are identical, modulo @protected
-      # @return [Boolean]
-      def ==(other)
-        other.is_a?(TermDefinition) &&
-        id == other.id &&
-        term == other.term &&
-        type_mapping == other.type_mapping &&
-        container_mapping == other.container_mapping &&
-        nest == other.nest &&
-        language_mapping == other.language_mapping &&
-        direction_mapping == other.direction_mapping &&
-        reverse_property == other.reverse_property &&
-        simple == other.simple &&
-        index == other.index &&
-        context == other.context &&
-        prefix? == other.prefix? &&
-        as_set? == other.as_set?
-      end
-
-      def inspect
-        v = %w([TD)
-        v << "id=#{@id}"
-        v << "index=#{index.inspect}" unless index.nil?
-        v << "term=#{@term}"
-        v << "rev" if reverse_property
-        v << "container=#{container_mapping}" if container_mapping
-        v << "as_set=#{as_set?.inspect}"
-        v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
-        v << "dir=#{direction_mapping.inspect}" unless direction_mapping.nil?
-        v << "type=#{type_mapping}" unless type_mapping.nil?
-        v << "nest=#{nest.inspect}" unless nest.nil?
-        v << "simple=true" if @simple
-        v << "protected=true" if @protected
-        v << "prefix=#{@prefix.inspect}" unless @prefix.nil?
-        v << "has-context" unless context.nil?
-        v.join(" ") + "]"
-      end
-    end
-
     # The base.
     #
     # @return [RDF::URI] Current base IRI, used for expanding relative IRIs.
     attr_reader :base
 
-    # The base.
-    #
-    # @return [RDF::URI] Document base IRI, to initialize `base`.
-    attr_reader :doc_base
-
     # @return [RDF::URI] base IRI of the context, if loaded remotely.
     attr_accessor :context_base
 
@@ -321,9 +95,6 @@ module JSON::LD
     # @return [Hash{Symbol => Object}] Global options used in generating IRIs
     attr_accessor :options
 
-    # @return [Context] A context provided to us that we can use without re-serializing XXX
-    attr_accessor :provided_context
-
     # @return [BlankNodeNamer]
     attr_accessor :namer
 
@@ -333,11 +104,33 @@ module JSON::LD
     # @see #initialize
     # @see #parse
     # @param [String, #read, Array, Hash, Context] local_context
+    # @param [String, #to_s] :base (nil)
+    #   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.
+    # @param [Proc] :documentLoader (nil)
+    #   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.
+    # @param [Boolean] override_protected (false)
+    #   Protected terms may be cleared.
+    # @param [Boolean] propagate (true)
+    #   If false, retains any previously defined term, which can be rolled back when the descending into a new node object changes.
+    # @param [Boolean] validate (false)
+    #   Extra validatation
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
-    def self.parse(local_context, override_protected: false, propagate: true, **options)
-      self.new(**options).parse(local_context, override_protected: override_protected, propagate: propagate)
+    def self.parse(local_context,
+                   base: nil,
+                   override_protected: false,
+                   propagate: true,
+                   **options)
+      c = self.new(**options)
+      if local_context.respond_to?(:empty?) && local_context.empty?
+        c
+      else
+        c.parse(local_context,
+                base: base,
+                override_protected: override_protected,
+                propagate: propagate)
+      end
     end
 
     ##
@@ -346,17 +139,50 @@ module JSON::LD
     # @return [RDF::Util::Cache]
     # @private
     def self.cache
-      require 'rdf/util/cache' unless defined?(::RDF::Util::Cache)
       @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
     end
 
+    ##
+    # Class-level cache inverse contexts.
+    #
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.inverse_cache
+      @inverse_cache ||= RDF::Util::Cache.new(CACHE_SIZE)
+    end
+
+    ##
+    # @private
+    # Allow caching of well-known contexts
+    def self.new(**options)
+      if (options.keys - [
+          :compactArrays,
+          :documentLoader,
+          :extractAllScripts,
+          :ordered,
+          :processingMode,
+          :validate
+          ]).empty?
+        # allow caching
+        key = options.hash
+        INITIAL_CONTEXTS[key] ||= begin
+          context = JSON::LD::Context.allocate
+          context.send(:initialize, **options)
+          context.freeze
+          context.term_definitions.freeze
+          context
+        end
+      else
+        # Don't try to cache
+        context = JSON::LD::Context.allocate
+        context.send(:initialize, **options)
+        context
+      end
+    end
+
     ##
     # 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`
     # @option options [String, #to_s] :vocab
@@ -367,11 +193,9 @@ module JSON::LD
     # @yieldparam [Context]
     # @return [Context]
     def initialize(**options)
-      if options[:base]
-        @base = @doc_base = RDF::URI(options[:base]).dup
-        @doc_base.canonicalize! if options[:canonicalize]
+      if options[:processingMode] == 'json-ld-1.0'
+        @processingMode = 'json-ld-1.0'
       end
-      self.processingMode = options[:processingMode] if options.has_key?(:processingMode)
       @term_definitions = {}
       @iri_to_term = {
         RDF.to_uri.to_s => "rdf",
@@ -397,135 +221,6 @@ module JSON::LD
       yield(self) if block_given?
     end
 
-    ##
-    # Initial context, without mappings, vocab or default language
-    #
-    # @return [Boolean]
-    def empty?
-      @term_definitions.empty? && self.vocab.nil? && self.default_language.nil?
-    end
-
-    # @param [String] value must be an absolute IRI
-    def base=(value, **options)
-      if value
-        raise JsonLdError::InvalidBaseIRI, "@base must be a string: #{value.inspect}" unless value.is_a?(String) || value.is_a?(RDF::URI)
-        value = RDF::URI(value).dup
-        value = @base.join(value) if @base && value.relative?
-        @base = value
-        @base.canonicalize! if @options[:canonicalize]
-        raise JsonLdError::InvalidBaseIRI, "@base must be an absolute IRI: #{value.inspect}" unless @base.absolute? || !@options[:validate]
-        @base
-      else
-        @base = nil
-      end
-
-    end
-
-    # @param [String] value
-    def default_language=(value, **options)
-      @default_language = case value
-      when String
-        # Warn on an invalid language tag, unless :validate is true, in which case it's an error
-        if value !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
-          warn "@language must be valid BCP47: #{value.inspect}"
-        end
-        options[:lowercaseLanguage] ? value.downcase : value
-      when nil
-        nil
-      else
-        raise JsonLdError::InvalidDefaultLanguage, "@language must be a string: #{value.inspect}"
-      end
-    end
-
-    # @param [String] value
-    def default_direction=(value, **options)
-      @default_direction = if value
-        raise JsonLdError::InvalidBaseDirection, "@direction must be one or 'ltr', or 'rtl': #{value.inspect}" unless %w(ltr rtl).include?(value)
-        value
-      else
-        nil
-      end
-    end
-
-    ##
-    # Retrieve, or check processing mode.
-    #
-    # * With no arguments, retrieves the current set processingMode.
-    # * With an argument, verifies that the processingMode is at least that provided, either as an integer, or a string of the form "json-ld-1.x"
-    # * If expecting 1.1, and not set, it has the side-effect of setting mode to json-ld-1.1.
-    #
-    # @param [String, Number] expected (nil)
-    # @return [String]
-    def processingMode(expected = nil)
-      case expected
-      when 1.0, 'json-ld-1.0'
-        @processingMode == 'json-ld-1.0'
-      when 1.1, 'json-ld-1.1'
-        @processingMode ||= 'json-ld-1.1'
-        @processingMode == 'json-ld-1.1'
-      when nil
-        @processingMode
-      else
-        false
-      end
-    end
-
-    ##
-    # Set processing mode.
-    #
-    # * With an argument, verifies that the processingMode is at least that provided, either as an integer, or a string of the form "json-ld-1.x"
-    #
-    # If contex has a @version member, it's value MUST be 1.1, otherwise an "invalid @version value" has been detected, and processing is aborted.
-    # If processingMode has been set, and it is not "json-ld-1.1", a "processing mode conflict" has been detecting, and processing is aborted.
-    #
-    # @param [String, Number] expected
-    # @return [String]
-    # @raise [JsonLdError::ProcessingModeConflict]
-    def processingMode=(value = nil, **options)
-      value = "json-ld-1.1" if value == 1.1
-      case value
-      when "json-ld-1.0", "json-ld-1.1"
-        if @processingMode && @processingMode != value
-          raise JsonLdError::ProcessingModeConflict, "#{value} not compatible with #{@processingMode}"
-        end
-        @processingMode = value
-      else
-        raise JsonLdError::InvalidVersionValue, value.inspect
-      end
-    end
-
-    # 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.
-    # @param [String] value must be an absolute IRI
-    def vocab=(value, **options)
-      @vocab = case value
-      when /_:/
-        # BNode vocab is deprecated
-        warn "[DEPRECATION] Blank Node vocabularies deprecated in JSON-LD 1.1." if @options[:validate] && processingMode("json-ld-1.1")
-        value
-      when String, RDF::URI
-        if (RDF::URI(value.to_s).relative? && processingMode("json-ld-1.0"))
-          raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI in 1.0 mode: #{value.inspect}"
-        end
-        v = expand_iri(value.to_s, vocab: true, documentRelative: true)
-        raise JsonLdError::InvalidVocabMapping, "@vocab must be an IRI: #{value.inspect}" if !v.valid? && @options[:validate]
-        v
-      when nil
-        nil
-      else
-        raise JsonLdError::InvalidVocabMapping, "@vocab must be an IRI: #{value.inspect}"
-      end
-    end
-
-    # Set propagation
-    # @note: by the time this is called, the work has already been done.
-    #
-    # @param [Boolean] value
-    def propagate=(value, **options)
-      raise JsonLdError::InvalidContextEntry, "@propagate may only be set in 1.1 mode" if processingMode("json-ld-1.0")
-      raise JsonLdError::InvalidPropagateValue, "@propagate must be boolean valued: #{value.inspect}" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
-      value
-    end
-
     # Create an Evaluation Context
     #
     # When processing a JSON-LD data structure, each processing rule is applied using information provided by the active context. This section describes how to produce an active context.
@@ -536,10 +231,14 @@ module JSON::LD
     #
     #
     # @param [String, #read, Array, Hash, Context] local_context
-    # @param [Array<String>] remote_contexts
+    # @param [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.
     # @param [Boolean] override_protected Protected terms may be cleared.
-    # @param [Boolean] propagate
+    # @param [Boolean] propagate (true)
     #   If false, retains any previously defined term, which can be rolled back when the descending into a new node object changes.
+    # @param [Array<String>] remote_contexts ([])
+    # @param [Boolean] validate (false)
+    #   Extra validatation
     # @param [Boolean] validate_scoped (true).
     #   Validate scoped context, loading if necessary.
     #   If false, do not load scoped contexts.
@@ -548,12 +247,12 @@ module JSON::LD
     # @return [Context]
     # @see https://www.w3.org/TR/json-ld11-api/index.html#context-processing-algorithm
     def parse(local_context,
-              remote_contexts: [],
+              base: nil,
               override_protected: false,
               propagate: true,
+              remote_contexts: [],
               validate_scoped: true)
       result = self.dup
-      result.provided_context = local_context if self.empty?
       # Early check for @propagate, which can only appear in a local context
       propagate = local_context.is_a?(Hash) ? local_context.fetch('@propagate', propagate) : propagate
       result.previous_context ||= result.dup unless propagate
@@ -562,7 +261,7 @@ module JSON::LD
 
       local_context.each do |context|
         case context
-        when nil
+        when nil,false
           # 3.1 If the `override_protected` is  false, and the active context contains protected terms, an error is raised.
           if override_protected || result.term_definitions.values.none?(&:protected?)
             null_context = Context.new(**options)
@@ -581,18 +280,17 @@ module JSON::LD
           begin
             ctx = JSON.load(context)
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
-            result = result.dup.parse(ctx["@context"] ? ctx["@context"].dup : {})
-            result.provided_context = ctx["@context"] if [context] == local_context
+            result = result.parse(ctx["@context"] ? ctx["@context"] : {})
           rescue JSON::ParserError => e
             #log_debug("parse") {"Failed to parse @context from remote document at #{context}: #{e.message}"}
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Failed to parse remote context at #{context}: #{e.message}" if @options[:validate]
-            self.dup
+            self
           end
         when String, RDF::URI
           #log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
 
           # 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 || options[:base]).join(context)
+          context = RDF::URI(result.context_base || base).join(context)
           context_canon = context.canonicalize
           context_canon.scheme = 'http' if context_canon.scheme == 'https'
 
@@ -625,10 +323,10 @@ module JSON::LD
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
 
                 # Parse stand-alone
-                ctx = Context.new(**options)
+                ctx = Context.new(unfrozen: true, **options).dup
                 ctx.context_base = context.to_s
                 ctx = ctx.parse(remote_doc.document['@context'], remote_contexts: remote_contexts.dup)
-                ctx.base = nil
+                ctx.instance_variable_set(:@base, nil)
                 ctx
               end
             rescue JsonLdError::LoadingDocumentFailed => e
@@ -647,7 +345,6 @@ module JSON::LD
 
           context.previous_context = self unless propagate
           result = context
-          #log_debug("parse") {"=> provided_context: #{context.inspect}"}
         when Hash
           context = context.dup # keep from modifying a hash passed as a param
 
@@ -666,7 +363,7 @@ module JSON::LD
               # Retrieve remote context and merge the remaining context object into the result.
               raise JsonLdError::InvalidContextEntry, "@import may only be used in 1.1 mode}" if result.processingMode("json-ld-1.0")
               raise JsonLdError::InvalidImportValue, "@import must be a string: #{context['@import'].inspect}" unless context['@import'].is_a?(String)
-              source = RDF::URI(result.context_base || result.base).join(context['@import'])
+              import_loc = RDF::URI(result.context_base || base).join(context['@import'])
               begin
                 context_opts = @options.merge(
                   profile: 'http://www.w3.org/ns/json-ld#context',
@@ -674,9 +371,9 @@ module JSON::LD
                   base: nil)
                 context_opts.delete(:headers)
                 # FIXME: should cache this, but ContextCache is for parsed contexts
-                JSON::LD::API.loadRemoteDocument(source, **context_opts) do |remote_doc|
-                  # Dereference source. 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.
-                  raise JsonLdError::InvalidRemoteContext, "#{source}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
+                JSON::LD::API.loadRemoteDocument(import_loc, **context_opts) do |remote_doc|
+                  # Dereference import_loc. 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.
+                  raise JsonLdError::InvalidRemoteContext, "#{import_loc}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
                   import_context = remote_doc.document['@context']
                   import_context.delete('@base')
                   raise JsonLdError::InvalidRemoteContext, "#{import_context.to_json} must be an object" unless import_context.is_a?(Hash)
@@ -685,11 +382,11 @@ module JSON::LD
                   context = import_context.merge(context)
                 end
               rescue JsonLdError::LoadingDocumentFailed => e
-                raise JsonLdError::LoadingRemoteContextFailed, "#{source}: #{e.message}", e.backtrace
+                raise JsonLdError::LoadingRemoteContextFailed, "#{import_loc}: #{e.message}", e.backtrace
               rescue JsonLdError
                 raise
               rescue StandardError => e
-                raise JsonLdError::LoadingRemoteContextFailed, "#{source}: #{e.message}", e.backtrace
+                raise JsonLdError::LoadingRemoteContextFailed, "#{import_loc}: #{e.message}", e.backtrace
               end
             else
               result.send(setter, context[key], remote_contexts: remote_contexts)
@@ -703,6 +400,7 @@ module JSON::LD
           context.each_key do |key|
             # ... where key is not @base, @vocab, @language, or @version
             result.create_term_definition(context, key, defined,
+                                          base: base,
                                           override_protected: override_protected,
                                           protected: context['@protected'],
                                           remote_contexts: remote_contexts.dup,
@@ -726,13 +424,12 @@ module JSON::LD
     # @param [Boolean]
     # @return [Context]
     def merge(context, override_protected: false)
-      ctx = Context.new(term_definitions: self.term_definitions.dup(), standard_prefixes: options[:standard_prefixes])
+      ctx = Context.new(term_definitions: self.term_definitions, standard_prefixes: options[:standard_prefixes])
       ctx.context_base = context.context_base || self.context_base
       ctx.default_language = context.default_language || self.default_language
       ctx.default_direction = context.default_direction || self.default_direction
       ctx.vocab = context.vocab || self.vocab
-      ctx.base = context.base || self.base
-      ctx.provided_context = self.provided_context
+      ctx.base = self.base unless self.base.nil?
       if !override_protected
         ctx.term_definitions.each do |term, definition|
           next unless definition.protected? && (other = context.term_definitions[term])
@@ -769,6 +466,7 @@ module JSON::LD
     # @param [Hash] local_context
     # @param [String] term
     # @param [Hash] defined
+    # @param [String, RDF::URI] base for resolving document-relative IRIs
     # @param [Boolean] protected if true, causes all terms to be marked protected
     # @param [Boolean] override_protected Protected terms may be cleared.
     # @param [Boolean] propagate
@@ -781,6 +479,7 @@ module JSON::LD
     #   Represents a cyclical term dependency
     # @see https://www.w3.org/TR/json-ld11-api/index.html#create-term-definition
     def create_term_definition(local_context, term, defined,
+        base: nil,
         override_protected: false,
         protected: nil,
         remote_contexts: [],
@@ -1000,6 +699,7 @@ module JSON::LD
       if value.has_key?('@context')
         begin
           new_ctx = self.parse(value['@context'],
+                               base: base,
                                override_protected: true,
                                remote_contexts: remote_contexts,
                                validate_scoped: false)
@@ -1066,9 +766,130 @@ module JSON::LD
 
       term_definitions[term] = definition
       defined[term] = true
-    ensure
-      # Re-build after term definitions set
-      @inverse_context = nil
+    end
+
+    ##
+    # Initial context, without mappings, vocab or default language
+    #
+    # @return [Boolean]
+    def empty?
+      @term_definitions.empty? && self.vocab.nil? && self.default_language.nil?
+    end
+
+    # @param [String] value must be an absolute IRI
+    def base=(value, **options)
+      if value
+        raise JsonLdError::InvalidBaseIRI, "@base must be a string: #{value.inspect}" unless value.is_a?(String) || value.is_a?(RDF::URI)
+        value = RDF::URI(value)
+        value = @base.join(value) if @base && value.relative?
+        # still might be relative to document
+        @base = value
+      else
+        @base = false
+      end
+
+    end
+
+    # @param [String] value
+    def default_language=(value, **options)
+      @default_language = case value
+      when String
+        # Warn on an invalid language tag, unless :validate is true, in which case it's an error
+        if value !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+          warn "@language must be valid BCP47: #{value.inspect}"
+        end
+        options[:lowercaseLanguage] ? value.downcase : value
+      when nil
+        nil
+      else
+        raise JsonLdError::InvalidDefaultLanguage, "@language must be a string: #{value.inspect}"
+      end
+    end
+
+    # @param [String] value
+    def default_direction=(value, **options)
+      @default_direction = if value
+        raise JsonLdError::InvalidBaseDirection, "@direction must be one or 'ltr', or 'rtl': #{value.inspect}" unless %w(ltr rtl).include?(value)
+        value
+      else
+        nil
+      end
+    end
+
+    ##
+    # Retrieve, or check processing mode.
+    #
+    # * With no arguments, retrieves the current set processingMode.
+    # * With an argument, verifies that the processingMode is at least that provided, either as an integer, or a string of the form "json-ld-1.x"
+    # * If expecting 1.1, and not set, it has the side-effect of setting mode to json-ld-1.1.
+    #
+    # @param [String, Number] expected (nil)
+    # @return [String]
+    def processingMode(expected = nil)
+      case expected
+      when 1.0, 'json-ld-1.0'
+        @processingMode == 'json-ld-1.0'
+      when 1.1, 'json-ld-1.1'
+        @processingMode.nil? || @processingMode == 'json-ld-1.1'
+      when nil
+        @processingMode || 'json-ld-1.1'
+      else
+        false
+      end
+    end
+
+    ##
+    # Set processing mode.
+    #
+    # * With an argument, verifies that the processingMode is at least that provided, either as an integer, or a string of the form "json-ld-1.x"
+    #
+    # If contex has a @version member, it's value MUST be 1.1, otherwise an "invalid @version value" has been detected, and processing is aborted.
+    # If processingMode has been set, and it is not "json-ld-1.1", a "processing mode conflict" has been detecting, and processing is aborted.
+    #
+    # @param [String, Number] expected
+    # @return [String]
+    # @raise [JsonLdError::ProcessingModeConflict]
+    def processingMode=(value = nil, **options)
+      value = "json-ld-1.1" if value == 1.1
+      case value
+      when "json-ld-1.0", "json-ld-1.1"
+        if @processingMode && @processingMode != value
+          raise JsonLdError::ProcessingModeConflict, "#{value} not compatible with #{@processingMode}"
+        end
+        @processingMode = value
+      else
+        raise JsonLdError::InvalidVersionValue, value.inspect
+      end
+    end
+
+    # 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.
+    # @param [String] value must be an absolute IRI
+    def vocab=(value, **options)
+      @vocab = case value
+      when /_:/
+        # BNode vocab is deprecated
+        warn "[DEPRECATION] Blank Node vocabularies deprecated in JSON-LD 1.1." if @options[:validate] && processingMode("json-ld-1.1")
+        value
+      when String, RDF::URI
+        if (RDF::URI(value.to_s).relative? && processingMode("json-ld-1.0"))
+          raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI in 1.0 mode: #{value.inspect}"
+        end
+        expand_iri(value.to_s, vocab: true, documentRelative: true)
+      when nil
+        nil
+      else
+        raise JsonLdError::InvalidVocabMapping, "@vocab must be an IRI: #{value.inspect}"
+      end
+    end
+
+    # Set propagation
+    # @note: by the time this is called, the work has already been done.
+    #
+    # @param [Boolean] value
+    def propagate=(value, **options)
+      raise JsonLdError::InvalidContextEntry, "@propagate may only be set in 1.1 mode" if processingMode("json-ld-1.0")
+      raise JsonLdError::InvalidPropagateValue, "@propagate must be boolean valued: #{value.inspect}" unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      value
     end
 
     ##
@@ -1077,40 +898,44 @@ module JSON::LD
     # If a context was supplied in global options, use that, otherwise, generate one
     # from this representation.
     #
+    # @param [Array, Hash, Context, IO, StringIO] provided_context (nil)
+    #   Original context to use, if available
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
-    def serialize(**options)
-      # FIXME: not setting provided_context now
+    def serialize(provided_context: nil, **options)
+      #log_debug("serlialize: generate context")
+      #log_debug("") {"=> context: #{inspect}"}
       use_context = case provided_context
       when String, RDF::URI
         #log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context.to_s
-      when Hash, Array
+      when Hash
+        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        # If it has an @context entry use it, otherwise it is assumed to be the body of a context
+        provided_context.fetch('@context', provided_context)
+      when Array
         #log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context
+      when IO, StringIO
+        provided_context.rewind
+        JSON.load(provided_context).fetch('@context', {})
       else
-        #log_debug("serlialize: generate context")
-        #log_debug("") {"=> context: #{inspect}"}
         ctx = {}
-        ctx['@base'] = base.to_s if base && base != doc_base
+        ctx['@version'] = 1.1 if @processingMode == 'json-ld-1.1'
+        ctx['@base'] = base.to_s if base
         ctx['@direction'] = default_direction.to_s if default_direction
         ctx['@language'] = default_language.to_s if default_language
         ctx['@vocab'] = vocab.to_s if vocab
 
         # Term Definitions
-        term_definitions.keys.each do |term|
-          defn = term_definitions[term].to_context_definition(self)
-          ctx[term] = defn if defn
+        term_definitions.each do |term, defn|
+          ctx[term] = defn.to_context_definition(self)
         end
-
-        #log_debug("") {"start_doc: context=#{ctx.inspect}"}
         ctx
       end
 
       # Return hash with @context, or empty
-      r = {}
-      r['@context'] = use_context unless use_context.nil? || use_context.empty?
-      r
+      use_context.nil? || use_context.empty? ? {} : {'@context' => use_context}
     end
 
     ##
@@ -1338,26 +1163,27 @@ module JSON::LD
     #
     # @param [String] value
     #   A keyword, term, prefix:suffix or possibly relative IRI
+    # @param [Boolean] as_string (false) transform RDF::Resource values to string
+    # @param [String, RDF::URI] base for resolving document-relative IRIs
+    # @param [Hash] defined
+    #   Used during Context Processing.
     # @param [Boolean] documentRelative (false)
-    # @param [Boolean] vocab (false)
     # @param [Hash] local_context
     #   Used during Context Processing.
-    # @param [Hash] defined
-    #   Used during Context Processing.
-    # @param [Boolean] as_string (false) transform RDF::Resource values to string
+    # @param [Boolean] vocab (false)
     # @param  [Hash{Symbol => Object}] options
     # @return [RDF::Resource, String]
     #   IRI or String, if it's a keyword
     # @raise [JSON::LD::JsonLdError::InvalidIRIMapping] if the value cannot be expanded
     # @see https://www.w3.org/TR/json-ld11-api/#iri-expansion
     def expand_iri(value,
+      as_string: false,
+      base: nil,
+      defined: nil,
       documentRelative: false,
-      vocab: false,
       local_context: nil,
-      defined: nil,
-      as_string: false,
-      **options
-    )
+      vocab: false,
+      **options)
       return (value && as_string ? value.to_s : value) unless value.is_a?(String)
 
       return value if KEYWORDS.include?(value)
@@ -1377,7 +1203,8 @@ module JSON::LD
       # If active context has a term definition for value, and the associated mapping is a keyword, return that keyword.
       # If vocab is true and the active context has a term definition for value, return the associated IRI mapping.
       if (v_td = term_definitions[value]) && (vocab || KEYWORDS.include?(v_td.id))
-        return (as_string ? v_td.id.to_s : v_td.id)
+        iri = base && v_td.id ? base.join(v_td.id) : v_td.id # vocab might be doc relative
+        return (as_string ? iri.to_s : iri)
       end
 
       # If value contains a colon (:), it is either an absolute IRI or a compact IRI:
@@ -1410,18 +1237,32 @@ module JSON::LD
         end
       end
 
+      iri = value.is_a?(RDF::URI) ? value : RDF::URI(value)
       result = if vocab && self.vocab
         # If vocab is true, and active context has a vocabulary mapping, return the result of concatenating the vocabulary mapping with value.
-        self.vocab + value
-      elsif documentRelative && (base ||= self.base)
-        # Otherwise, if document relative is true, set value to the result of resolving value against the base IRI. 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].
-        value = RDF::URI(value)
-        value.absolute? ? value : RDF::URI(base).join(value)
-      elsif local_context && RDF::URI(value).relative?
+        # Note that @vocab could still be relative to a document base
+        (base && self.vocab.is_a?(RDF::URI) && self.vocab.relative? ? base.join(self.vocab) : self.vocab) + value
+      elsif documentRelative
+        if iri.absolute?
+          iri
+        elsif self.base.is_a?(RDF::URI) && self.base.absolute?
+          self.base.join(iri)
+        elsif self.base == false
+          # No resollution of `@base: null`
+          iri
+        elsif base && self.base
+          base.join(self.base).join(iri)
+        elsif base
+          base.join(iri)
+        else
+          # Returns a relative IRI in an odd case.
+          iri
+        end
+      elsif local_context && iri.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::JsonLdError::InvalidIRIMapping, "not an absolute IRI: #{value}"
       else
-        RDF::URI(value)
+        iri
       end
       result && as_string ? result.to_s : result
     end
@@ -1442,17 +1283,17 @@ module JSON::LD
     # Compacts an absolute IRI to the shortest matching term or compact IRI
     #
     # @param [RDF::URI] iri
+    # @param [String, RDF::URI] base for resolving document-relative IRIs
     # @param [Object] value
     #   Value, used to select among various maps for the same IRI
-    # @param [Boolean] vocab
-    #   specifies whether the passed iri should be compacted using the active context's vocabulary mapping
     # @param [Boolean] reverse
     #   specifies whether a reverse property is being compacted
-    # @param  [Hash{Symbol => Object}] options ({})
+    # @param [Boolean] vocab
+    #   specifies whether the passed iri should be compacted using the active context's vocabulary mapping
     #
     # @return [String] compacted form of IRI
     # @see https://www.w3.org/TR/json-ld11-api/#iri-compaction
-    def compact_iri(iri, value: nil, vocab: nil, reverse: false, **options)
+    def compact_iri(iri, base: nil, reverse: false, value: nil, vocab: nil)
       return if iri.nil?
       iri = iri.to_s
 
@@ -1557,7 +1398,7 @@ module JSON::LD
         preferred_values = []
         preferred_values << '@reverse' if tl_value == '@reverse'
         if (tl_value == '@id' || tl_value == '@reverse') && value.is_a?(Hash) && value.has_key?('@id')
-          t_iri = compact_iri(value['@id'], vocab: true, document_relative: true)
+          t_iri = compact_iri(value['@id'], vocab: true, base: base)
           if (r_td = term_definitions[t_iri]) && r_td.id == value['@id']
             preferred_values.concat(CONTAINERS_VOCAB_ID)
           else
@@ -1623,7 +1464,7 @@ module JSON::LD
 
       if !vocab
         # transform iri to a relative IRI using the document's base IRI
-        iri = remove_base(iri)
+        iri = remove_base(self.base || base, iri)
         return iri
       else
         return iri
@@ -1643,26 +1484,24 @@ module JSON::LD
     #   Value (literal or IRI) to be expanded
     # @param [Boolean] useNativeTypes (false) use native representations
     # @param [Boolean] rdfDirection (nil) decode i18n datatype if i18n-datatype
+    # @param [String, RDF::URI] base for resolving document-relative IRIs
     # @param  [Hash{Symbol => Object}] options
     #
     # @return [Hash] Object representation of value
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see https://www.w3.org/TR/json-ld11-api/#value-expansion
-    def expand_value(property, value, useNativeTypes: false, rdfDirection: nil, **options)
-      #log_debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}"}
-
+    def expand_value(property, value, useNativeTypes: false, rdfDirection: nil, base: nil, **options)
       td = term_definitions.fetch(property, TermDefinition.new(property))
 
       # If the active property has a type mapping in active context that is @id, return a new JSON object containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, and true for document relative.
       if value.is_a?(String) && td.type_mapping == '@id'
         #log_debug("") {"as relative IRI: #{value.inspect}"}
-        return {'@id' => expand_iri(value, documentRelative: true).to_s}
+        return {'@id' => expand_iri(value, documentRelative: true, base: base).to_s}
       end
 
       # If active property has a type mapping in active context that is @vocab, return a new JSON object containing a single key-value pair where the key is @id and the value is the result of using the IRI Expansion algorithm, passing active context, value, true for vocab, and true for document relative.
       if value.is_a?(String) && td.type_mapping == '@vocab'
-        #log_debug("") {"as vocab IRI: #{value.inspect}"}
-        return {'@id' => expand_iri(value, vocab: true, documentRelative: true).to_s}
+        return {'@id' => expand_iri(value, vocab: true, documentRelative: true, base: base).to_s}
       end
 
       value = RDF::Literal(value) if
@@ -1672,16 +1511,14 @@ module JSON::LD
 
       result = case value
       when RDF::URI, RDF::Node
-        #log_debug("URI | BNode") { value.to_s }
         {'@id' => value.to_s}
       when RDF::Literal
-        #log_debug("Literal") {"datatype: #{value.datatype.inspect}"}
         res = {}
         if value.datatype == RDF::URI(RDF.to_uri + "JSON") && processingMode('json-ld-1.1')
           # Value parsed as JSON
           # FIXME: MultiJson
-          res['@value'] = ::JSON.parse(value.object)
           res['@type'] = '@json'
+          res['@value'] = ::JSON.parse(value.object)
         elsif value.datatype.start_with?("https://www.w3.org/ns/i18n#") && rdfDirection == 'i18n-datatype' && processingMode('json-ld-1.1')
           lang, dir = value.datatype.fragment.split('_')
           res['@value'] = value.to_s
@@ -1697,24 +1534,23 @@ module JSON::LD
           end
           res['@direction'] = dir
         elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype)
-          res['@value'] = value.object
           res['@type'] = uri(coerce(property)) if coerce(property)
+          res['@value'] = value.object
         else
           value.canonicalize! if value.datatype == RDF::XSD.double
-          res['@value'] = value.to_s
           if coerce(property)
             res['@type'] = uri(coerce(property)).to_s
           elsif value.has_datatype?
             res['@type'] = uri(value.datatype).to_s
           elsif value.has_language? || language(property)
             res['@language'] = (value.language || language(property)).to_s
-            # FIXME: direction
           end
+          res['@value'] = value.to_s
         end
         res
       else
         # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
-        res = {'@value' => value}
+        res = {}
 
         if td.type_mapping && !CONTAINERS_ID_VOCAB.include?(td.type_mapping.to_s)
           res['@type'] = td.type_mapping.to_s
@@ -1725,10 +1561,9 @@ module JSON::LD
           res['@direction'] = direction if direction
         end
 
-        res
+        res.merge('@value' => value)
       end
 
-      #log_debug("") {"=> #{result.inspect}"}
       result
     rescue ::JSON::ParserError => e
       raise JSON::LD::JsonLdError::InvalidJsonLiteral, e.message
@@ -1741,13 +1576,13 @@ module JSON::LD
     #   Associated property used to find coercion rules
     # @param [Hash] value
     #   Value (literal or IRI), in full object representation, to be compacted
-    # @param  [Hash{Symbol => Object}] options
+    # @param [String, RDF::URI] base for resolving document-relative IRIs
     #
     # @return [Hash] Object representation of value
     # @raise [JsonLdError] if the iri cannot be expanded
     # @see https://www.w3.org/TR/json-ld11-api/#value-compaction
     # FIXME: revisit the specification version of this.
-    def compact_value(property, value, **options)
+    def compact_value(property, value, base: nil)
       #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
       indexing = index?(value) && container(property).include?('@index')
@@ -1758,7 +1593,7 @@ module JSON::LD
       when coerce(property) == '@id' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce)"}
-        compact_iri(value['@id'])
+        compact_iri(value['@id'], base: base)
       when coerce(property) == '@vocab' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce & vocab)"}
@@ -1848,16 +1683,21 @@ module JSON::LD
       v.join(" ") + "]"
     end
 
+    # Duplicate an active context, allowing it to be modified.
     def dup
-      # Also duplicate mappings, coerce and list
       that = self
-      ec = super
+      ec = Context.new(unfrozen: true, **@options)
+      ec.context_base = that.context_base
+      ec.base = that.base unless that.base.nil?
+      ec.default_direction = that.default_direction
+      ec.default_language = that.default_language
+      ec.previous_context = that.previous_context
+      ec.processingMode = that.processingMode if that.instance_variable_get(:@processingModee)
+      ec.vocab = that.vocab if that.vocab
+
       ec.instance_eval do
-        @term_definitions = that.term_definitions.inject({}) do |memo, (term, defn)|
-          memo.merge(term => defn.dup())
-        end
-        @iri_to_term = that.iri_to_term.dup
-        @inverse_context = nil
+        @term_definitions = that.term_definitions.dup
+        @iri_to_term = that.iri_to_term
       end
       ec
     end
@@ -1903,20 +1743,11 @@ module JSON::LD
         bnode(namer.get_sym($1))
       else
         value = RDF::URI(value)
-        value.validate! if @options[:validate]
-        value.canonicalize! if @options[:canonicalize]
-        value = RDF::URI.intern(value, {}) if @options[:intern]
+        #value.validate! if options[:validate]
         value
       end
     end
 
-    # Clear the provided context, used for testing
-    # @return [Context] self
-    def clear_provided_context
-      @provided_context = nil
-      self
-    end
-
     # Keep track of allocated BNodes
     #
     # Don't actually use the name provided, to prevent name alias issues.
@@ -1957,7 +1788,7 @@ module JSON::LD
     # @return [Hash{String => Hash{String => String}}]
     # @todo May want to include @set along with container to allow selecting terms using @set over those without @set. May require adding some notion of value cardinality to compact_iri
     def inverse_context
-      @inverse_context ||= begin
+      Context.inverse_cache[self.hash] ||= begin
         result = {}
         default_language = (self.default_language || '@none').downcase
         term_definitions.keys.sort do |a, b|
@@ -2052,10 +1883,11 @@ module JSON::LD
     ##
     # Removes a base IRI from the given absolute IRI.
     #
+    # @param [String] base the base used for making `iri` relative
     # @param [String] iri the absolute IRI
     # @return [String]
     #   the relative IRI if relative to base, otherwise the absolute IRI.
-    def remove_base(iri)
+    def remove_base(base, iri)
       return iri unless base
       @base_and_parents ||= begin
         u = base
@@ -2165,5 +1997,232 @@ module JSON::LD
       end
       Array(container)
     end
+
+    # Term Definitions specify how properties and values have to be interpreted as well as the current vocabulary mapping and the default language
+    class TermDefinition
+      # @return [RDF::URI] IRI map
+      attr_accessor :id
+
+      # @return [String] term name
+      attr_accessor :term
+
+      # @return [String] Type mapping
+      attr_accessor :type_mapping
+
+      # Base container mapping, without @set
+      # @return [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] Container mapping
+      attr_reader :container_mapping
+
+      # @return [String] Term used for nest properties
+      attr_accessor :nest
+
+      # Language mapping of term, `false` is used if there is an explicit language mapping for this term.
+      # @return [String] Language mapping
+      attr_accessor :language_mapping
+
+      # Direction of term, `false` is used if there is explicit direction mapping mapping for this term.
+      # @return ["ltr", "rtl"] direction_mapping
+      attr_accessor :direction_mapping
+
+      # @return [Boolean] Reverse Property
+      attr_accessor :reverse_property
+
+      # This is a simple term definition, not an expanded term definition
+      # @return [Boolean]
+      attr_accessor :simple
+
+      # Property used for data indexing; defaults to @index
+      # @return [Boolean]
+      attr_accessor :index
+
+      # Indicate that term may be used as a prefix
+      attr_writer :prefix
+
+      # Term-specific context
+      # @return [Hash{String => Object}]
+      attr_accessor :context
+
+      # Term is protected.
+      # @return [Boolean]
+      attr_writer :protected
+
+      # This is a simple term definition, not an expanded term definition
+      # @return [Boolean] simple
+      def simple?; simple; end
+
+      # This is an appropriate term to use as the prefix of a compact IRI
+      # @return [Boolean] simple
+      def prefix?; @prefix; end
+
+      # Create a new Term Mapping with an ID
+      # @param [String] term
+      # @param [String] id
+      # @param [String] type_mapping Type mapping
+      # @param [Set<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>] container_mapping
+      # @param [String] language_mapping
+      #   Language mapping of term, `false` is used if there is an explicit language mapping for this term
+      # @param ["ltr", "rtl"] direction_mapping
+      #   Direction mapping of term, `false` is used if there is an explicit direction mapping for this term
+      # @param [Boolean] reverse_property
+      # @param [Boolean] protected
+      # @param [String] nest term used for nest properties
+      # @param [Boolean] simple
+      #   This is a simple term definition, not an expanded term definition
+      # @param [Boolean] prefix
+      #   Term may be used as a prefix
+      def initialize(term,
+                    id: nil,
+                    index: nil,
+                    type_mapping: nil,
+                    container_mapping: nil,
+                    language_mapping: nil,
+                    direction_mapping: nil,
+                    reverse_property: false,
+                    nest: nil,
+                    protected: nil,
+                    simple: false,
+                    prefix: nil,
+                    context: nil)
+        @term                   = term
+        @id                     = id.to_s           unless id.nil?
+        @index                  = index.to_s        unless index.nil?
+        @type_mapping           = type_mapping.to_s unless type_mapping.nil?
+        self.container_mapping  = container_mapping
+        @language_mapping       = language_mapping  unless language_mapping.nil?
+        @direction_mapping      = direction_mapping unless direction_mapping.nil?
+        @reverse_property       = reverse_property
+        @protected              = protected
+        @nest                   = nest              unless nest.nil?
+        @simple                 = simple
+        @prefix                 = prefix            unless prefix.nil?
+        @context                = context           unless context.nil?
+      end
+
+      # Term is protected.
+      # @return [Boolean]
+      def protected?; !!@protected; end
+
+      # Set container mapping, from an array which may include @set
+      def container_mapping=(mapping)
+        mapping = case mapping
+        when Set then mapping
+        when Array then Set.new(mapping)
+        when String then Set[mapping]
+        when nil then Set.new
+        else
+          raise "Shouldn't happen with #{mapping.inspect}"
+        end
+        if @as_set = mapping.include?('@set')
+          mapping = mapping.dup
+          mapping.delete('@set')
+        end
+        @container_mapping = mapping
+        @index ||= '@index' if mapping.include?('@index')
+      end
+
+      ##
+      # Output Hash or String definition for this definition considering @language and @vocab
+      #
+      # @param [Context] context
+      # @return [String, Hash{String => Array[String], String}]
+      def to_context_definition(context)
+        cid = if context.vocab && id.start_with?(context.vocab)
+          # Nothing to return unless it's the same as the vocab
+          id == context.vocab ? context.vocab : id.to_s[context.vocab.length..-1]
+        else
+          # Find a term to act as a prefix
+          iri, prefix = context.iri_to_term.detect {|i,p| id.to_s.start_with?(i.to_s)}
+          iri && iri != id ? "#{prefix}:#{id.to_s[iri.length..-1]}" : id
+        end
+
+        if simple?
+           cid.to_s unless cid == term && context.vocab
+        else
+          defn = {}
+          defn[reverse_property ? '@reverse' : '@id'] = cid.to_s unless cid == term && !reverse_property
+          if type_mapping
+            defn['@type'] = if KEYWORDS.include?(type_mapping)
+              type_mapping
+            else
+              context.compact_iri(type_mapping, vocab: true)
+            end
+          end
+
+          cm = Array(container_mapping)
+          cm << "@set" if as_set? && !cm.include?("@set")
+          cm = cm.first if cm.length == 1
+          defn['@container'] = cm unless cm.empty?
+          # Language set as false to be output as null
+          defn['@language'] = (@language_mapping ? @language_mapping : nil) unless @language_mapping.nil?
+          defn['@direction'] = (@direction_mapping ? @direction_mapping : nil) unless @direction_mapping.nil?
+          defn['@context'] = @context if @context
+          defn['@nest'] = @nest if @nest
+          defn['@index'] = @index if @index
+          defn['@prefix'] = @prefix unless @prefix.nil?
+          defn
+        end
+      end
+
+      ##
+      # Turn this into a source for a new instantiation
+      # FIXME: context serialization
+      # @return [String]
+      def to_rb
+        defn = [%(TermDefinition.new\(#{term.inspect})]
+        %w(id index type_mapping container_mapping language_mapping direction_mapping reverse_property nest simple prefix context protected).each do |acc|
+          v = instance_variable_get("@#{acc}".to_sym)
+          v = v.to_s if v.is_a?(RDF::Term)
+          if acc == 'container_mapping'
+            v = v.to_a
+            v << '@set' if as_set?
+            v = v.first if v.length <= 1
+          end
+          defn << "#{acc}: #{v.inspect}" if v
+        end
+        defn.join(', ') + ")"
+      end
+
+      # If container mapping was defined along with @set
+      # @return [Boolean]
+      def as_set?; @as_set || false; end
+
+      # Check if term definitions are identical, modulo @protected
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(TermDefinition) &&
+        id == other.id &&
+        term == other.term &&
+        type_mapping == other.type_mapping &&
+        container_mapping == other.container_mapping &&
+        nest == other.nest &&
+        language_mapping == other.language_mapping &&
+        direction_mapping == other.direction_mapping &&
+        reverse_property == other.reverse_property &&
+        simple == other.simple &&
+        index == other.index &&
+        context == other.context &&
+        prefix? == other.prefix? &&
+        as_set? == other.as_set?
+      end
+
+      def inspect
+        v = %w([TD)
+        v << "id=#{@id}"
+        v << "index=#{index.inspect}" unless index.nil?
+        v << "term=#{@term}"
+        v << "rev" if reverse_property
+        v << "container=#{container_mapping}" if container_mapping
+        v << "as_set=#{as_set?.inspect}"
+        v << "lang=#{language_mapping.inspect}" unless language_mapping.nil?
+        v << "dir=#{direction_mapping.inspect}" unless direction_mapping.nil?
+        v << "type=#{type_mapping}" unless type_mapping.nil?
+        v << "nest=#{nest.inspect}" unless nest.nil?
+        v << "simple=true" if @simple
+        v << "protected=true" if @protected
+        v << "prefix=#{@prefix.inspect}" unless @prefix.nil?
+        v << "has-context" unless context.nil?
+        v.join(" ") + "]"
+      end
+    end
   end
 end