json-ld 2.0.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d460373a6fabcbbd48f31b6b2dc12d473882802d
-  data.tar.gz: 58f8dd9acb20a4f46241100a178217dc31dba372
+  metadata.gz: 693e380cfc75c04525a1144d742a4c98737df5bf
+  data.tar.gz: a6d0d85e8323532379bfeef2be95361b1a5c1a01
 SHA512:
-  metadata.gz: d1af7beafcff3c9008b04d8efeebae47a7786296decd2f1d231d5ba4ecedda764f495927d0dc52a22cdde6ac8186299ed569a673ca3f78c0ebfe0f2dadb689f5
-  data.tar.gz: 168dbef959bf418880c42357e5bca85d9bb0688fce3037f22b0e6f6b98166a053377c912606e3a08ffdf6fcf4193b3dfd83dc272357607a694169c779e91a589
+  metadata.gz: d18d9ad16dc730a96037c4b5f8b1926910d75820a94529a1287fe82dcc1e251b1c73fce936ba3988c6672f5615e8361298971018d24525ce51dd1c2667062492
+  data.tar.gz: 34cfa1b4561de877b8eb94513a42c8c383f8ce037a03c67f9535cbd1a71ed4a9023e71a70a7ba8bb79b73c7c9e49827d664028af416a7f1b489f25a3dd821e8d

data/README.md

@@ -240,6 +240,17 @@ Then, when performing something like expansion:
 
     JSON::LD::API.expand(input, documentLoader: load_document_local)
 
+
+## Preloading contexts
+In many cases, for small documents, processing time can be dominated by loading and parsing remote contexts. In particular, a small schema.org example may need to download a large context and turn it into an internal representation, before the actual document can be expanded for processing. Using {JSON::LD::Context.add_preloaded}, an implementation can perform this loading up-front, and make it available to the processor.
+
+    ctx = JSON::LD::Context.new().parse('http://schema.org/')
+    JSON::LD::Context.add_preloaded('http://schema.org/', ctx)
+
+On lookup, URIs with an `https` prefix are normalized to `http`.
+
+A context may be serialized to Ruby to speed this process using `Context#to_rb`. When loaded, this generated file will add entries to the {JSON::LD::Context::PRELOADED}.
+
 ## RDF Reader and Writer
 {JSON::LD} also acts as a normal RDF reader and writer, using the standard RDF.rb reader/writer interfaces:
 
@@ -274,7 +285,7 @@ Note, the API method signatures differed in versions before 1.0, in that they al
   * {JSON::LD::Writer}
 
 ## Dependencies
-* [Ruby](http://ruby-lang.org/) (>= 2.0)
+* [Ruby](http://ruby-lang.org/) (>= 2.2.2)
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5)
 

data/VERSION

@@ -1 +1 @@
-2.0.0.1
+2.1.0

data/lib/json/ld.rb

@@ -1,4 +1,6 @@
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+$:.unshift(File.expand_path("../ld", __FILE__))
 require 'rdf' # @see http://rubygems.org/gems/rdf
 require 'multi_json'
 

data/lib/json/ld/api.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'openssl'
 require 'json/ld/expand'
 require 'json/ld/compact'
@@ -70,12 +72,6 @@ module JSON::LD
     #   If set to a value that is not `false`, the JSON-LD processor must modify the output of the Compaction Algorithm or the Expansion Algorithm by coalescing all properties associated with each subject via the Flattening Algorithm. The value of `flatten must` be either an _IRI_ value representing the name of the graph to flatten, or `true`. If the value is `true`, then the first graph encountered in the input document is selected and flattened.
     # @option options [String] :processingMode ("json-ld-1.0")
     #   If set to "json-ld-1.0", the JSON-LD processor must produce exactly the same results as the algorithms defined in this specification. If set to another value, the JSON-LD processor is allowed to extend or modify the algorithms defined in this specification to enable application-specific optimizations. The definition of such optimizations is beyond the scope of this specification and thus not defined. Consequently, different implementations may implement different optimizations. Developers must not define modes beginning with json-ld as they are reserved for future versions of this specification.
-    # @option options [String] :produceGeneralizedRdf (false)
-    #   Unless the produce generalized RDF flag is set to true, RDF triples containing a blank node predicate are excluded from output.
-    # @option options [Boolean] :useNativeTypes (false)
-    #   If set to `true`, the JSON-LD processor will use native datatypes for expression xsd:integer, xsd:boolean, and xsd:double values, otherwise, it will use the expanded form.
-    # @option options [Boolean] :useRdfType (false)
-    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @option options [Boolean] :rename_bnodes (true)
     #   Rename bnodes as part of expansion, or keep them the same.
     # @option options [Boolean]  :unique_bnodes   (false)
@@ -141,6 +137,9 @@ module JSON::LD
         end
       end
     end
+
+    # This is used internally only
+    private :initialize
     
     ##
     # Expands the given input according to the steps in the Expansion Algorithm. The input must be copied, expanded and returned
@@ -152,6 +151,8 @@ module JSON::LD
     #   The JSON-LD object to copy and perform the expansion upon.
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
+    # @option options [String, #read, Hash, Array, JSON::LD::Context] :expandContext
+    #   A context that is used to initialize the active context when expanding a document.
     # @raise [JsonLdError]
     # @yield jsonld
     # @yieldparam [Array<Hash>] jsonld
@@ -163,7 +164,10 @@ module JSON::LD
     def self.expand(input, options = {})
       result = nil
       API.new(input, options[:expandContext], options) do |api|
-        result = api.expand(api.value, nil, api.context)
+        result = api.expand(api.value, nil, api.context,
+                            ordered: options.fetch(:ordered, true),
+                            framing: options.fetch(:framing, false),
+                            keep_free_floating_nodes: options.fetch(:keep_free_floating_nodes, false))
       end
 
       # If, after the algorithm outlined above is run, the resulting element is an
@@ -204,9 +208,9 @@ module JSON::LD
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded = options[:expanded] ? input : API.expand(input, options)
+      expanded_input = options[:expanded] ? input : API.expand(input, options)
 
-      API.new(expanded, context, options) do
+      API.new(expanded_input, context, options) do
         log_debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value, nil)
 
@@ -270,7 +274,7 @@ module JSON::LD
 
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
-          compacted = log_depth {compact(flattened, nil)}
+          compacted = compact(flattened, nil)
           compacted = [compacted] unless compacted.is_a?(Array)
           kwgraph = self.context.compact_iri('@graph', quiet: true)
           flattened = self.context.serialize.merge(kwgraph => compacted)
@@ -294,7 +298,7 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
     #   Other options passed to {JSON::LD::API.expand}
-    # @option options ['@last', '@always', '@never', '@link'] :embed ('@link')
+    # @option options ['@last', '@always', '@never', '@link'] :embed ('@last')
     #   a flag specifying that objects should be directly embedded in the output,
     #   instead of being referred to by their IRI.
     # @option options [Boolean] :explicit (false)
