json-ld 3.1.0 → 3.1.5

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,14 @@
 require 'json'
 require 'bigdecimal'
 require 'set'
+require 'rdf/util/cache'
+
+begin
+  # Attempt to load this to avoid unnecessary context fetches
+  require 'json-ld-preloaded'
+rescue LoadError
+  # Silently allow this to fail
+end
 
 module JSON::LD
   class Context
@@ -15,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.
@@ -34,234 +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 [Array<'@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 = Array(mapping)
-        if @as_set = mapping.include?('@set')
-          mapping = mapping.dup
-          mapping.delete('@set')
-        end
-        @container_mapping = mapping.sort
-        @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.concat(%w(@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
 
@@ -302,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
 
@@ -314,20 +104,81 @@ 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, protected: false, override_protected: false, propagate: true, **options)
-      self.new(**options).parse(local_context, protected: false, 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
+
+    ##
+    # 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
+
+    ##
+    # 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
@@ -338,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",
@@ -368,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::InvalidContextMember, "@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.
@@ -507,18 +227,26 @@ 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.
     # @raise [JsonLdError]
     #   on a remote context load error, syntax error, or a reference to a term which is not defined.
     # @return [Context]
     # @see https://www.w3.org/TR/json-ld11-api/index.html#context-processing-algorithm
-    def parse(local_context, remote_contexts: [], protected: false, override_protected: false, propagate: true)
+    def parse(local_context,
+              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
@@ -527,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)
@@ -539,37 +267,34 @@ 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)
 
           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}"}
 
@@ -578,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',
@@ -590,26 +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)
-            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
 
@@ -626,33 +355,35 @@ module JSON::LD
             next unless context.has_key?(key)
             if key == '@import'
               # Retrieve remote context and merge the remaining context object into the result.
-              raise JsonLdError::InvalidContextMember, "@import may only be used in 1.1 mode}" if result.processingMode("json-ld-1.0")
+              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::InvalidContextMember, "#{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.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
@@ -663,8 +394,12 @@ 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)) unless NON_TERMDEF_KEYS.include?(key)
+                                          protected: context['@protected'],
+                                          remote_contexts: remote_contexts.dup,
+                                          validate_scoped: validate_scoped
+                                          ) unless NON_TERMDEF_KEYS.include?(key)
           end
         else
           # 3.3) If context is not a JSON object, an invalid local context error has been detected and processing is aborted.
@@ -678,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
@@ -722,14 +458,22 @@ 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.
+    #   If false, do not load scoped contexts.
     # @raise [JsonLdError]
     #   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, override_protected: false, protected: false)
+    def create_term_definition(local_context, term, defined,
+        base: nil,
+        override_protected: false,
+        protected: nil,
+        remote_contexts: [],
+        validate_scoped: true)
       # Expand a string value, unless it matches a keyword
       #log_debug("create_term_definition") {"term = #{term.inspect}"}
 
@@ -749,6 +493,7 @@ module JSON::LD
       # Since keywords cannot be overridden, term must not be a keyword. Otherwise, an invalid value has been detected, which is an error.
       if term == '@type' &&
          value.is_a?(Hash) &&
+         !value.empty? &&
          processingMode("json-ld-1.1") &&
          (value.keys - %w(@container @protected)).empty? &&
          value.fetch('@container', '@set') == '@set'
@@ -827,6 +572,11 @@ module JSON::LD
         raise JsonLdError::InvalidIRIMapping, "expected value of @reverse to be a string: #{value['@reverse'].inspect} on term #{term.inspect}" unless
           value['@reverse'].is_a?(String)
 
