json-ld 3.1.2 → 3.1.7

data/lib/json/ld/conneg.rb

@@ -46,7 +46,7 @@ module JSON::LD
     #
     # @param  [Hash{String => String}] env
     # @return [Array(Integer, Hash, #each)] Status, Headers and Body
-    # @see    http://rack.rubyforge.org/doc/SPEC.html
+    # @see    https://rubydoc.info/github/rack/rack/file/SPEC
     def call(env)
       response = app.call(env)
       body = response[2].respond_to?(:body) ? response[2].body : response[2]

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,6 +23,14 @@ 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 = 100 # unlimited by default
+
     class << self
       ##
       # Add preloaded context. In the block form, the context is lazy evaulated on first use.
@@ -40,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: false,
-                    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
 
@@ -316,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
 
@@ -328,187 +104,117 @@ module JSON::LD
     # @see #initialize
     # @see #parse
     # @param [String, #read, Array, Hash, Context] local_context
-    # @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, protected: false, override_protected: false, propagate: true, **options)
-      self.new(**options).parse(local_context, protected: false, override_protected: override_protected, propagate: propagate)
-    end
-
-    ##
-    # Create new evaluation context
-    # @param [Hash] options
-    # @option options [String, #to_s] :base
+    # @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.
-    # @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
-    #   Initial value for @vocab
-    # @option options [String, #to_s] :language
-    #   Initial value for @langauge
-    # @yield [ec]
-    # @yieldparam [Context]
-    # @return [Context]
-    def initialize(**options)
-      if options[:base]
-        @base = @doc_base = RDF::URI(options[:base]).dup
-        @doc_base.canonicalize! if options[:canonicalize]
-      end
-      self.processingMode = options[:processingMode] if options.has_key?(:processingMode)
-      @term_definitions = {}
-      @iri_to_term = {
-        RDF.to_uri.to_s => "rdf",
-        RDF::XSD.to_uri.to_s => "xsd"
-      }
-      @namer = BlankNodeMapper.new("t")
-
-      @options = options
-
-      # Load any defined prefixes
-      (options[:prefixes] || {}).each_pair do |k, v|
-        next if k.nil?
-        @iri_to_term[v.to_s] = k
-        @term_definitions[k.to_s] = TermDefinition.new(k, id: v.to_s, simple: true, prefix: true)
-      end
-
-      self.vocab = options[:vocab] if options[:vocab]
-      self.default_language = options[:language] if options[:language] =~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
-      @term_definitions = options[:term_definitions] if options[:term_definitions]
-
-      #log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
-
-      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
+    # @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.
+    # @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,
+                   base: nil,
+                   override_protected: false,
+                   propagate: true,
+                   **options)
+      c = self.new(**options)
+      if local_context.respond_to?(:empty?) && local_context.empty?
+        c
       else
-        raise JsonLdError::InvalidDefaultLanguage, "@language must be a string: #{value.inspect}"
+        c.parse(local_context,
+                base: base,
+                override_protected: override_protected,
+                propagate: propagate)
       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
+    ##
+    # Class-level cache used for retaining parsed remote contexts.
+    #
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.cache
+      @cache ||= RDF::Util::Cache.new(CACHE_SIZE)
     end
 
     ##
-    # Retrieve, or check processing mode.
+    # Class-level cache inverse contexts.
     #
-    # * 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
+    # @return [RDF::Util::Cache]
+    # @private
+    def self.inverse_cache
+      @inverse_cache ||= RDF::Util::Cache.new(CACHE_SIZE)
     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}"
+    # @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
-        @processingMode = value
       else
-        raise JsonLdError::InvalidVersionValue, value.inspect
+        # Don't try to cache
+        context = JSON::LD::Context.allocate
+        context.send(:initialize, **options)
+        context
       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}"
+    ##
+    # Create new evaluation context
+    # @param [Hash] options
+    # @option options [Hash{Symbol => String}] :prefixes
+    #   See `RDF::Reader#initialize`
+    # @option options [String, #to_s] :vocab
+    #   Initial value for @vocab
+    # @option options [String, #to_s] :language
+    #   Initial value for @langauge
+    # @yield [ec]
+    # @yieldparam [Context]
+    # @return [Context]
+    def initialize(**options)
+      if options[:processingMode] == 'json-ld-1.0'
+        @processingMode = 'json-ld-1.0'
       end
-    end
+      @term_definitions = {}
+      @iri_to_term = {
+        RDF.to_uri.to_s => "rdf",
+        RDF::XSD.to_uri.to_s => "xsd"
+      }
+      @namer = BlankNodeMapper.new("t")
 
