json-ld 3.1.3 → 3.1.8

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,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,29 @@ 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 [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, 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 +135,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 +189,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 +217,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 +227,12 @@ 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_scoped (true).
     #   Validate scoped context, loading if necessary.
     #   If false, do not load scoped contexts.
@@ -548,12 +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: [],
+              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 +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)
@@ -581,18 +274,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'
 
@@ -622,13 +314,13 @@ module JSON::LD
               #context_opts.delete(:headers)
               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')
+                raise JsonLdError::InvalidRemoteContext, "#{context}" unless remote_doc.document.is_a?(Hash) && remote_doc.document.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 +339,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
 
@@ -661,12 +352,12 @@ module JSON::LD
             '@propagate'  => :propagate=,
             '@vocab'      => :vocab=,
           }.each do |key, setter|
-            next unless context.has_key?(key)
+            next unless context.key?(key)
             if key == '@import'
               # 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,22 +365,22 @@ 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.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')
+                  raise JsonLdError::InvalidContextEntry, "#{import_context.to_json} must not include @import entry" if import_context.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)
@@ -703,6 +394,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,
@@ -721,18 +413,15 @@ module JSON::LD
     # Merge in a context, creating a new context with updates from `context`
     #
     # @param [Context] context
-    # @param [Boolean] protected mark resulting context as protected
     # @param [Boolean] override_protected Allow or disallow protected terms to be changed
-    # @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,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.
@@ -781,6 +469,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: [],
@@ -853,7 +542,7 @@ module JSON::LD
       # Potentially note that the term is protected
       definition.protected = value.fetch('@protected', protected)
 
-      if value.has_key?('@type')
+      if value.key?('@type')
         type = value['@type']
         # SPEC FIXME: @type may be nil
         type = case type
@@ -877,7 +566,7 @@ module JSON::LD
         definition.type_mapping = type
       end
 
-      if value.has_key?('@reverse')
+      if value.key?('@reverse')
         raise JsonLdError::InvalidReverseProperty, "unexpected key in #{value.inspect} on term #{term.inspect}" if
           value.key?('@id') || value.key?('@nest')
         raise JsonLdError::InvalidIRIMapping, "expected value of @reverse to be a string: #{value['@reverse'].inspect} on term #{term.inspect}" unless
@@ -903,7 +592,7 @@ module JSON::LD
         warn "[DEPRECATION] Blank Node terms deprecated in JSON-LD 1.1." if @options[:validate] && processingMode('json-ld-1.1') && definition.id.to_s.start_with?("_:")
 
         # If value contains an @container member, set the container mapping of definition to its value; if its value is neither @set, @index, @type, @id, an absolute IRI nor null, an invalid reverse property error has been detected (reverse properties only support set- and index-containers) and processing is aborted.
-        if value.has_key?('@container')
+        if value.key?('@container')
           container = value['@container']
           raise JsonLdError::InvalidReverseProperty,
                 "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless
@@ -911,9 +600,9 @@ module JSON::LD
           definition.container_mapping = check_container(container, local_context, defined, term)
         end
         definition.reverse_property = true
-      elsif value.has_key?('@id') && value['@id'].nil?
+      elsif value.key?('@id') && value['@id'].nil?
         # Allowed to reserve a null term, which may be protected
-      elsif value.has_key?('@id') && value['@id'] != term
+      elsif value.key?('@id') && value['@id'] != term
         raise JsonLdError::InvalidIRIMapping, "expected value of @id to be a string: #{value['@id'].inspect} on term #{term.inspect}" unless
           value['@id'].is_a?(String)
 
@@ -948,7 +637,7 @@ module JSON::LD
       elsif term[1..-1].include?(':')
         # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
         prefix, suffix = term.split(':', 2)
-        create_term_definition(local_context, prefix, defined, protected: protected) if local_context.has_key?(prefix)
+        create_term_definition(local_context, prefix, defined, protected: protected) if local_context.key?(prefix)
 
         definition.id = if td = term_definitions[prefix]
           # If term's prefix has a term definition in active context, set the IRI mapping for definition to the result of concatenating the value associated with the prefix's IRI mapping and the term's suffix.