@@ -347,28 +351,25 @@ module JSON::LD
       expanded_input = options[:expanded] ? input : API.expand(input, options)
 
       # Expand frame to simplify processing
-      expanded_frame = API.expand(frame, options)
+      expanded_frame = API.expand(frame, options.merge(framing: true, keep_free_floating_nodes: true))
 
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
-        #log_debug(".frame") {"context from frame: #{context.inspect}"}
         log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         old_logger, @options[:logger] = @options[:logger], []
-        create_node_map(value, framing_state[:graphs], '@merged')
+        create_node_map(value, framing_state[:graphs], graph: '@merged')
         @options[:logger] = old_logger
         framing_state[:subjects] = framing_state[:graphs]['@merged']
-        log_debug(".frame") {"subjects: #{framing_state[:subjects].to_json(JSON_STATE) rescue 'malformed json'}"}
 
         result = []
         frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
-        log_debug(".frame") {"after frame: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         
         # Initalize context from frame
-        @context = log_depth {@context.parse(frame['@context'])}
+        @context = @context.parse(frame['@context'])
         # Compact result
-        compacted = log_depth {compact(result, nil)}
+        compacted = compact(result, nil)
         compacted = [compacted] unless compacted.is_a?(Array)
 
         # Add the given context to the output
@@ -449,6 +450,8 @@ module JSON::LD
     # @param [Array<RDF::Statement>] input
     # @param  [Hash{Symbol => Object}] options
     #   See options in {JSON::LD::API#initialize}
+    # @option options [Boolean] :useRdfType (false)
+    #   If set to `true`, the JSON-LD processor will treat `rdf:type` like a normal property instead of using `@type`.
     # @yield jsonld
     # @yieldparam [Hash] jsonld
     #   The JSON-LD document in expanded form
@@ -456,11 +459,11 @@ module JSON::LD
     # @return [Object, Hash]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     def self.fromRdf(input, options = {}, &block)
-      options = {useNativeTypes: false}.merge!(options)
+      useRdfType = options.fetch(:useRdfType, false)
       result = nil
 
       API.new(nil, nil, options) do |api|
-        result = api.from_statements(input)
+        result = api.from_statements(input, useRdfType: useRdfType)
       end
 
       block_given? ? yield(result) : result

data/lib/json/ld/compact.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 module JSON::LD
   module Compact
     include Utils
@@ -9,24 +11,24 @@ module JSON::LD
     # @param [String] property (nil)
     # @return [Array, Hash]
     def compact(element, property = nil)
-      if property.nil?
-        log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
-      else
-        log_debug("compact") {"property: #{property.inspect}"}
-      end
+      #if property.nil?
+      #  log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
+      #else
+      #  log_debug("compact") {"property: #{property.inspect}"}
+      #end
       case element
       when Array
-        log_debug("") {"Array #{element.inspect}"}
-        result = log_depth {element.map {|item| compact(item, property)}.compact}
+        #log_debug("") {"Array #{element.inspect}"}
+        result = element.map {|item| compact(item, property)}.compact
 
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
         # member; otherwise the compacted value is element
         if result.length == 1 && context.container(property).nil? && @options[:compactArrays]
-          log_debug("=> extract single element: #{result.first.inspect}")
+          #log_debug("=> extract single element: #{result.first.inspect}")
           result.first
         else
-          log_debug("=> array result: #{result.inspect}")
+          #log_debug("=> array result: #{result.inspect}")
           result
         end
       when Hash
@@ -38,7 +40,7 @@ module JSON::LD
         if element.keys.any? {|k| %w(@id @value).include?(k)}
           result = context.compact_value(property, element, log_depth: @options[:log_depth])
           unless result.is_a?(Hash)
-            log_debug("") {"=> scalar result: #{result.inspect}"}
+            #log_debug("") {"=> scalar result: #{result.inspect}"}
             return result
           end
         end
@@ -48,28 +50,28 @@ module JSON::LD
 
         element.each_key do |expanded_property|
           expanded_value = element[expanded_property]
-          log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
+          #log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if %w(@id @type).include?(expanded_property)
             compacted_value = [expanded_value].flatten.compact.map do |expanded_type|
-              log_depth {context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), log_depth: @options[:log_depth])}
+              context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), log_depth: @options[:log_depth])
             end
             compacted_value = compacted_value.first if compacted_value.length == 1
 
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
-            log_debug(expanded_property) {"result[#{al}] = #{compacted_value.inspect}"}
+            #log_debug(expanded_property) {"result[#{al}] = #{compacted_value.inspect}"}
             result[al] = compacted_value
             next
           end
 
           if expanded_property == '@reverse'
-            compacted_value = log_depth {compact(expanded_value, '@reverse')}
-            log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
+            compacted_value = compact(expanded_value, '@reverse')
+            #log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
                 value = [value] if !value.is_a?(Array) &&
                   (context.container(prop) == '@set' || !@options[:compactArrays])
-                log_debug("") {"merge #{prop} => #{value.inspect}"}
+                #log_debug("") {"merge #{prop} => #{value.inspect}"}
                 merge_compacted_value(result, prop, value)
                 compacted_value.delete(prop)
               end
@@ -77,33 +79,32 @@ module JSON::LD
 
             unless compacted_value.empty?
               al = context.compact_iri('@reverse', quiet: true)
-              log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
+              #log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
             next
           end
 
           if expanded_property == '@index' && context.container(property) == '@index'
-            log_debug("@index") {"drop @index"}
+            #log_debug("@index") {"drop @index"}
             next
           end
 
           # Otherwise, if expanded property is @index, @value, or @language:
           if %w(@index @value @language).include?(expanded_property)
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
-            log_debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
+            #log_debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
           end
 
           if expanded_value == []
-            item_active_property = log_depth do
+            item_active_property =
               context.compact_iri(expanded_property,
                                   value: expanded_value,
                                   vocab: true,
                                   reverse: inside_reverse,
                                   log_depth: @options[:log_depth])
-            end
 
             iap = result[item_active_property] ||= []
             result[item_active_property] = [iap] unless iap.is_a?(Array)
@@ -111,17 +112,17 @@ module JSON::LD
 
           # At this point, expanded value must be an array due to the Expansion algorithm.
           expanded_value.each do |expanded_item|
-            item_active_property = log_depth do
+            item_active_property =
               context.compact_iri(expanded_property,
                                   value: expanded_item,
                                   vocab: true,
                                   reverse: inside_reverse,
                                   log_depth: @options[:log_depth])
-            end
+
             container = context.container(item_active_property)
             value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
-            compacted_item = log_depth {compact(value, item_active_property)}
-            log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
+            compacted_item = compact(value, item_active_property)
+            #log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             if list?(expanded_item)
               compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
@@ -159,7 +160,7 @@ module JSON::LD
         result.keys.kw_sort.inject({}) {|map, kk| map[kk] = result[kk]; map}
       else
         # For other types, the compacted value is the element value