-    # 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
+      @options = options
+
+      # Load any defined prefixes
+      (options[:prefixes] || {}).each_pair do |k, v|
+        next if k.nil?
+        @iri_to_term[v.to_s] = k
+        @term_definitions[k.to_s] = TermDefinition.new(k, id: v.to_s, simple: true, prefix: true)
+      end
+
+      self.vocab = options[:vocab] if options[:vocab]
+      self.default_language = options[:language] if options[:language] =~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
+      @term_definitions = options[:term_definitions] if options[:term_definitions]
+
+      #log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
+
+      yield(self) if block_given?
     end
 
     # Create an Evaluation Context
@@ -521,11 +227,12 @@ module JSON::LD
     #
     #
     # @param [String, #read, Array, Hash, Context] local_context
-    # @param [Array<String>] remote_contexts
-    # @param [Boolean] protected Make defined terms protected (as if `@protected` were used).
+    # @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_scoped (true).
     #   Validate scoped context, loading if necessary.
     #   If false, do not load scoped contexts.
@@ -534,13 +241,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: [],
-              protected: false,
+              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
@@ -549,7 +255,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)
@@ -561,28 +267,26 @@ module JSON::LD
           end
         when Context
            #log_debug("parse") {"context: #{context.inspect}"}
-           result = context.dup
+           result = result.merge(context)
         when IO, StringIO
           #log_debug("parse") {"io: #{context}"}
           # Load context document, if it is an open file
           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 = 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'
+          context_canon.scheme = 'http' if context_canon.scheme == 'https'
 
           # If validating a scoped context which has already been loaded, skip to the next one
           next if !validate_scoped && remote_contexts.include?(context.to_s)
@@ -590,11 +294,7 @@ module JSON::LD
           remote_contexts << context.to_s
           raise JsonLdError::ContextOverflow, "#{context}" if remote_contexts.length >= MAX_CONTEXTS_LOADED
 
-          context_no_base = result.dup
-          context_no_base.base = nil
-          context_no_base.context_base = context.to_s
-
-          if PRELOADED[context_canon.to_s]
+          cached_context = if PRELOADED[context_canon.to_s]
             # If we have a cached context, merge it into the current context (result) and use as the new context
             #log_debug("parse") {"=> cached_context: #{context_canon.to_s.inspect}"}
 
@@ -603,10 +303,10 @@ module JSON::LD
               #log_debug("parse") {"=> (call)"}
               PRELOADED[context_canon.to_s] = PRELOADED[context_canon.to_s].call
             end
-            context = context_no_base.merge!(PRELOADED[context_canon.to_s])
+            PRELOADED[context_canon.to_s]
           else
             # Load context document, if it is a string
-            begin
+            Context.cache[context_canon.to_s] ||= begin
               context_opts = @options.merge(
                 profile: 'http://www.w3.org/ns/json-ld#context',
                 requestProfile: 'http://www.w3.org/ns/json-ld#context',
@@ -615,31 +315,30 @@ module JSON::LD
               JSON::LD::API.loadRemoteDocument(context.to_s, **context_opts) 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.
                 raise JsonLdError::InvalidRemoteContext, "#{context}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.has_key?('@context')
-                context = remote_doc.document['@context']
+
+                # Parse stand-alone
+                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.instance_variable_set(:@base, nil)
+                ctx
               end
             rescue JsonLdError::LoadingDocumentFailed => e
               #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context}: #{e.message}", e.backtrace
             rescue JsonLdError
               raise
             rescue StandardError => e
               #log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
-              raise JsonLdError::LoadingRemoteContextFailed, "#{context_no_base.context_base}: #{e.message}", e.backtrace
+              raise JsonLdError::LoadingRemoteContextFailed, "#{context}: #{e.message}", e.backtrace
             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: remote_contexts.dup,
-                protected: protected,
-                override_protected: override_protected,
-                propagate: propagate,
-                validate_scoped: validate_scoped)
-            PRELOADED[context_canon.to_s] = context.dup
-            context.provided_context = result.provided_context
           end
-          context.base ||= result.base
+
+          # Merge loaded context noting protected term overriding
+          context = result.merge(cached_context, override_protected: override_protected)
+
+          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
 
@@ -658,31 +357,33 @@ 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',
                   requestProfile: 'http://www.w3.org/ns/json-ld#context',
                   base: nil)
                 context_opts.delete(:headers)
