json-ld 3.2.2 → 3.2.4

data/lib/json/ld/context.rb

@@ -212,7 +212,7 @@ module JSON::LD
       self.default_language = options[:language] if options[:language] =~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
       @term_definitions = options[:term_definitions] if options[:term_definitions]
 
-      #log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
+      # log_debug("init") {"iri_to_term: #{iri_to_term.inspect}"}
 
       yield(self) if block_given?
     end
@@ -267,13 +267,13 @@ module JSON::LD
                   "Attempt to clear a context with protected terms"
           end
         when Context
-           log_debug("parse") {"context: #{context.inspect}"}
+           # log_debug("parse") {"context: #{context.inspect}"}
            result = result.merge(context)
         when IO, StringIO
-          log_debug("parse") {"io: #{context}"}
+          # log_debug("parse") {"io: #{context}"}
           # Load context document, if it is an open file
           begin
-            ctx = JSON.load(context)
+            ctx = load_context(context, **@options)
             raise JSON::LD::JsonLdError::InvalidRemoteContext, "Context missing @context key" if @options[:validate] && ctx['@context'].nil?
             result = result.parse(ctx["@context"] ? ctx["@context"] : {})
           rescue JSON::ParserError => e
@@ -282,7 +282,7 @@ module JSON::LD
             self
           end
         when String, RDF::URI
-          log_debug("parse") {"remote: #{context}, base: #{result.context_base || result.base}"}
+          # 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 || base).join(context)
@@ -297,13 +297,14 @@ module JSON::LD
 
           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}"}
+            # 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)"}
+              # log_debug("parse") {"=> (call)"}
               PRELOADED[context_canon.to_s] = PRELOADED[context_canon.to_s].call
             end
+            PRELOADED[context_canon.to_s].context_base ||= context_canon.to_s
             PRELOADED[context_canon.to_s]
           else
             # Load context document, if it is a string
@@ -478,7 +479,7 @@ module JSON::LD
         remote_contexts: [],
         validate_scoped: true)
       # 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]
@@ -523,7 +524,7 @@ module JSON::LD
 
       raise JsonLdError::InvalidTermDefinition, "Term definition for #{term.inspect} is an #{value.class} on term #{term.inspect}" unless value.is_a?(Hash)
 
-      #log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
+      # log_debug("") {"Hash[#{term.inspect}] = #{value.inspect}"}
       definition = TermDefinition.new(term)
       definition.simple = simple_term
 
@@ -565,7 +566,7 @@ module JSON::LD
         elsif !JSON_LD_10_TYPE_VALUES.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
 
@@ -649,7 +650,7 @@ 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}"}
       elsif term.include?('/')
         # If term is a relative IRI
         definition.id = expand_iri(term, vocab: true)
@@ -662,13 +663,13 @@ module JSON::LD
         # 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
 
       if value.key?('@container')
-        #log_debug("") {"container_mapping: #{value['@container'].inspect}"}
+        # log_debug("") {"container_mapping: #{value['@container'].inspect}"}
         definition.container_mapping = check_container(value['@container'], local_context, defined, term)
 
         # If @container includes @type
@@ -702,7 +703,7 @@ module JSON::LD
           when nil then [nil]
           else value['@context']
           end
-          log_debug("") {"context: #{definition.context.inspect}"}
+          # log_debug("") {"context: #{definition.context.inspect}"}
         rescue JsonLdError => e
           raise JsonLdError::InvalidScopedContext, "Term definition for #{term.inspect} contains illegal value for @context: #{e.message}"
         end
@@ -722,14 +723,14 @@ module JSON::LD
         else
           raise JsonLdError::InvalidLanguageMapping, "language must be null or a string, was #{value['@language'].inspect}} on term #{term.inspect}"
         end
-        #log_debug("") {"language_mapping: #{language.inspect}"}
+        # log_debug("") {"language_mapping: #{language.inspect}"}
         definition.language_mapping = language || false
       end
 
       if value.key?('@direction')
         direction = value['@direction']
         raise JsonLdError::InvalidBaseDirection, "direction must be null, 'ltr', or 'rtl', was #{language.inspect}} on term #{term.inspect}" unless direction.nil? || %w(ltr rtl).include?(direction)