+        if value['@reverse'].to_s.match?(/^@[a-zA-Z]+$/) && @options[:validate]
+          warn "Values beginning with '@' are reserved for future use and ignored: #{value['@reverse']}."
+          return
+        end
+
         # Otherwise, set the IRI mapping of definition to the result of using the IRI Expansion algorithm, passing active context, the value associated with the @reverse key for value, true for vocab, true for document relative, local context, and defined. If the result is not an absolute IRI, i.e., it contains no colon (:), an invalid IRI mapping error has been detected and processing is aborted.
         definition.id =  expand_iri(value['@reverse'],
                                     vocab: true,
@@ -835,11 +585,6 @@ module JSON::LD
         raise JsonLdError::InvalidIRIMapping, "non-absolute @reverse IRI: #{definition.id} on term #{term.inspect}" unless
           definition.id.is_a?(RDF::Node) || definition.id.is_a?(RDF::URI) && definition.id.absolute?
 
-        if value['@reverse'].to_s.match?(/^@[a-zA-Z]+$/) && @options[:validate]
-          warn "Values beginning with '@' are reserved for future use and ignored: #{value['@reverse']}."
-          return
-        end
-
         if term[1..-1].to_s.include?(':') && (term_iri = expand_iri(term)) != definition.id
           raise JsonLdError::InvalidIRIMapping, "term #{term} expands to #{definition.id}, not #{term_iri}"
         end
@@ -943,9 +688,17 @@ module JSON::LD
 
       if value.has_key?('@context')
         begin
-          self.parse(value['@context'], override_protected: true)
+          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
@@ -1003,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
 
     ##
@@ -1014,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
 
     ##
@@ -1162,7 +1040,7 @@ module JSON::LD
     def container(term)
       return [term] if term == '@list'
       term = find_definition(term)
-      term ? term.container_mapping : []
+      term ? term.container_mapping : Set.new
     end
 
     ##
@@ -1214,7 +1092,7 @@ module JSON::LD
           term.nest
         else
           nest_term = find_definition(term.nest)
-          raise JsonLdError::InvalidNestValue, "nest must a term resolving to @nest, was #{nest_term.inspect}" unless nest_term && nest_term.simple? && nest_term.id == '@nest'
+          raise JsonLdError::InvalidNestValue, "nest must a term resolving to @nest, was #{nest_term.inspect}" unless nest_term && nest_term.id == '@nest'
           term.nest
         end
       end
@@ -1275,24 +1153,31 @@ 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] quiet (false)
+    # @param [Boolean] vocab (false)
     # @param  [Hash{Symbol => Object}] options
-    # @return [RDF::URI, String]
+    # @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, documentRelative: false, vocab: false, local_context: nil, defined: nil, quiet: false, **options)
-      return value unless value.is_a?(String)
+    def expand_iri(value,
+      as_string: false,
+      base: nil,
+      defined: nil,
+      documentRelative: false,
+      local_context: nil,
+      vocab: false,
+      **options)
+      return (value && as_string ? value.to_s : value) unless value.is_a?(String)
 
       return value if KEYWORDS.include?(value)
       return nil if value.match?(/^@[a-zA-Z]+$/)
-      #log_debug("expand_iri") {"value: #{value.inspect}"} unless quiet
 
       defined = defined || {} # if we initialized in the keyword arg we would allocate {} at each invokation, even in the 2 (common) early returns above.
 
@@ -1302,25 +1187,29 @@ module JSON::LD
       end
 
       if (v_td = term_definitions[value]) && KEYWORDS.include?(v_td.id)
-        #log_debug("") {"match with #{v_td.id}"} unless quiet
-        return v_td.id
+        return (as_string ? v_td.id.to_s : v_td.id)
       end
 
       # 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))
-        #log_debug("") {"match with #{v_td.id}"} unless quiet
-        return 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:
       if value[1..-1].to_s.include?(':')
         prefix, suffix = value.split(':', 2)
-        #log_debug("") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{self.vocab.inspect}"} unless quiet
 
         # If prefix is underscore (_) or suffix begins with double-forward-slash (//), return value as it is already an absolute IRI or a blank node identifier.