-                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')
+                # FIXME: should cache this, but ContextCache is for parsed contexts
+                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)
                   raise JsonLdError::InvalidContextEntry, "#{import_context.to_json} must not include @import entry" if import_context.has_key?('@import')
                   context.delete(key)
                   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, protected: context.fetch('@protected', protected))
+              result.send(setter, context[key], remote_contexts: remote_contexts)
             end
             context.delete(key)
           end
@@ -693,8 +394,9 @@ 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.fetch('@protected', protected),
+                                          protected: context['@protected'],
                                           remote_contexts: remote_contexts.dup,
                                           validate_scoped: validate_scoped
                                           ) unless NON_TERMDEF_KEYS.include?(key)
@@ -711,28 +413,29 @@ module JSON::LD
     # Merge in a context, creating a new context with updates from `context`
     #
     # @param [Context] context
+    # @param [Boolean] override_protected Allow or disallow protected terms to be changed
     # @return [Context]
-    def merge(context)
-      c = self.dup.merge!(context)
-      c.instance_variable_set(:@term_definitions, context.term_definitions.dup)
-      c
-    end
+    def merge(context, override_protected: false)
+      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 = 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])
+          unless definition == other
+            raise JSON::LD::JsonLdError::ProtectedTermRedefinition, "Attempt to redefine protected term #{term}"
+          end
+        end
+      end
 
-    ##
-    # Update context with definitions from `context`
-    #
-    # @param [Context] context
-    # @return [self]
-    def merge!(context)
-      # FIXME: if new context removes the default language, this won't do anything
-      self.default_language = context.default_language if context.default_language
-      self.vocab = context.vocab if context.vocab
-      self.base = context.base if context.base
-
-      # Merge in Term Definitions
-      term_definitions.merge!(context.term_definitions)
-      @inverse_context = nil  # Re-build after term definitions set
-      self
+      # Add term definitions
+      context.term_definitions.each do |term, definition|
+        ctx.term_definitions[term] = definition
+      end
+      ctx
     end
 
     # The following constants are used to reduce object allocations in #create_term_definition below
@@ -755,10 +458,9 @@ 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
-    #   Context is propagated across node objects.
     # @param [Array<String>] remote_contexts
     # @param [Boolean] validate_scoped (true).
     #   Validate scoped context, loading if necessary.
@@ -767,8 +469,9 @@ 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: false,
+        protected: nil,
         remote_contexts: [],
         validate_scoped: true)
       # Expand a string value, unless it matches a keyword
@@ -985,9 +688,17 @@ module JSON::LD
 
       if value.has_key?('@context')
         begin
-          self.parse(value['@context'], override_protected: true, remote_contexts: remote_contexts, validate_scoped: false)
+          new_ctx = self.parse(value['@context'],
+                               base: base,
+                               override_protected: true,
+                               remote_contexts: remote_contexts,
+                               validate_scoped: false)
           # Record null context in array form
-          definition.context = value['@context'] ? value['@context'] : [nil]
+          definition.context = case value['@context']
+          when String then new_ctx.context_base
+          when nil then [nil]
+          else value['@context']
+          end
         rescue JsonLdError => e
           raise JsonLdError::InvalidScopedContext, "Term definition for #{term.inspect} contains illegal value for @context: #{e.message}"
         end
@@ -1045,9 +756,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] value
+    # @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
 
     ##
@@ -1056,40 +888,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
 
     ##
@@ -1202,7 +1038,7 @@ module JSON::LD
     # @param [Term, #to_s] term in unexpanded form
     # @return [Array<'@index', '@language', '@index', '@set', '@type', '@id', '@graph'>]
     def container(term)
-      return [term] if term == '@list'
+      return Set[term] if term == '@list'
       term = find_definition(term)
       term ? term.container_mapping : Set.new
     end
@@ -1317,26 +1153,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)
@@ -1356,7 +1193,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:
@@ -1389,18 +1227,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
@@ -1421,17 +1273,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
 
@@ -1536,7 +1388,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
@@ -1602,7 +1454,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
@@ -1622,26 +1474,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
@@ -1651,16 +1501,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
@@ -1676,24 +1524,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
@@ -1704,10 +1551,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
@@ -1720,13 +1566,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')
@@ -1737,7 +1583,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)"}
@@ -1827,13 +1673,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.dup
-        @iri_to_term = that.iri_to_term.dup
+        @iri_to_term = that.iri_to_term
       end
       ec
     end
@@ -1879,20 +1733,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.
@@ -1933,7 +1778,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|
@@ -2028,10 +1873,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
@@ -2141,5 +1987,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 mark resulting context as 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