-        log_debug("compact") {element.class.to_s}
+        #log_debug("compact") {element.class.to_s}
         element
       end
     end

data/lib/json/ld/context.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 require 'json'
 require 'bigdecimal'
 
@@ -6,6 +8,23 @@ module JSON::LD
     include Utils
     include RDF::Util::Logger
 
+    ##
+    # Preloaded contexts.
+    # To avoid runtime context parsing and downloading, contexts may be pre-loaded by implementations.
+    # @return [Hash{Symbol => Context}]
+    PRELOADED = {}
+
+    class << self
+      ##
+      # Add preloaded context. In the block form, the context is lazy evaulated on first use.
+      # @param [String, RDF::URI] url
+      # @param [Context] context (nil)
+      # @yieldreturn [Context]
+      def add_preloaded(url, context = nil, &block)
+        PRELOADED[url.to_s.freeze] = context || block
+      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
@@ -17,7 +36,7 @@ module JSON::LD
       # @return [String] Type mapping
       attr_accessor :type_mapping
 
-      # @return [String] Container mapping
+      # @return ['@set', '@list'] Container mapping
       attr_accessor :container_mapping
 
       # Language mapping of term, `false` is used if there is explicitly no language mapping for this term.
@@ -38,9 +57,27 @@ module JSON::LD
       # Create a new Term Mapping with an ID
       # @param [String] term
       # @param [String] id
-      def initialize(term, id = nil)
-        @term = term
-        @id = id.to_s if id
+      # @param [String] type_mapping Type mapping
+      # @param ['@set', '@list'] container_mapping
+      # @param [String] language_mapping
+      #   Language mapping of term, `false` is used if there is explicitly no language mapping for this term
+      # @param [Boolean] reverse_property
+      # @param [Boolean] simple
+      #   This is a simple term definition, not an expanded term definition
+      def initialize(term,
+                    id: nil,
+                    type_mapping: nil,
+                    container_mapping: nil,
+                    language_mapping: nil,
+                    reverse_property: false,
+                    simple: false)
+        @term               = term
+        @id                 = id.to_s           if id
+        @type_mapping       = type_mapping.to_s if type_mapping
+        @container_mapping  = container_mapping if container_mapping
+        @language_mapping   = language_mapping  if language_mapping
+        @reverse_property   = reverse_property  if reverse_property
+        @simple             = simple            if simple
       end
 
       ##
@@ -81,6 +118,19 @@ module JSON::LD
         end
       end
 