-        return RDF::Node.new(namer.get_sym(suffix)) if prefix == '_'
-        return RDF::URI(value) if suffix.start_with?('//')
+        if prefix == '_'
+          v = RDF::Node.new(namer.get_sym(suffix))
+          return (as_string ? v.to_s : v)
+        end
+        if suffix.start_with?('//')
+          v = RDF::URI(value)
+          return (as_string ? v.to_s : v)
+        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]
@@ -1329,31 +1218,43 @@ module JSON::LD
 
         # If active context contains a term definition for prefix, return the result of concatenating the IRI mapping associated with prefix and suffix.
         if (td = term_definitions[prefix]) && !td.id.nil? && td.prefix?
-          return td.id + suffix
+          return (as_string ? td.id.to_s : td.id) + suffix
         elsif RDF::URI(value).absolute?
           # Otherwise, if the value has the form of an absolute IRI, return it
-          return RDF::URI(value)
+          return (as_string ? value.to_s : RDF::URI(value))
         else
           # Otherwise, it is a relative IRI
         end
       end
-      #log_debug("") {"=> #{result.inspect}"} unless quiet
 
+      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
-      #log_debug("") {"=> #{result}"} unless quiet
-      result
+      result && as_string ? result.to_s : result
     end
 
     # The following constants are used to reduce object allocations in #compact_iri below
@@ -1372,24 +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 [Boolean] quiet (false)
-    # @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, quiet: false, **options)
+    def compact_iri(iri, base: nil, reverse: false, value: nil, vocab: nil)
       return if iri.nil?
       iri = iri.to_s
-      #log_debug("compact_iri(#{iri.inspect}", options) {[value, vocab, reverse].inspect} unless quiet
 
       if vocab && inverse_context.has_key?(iri)
-        #log_debug("") {"vocab and key in inverse context"} unless quiet
         default_language = if self.default_direction
           "#{self.default_language}_#{self.default_direction}".downcase
         else
@@ -1406,7 +1304,6 @@ module JSON::LD
           tl, tl_value = "@type", "@reverse"
           containers << '@set'
         elsif list?(value)
-          #log_debug("") {"list(#{value.inspect})"} unless quiet
           # if value is a list object, then set type/language and type/language value to the most specific values that work for all items in the list as follows:
           containers << "@list" unless index?(value)
           list = value['@list']
@@ -1429,25 +1326,21 @@ module JSON::LD
             end
             common_language ||= item_language
             if item_language != common_language && value?(item)
-              #log_debug("") {"-- #{item_language} conflicts with #{common_language}, use @none"} unless quiet
               common_language = '@none'
             end
             common_type ||= item_type
             if item_type != common_type
               common_type = '@none'
-              #log_debug("") {"#{item_type} conflicts with #{common_type}, use @none"} unless quiet
             end
           end
 
           common_language ||= '@none'
           common_type ||= '@none'
-          #log_debug("") {"common type: #{common_type}, common language: #{common_language}"} unless quiet
           if common_type != '@none'
             tl, tl_value = '@type', common_type
           else
             tl_value = common_language
           end
-          #log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
         elsif graph?(value)
           # Prefer @index and @id containers, then @graph, then @index
           containers.concat(CONTAINERS_GRAPH_INDEX_INDEX) if index?(value)
@@ -1482,7 +1375,6 @@ module JSON::LD
             tl, tl_value = '@type', '@id'
           end
           containers << '@set'
-          #log_debug("") {"value: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
         end
 
         containers << '@none'
@@ -1496,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
@@ -1506,7 +1398,6 @@ module JSON::LD
           tl = '@any' if list?(value) && value['@list'].empty?
           preferred_values.concat([tl_value, '@none'].compact)
         end
-        #log_debug("") {"preferred_values: #{preferred_values.inspect}"} unless quiet
         preferred_values << '@any'
 
         # if containers included `@language` and preferred_values includes something of the form language-tag_direction, add just the _direction part, to select terms that have that direction.
@@ -1515,7 +1406,6 @@ module JSON::LD
         end
 
         if p_term = select_term(iri, containers, tl, preferred_values)