@@ -975,7 +664,7 @@ module JSON::LD
 
       @iri_to_term[definition.id] = term if simple_term && definition.id
 
-      if value.has_key?('@container')
+      if value.key?('@container')
         #log_debug("") {"container_mapping: #{value['@container'].inspect}"}
         definition.container_mapping = check_container(value['@container'], local_context, defined, term)
 
@@ -990,16 +679,17 @@ module JSON::LD
         end
       end
 
-      if value.has_key?('@index')
+      if value.key?('@index')
         # property-based indexing
         raise JsonLdError::InvalidTermDefinition, "@index without @index in @container: #{value['@index']} on term #{term.inspect}" unless definition.container_mapping.include?('@index')
         raise JsonLdError::InvalidTermDefinition, "@index must expand to an IRI: #{value['@index']} on term #{term.inspect}" unless value['@index'].is_a?(String) && !value['@index'].start_with?('@')
         definition.index = value['@index'].to_s
       end
 
-      if value.has_key?('@context')
+      if value.key?('@context')
         begin
           new_ctx = self.parse(value['@context'],
+                               base: base,
                                override_protected: true,
                                remote_contexts: remote_contexts,
                                validate_scoped: false)
@@ -1014,7 +704,7 @@ module JSON::LD
         end
       end
 
-      if value.has_key?('@language')
+      if value.key?('@language')
         language = value['@language']
         language = case value['@language']
         when String
@@ -1032,14 +722,14 @@ module JSON::LD
         definition.language_mapping = language || false
       end
 
-      if value.has_key?('@direction')
+      if value.key?('@direction')
         direction = value['@direction']
         raise JsonLdError::InvalidBaseDirection, "direction must be null, 'ltr', or 'rtl', was #{language.inspect}} on term #{term.inspect}" unless direction.nil? || %w(ltr rtl).include?(direction)
         #log_debug("") {"direction_mapping: #{direction.inspect}"}
         definition.direction_mapping = direction || false
       end
 
-      if value.has_key?('@nest')
+      if value.key?('@nest')
         nest = value['@nest']
         raise JsonLdError::InvalidNestValue, "nest must be a string, was #{nest.inspect}} on term #{term.inspect}" unless nest.is_a?(String)
         raise JsonLdError::InvalidNestValue, "nest must not be a keyword other than @nest, was #{nest.inspect}} on term #{term.inspect}" if nest.match?(/^@[a-zA-Z]+$/) && nest != '@nest'
@@ -1047,7 +737,7 @@ module JSON::LD
         definition.nest = nest
       end
 
-      if value.has_key?('@prefix')
+      if value.key?('@prefix')
         raise JsonLdError::InvalidTermDefinition, "@prefix used on compact or relative IRI term #{term.inspect}" if term.match?(%r{:|/})
         case pfx = value['@prefix']
         when TrueClass, FalseClass
@@ -1066,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
 
     ##
@@ -1077,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
 
     ##
@@ -1203,7 +1018,7 @@ module JSON::LD
 
       term_sym = term.empty? ? "" : term.to_sym
       iri_to_term.delete(term_definitions[term].id.to_s) if term_definitions[term].id.is_a?(String)
-      @options[:prefixes][term_sym] = value if @options.has_key?(:prefixes)
+      @options[:prefixes][term_sym] = value if @options.key?(:prefixes)
       iri_to_term[value.to_s] = term
       term_definitions[term]
     end
@@ -1223,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
@@ -1319,7 +1134,7 @@ module JSON::LD
     # @return [Term] related term definition
     def reverse_term(term)
       # Direct lookup of term
-      term = term_definitions[term.to_s] if term_definitions.has_key?(term.to_s) && !term.is_a?(TermDefinition)
+      term = term_definitions[term.to_s] if term_definitions.key?(term.to_s) && !term.is_a?(TermDefinition)
 
       # Lookup term, assuming term is an IRI
       unless term.is_a?(TermDefinition)