+      ##
+      # Turn this into a source for a new instantiation
+      # @return [String]
+      def to_rb
+        defn = [%(TermDefinition.new\(#{term.inspect})]
+        %w(id type_mapping container_mapping language_mapping reverse_property simple).each do |acc|
+          v = instance_variable_get("@#{acc}".to_sym)
+          v = v.to_s if v.is_a?(RDF::Term)
+          defn << "#{acc}: #{v.inspect}" if v
+        end
+        defn.join(', ') + ")"
+      end
+
       def inspect
         v = %w([TD)
         v << "id=#{@id}"
@@ -173,12 +223,13 @@ module JSON::LD
       (options[:prefixes] || {}).each_pair do |k, v|
         next if k.nil?
         @iri_to_term[v.to_s] = k
-        @term_definitions[k.to_s] = TermDefinition.new(k, v.to_s)
+        @term_definitions[k.to_s] = TermDefinition.new(k, id: v.to_s)
         @term_definitions[k.to_s].simple = true
       end
 
       self.vocab = options[:vocab] if options[:vocab]
       self.default_language = options[:language] if options[:language]
+      @term_definitions = options[:term_definitions] if options[:term_definitions]
 
       #log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
       
@@ -224,14 +275,14 @@ module JSON::LD
       @vocab = case value
       when /_:/
         value
-      when String
-        v = as_resource(value)
-        raise JsonLdError::InvalidVocabMapping, "@value must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative? && @options[:validate]
+      when String, RDF::URI
+        v = as_resource(value.to_s)
+        raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI: #{value.inspect}" if v.uri? && v.relative? && @options[:validate]
         v
       when nil
         nil
       else
-        raise JsonLdError::InvalidVocabMapping, "@value must be a string: #{value.inspect}"
+        raise JsonLdError::InvalidVocabMapping, "@vocab must be an absolute IRI: #{value.inspect}"
       end
     end
 
@@ -255,41 +306,55 @@ module JSON::LD
       local_context = [local_context] unless local_context.is_a?(Array)
 
       local_context.each do |context|
-        log_depth do
-          case context
-          when nil
-            # 3.1 If niil, set to a new empty context
-            result = Context.new(options)
-          when Context
-             log_debug("parse") {"context: #{context.inspect}"}
-             result = context.dup
-          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
-            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
-            end
-          when String, RDF::URI
-            log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
-            # Load context document, if it is a string
-            # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
-            context = RDF::URI(result.context_base || result.base).join(context)
+        case context
+        when nil
+          # 3.1 If niil, set to a new empty context
+          result = Context.new(options)
+        when Context
+           #log_debug("parse") {"context: #{context.inspect}"}
+           result = context.dup
+        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
+          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
+          end
+        when String, RDF::URI
+          #log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
 
-            raise JsonLdError::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context.to_s)
-            remote_contexts << context.to_s
+          # 3.2.1) Set context to the result of resolving value against the base IRI which is established as specified in section 5.1 Establishing a Base URI of [RFC3986]. Only the basic algorithm in section 5.2 of [RFC3986] is used; neither Syntax-Based Normalization nor Scheme-Based Normalization are performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [RFC3987].
+          context = RDF::URI(result.context_base || result.base).join(context)
+          context_canon = RDF::URI(context).canonicalize
+          context_canon.dup.scheme = 'http'.dup if context_canon.scheme == 'https'
 
-            context_no_base = result.dup
-            context_no_base.base = nil
-            context_no_base.context_base = context.to_s
+          raise JsonLdError::RecursiveContextInclusion, "#{context}" if remote_contexts.include?(context.to_s)
+          remote_contexts << context.to_s
 
+          context_no_base = result.dup
+          context_no_base.base = nil
+          context_no_base.context_base = context.to_s
+
+          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}"}
+
+            # If this is a Proc, then replace the entry with the result of running the Proc
+            if PRELOADED[context_canon.to_s].respond_to?(:call)
+              #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])
+          else
+
+            # Load context document, if it is a string
             begin
               context_opts = @options.dup
               context_opts.delete(:headers)
@@ -306,48 +371,46 @@ module JSON::LD
                 end
               end
             rescue JsonLdError::LoadingDocumentFailed => e
-              log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
+              #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.backtrace
             rescue JsonLdError
               raise
             rescue Exception => e
-              log_debug("parse") {"Failed to retrieve @context from remote document at #{context_no_base.context_base.inspect}: #{e.message}"}
+              #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.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.dup)
             context.provided_context = result.provided_context
-            context.base ||= result.base
-            result = context
-            log_debug("parse") {"=> provided_context: #{context.inspect}"}
-          when Hash
-            # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
-            context = context.dup # keep from modifying a hash passed as a param
-            {
-              '@base' => :base=,
-              '@language' => :default_language=,
-              '@vocab'    => :vocab=
-            }.each do |key, setter|
-              v = context.fetch(key, false)
-              unless v == false
-                context.delete(key)
-                log_debug("parse") {"Set #{key} to #{v.inspect}"}
-                result.send(setter, v)
-              end
+          end
+          context.base ||= result.base
+          result = context
+          #log_debug("parse") {"=> provided_context: #{context.inspect}"}
+        when Hash
+          # If context has a @vocab member: if its value is not a valid absolute IRI or null trigger an INVALID_VOCAB_MAPPING error; otherwise set the active context's vocabulary mapping to its value and remove the @vocab member from context.
+          context = context.dup # keep from modifying a hash passed as a param
+          {
+            '@base' => :base=,
+            '@language' => :default_language=,
+            '@vocab'    => :vocab=
+          }.each do |key, setter|
+            v = context.fetch(key, false)
+            unless v == false
+              context.delete(key)
+              #log_debug("parse") {"Set #{key} to #{v.inspect}"}
+              result.send(setter, v)
             end
+          end
 
-            defined = {}
-          # For each key-value pair in context invoke the Create Term Definition subalgorithm, passing result for active context, context for local context, key, and defined
-            log_depth do
-              context.each_key do |key|
-                result.create_term_definition(context, key, defined)
-              end
-            end
-          else
-            # 3.3) If context is not a JSON object, an invalid local context error has been detected and processing is aborted.
-            raise JsonLdError::InvalidLocalContext, context.inspect
+          defined = {}
+        # For each key-value pair in context invoke the Create Term Definition subalgorithm, passing result for active context, context for local context, key, and defined
+          context.each_key do |key|
+            result.create_term_definition(context, key, defined)
           end
+        else
+          # 3.3) If context is not a JSON object, an invalid local context error has been detected and processing is aborted.
+          raise JsonLdError::InvalidLocalContext, context.inspect
         end
       end
       result
@@ -395,7 +458,7 @@ module JSON::LD
     # @see http://json-ld.org/spec/latest/json-ld-api/index.html#create-term-definition
     def create_term_definition(local_context, term, defined)
       # Expand a string value, unless it matches a keyword
-      log_debug("create_term_definition") {"term = #{term.inspect}"}
+      #log_debug("create_term_definition") {"term = #{term.inspect}"}
 
       # If defined contains the key term, then the associated value must be true, indicating that the term definition has already been created, so return. Otherwise, a cyclical term definition has been detected, which is an error.
       case defined[term]
@@ -425,12 +488,12 @@ module JSON::LD
       case value
       when nil, {'@id' => nil}
         # If value equals null or value is a JSON object containing the key-value pair (@id-null), then set the term definition in active context to null, set the value associated with defined's key term to true, and return.
-        log_debug("") {"=> nil"}
+        #log_debug("") {"=> nil"}
         term_definitions[term] = TermDefinition.new(term)
         defined[term] = true
         return
       when Hash
-        log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
+        #log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
         definition = TermDefinition.new(term)
         definition.simple = simple_term
 
@@ -452,7 +515,7 @@ module JSON::LD
           unless %w(@id @vocab).include?(type) || type.is_a?(RDF::URI) && type.absolute?
             raise JsonLdError::InvalidTypeMapping, "unknown mapping for '@type': #{type.inspect} on term #{term.inspect}"
           end
-          log_debug("") {"type_mapping: #{type.inspect}"}
+          #log_debug("") {"type_mapping: #{type.inspect}"}
           definition.type_mapping = type
         end
 
@@ -492,7 +555,7 @@ module JSON::LD
         elsif term.include?(':')
           # If term is a compact IRI with a prefix that is a key in local context then a dependency has been found. Use this algorithm recursively passing active context, local context, the prefix as term, and defined.
           prefix, suffix = term.split(':')
-          log_depth {create_term_definition(local_context, prefix, defined)} if local_context.has_key?(prefix)
+          create_term_definition(local_context, prefix, defined) if local_context.has_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.
@@ -501,12 +564,12 @@ module JSON::LD
             # Otherwise, term is an absolute IRI. Set the IRI mapping for definition to term
             term
           end
-          log_debug("") {"=> #{definition.id}"}
+          #log_debug("") {"=> #{definition.id}"}
         else
           # Otherwise, active context must have a vocabulary mapping, otherwise an invalid value has been detected, which is an error. Set the IRI mapping for definition to the result of concatenating the value associated with the vocabulary mapping and term.
           raise JsonLdError::InvalidIRIMapping, "relative term definition without vocab: #{term} on term #{term.inspect}" unless vocab
           definition.id = vocab + term
-          log_debug("") {"=> #{definition.id}"}
+          #log_debug("") {"=> #{definition.id}"}
         end
 
         @iri_to_term[definition.id] = term if simple_term && definition.id
@@ -514,7 +577,7 @@ module JSON::LD
         if value.has_key?('@container')
           container = value['@container']
           raise JsonLdError::InvalidContainerMapping, "unknown mapping for '@container' to #{container.inspect} on term #{term.inspect}" unless %w(@list @set @language @index).include?(container)
-          log_debug("") {"container_mapping: #{container.inspect}"}
+          #log_debug("") {"container_mapping: #{container.inspect}"}
           definition.container_mapping = container
         end
 
@@ -522,7 +585,7 @@ module JSON::LD
           language = value['@language']
           raise JsonLdError::InvalidLanguageMapping, "language must be null or a string, was #{language.inspect}} on term #{term.inspect}" unless language.nil? || (language || "").is_a?(String)
           language = language.downcase if language.is_a?(String)
-          log_debug("") {"language_mapping: #{language.inspect}"}
+          #log_debug("") {"language_mapping: #{language.inspect}"}
           definition.language_mapping = language || false
         end
 
@@ -542,38 +605,36 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
     def serialize(options = {})
-      log_depth(options) do
-        # FIXME: not setting provided_context now
-        use_context = case provided_context
-        when String, RDF::URI
-          log_debug "serlialize: reuse context: #{provided_context.inspect}"
-          provided_context.to_s
-        when Hash, Array
-          log_debug "serlialize: reuse context: #{provided_context.inspect}"
-          provided_context
-        else
-          log_debug("serlialize: generate context")
-          log_debug("") {"=> context: #{inspect}"}
-          ctx = {}
-          ctx['@base'] = base.to_s if base && base != doc_base
-          ctx['@language'] = default_language.to_s if default_language
-          ctx['@vocab'] = vocab.to_s if vocab
-
-          # Term Definitions
-          term_definitions.keys.sort.each do |term|
-            defn = term_definitions[term].to_context_definition(self)
-            ctx[term] = defn if defn
-          end
-
-          log_debug("") {"start_doc: context=#{ctx.inspect}"}
-          ctx
+      # FIXME: not setting provided_context now
+      use_context = case provided_context
+      when String, RDF::URI
+        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        provided_context.to_s
+      when Hash, Array
+        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        provided_context
+      else
+        #log_debug("serlialize: generate context")
+        #log_debug("") {"=> context: #{inspect}"}
+        ctx = {}
+        ctx['@base'] = base.to_s if base && base != doc_base
+        ctx['@language'] = default_language.to_s if default_language
+        ctx['@vocab'] = vocab.to_s if vocab
+
+        # Term Definitions
+        term_definitions.keys.sort.each do |term|
+          defn = term_definitions[term].to_context_definition(self)
+          ctx[term] = defn if defn
         end
 
-        # Return hash with @context, or empty
-        r = {}
-        r['@context'] = use_context unless use_context.nil? || use_context.empty?
-        r
+        #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
     end
 
     ##
@@ -620,14 +681,14 @@ module JSON::LD
           next if vocab && subject.to_s.start_with?(vocab)
 
           # otherwise, create a term definition
-          td = term_definitions[term] = TermDefinition.new(term, subject.to_s)
+          td = term_definitions[term] = TermDefinition.new(term, id: subject.to_s)
         else
           prop_ranges = ranges.fetch(subject, [])
           # If any range is empty or member of range includes rdfs:Literal or schema:Text
           next if vocab && prop_ranges.empty? ||
                            prop_ranges.include?(RDF::SCHEMA.Text) ||
                            prop_ranges.include?(RDF::RDFS.Literal)
-          td = term_definitions[term] = TermDefinition.new(term, subject.to_s)
+          td = term_definitions[term] = TermDefinition.new(term, id: subject.to_s)
 
           # Set context typing based on first element in range
           case r = prop_ranges.first
@@ -658,9 +719,9 @@ module JSON::LD
     #
     # @return [TermDefinition]
     def set_mapping(term, value)
-      log_debug("") {"map #{term.inspect} to #{value.inspect}"}
+      #log_debug("") {"map #{term.inspect} to #{value.inspect}"}
       term = term.to_s
-      term_definitions[term] = TermDefinition.new(term, value)
+      term_definitions[term] = TermDefinition.new(term, id: value)
       term_definitions[term].simple = true
 
       term_sym = term.empty? ? "" : term.to_sym
@@ -724,7 +785,7 @@ module JSON::LD
         td = term_definitions.values.detect {|t| t.id == term.to_s}
 
         # Otherwise create a temporary term definition
-        term = td || TermDefinition.new(term.to_s, expand_iri(term, vocab:true))
+        term = td || TermDefinition.new(term.to_s, id: expand_iri(term, vocab:true))
       end
 
       # Now, return a term, which reverses this term
@@ -737,244 +798,240 @@ module JSON::LD
     # @param [String] value
     #   A keyword, term, prefix:suffix or possibly relative IRI
     # @param  [Hash{Symbol => Object}] options
-    # @option options [Boolean] documentRelative (false)
-    # @option options [Boolean] vocab (false)
-    # @option options [Hash] local_context
+    # @param [Boolean] documentRelative (false)
+    # @param [Boolean] vocab (false)
+    # @param [RDF::URI] base
+    # @param [Hash] local_context
     #   Used during Context Processing.
-    # @option options [Hash] defined
+    # @param [Hash] defined
     #   Used during Context Processing.
+    # @param [Boolean] quiet (false)
+    # @param [Hash] options ({})
     # @return [RDF::URI, String]
     #   IRI or String, if it's a keyword
     # @raise [JSON::LD::JsonLdError::InvalidIRIMapping] if the value cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#iri-expansion
-    def expand_iri(value, options = {})
+    def expand_iri(value, documentRelative: false, vocab: false, local_context: nil, defined: {}, quiet: false, **options)
       return value unless value.is_a?(String)
 
       return value if KEYWORDS.include?(value)
-      log_depth(options) do
-        log_debug("expand_iri") {"value: #{value.inspect}"} unless options[:quiet]
-        local_context = options[:local_context]
-        defined = options.fetch(:defined, {})
-
-        # 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]
-          log_depth {create_term_definition(local_context, value, defined)}
-        end
+      #log_debug("expand_iri") {"value: #{value.inspect}"} unless quiet
 
-        # If vocab is true and the active context has a term definition for value, return the associated IRI mapping.
-        if options[:vocab] && (v_td = term_definitions[value])
-          log_debug("") {"match with #{v_td.id}"} unless options[:quiet]
-          return v_td.id
-        end
+      # 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]
+        create_term_definition(local_context, value, defined)
+      end
 
-        # If value contains a colon (:), it is either an absolute IRI or a compact IRI:
-        if value.include?(':')
-          prefix, suffix = value.split(':', 2)
-          log_debug("") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{vocab.inspect}"} unless options[:quiet]
+      # If vocab is true and the active context has a term definition for value, return the associated IRI mapping.
+      if vocab && (v_td = term_definitions[value])
+        #log_debug("") {"match with #{v_td.id}"} unless quiet
+        return v_td.id
+      end
 
-          # 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[0,2] == '//'
+      # If value contains a colon (:), it is either an absolute IRI or a compact IRI:
+      if value.include?(':')
+        prefix, suffix = value.split(':', 2)
+        #log_debug("") {"prefix: #{prefix.inspect}, suffix: #{suffix.inspect}, vocab: #{self.vocab.inspect}"} unless quiet
 
-          # 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]
-            create_term_definition(local_context, prefix, defined)
-          end
+        # 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[0,2] == '//'
 
-          # If active context contains a term definition for prefix, return the result of concatenating the IRI mapping associated with prefix and suffix.
-          result = if (td = term_definitions[prefix])
-            result = td.id + suffix
-          else
-            # (Otherwise) Return value as it is already an absolute IRI.
-            RDF::URI(value)
-          end
-
-          log_debug("") {"=> #{result.inspect}"} unless options[:quiet]
-          return result
+        # 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]
+          create_term_definition(local_context, prefix, defined)
         end
-        log_debug("") {"=> #{result.inspect}"} unless options[:quiet]
-
-        result = if options[:vocab] && vocab
-          # If vocab is true, and active context has a vocabulary mapping, return the result of concatenating the vocabulary mapping with value.
-          vocab + value
-        elsif options[:documentRelative] && base = options.fetch(: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?
-          # 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}"
+
+        # If active context contains a term definition for prefix, return the result of concatenating the IRI mapping associated with prefix and suffix.
+        result = if (td = term_definitions[prefix])
+          result = td.id + suffix
         else
+          # (Otherwise) Return value as it is already an absolute IRI.
           RDF::URI(value)
         end
-        log_debug("") {"=> #{result}"} unless options[:quiet]
-        result
+
+        #log_debug("") {"=> #{result.inspect}"} unless quiet
+        return result
+      end
+      #log_debug("") {"=> #{result.inspect}"} unless quiet
+
+      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?
+        # 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)
       end
+      #log_debug("") {"=> #{result}"} unless quiet
+      result
     end
 
     ##
     # Compacts an absolute IRI to the shortest matching term or compact IRI
     #
     # @param [RDF::URI] iri
-    # @param  [Hash{Symbol => Object}] options ({})
-    # @option options [Object] :value
+    # @param [Object] value
     #   Value, used to select among various maps for the same IRI
-    # @option options [Boolean] :vocab
+    # @param [Boolean] :vocab
     #   specifies whether the passed iri should be compacted using the active context's vocabulary mapping
-    # @option options [Boolean] :reverse
+    # @param [Boolean] reverse
     #   specifies whether a reverse property is being compacted 
+    # @param [Boolean] quiet (false)
+    # @param  [Hash{Symbol => Object}] options ({})
     #
     # @return [String] compacted form of IRI
     # @see http://json-ld.org/spec/latest/json-ld-api/#iri-compaction
-    def compact_iri(iri, options = {})
+    def compact_iri(iri, value: nil, vocab: nil, reverse: false, quiet: false, **options)
       return if iri.nil?
       iri = iri.to_s
-      log_debug("compact_iri(#{iri.inspect}", options) {options.inspect} unless options[:quiet]
-      log_depth(options) do
-
-        value = options.fetch(:value, nil)
-
-        if options[:vocab] && inverse_context.has_key?(iri)
-          log_debug("") {"vocab and key in inverse context"} unless options[:quiet]
-          default_language = self.default_language || @none
-          containers = []
-          tl, tl_value = "@language", "@null"
-          containers << '@index' if index?(value)
-          if options[:reverse]
-            tl, tl_value = "@type", "@reverse"
-            containers << '@set'
-          elsif list?(value)
-            log_debug("") {"list(#{value.inspect})"} unless options[: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']
-            common_type = nil
-            common_language = default_language if list.empty?
-            list.each do |item|
-              item_language, item_type = "@none", "@none"
-              if value?(item)
-                if item.has_key?('@language')
-                  item_language = item['@language']
-                elsif item.has_key?('@type')
-                  item_type = item['@type']
-                else
-                  item_language = "@null"
-                end
+      #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 = self.default_language || @none
+        containers = []
+        tl, tl_value = "@language", "@null"
+        containers << '@index' if index?(value)
+        if reverse
+          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']
+          common_type = nil
+          common_language = default_language if list.empty?
+          list.each do |item|
+            item_language, item_type = "@none", "@none"
+            if value?(item)
+              if item.has_key?('@language')
+                item_language = item['@language']
+              elsif item.has_key?('@type')
+                item_type = item['@type']
               else
-                item_type = '@id'
+                item_language = "@null"
               end
-              common_language ||= item_language
-              if item_language != common_language && value?(item)
-                log_debug("") {"-- #{item_language} conflicts with #{common_language}, use @none"} unless options[: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 options[:quiet]
-              end
-            end
-
-            common_language ||= '@none'
-            common_type ||= '@none'
-            log_debug("") {"common type: #{common_type}, common language: #{common_language}"} unless options[:quiet]
-            if common_type != '@none'
-              tl, tl_value = '@type', common_type
             else
-              tl_value = common_language
+              item_type = '@id'
             end
-            log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless options[:quiet]
-          else
-            if value?(value)
-              if value.has_key?('@language') && !index?(value)
-                tl_value = value['@language']
-                containers << '@language'
-              elsif value.has_key?('@type')
-                tl_value = value['@type']
-                tl = '@type'
-              end
-            else
-              tl, tl_value = '@type', '@id'
+            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
-            containers << '@set'
-            log_debug("") {"value: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless options[:quiet]
           end
 
-          containers << '@none'
-          tl_value ||= '@null'
-          preferred_values = []
-          preferred_values << '@reverse' if tl_value == '@reverse'
-          if %w(@id @reverse).include?(tl_value) && value.is_a?(Hash) && value.has_key?('@id')
-            t_iri = compact_iri(value['@id'], vocab: true, document_relative: true)
-            if (r_td = term_definitions[t_iri]) && r_td.id == value['@id']
-              preferred_values.concat(%w(@vocab @id @none))
-            else
-              preferred_values.concat(%w(@id @vocab @none))
-            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
-            preferred_values.concat([tl_value, '@none'])
+            tl_value = common_language
           end
-          log_debug("") {"preferred_values: #{preferred_values.inspect}"} unless options[:quiet]
-          if p_term = select_term(iri, containers, tl, preferred_values)
-            log_debug("") {"=> term: #{p_term.inspect}"} unless options[:quiet]
-            return p_term
+          #log_debug("") {"list: containers: #{containers.inspect}, type/language: #{tl.inspect}, type/language value: #{tl_value.inspect}"} unless quiet
+        else
+          if value?(value)
+            if value.has_key?('@language') && !index?(value)
+              tl_value = value['@language']
+              containers << '@language'
+            elsif value.has_key?('@type')
+              tl_value = value['@type']
+              tl = '@type'
+            end
+          else
+            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
 
-        # 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 options[:vocab] && vocab && iri.start_with?(vocab) && iri.length > vocab.length
-          suffix = iri[vocab.length..-1]
-          log_debug("") {"=> vocab suffix: #{suffix.inspect}"} unless options[:quiet]
-          return suffix unless term_definitions.has_key?(suffix)
+        containers << '@none'
+        tl_value ||= '@null'
+        preferred_values = []
+        preferred_values << '@reverse' if tl_value == '@reverse'
+        if %w(@id @reverse).include?(tl_value) && value.is_a?(Hash) && value.has_key?('@id')
+          t_iri = compact_iri(value['@id'], vocab: true, document_relative: true)
+          if (r_td = term_definitions[t_iri]) && r_td.id == value['@id']
+            preferred_values.concat(%w(@vocab @id @none))
+          else
+            preferred_values.concat(%w(@id @vocab @none))
+          end
+        else
+          preferred_values.concat([tl_value, '@none'])
+        end
+        #log_debug("") {"preferred_values: #{preferred_values.inspect}"} unless quiet
+        if p_term = select_term(iri, containers, tl, preferred_values)
+          #log_debug("") {"=> term: #{p_term.inspect}"} unless quiet
+          return p_term
         end
+      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.
-        candidates = []
+      # 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
 
-        term_definitions.each do |term, td|
-          next if term.include?(":")
-          next if td.nil? || td.id.nil? || td.id == iri || !iri.start_with?(td.id)
+      # 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.
+      candidates = []
 
-          # Also skip term if it was not a simple term and the :simple_compact_iris flag is true
-          next if @options[:simple_compact_iris] && !td.simple?
+      term_definitions.each do |term, td|
+        next if term.include?(":")
+        next if td.nil? || td.id.nil? || td.id == iri || !iri.start_with?(td.id)
 
-          suffix = iri[td.id.length..-1]
-          ciri = "#{term}:#{suffix}"
-          candidates << ciri unless value && term_definitions.has_key?(ciri)
-        end
+        # Also skip term if it was not a simple term and the :simple_compact_iris flag is true
+        next if @options[:simple_compact_iris] && !td.simple?
 
-        if !candidates.empty?
-          log_debug("") {"=> compact iri: #{candidates.term_sort.first.inspect}"} unless options[:quiet]
-          return candidates.term_sort.first
-        end
+        suffix = iri[td.id.length..-1]
+        ciri = "#{term}:#{suffix}"
+        candidates << ciri unless value && term_definitions.has_key?(ciri)
+      end
 
-        # If we still don't have any terms and we're using standard_prefixes,
-        # try those, and add to mapping
-        if @options[:standard_prefixes]
-          candidates = RDF::Vocabulary.
-            select {|v| iri.start_with?(v.to_uri.to_s) && iri != v.to_uri.to_s}.
-            map do |v|
-              prefix = v.__name__.to_s.split('::').last.downcase
-              set_mapping(prefix, v.to_uri.to_s)
-              iri.sub(v.to_uri.to_s, "#{prefix}:").sub(/:$/, '')
-            end
+      if !candidates.empty?
+        #log_debug("") {"=> compact iri: #{candidates.term_sort.first.inspect}"} unless quiet
+        return candidates.term_sort.first
+      end
 
-          if !candidates.empty?
-            log_debug("") {"=> standard prefies: #{candidates.term_sort.first.inspect}"} unless options[:quiet]
-            return candidates.term_sort.first
+      # If we still don't have any terms and we're using standard_prefixes,
+      # try those, and add to mapping
+      if @options[:standard_prefixes]
+        candidates = RDF::Vocabulary.
+          select {|v| iri.start_with?(v.to_uri.to_s) && iri != v.to_uri.to_s}.
+          map do |v|
+            prefix = v.__name__.to_s.split('::').last.downcase
+            set_mapping(prefix, v.to_uri.to_s)
+            iri.sub(v.to_uri.to_s, "#{prefix}:").sub(/:$/, '')
           end
-        end
 
-        if !options[:vocab]
-          # transform iri to a relative IRI using the document's base IRI
-          iri = remove_base(iri)
-          log_debug("") {"=> relative iri: #{iri.inspect}"} unless options[:quiet]
-          return iri
-        else
-          log_debug("") {"=> absolute iri: #{iri.inspect}"} unless options[:quiet]
-          return iri
+        if !candidates.empty?
+          #log_debug("") {"=> standard prefies: #{candidates.term_sort.first.inspect}"} unless quiet
+          return candidates.term_sort.first
         end
       end
+
+      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
+        return iri
+      else
+        #log_debug("") {"=> absolute iri: #{iri.inspect}"} unless quiet
+        return iri
+      end
     end
 
     ##
@@ -986,75 +1043,72 @@ module JSON::LD
     #   Associated property used to find coercion rules
     # @param [Hash, String] value
     #   Value (literal or IRI) to be expanded
+    # @param [Boolean] useNativeTypes (false) use native representations
     # @param  [Hash{Symbol => Object}] options
-    # @option options [Boolean] :useNativeTypes (false) use native representations
     #
     # @return [Hash] Object representation of value
     # @raise [RDF::ReaderError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-expansion
-    def expand_value(property, value, options = {})
-      options = {useNativeTypes: false}.merge!(options)
-      log_depth(options) do
-        log_debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}"}
-
-        # 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 (td = term_definitions.fetch(property, TermDefinition.new(property))) && td.type_mapping == '@id'
-          log_debug("") {"as relative IRI: #{value.inspect}"}
-          return {'@id' => expand_iri(value, documentRelative: true).to_s}
-        end
+    def expand_value(property, value, useNativeTypes: false, **options)
+      #log_debug("expand_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
-        # 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 td.type_mapping == '@vocab'
-          log_debug("") {"as vocab IRI: #{value.inspect}"}
-          return {'@id' => expand_iri(value, vocab: true, documentRelative: true).to_s}
-        end
+      # 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 (td = term_definitions.fetch(property, TermDefinition.new(property))) && td.type_mapping == '@id'
+        #log_debug("") {"as relative IRI: #{value.inspect}"}
+        return {'@id' => expand_iri(value, documentRelative: true).to_s}
+      end
 
-        value = RDF::Literal(value) if
-          value.is_a?(Date) ||
-          value.is_a?(DateTime) ||
-          value.is_a?(Time)
-
-        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 options[:useNativeTypes] && [RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double].include?(value.datatype)
-            res['@value'] = value.object
-            res['@type'] = uri(coerce(property)) if coerce(property)
-          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
-            end
-          end
-          res
+      # 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 td.type_mapping == '@vocab'
+        #log_debug("") {"as vocab IRI: #{value.inspect}"}
+        return {'@id' => expand_iri(value, vocab: true, documentRelative: true).to_s}
+      end
+
+      value = RDF::Literal(value) if
+        value.is_a?(Date) ||
+        value.is_a?(DateTime) ||
+        value.is_a?(Time)
+
+      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 useNativeTypes && [RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double].include?(value.datatype)
+          res['@value'] = value.object
+          res['@type'] = uri(coerce(property)) if coerce(property)
         else
-          # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
-          res = {'@value' => value}
-
-          if td.type_mapping
-            res['@type'] = td.type_mapping.to_s
-          elsif value.is_a?(String)
-            if td.language_mapping
-              res['@language'] = td.language_mapping
-            elsif default_language && td.language_mapping.nil?
-              res['@language'] = default_language
-            end
+          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
           end
-          res
         end
-
-        log_debug("") {"=> #{result.inspect}"}
-        result
+        res
+      else
+        # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
+        res = {'@value' => value}
+
+        if td.type_mapping
+          res['@type'] = td.type_mapping.to_s
+        elsif value.is_a?(String)
+          if td.language_mapping
+            res['@language'] = td.language_mapping
+          elsif default_language && td.language_mapping.nil?
+            res['@language'] = default_language
+          end
+        end
+        res
       end
+
+      #log_debug("") {"=> #{result.inspect}"}
+      result
     end
 
     ##
@@ -1071,71 +1125,90 @@ module JSON::LD
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-compaction
     # FIXME: revisit the specification version of this.
     def compact_value(property, value, options = {})
+      #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
-      log_depth(options) do
-        log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
+      num_members = value.keys.length
 
-        num_members = value.keys.length
+      num_members -= 1 if index?(value) && container(property) == '@index'
+      if num_members > 2
+        #log_debug("") {"can't compact value with # members > 2"}
+        return value
+      end
 
-        num_members -= 1 if index?(value) && container(property) == '@index'
-        if num_members > 2
-          log_debug("") {"can't compact value with # members > 2"}
-          return value
+      result = case
+      when coerce(property) == '@id' && value.has_key?('@id') && num_members == 1
+        # Compact an @id coercion
+        #log_debug("") {" (@id & coerce)"}
+        compact_iri(value['@id'])
+      when coerce(property) == '@vocab' && value.has_key?('@id') && num_members == 1
+        # Compact an @id coercion
+        #log_debug("") {" (@id & coerce & vocab)"}
+        compact_iri(value['@id'], vocab: true)
+      when value.has_key?('@id')
+        #log_debug("") {" (@id)"}
+        # return value as is
+        value
+      when value['@type'] && expand_iri(value['@type'], vocab: true) == coerce(property)
+        # Compact common datatype
+        #log_debug("") {" (@type & coerce) == #{coerce(property)}"}
+        value['@value']
+      when value['@language'] && (value['@language'] == language(property))
+        # Compact language
+        #log_debug("") {" (@language) == #{language(property).inspect}"}
+        value['@value']
+      when num_members == 1 && !value['@value'].is_a?(String)
+        #log_debug("") {" (native)"}
+        value['@value']
+      when num_members == 1 && default_language.nil? || language(property) == false
+        #log_debug("") {" (!@language)"}
+        value['@value']
+      else
+        # Otherwise, use original value
+        #log_debug("") {" (no change)"}
+        value
+      end
+      
+      # If the result is an object, tranform keys using any term keyword aliases
+      if result.is_a?(Hash) && result.keys.any? {|k| self.alias(k) != k}
+        #log_debug("") {" (map to key aliases)"}
+        new_element = {}
+        result.each do |k, v|
+          new_element[self.alias(k)] = v
         end
+        result = new_element
+      end
 
-        result = case
-        when coerce(property) == '@id' && value.has_key?('@id') && num_members == 1
-          # Compact an @id coercion
-          log_debug("") {" (@id & coerce)"}
-          compact_iri(value['@id'])
-        when coerce(property) == '@vocab' && value.has_key?('@id') && num_members == 1
-          # Compact an @id coercion
-          log_debug("") {" (@id & coerce & vocab)"}
-          compact_iri(value['@id'], vocab: true)
-        when value.has_key?('@id')
-          log_debug("") {" (@id)"}
-          # return value as is
-          value
-        when value['@type'] && expand_iri(value['@type'], vocab: true) == coerce(property)
-          # Compact common datatype
-          log_debug("") {" (@type & coerce) == #{coerce(property)}"}
-          value['@value']
-        when value['@language'] && (value['@language'] == language(property))
-          # Compact language
-          log_debug("") {" (@language) == #{language(property).inspect}"}
-          value['@value']
-        when num_members == 1 && !value['@value'].is_a?(String)
-          log_debug("") {" (native)"}
-          value['@value']
-        when num_members == 1 && default_language.nil? || language(property) == false
-          log_debug("") {" (!@language)"}
-          value['@value']
-        else
-          # Otherwise, use original value
-          log_debug("") {" (no change)"}
-          value
-        end
-        
-        # If the result is an object, tranform keys using any term keyword aliases
-        if result.is_a?(Hash) && result.keys.any? {|k| self.alias(k) != k}
-          log_debug("") {" (map to key aliases)"}
-          new_element = {}
-          result.each do |k, v|
-            new_element[self.alias(k)] = v
-          end
-          result = new_element
-        end
+      #log_debug("") {"=> #{result.inspect}"}
+      result
+    end
 
-        log_debug("") {"=> #{result.inspect}"}
-        result
+    ##
+    # Turn this into a source for a new instantiation
+    # @return [String]
+    def to_rb
+      defn = []
+
+      defn << "base: #{self.base.to_s.inspect}" if self.base
+      defn << "language: #{self.default_language.inspect}" if self.default_language
+      defn << "vocab: #{self.vocab.to_s.inspect}" if self.vocab
+      term_defs = term_definitions.map do |term, td|
+        "      " + term.inspect + " => " + td.to_rb
       end
+      defn << "term_definitions: {\n#{term_defs.join(",\n")    }\n    }" unless term_defs.empty?
+      %(# -*- encoding: utf-8 -*-
+      # frozen_string_literal: true
+      # This file generated automatically from #{context_base}
+      require 'json/ld'
+      class JSON::LD::Context
+      ).gsub(/^      /, '') +
+      "  add_preloaded(#{RDF::URI(context_base).canonicalize.to_s.inspect}) do\n    new(" + defn.join(", ")  + ")\n  end\nend\n"
     end
 
     def inspect
       v = %w([Context)
       v << "base=#{base}" if base
       v << "vocab=#{vocab}" if vocab
-      v << "def_language=#{default_language}" if default_language
+      v << "default_language=#{default_language}" if default_language
       v << "term_definitions[#{term_definitions.length}]=#{term_definitions}"
       v.join(" ") + "]"
     end
@@ -1195,7 +1268,7 @@ module JSON::LD
       case value.to_s
       when /^_:(.*)$/
         # Map BlankNodes if a namer is given
-        log_debug "uri(bnode)#{value}: #{$1}"
+        #log_debug "uri(bnode)#{value}: #{$1}"
         bnode(namer.get_sym($1))
       else
         value = RDF::URI.new(value)
@@ -1274,28 +1347,26 @@ module JSON::LD
     #   for the type mapping or language mapping
     # @return [String]
     def select_term(iri, containers, type_language, preferred_values)
-      log_depth do
-        log_debug("select_term") {
-          "iri: #{iri.inspect}, " +
-          "containers: #{containers.inspect}, " +
-          "type_language: #{type_language.inspect}, " +
-          "preferred_values: #{preferred_values.inspect}"
-        }
-        container_map = inverse_context[iri]
-        log_debug("  ") {"container_map: #{container_map.inspect}"}
-        containers.each do |container|
-          next unless container_map.has_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)
-            log_debug("=>") {value_map[item].inspect}
-            return value_map[item]
-          end
+      #log_debug("select_term") {
+      #  "iri: #{iri.inspect}, " +
+      #  "containers: #{containers.inspect}, " +
+      #  "type_language: #{type_language.inspect}, " +
+      #  "preferred_values: #{preferred_values.inspect}"
+      #}
+      container_map = inverse_context[iri]
+      #log_debug("  ") {"container_map: #{container_map.inspect}"}
+      containers.each do |container|
+        next unless container_map.has_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)
+          #log_debug("=>") {value_map[item].inspect}
+          return value_map[item]
         end
-        log_debug("=>") {"nil"}
-        nil
       end
+      #log_debug("=>") {"nil"}
+      nil
     end
 
     ##
@@ -1315,9 +1386,9 @@ module JSON::LD
       b = base.to_s
       return iri[b.length..-1] if iri.start_with?(b) && %w(? #).include?(iri[b.length, 1])
 
-      @base_and_parents.each_with_index do |b, index|
-        next unless iri.start_with?(b)
-        rel = "../" * index + iri[b.length..-1]
+      @base_and_parents.each_with_index do |bb, index|
+        next unless iri.start_with?(bb)
+        rel = "../" * index + iri[bb.length..-1]
         return rel.empty? ? "./" : rel
       end
       iri