-          #log_debug("") {"=> term: #{p_term.inspect}"} unless quiet
           return p_term
         end
       end
@@ -1523,7 +1413,6 @@ 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]
-        #log_debug("") {"=> vocab suffix: #{suffix.inspect}"} unless quiet
         return suffix unless term_definitions.has_key?(suffix)
       end
 
@@ -1565,11 +1454,9 @@ module JSON::LD
 
       if !vocab
         # transform iri to a relative IRI using the document's base IRI
-        iri = remove_base(iri)
-        #log_debug("") {"=> relative iri: #{iri.inspect}"} unless quiet
+        iri = remove_base(self.base || base, iri)
         return iri
       else
-        #log_debug("") {"=> absolute iri: #{iri.inspect}"} unless quiet
         return iri
       end
     end
@@ -1587,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
@@ -1616,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
@@ -1641,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
@@ -1669,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
@@ -1685,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')
@@ -1702,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)"}
@@ -1792,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
@@ -1812,7 +1701,7 @@ module JSON::LD
     # @param [String] term
     # @return [Boolean]
     def term_valid?(term)
-      term.is_a?(String)
+      term.is_a?(String) && !term.empty?
     end
 
     # Reverse term mapping, typically used for finding aliases for keys.
@@ -1830,9 +1719,9 @@ module JSON::LD
 
   private
 
-    CONTEXT_CONTAINER_ARRAY_TERMS = %w(@set @list @graph).freeze
-    CONTEXT_CONTAINER_ID_GRAPH = %w(@id @graph).freeze
-    CONTEXT_CONTAINER_INDEX_GRAPH = %w(@index @graph).freeze
+    CONTEXT_CONTAINER_ARRAY_TERMS = Set.new(%w(@set @list @graph)).freeze
+    CONTEXT_CONTAINER_ID_GRAPH = Set.new(%w(@id @graph)).freeze
+    CONTEXT_CONTAINER_INDEX_GRAPH = Set.new(%w(@index @graph)).freeze
     CONTEXT_BASE_FRAG_OR_QUERY = %w(? #).freeze
     CONTEXT_TYPE_ID_VOCAB = %w(@id @vocab).freeze
 
@@ -1844,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.
@@ -1898,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|
@@ -1906,7 +1786,7 @@ module JSON::LD
         end.each do |term|
           next unless td = term_definitions[term]
 
-          container = td.container_mapping.join('')
+          container = td.container_mapping.to_a.join('')
           if container.empty?
             container = td.as_set? ? %(@set) : %(@none)
           end
@@ -1943,7 +1823,7 @@ module JSON::LD
             lang_dir = td.direction_mapping ? "_#{td.direction_mapping}" : '@none'
             language_map[lang_dir] ||= term
           elsif default_direction
-            language_map[("#{td.language_mapping}_#{default_direction}").downcase] ||= term
+            language_map["_#{default_direction}"] ||= term
             language_map['@none'] ||= term
             type_map['@none'] ||= term
           else
@@ -1993,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
@@ -2058,7 +1939,7 @@ module JSON::LD
               "'@container' on term #{term.inspect} must be a string: #{container.inspect}"
       end
 
-      val = Array(container).dup
+      val = Set.new(Array(container))
       val.delete('@set') if has_set = val.include?('@set')
 
       if val.include?('@list')
@@ -2088,7 +1969,7 @@ module JSON::LD
                processingMode('json-ld-1.0')
         raise JsonLdError::InvalidContainerMapping,
           "'@container' on term #{term.inspect} using @id cannot have any values other than @set and/or @graph, found  #{container.inspect}" unless
-          (val - CONTEXT_CONTAINER_ID_GRAPH).empty?
+          val.subset?(CONTEXT_CONTAINER_ID_GRAPH)
         # Okay
       elsif val.include?('@type') || val.include?('@graph')
         raise JsonLdError::InvalidContainerMapping,
@@ -2106,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