-        #log_debug("") {"direction_mapping: #{direction.inspect}"}
+        # log_debug("") {"direction_mapping: #{direction.inspect}"}
         definition.direction_mapping = direction || false
       end
 
@@ -737,7 +738,7 @@ module JSON::LD
         nest = value['@nest']
         raise JsonLdError::InvalidNestValue, "nest must be a string, was #{nest.inspect}} on term #{term.inspect}" unless nest.is_a?(String)
         raise JsonLdError::InvalidNestValue, "nest must not be a keyword other than @nest, was #{nest.inspect}} on term #{term.inspect}" if nest.match?(/^@[a-zA-Z]+$/) && nest != '@nest'
-        #log_debug("") {"nest: #{nest.inspect}"}
+        # log_debug("") {"nest: #{nest.inspect}"}
         definition.nest = nest
       end
 
@@ -897,22 +898,21 @@ module JSON::LD
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
     def serialize(provided_context: nil, **options)
-      #log_debug("serlialize: generate context")
-      #log_debug("") {"=> context: #{inspect}"}
+      # 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}"
+        # log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context.to_s
       when Hash
-        #log_debug "serlialize: reuse context: #{provided_context.inspect}"
+        # 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}"
+        # log_debug "serlialize: reuse context: #{provided_context.inspect}"
         provided_context
       when IO, StringIO
-        provided_context.rewind
-        JSON.load(provided_context).fetch('@context', {})
+        load_context(provided_context, **@options).fetch('@context', {})
       else
         ctx = {}
         ctx['@version'] = 1.1 if @processingMode == 'json-ld-1.1'
@@ -1015,7 +1015,7 @@ 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, id: value, simple: true, prefix: (value.to_s.end_with?(*PREFIX_URI_ENDINGS)))
       term_definitions[term].simple = true
@@ -1467,8 +1467,6 @@ module JSON::LD
       end
     end
 
-    RDF_LITERAL_NATIVE_TYPES = Set.new([RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double]).freeze
-
     ##
     # If active property has a type mapping in the active context set to @id or @vocab, a JSON object with a single member @id whose value is the result of using the IRI Expansion algorithm on value is returned.
     #
@@ -1491,7 +1489,7 @@ module JSON::LD
 
       # 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}"}
+        # log_debug("") {"as relative IRI: #{value.inspect}"}
         return {'@id' => expand_iri(value, documentRelative: true, base: base).to_s}
       end
 