@@ -1338,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)
@@ -1366,7 +1182,7 @@ module JSON::LD
       defined = defined || {} # if we initialized in the keyword arg we would allocate {} at each invokation, even in the 2 (common) early returns above.
 
       # If local context is not null, it contains a key that equals value, and the value associated with the key that equals value in defined is not true, then invoke the Create Term Definition subalgorithm, passing active context, local context, value as term, and defined. This will ensure that a term definition is created for value in active context during Context Processing.
-      if local_context && local_context.has_key?(value) && !defined[value]
+      if local_context && local_context.key?(value) && !defined[value]
         create_term_definition(local_context, value, defined)
       end
 
@@ -1377,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:
@@ -1395,7 +1212,7 @@ module JSON::LD
         end
 
         # If local context is not null, it contains a key that equals prefix, and the value associated with the key that equals prefix in defined is not true, invoke the Create Term Definition algorithm, passing active context, local context, prefix as term, and defined. This will ensure that a term definition is created for prefix in active context during Context Processing.
-        if local_context && local_context.has_key?(prefix) && !defined[prefix]
+        if local_context && local_context.key?(prefix) && !defined[prefix]
           create_term_definition(local_context, prefix, defined)
         end
 
@@ -1410,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
@@ -1442,21 +1273,21 @@ 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
 
-      if vocab && inverse_context.has_key?(iri)
+      if vocab && inverse_context.key?(iri)
         default_language = if self.default_direction
           "#{self.default_language}_#{self.default_direction}".downcase
         else
@@ -1467,7 +1298,7 @@ module JSON::LD
         containers.concat(CONTAINERS_INDEX_SET) if index?(value) && !graph?(value)
 
         # If the value is a JSON Object with the key @preserve, use the value of @preserve.
-        value = value['@preserve'].first if value.is_a?(Hash) && value.has_key?('@preserve')
+        value = value['@preserve'].first if value.is_a?(Hash) && value.key?('@preserve')
 
         if reverse
           tl, tl_value = "@type", "@reverse"
@@ -1481,11 +1312,11 @@ module JSON::LD
           list.each do |item|
             item_language, item_type = "@none", "@none"
             if value?(item)
-              if item.has_key?('@direction')
+              if item.key?('@direction')
                 item_language = "#{item['@language']}_#{item['@direction']}".downcase
-              elsif item.has_key?('@language')
+              elsif item.key?('@language')
                 item_language = item['@language'].downcase
-              elsif item.has_key?('@type')
+              elsif item.key?('@type')
                 item_type = item['@type']
               else
                 item_language = "@null"
@@ -1513,14 +1344,14 @@ module JSON::LD
         elsif graph?(value)
           # Prefer @index and @id containers, then @graph, then @index
           containers.concat(CONTAINERS_GRAPH_INDEX_INDEX) if index?(value)
-          containers.concat(CONTAINERS_GRAPH) if value.has_key?('@id')
+          containers.concat(CONTAINERS_GRAPH) if value.key?('@id')
 
           # Prefer an @graph container next
           containers.concat(CONTAINERS_GRAPH_SET)
 
           # Lastly, in 1.1, any graph can be indexed on @index or @id, so add if we haven't already
           containers.concat(CONTAINERS_GRAPH_INDEX) unless index?(value)
-          containers.concat(CONTAINERS_GRAPH) unless value.has_key?('@id')
+          containers.concat(CONTAINERS_GRAPH) unless value.key?('@id')
           containers.concat(CONTAINERS_INDEX_SET) unless index?(value)
           containers << '@set'
 
@@ -1528,13 +1359,13 @@ module JSON::LD
         else
           if value?(value)
             # In 1.1, an language map can be used to index values using @none
-            if value.has_key?('@language') && !index?(value)
+            if value.key?('@language') && !index?(value)
               tl_value = value['@language'].downcase
               tl_value += "_#{value['@direction']}" if value['@direction']
               containers.concat(CONTAINERS_LANGUAGE)