@@ -1500,50 +1498,12 @@ module JSON::LD
         return {'@id' => expand_iri(value, vocab: true, documentRelative: true, base: base).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
         {'@id' => value.to_s}
-      when RDF::Literal
-        res = {}
-        if value.datatype == RDF::URI(RDF.to_uri + "JSON") && processingMode('json-ld-1.1')
-          # Value parsed as JSON
-          # FIXME: MultiJson
-          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
-          unless lang.empty?
-            if lang !~ /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/
-              if options[:validate]
-                raise JsonLdError::InvalidLanguageMapping, "rdf:language must be valid BCP47: #{lang.inspect}"
-              else
-                warn "rdf:language must be valid BCP47: #{lang.inspect}"
-              end
-            end
-            res['@language'] = lang
-          end
-          res['@direction'] = dir
-        elsif useNativeTypes && RDF_LITERAL_NATIVE_TYPES.include?(value.datatype) && value.valid?
-          res['@type'] = uri(coerce(property)) if coerce(property)
-          res['@value'] = value.object
-        else
-          value.canonicalize! if value.valid? && value.datatype == RDF::XSD.double
-          if coerce(property)
-            res['@type'] = uri(coerce(property)).to_s
-          elsif value.datatype?
-            res['@type'] = uri(value.datatype).to_s
-          elsif value.language? || language(property)
-            res['@language'] = (value.language || language(property)).to_s
-          end
-          res['@value'] = value.to_s
-        end
-        res
+      when Date, DateTime, Time
+        lit = RDF::Literal.new(value)
+        {'@value' => lit.to_s, '@type' => lit.datatype.to_s}
       else
         # Otherwise, initialize result to a JSON object with an @value member whose value is set to value.
         res = {}
@@ -1561,8 +1521,6 @@ module JSON::LD
       end
 
       result
-    rescue ::JSON::ParserError => e
-      raise JSON::LD::JsonLdError::InvalidJsonLiteral, e.message
     end
 
     ##
@@ -1579,7 +1537,7 @@ module JSON::LD
     # @see https://www.w3.org/TR/json-ld11-api/#value-compaction
     # FIXME: revisit the specification version of this.
     def compact_value(property, value, base: nil)
-      #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
+      # log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
       indexing = index?(value) && container(property).include?('@index')
       language = language(property)
@@ -1588,25 +1546,25 @@ module JSON::LD
       result = case
       when coerce(property) == '@id' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
-        #log_debug("") {" (@id & coerce)"}
+        # log_debug("") {" (@id & coerce)"}
         compact_iri(value['@id'], base: base)
       when coerce(property) == '@vocab' && value.key?('@id') && (value.keys - %w(@id @index)).empty?
         # Compact an @id coercion
-        #log_debug("") {" (@id & coerce & vocab)"}
+        # log_debug("") {" (@id & coerce & vocab)"}
         compact_iri(value['@id'], vocab: true)
       when value.key?('@id')
-        #log_debug("") {" (@id)"}
+        # log_debug("") {" (@id)"}
         # return value as is
         value
       when value['@type'] && value['@type'] == coerce(property)
         # Compact common datatype
-        #log_debug("") {" (@type & coerce) == #{coerce(property)}"}
+        # log_debug("") {" (@type & coerce) == #{coerce(property)}"}
         value['@value']
       when coerce(property) == '@none' || value['@type']
         # use original expanded value
         value
       when !value['@value'].is_a?(String)
-        #log_debug("") {" (native)"}
+        # log_debug("") {" (native)"}
         indexing || !index?(value) ? value['@value'] : value
       when value['@language'].to_s.downcase == language.to_s.downcase && value['@direction'] == direction
         # Compact language and direction
@@ -1627,7 +1585,7 @@ module JSON::LD
       
       # 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)"}
+        # log_debug("") {" (map to key aliases)"}
         new_element = {}
         result.each do |k, v|
           new_element[self.alias(k)] = v
@@ -1635,7 +1593,7 @@ module JSON::LD
         result = new_element
       end
 
-      #log_debug("") {"=> #{result.inspect}"}
+      # log_debug("") {"=> #{result.inspect}"}
       result
     end
 
@@ -1731,11 +1689,21 @@ module JSON::LD
     CONTEXT_BASE_FRAG_OR_QUERY = %w(? #).freeze
     CONTEXT_TYPE_ID_VOCAB = %w(@id @vocab).freeze
 
+    ##
+    # Reads the `@context` from an IO
+    def load_context(io, **options)
+      io.rewind
+      remote_doc = API.loadRemoteDocument(io, **options)
+      remote_doc.document.is_a?(String) ?
+        MultiJson.load(remote_doc.document) :
+        remote_doc.document
+    end
+
     def uri(value)
       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(value)
@@ -1854,25 +1822,25 @@ module JSON::LD
     #   for the type mapping or language mapping
     # @return [String]
     def select_term(iri, containers, type_language, preferred_values)
-      #log_debug("select_term") {
+      # 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}"}
+      # log_debug("  ") {"container_map: #{container_map.inspect}"}
       containers.each do |container|
         next unless container_map.key?(container)
         tl_map = container_map[container]
         value_map = tl_map[type_language]
         preferred_values.each do |item|
           next unless value_map.key?(item)
-          #log_debug("=>") {value_map[item].inspect}
+          # log_debug("=>") {value_map[item].inspect}
           return value_map[item]
         end
       end
-      #log_debug("=>") {"nil"}
+      # log_debug("=>") {"nil"}
       nil
     end
 

data/lib/json/ld/expand.rb

@@ -29,13 +29,13 @@ module JSON::LD
     # @return [Array<Hash{String => Object}>]
     def expand(input, active_property, context,
                framing: false, from_map: false, log_depth: nil)
-      log_debug("expand", depth: log_depth.to_i) {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
+      # log_debug("expand", depth: log_depth.to_i) {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       framing = false if active_property == '@default'
       expanded_active_property = context.expand_iri(active_property, vocab: true, as_string: true, base: @options[:base]) if active_property
 
       # Use a term-specific context, if defined, based on the non-type-scoped context.
       property_scoped_context = context.term_definitions[active_property].context if active_property && context.term_definitions[active_property]
-      log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{property_scoped_context.inspect}"} unless property_scoped_context.nil?
+      # log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{property_scoped_context.inspect}"} unless property_scoped_context.nil?
 
       result = case input
       when Array
@@ -76,7 +76,7 @@ module JSON::LD
             !(expanded_key_map.values == ['@id'])
 
           # If there's a previous context, the context was type-scoped
-          log_debug("expand", depth: log_depth.to_i) {"previous_context: #{context.previous_context.inspect}"} if revert_context
+          # log_debug("expand", depth: log_depth.to_i) {"previous_context: #{context.previous_context.inspect}"} if revert_context
           context = context.previous_context if revert_context
         end
 
@@ -84,12 +84,12 @@ module JSON::LD
         unless property_scoped_context.nil?
           context = context.parse(property_scoped_context, base: @options[:base], override_protected: true)
         end
-        log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
+        # log_debug("expand", depth: log_depth.to_i) {"after property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         # If element contains the key @context, set active context to the result of the Context Processing algorithm, passing active context and the value of the @context key as local context.
         if input.key?('@context')
           context = context.parse(input['@context'], base: @options[:base])
-          log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
+          # log_debug("expand", depth: log_depth.to_i) {"context: #{context.inspect}"}
         end
 
         # Set the type-scoped context to the context on input, for use later
@@ -107,7 +107,7 @@ module JSON::LD
           Array(input[tk]).sort.each do |term|
             term_context = type_scoped_context.term_definitions[term].context if type_scoped_context.term_definitions[term]
             unless term_context.nil?
-              log_debug("expand", depth: log_depth.to_i) {"term_context[#{term}]: #{term_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"term_context[#{term}]: #{term_context.inspect}"}
               context = context.parse(term_context, base: @options[:base], propagate: false)
             end
           end
@@ -121,7 +121,7 @@ module JSON::LD
                       type_scoped_context: type_scoped_context,
                       log_depth: log_depth.to_i + 1)
 
-        log_debug("output object", depth: log_depth.to_i) {output_object.inspect}
+        # log_debug("output object", depth: log_depth.to_i) {output_object.inspect}
 
         # If result contains the key @value:
         if value?(output_object)
@@ -199,7 +199,7 @@ module JSON::LD
         if (expanded_active_property || '@graph') == '@graph' &&
            (output_object.key?('@value') || output_object.key?('@list') ||
            (output_object.keys - KEY_ID).empty? && !framing)
-          log_debug(" =>", depth: log_depth.to_i) { "empty top-level: " + output_object.inspect}
+          # log_debug(" =>", depth: log_depth.to_i) { "empty top-level: " + output_object.inspect}
           return nil
         end
 
@@ -219,12 +219,12 @@ module JSON::LD
                                   base: @options[:base],
                                   override_protected: true)
         end
-        log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
+        # log_debug("expand", depth: log_depth.to_i) {"property_scoped_context: #{context.inspect}"} unless property_scoped_context.nil?
 
         context.expand_value(active_property, input, base: @options[:base])
       end
 
-      log_debug(depth: log_depth.to_i) {" => #{result.inspect}"}
+      # log_debug(depth: log_depth.to_i) {" => #{result.inspect}"}
       result
     end
 
@@ -258,10 +258,10 @@ module JSON::LD
           expanded_property.to_s.start_with?("_:") &&
           context.processingMode('json-ld-1.1')
 
-        log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
+        # log_debug("expand property", depth: log_depth.to_i) {"ap: #{active_property.inspect}, expanded: #{expanded_property.inspect}, value: #{value.inspect}"}
 
         if expanded_property.nil?
-          log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
+          # log_debug(" => ", depth: log_depth.to_i) {"skip nil property"}
           next
         end
 
@@ -341,7 +341,7 @@ module JSON::LD
             Array(output_object['@included']) + included_result
           when '@type'
             # If expanded property is @type and value is neither a string nor an array of strings, an invalid type value error has been detected and processing is aborted. Otherwise, set expanded value to the result of using the IRI Expansion algorithm, passing active context, true for vocab, and true for document relative to expand the value or each of its items.
-            log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
+            # log_debug("@type", depth: log_depth.to_i) {"value: #{value.inspect}"}
             e_type = case value
             when Array
               value.map do |v|
@@ -516,7 +516,7 @@ module JSON::LD
 
             # If expanded value contains an @reverse member, i.e., properties that are reversed twice, execute for each of its property and item the following steps:
             if value.key?('@reverse')
-              log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
+              # log_debug("@reverse", depth: log_depth.to_i) {"double reverse: #{value.inspect}"}
               value['@reverse'].each do |property, item|
                 # If result does not have a property member, create one and set its value to an empty array.
                 # Append item to the value of the property member of result.
@@ -566,7 +566,7 @@ module JSON::LD
           end
 
           # Unless expanded value is null, set the expanded property member of result to expanded value.
-          log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
+          # log_debug("expand #{expanded_property}", depth: log_depth.to_i) { expanded_value.inspect}
           output_object[expanded_property] = expanded_value unless expanded_value.nil? && expanded_property == '@value' && input_type != '@json'
           next
         end
@@ -619,7 +619,7 @@ module JSON::LD
             if id_context.nil?
               context
             else
-              log_debug("expand", depth: log_depth.to_i) {"id_context: #{id_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"id_context: #{id_context.inspect}"}
               context.parse(id_context, base: @options[:base], propagate: false)
             end
           else
@@ -632,7 +632,7 @@ module JSON::LD
             # If container mapping in the active context includes @type, and k is a term in the active context having a local context, use that context when expanding values
             map_context = container_context.term_definitions[k].context if container.include?('@type') && container_context.term_definitions[k]
             unless map_context.nil?
-              log_debug("expand", depth: log_depth.to_i) {"map_context: #{map_context.inspect}"}
+              # log_debug("expand", depth: log_depth.to_i) {"map_context: #{map_context.inspect}"}
               map_context = container_context.parse(map_context, base: @options[:base],
                                                     propagate: false)
             end
@@ -688,21 +688,21 @@ module JSON::LD
 
         # If expanded value is null, ignore key by continuing to the next key from element.
         if expanded_value.nil?
-          log_debug(" => skip nil value", depth: log_depth.to_i)
+          # log_debug(" => skip nil value", depth: log_depth.to_i)
           next
         end
-        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        # log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # If the container mapping associated to key in active context is @list and expanded value is not already a list object, convert expanded value to a list object by first setting it to an array containing only expanded value if it is not already an array, and then by setting it to a JSON object containing the key-value pair @list-expanded value.
         if container.first == '@list' && container.length == 1 && !list?(expanded_value)
-          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          # log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = {'@list' => as_array(expanded_value)}
         end
-        log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
+        # log_debug(depth: log_depth.to_i) {" => #{expanded_value.inspect}"}
 
         # convert expanded value to @graph if container specifies it
         if container.first == '@graph' && container.length == 1
-          log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
+          # log_debug(" => ", depth: log_depth.to_i) { "convert #{expanded_value.inspect} to list"}
           expanded_value = as_array(expanded_value).map do |v|
             {'@graph' => as_array(v)}
           end
@@ -742,7 +742,7 @@ module JSON::LD
         nest_context = if nest_context.nil?
           context
         else
-          log_debug("expand", depth: log_depth.to_i) {"nest_context: #{nest_context.inspect}"}
+          # log_debug("expand", depth: log_depth.to_i) {"nest_context: #{nest_context.inspect}"}
           context.parse(nest_context, base: @options[:base],
                         override_protected: true)
         end