-            elsif value.has_key?('@direction') && !index?(value)
+            elsif value.key?('@direction') && !index?(value)
               tl_value = "_#{value['@direction']}"
-            elsif value.has_key?('@type')
+            elsif value.key?('@type')
               tl_value = value['@type']
               tl = '@type'
             end
@@ -1556,8 +1387,8 @@ module JSON::LD
         tl_value ||= '@null'
         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)
+        if (tl_value == '@id' || tl_value == '@reverse') && value.is_a?(Hash) && value.key?('@id')
+          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
@@ -1582,7 +1413,7 @@ module JSON::LD
       # At this point, there is no simple term that iri can be compacted to. If vocab is true and active context has a vocabulary mapping:
       if vocab && self.vocab && iri.start_with?(self.vocab) && iri.length > self.vocab.length
         suffix = iri[self.vocab.length..-1]
-        return suffix unless term_definitions.has_key?(suffix)
+        return suffix unless term_definitions.key?(suffix)
       end
 
       # The iri could not be compacted using the active context's vocabulary mapping. Try to create a compact IRI, starting by initializing compact IRI to null. This variable will be used to tore the created compact IRI, if any.
@@ -1596,7 +1427,7 @@ module JSON::LD
 
         suffix = iri[td.id.length..-1]
         ciri = "#{term}:#{suffix}"
-        candidates << ciri unless value && term_definitions.has_key?(ciri)
+        candidates << ciri unless value && term_definitions.key?(ciri)
       end
 
       return candidates.sort.first if !candidates.empty?
@@ -1623,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
@@ -1643,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
@@ -1672,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
@@ -1696,25 +1523,24 @@ module JSON::LD
             res['@language'] = lang
           end
           res['@direction'] = dir
-        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype)
-          res['@value'] = value.object
+        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype) && value.valid?
           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
+          value.canonicalize! if value.valid? && value.datatype == RDF::XSD.double
           if coerce(property)
             res['@type'] = uri(coerce(property)).to_s
-          elsif value.has_datatype?
+          elsif value.datatype?
             res['@type'] = uri(value.datatype).to_s
-          elsif value.has_language? || language(property)
+          elsif value.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 +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
@@ -1741,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')
@@ -1755,15 +1580,15 @@ module JSON::LD
       direction = direction(property)
 
       result = case
-      when coerce(property) == '@id' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
+      when coerce(property) == '@id' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce)"}
-        compact_iri(value['@id'])
-      when coerce(property) == '@vocab' && value.has_key?('@id') && (value.keys - %w(@id @index)).empty?
+        compact_iri(value['@id'], base: base)
+      when coerce(property) == '@vocab' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
         #log_debug("") {" (@id & coerce & vocab)"}
         compact_iri(value['@id'], vocab: true)
-      when value.has_key?('@id')
+      when value.key?('@id')
         #log_debug("") {" (@id)"}
         # return value as is
         value
@@ -1784,7 +1609,7 @@ module JSON::LD
         value
       end
 
-      if result.is_a?(Hash) && result.has_key?('@type') && value['@type'] != '@json'
+      if result.is_a?(Hash) && result.key?('@type') && value['@type'] != '@json'
         # Compact values of @type
         c_type =  if result['@type'].is_a?(Array)
           result['@type'].map {|t| compact_iri(t, vocab: true)}
@@ -1848,16 +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.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 +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.
@@ -1957,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|
@@ -2036,11 +1857,11 @@ module JSON::LD
       container_map = inverse_context[iri]
       #log_debug("  ") {"container_map: #{container_map.inspect}"}
       containers.each do |container|
-        next unless container_map.has_key?(container)
+        next unless container_map.key?(container)
         tl_map = container_map[container]
         value_map = tl_map[type_language]
         preferred_values.each do |item|
-          next unless value_map.has_key?(item)
+          next unless value_map.key?(item)
           #log_debug("=>") {value_map[item].inspect}
           return value_map[item]
         end
@@ -2052,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
@@ -2165,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