solis 0.98.0 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b5f53e6ee613f19d1de7527908da768b55623f51f45bdc4ae31ab3ba338a5cc
-  data.tar.gz: d1dfade779a59ad0c36422a20bcc1b8b21fc7c74b75774e1b69be9488050c9ef
+  metadata.gz: 848141bb6e9f81fea57188c0a10cc3cf86b656a137e5f5a2a665a835af2ef6f5
+  data.tar.gz: 49505d5ce710f03daa6b14f2488df1c3d0ff8e2e24301b17940aa5d60aed67d1
 SHA512:
-  metadata.gz: ec93a8f1b15c02a1b2b5b52e4f85d0d3058c2528ad73d33d15944e5a3c5609bbfe9e2e83e8ab15efc41c1e98350745903b089cf3902cd2157a3a2aaaeb0f5657
-  data.tar.gz: fd75bb60d80282d6c285b0bb004cdb466a0fa3d6ce2de9960732bb201e5d068c6c4256e7cf560dbf1b67b86371706659f562bc72bb149826285f22cefac6ba84
+  metadata.gz: 16c1286a2b9046f5c267b2e59d9d2d293fd3919e5792a867d174d6385fbfe522bdc4b306e96af244ff4493f21727ce09f71c6c98015cac3ab2f1206cf1543771
+  data.tar.gz: 6e02c4c9c3511271295f010579f76c758c9c590fae999c01ac262615a6fb21384aa2b73bc7e719be61563faec7a080b5f2a95be3a857e156cb2be9400c96c5ff

data/lib/solis/model.rb

@@ -145,22 +145,28 @@ values ?s {<#{self.graph_id}>}
       else
         data = properties_to_hash(self)
         attributes = data.include?('attributes') ? data['attributes'] : data
+        readonly_list = (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)
+
         attributes.each_pair do |key, value|
           unless self.class.metadata[:attributes][key][:node].nil?
             value = [value] unless value.is_a?(Array)
             value.each do |sub_value|
               embedded = self.class.graph.shape_as_model(self.class.metadata[:attributes][key][:datatype].to_s).new(sub_value)
-              embedded_readonly_entities = Solis::Options.instance.get[:embedded_readonly].map{|s| s.to_s} || []
 
-              if (embedded.class.ancestors.map{|s| s.to_s} & embedded_readonly_entities).empty? || top_level
+              if readonly_entity?(embedded, readonly_list)
+                # Readonly entities (code tables) should never be modified
+                # Only verify they exist, do not create or update them
+                unless embedded.exists?(sparql)
+                  Solis::LOGGER.warn("#{embedded.class.name} (id: #{embedded.id}) is readonly but does not exist in database. Skipping.")
+                end
+              else
+                # Non-readonly entities can be created or updated
                 if embedded.exists?(sparql)
                   embedded_data = properties_to_hash(embedded)
                   embedded.update(embedded_data, validate_dependencies, false)
                 else
                   embedded.save(validate_dependencies, false)
                 end
-              else
-                Solis::LOGGER.info("#{embedded.class.name} is embedded not allowed to change. Skipping")
               end
             end
           end
@@ -193,6 +199,9 @@ values ?s {<#{self.graph_id}>}
       raise Solis::Error::NotFoundError if original_klass.nil?
       updated_klass = original_klass.deep_dup
 
+      # Cache readonly entities list once
+      readonly_list = (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)
+
       # Track entities to potentially delete
       entities_to_check_for_deletion = {}
 
@@ -216,9 +225,16 @@ values ?s {<#{self.graph_id}>}
             embedded = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s).new(sub_value)
             new_ids << embedded.id if embedded.id
 
-            embedded_readonly_entities = Solis::Options.instance.get[:embedded_readonly].map{|s| s.to_s} || []
-
-            if (embedded.class.ancestors.map{|s| s.to_s} & embedded_readonly_entities).empty? || top_level
+            if readonly_entity?(embedded, readonly_list)
+              # Readonly entities (code tables) should never be modified
+              # Only verify they exist, do not create or update them
+              if embedded.exists?(sparql)
+                new_embedded_values << embedded
+              else
+                Solis::LOGGER.warn("#{embedded.class.name} (id: #{embedded.id}) is readonly but does not exist in database. Skipping.")
+              end
+            else
+              # Non-readonly entities can be created or updated
               if embedded.exists?(sparql)
                 embedded_data = properties_to_hash(embedded)
                 embedded.update(embedded_data, validate_dependencies, false)
@@ -227,13 +243,11 @@ values ?s {<#{self.graph_id}>}
                 embedded_value = embedded.save(validate_dependencies, false)
                 new_embedded_values << embedded_value
               end
-            else
-              Solis::LOGGER.info("#{embedded.class.name} is embedded not allowed to change. Skipping")
-              new_embedded_values << embedded
             end
           end
 
           # Identify orphaned entities (in original but not in new)
+          # Note: Readonly entities will be filtered out in delete_orphaned_entities
           orphaned_ids = original_ids - new_ids
           unless orphaned_ids.empty?
             orphaned_entities = original_embedded.select { |e| solis_model?(e) && orphaned_ids.include?(e.id) }
@@ -289,11 +303,11 @@ values ?s {<#{self.graph_id}>}
 
       data
     rescue StandardError => e
-      original_graph = as_graph(original_klass, false)
+      original_graph = as_graph(original_klass, false) if defined?(original_klass) && original_klass
       Solis::LOGGER.error(e.message)
-      Solis::LOGGER.error original_graph.dump(:ttl)
+      Solis::LOGGER.error original_graph.dump(:ttl) if defined?(original_graph) && original_graph
       Solis::LOGGER.error delete_insert_query if defined?(delete_insert_query)
-      sparql.insert_data(original_graph, graph: original_graph.name)
+      sparql.insert_data(original_graph, graph: original_graph.name) if defined?(original_graph) && original_graph && defined?(sparql) && sparql
 
       raise e
     end
@@ -467,6 +481,12 @@ values ?s {<#{self.graph_id}>}
       obj.class.ancestors.include?(Solis::Model)
     end
 
+    # Helper method to check if an entity is readonly (code table)
+    def readonly_entity?(entity, readonly_list = nil)
+      readonly_list ||= (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)
+      (entity.class.ancestors.map(&:to_s) & readonly_list).any?
+    end
+
     # Helper method to get tableized class name
     def tableized_class_name(obj)
       obj.class.name.tableize
@@ -486,14 +506,18 @@ values ?s {<#{self.graph_id}>}
 
     # Delete orphaned entities that are no longer referenced
     def delete_orphaned_entities(entities_to_check, sparql)
-      embedded_readonly_entities = Solis::Options.instance.get[:embedded_readonly].map{|s| s.to_s} || []
+      return if entities_to_check.nil? || entities_to_check.empty?
+
+      readonly_list = (Solis::Options.instance.get[:embedded_readonly] || []).map(&:to_s)
 
       entities_to_check.each do |key, orphaned_entities|
+        next if orphaned_entities.nil?
+
         orphaned_entities.each do |orphaned_entity|
           next unless solis_model?(orphaned_entity)
 
           # Skip if it's a readonly entity (like code tables)
-          if (orphaned_entity.class.ancestors.map{|s| s.to_s} & embedded_readonly_entities).any?
+          if readonly_entity?(orphaned_entity, readonly_list)
             Solis::LOGGER.info("#{orphaned_entity.class.name} (id: #{orphaned_entity.id}) is in embedded_readonly list. Skipping deletion.")
             next
           end

data/lib/solis/query/run.rb

@@ -1,75 +1,282 @@
 require 'solis/store/sparql/client'
-require 'solis/query/result_transformer'
 require 'solis/config_file'
 
 class Solis::Query::Runner
   def self.run(entity, query, options = {})
-    sparql_client = Solis::Store::Sparql::Client.new(
-      Solis::Options.instance.get[:sparql_endpoint],
-      graph_name: graph_name
-    )
+    result = {}
 
-    raw_result = sparql_client.query(query, options)
-    model = options[:model] || nil
+    c = Solis::Store::Sparql::Client.new(Solis::Options.instance.get[:sparql_endpoint], graph_name: graph_name)
+    r = c.query(query, options)
 
-    transform_result(raw_result, entity, model)
+    if r.is_a?(SPARQL::Client)
+      result = direct_transform_with_embedding(r, entity, options)
+    else
+      t = r.map(&:to_h)
+      result = sanitize_result({'@graph' => t})
+    end
+    result
   rescue StandardError => e
     puts e.message
     raise e
   end
 
+  def self.direct_transform_with_embedding(client, entity, options = {})
+    results = client.query('select * where{?s ?p ?o}')
+
+    # Step 1: Group all triples by subject
+    grouped = group_by_subject(results)
+
+    # Step 2: Build objects index (without embedding yet)
+    objects_index = build_objects_index(grouped)
+
+    # Step 3: Embed references recursively
+    max_depth = options[:max_embed_depth] || 10
+    root_subjects = find_root_subjects(grouped, entity)
+
+    root_subjects.map do |subject|
+      embed_references(objects_index[subject], objects_index, max_depth, Set.new)
+    end.compact
+  end
+
   private
 
-  def self.transform_result(raw_result, entity, model)
-    if raw_result.is_a?(SPARQL::Client)
-      frame_and_transform(raw_result, entity, model)
-    else
-      transform_select_results(raw_result, model)
+  def self.group_by_subject(results)
+    results.each_with_object({}) do |solution, acc|
+      subject = solution.s.to_s
+      acc[subject] ||= []
+      acc[subject] << { predicate: solution.p, object: solution.o }
     end
   end
 
-  def self.frame_and_transform(sparql_result, entity, model)
-    graph = build_graph_from_result(sparql_result)
-    context = build_context(entity)
+  def self.build_objects_index(grouped)
+    grouped.each_with_object({}) do |(subject, triples), index|
+      obj = {
+        '_id' => subject,                    # Full URI for resolution
+        'id' => nil,                         # Will be set from predicate if exists
+        '@subject' => subject,               # Internal marker for reference resolution
+        '@type' => nil
+      }
+
+      triples.each do |triple|
+        predicate = triple[:predicate]
+        object = triple[:object]
+
+        # Handle rdf:type
+        if predicate.to_s =~ /type$/i || predicate == RDF::RDFV.type
+          obj['@type'] = object.to_s.split('/').last
+          next
+        end
 
-    framed = nil
-    JSON::LD::API.fromRDF(graph) do |expanded|
-      framed = JSON::LD::API.frame(expanded, context)
+        # Get predicate name (last part of URI)
+        pred_name = predicate.to_s.split('/').last.underscore
+
+        # Extract value
+        value = if object.is_a?(RDF::URI)
+                  { '@ref' => object.to_s } # Mark as reference for later resolution
+                else
+                  extract_value(object)
+                end
+
+        # Capture the 'id' predicate value specifically
+        if pred_name == 'id'
+          obj['id'] = value
+          next
+        end
+
+        # Handle multiple values for same predicate
+        if obj.key?(pred_name)
+          obj[pred_name] = [obj[pred_name]] unless obj[pred_name].is_a?(Array)
+          obj[pred_name] << value
+        else
+          obj[pred_name] = value
+        end
+      end
+
+      # Fallback: if no 'id' predicate was found, extract from URI
+      if obj['id'].nil?
+        obj['id'] = subject.split('/').last
+      end
+
+      if obj['@type'].nil?
+        obj['@type'] = subject.split('/')[-2].classify
+      end
+
+      index[subject] = obj
     end
+  end
+
+  def self.find_root_subjects(grouped, entity)
+    # Find subjects that match the requested entity type
+    grouped.select do |subject, triples|
+      type_triple = triples.find { |t| t[:predicate].to_s =~ /type$/i || t[:predicate] == RDF::RDFV.type }
+      next false unless type_triple
 
-    Solis::Query::ResultTransformer.new(model).transform(framed)
+      type_name = type_triple[:object].to_s.split('/').last
+      type_name.downcase == entity.downcase ||
+        type_name.tableize == entity.tableize ||
+        type_name == entity
+    end.keys
   end
 
-  def self.transform_select_results(raw_result, model)
-    results = raw_result.map(&:to_h)
-    Solis::Query::ResultTransformer.new(model).transform({'@graph' => results})
+  def self.embed_references(obj, objects_index, max_depth, visited, current_depth = 0)
+    return nil if obj.nil?
+
+    subject = obj['@subject']
+
+    # At max depth, return minimal reference with both IDs
+    if current_depth >= max_depth
+      #return { '_id' => obj['_id'], 'id' => obj['id'], '@type' => obj['@type'] }
+      return { '_id' => obj['_id'], 'id' => obj['id'] }
+    end
+
+    # Circular reference detection
+    if visited.include?(subject)
+      # Return a reference object instead of embedding
+      #return { '_id' => obj['_id'], 'id' => obj['id'], '@type' => obj['@type'] }
+      return { '_id' => obj['_id'], 'id' => obj['id'] }
+    end
+
+    visited = visited.dup
+    visited.add(subject)
+
+    # Create clean copy without internal markers (except _id)
+    result = {
+      '_id' => obj['_id'],
+      'id' => obj['id']
+    }
+
+    obj.each do |key, value|
+      next if key.start_with?('@')  # Skip internal markers
+      next if key == '_id' || key == 'id'  # Already added
+
+      result[key] = resolve_value(value, objects_index, max_depth, visited, current_depth)
+    end
+
+    result
   end
 
-  def self.build_graph_from_result(sparql_result)
-    graph = RDF::Graph.new
-    sparql_result.query('select * where{?s ?p ?o}').each do |statement|
-      graph << [statement.s, statement.p, statement.o]
+  def self.resolve_value(value, objects_index, max_depth, visited, current_depth)
+    case value
+    when Array
+      value.map { |v| resolve_value(v, objects_index, max_depth, visited, current_depth) }
+    when Hash
+      if value.key?('@ref')
+        # This is a reference - try to embed it
+        ref_uri = value['@ref']
+        referenced_obj = objects_index[ref_uri]
+
+        if referenced_obj
+          embed_references(referenced_obj, objects_index, max_depth, visited, current_depth + 1)
+        else
+          # External reference - return both IDs
+          { '_id' => ref_uri, 'id' => ref_uri.split('/').last }
+        end
+      else
+        # Regular hash - recurse
+        value.transform_values { |v| resolve_value(v, objects_index, max_depth, visited, current_depth) }
+      end
+    else
+      value
     end
-    graph
   end
 
-  def self.build_context(entity)
-    JSON.parse(%(
-{
-  "@context": {
-    "@vocab": "#{graph_name}",
-    "id": "@id"
-  },
-  "@type": "#{entity}",
-  "@embed": "@always"
-}
-    ))
+  def self.extract_value(literal)
+    return literal.to_s if literal.is_a?(RDF::URI)
+
+    datatype = literal.datatype&.to_s
+
+    case datatype
+    when "http://www.w3.org/2001/XMLSchema#dateTime"
+      DateTime.parse(literal.value)
+    when "http://www.w3.org/2001/XMLSchema#date"
+      Date.parse(literal.value)
+    when "http://www.w3.org/2001/XMLSchema#boolean"
+      literal.value == "true"
+    when "http://www.w3.org/2001/XMLSchema#integer", "http://www.w3.org/2001/XMLSchema#int"
+      literal.value.to_i
+    when "http://www.w3.org/2001/XMLSchema#float", "http://www.w3.org/2001/XMLSchema#double", "http://www.w3.org/2001/XMLSchema#decimal"
+      literal.value.to_f
+    when "http://www.w3.org/2006/time#DateTimeInterval"
+      ISO8601::TimeInterval.parse(literal.value).to_s
+    when "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON"
+      JSON.parse(literal.value) rescue literal.value
+    else
+      # Handle language-tagged strings
+      if literal.respond_to?(:language) && literal.language
+        { '@value' => literal.value, '@language' => literal.language.to_s }
+      else
+        literal.value
+      end
+    end
+  rescue StandardError => e
+    Solis::LOGGER.warn("Error extracting value: #{e.message}")
+    literal.to_s
   end
 
   def self.graph_name
-    graphs = Solis::Options.instance.get[:graphs]
-    raise Solis::Error::NotFoundError, 'No graph name found' if graphs.nil?
+    Solis::Options.instance.get.key?(:graphs) ? Solis::Options.instance.get[:graphs].select { |s| s['type'].eql?(:main) }&.first['name'] : ''
+  end
+
+  # Keep original methods for backward compatibility
+  def self.sanitize_result(framed)
+    data = framed&.key?('@graph') ? framed['@graph'] : [framed]
+    sanitatize_data_in_result(data)
+  end
 
-    graphs.find { |g| g['type'].eql?(:main) }&.fetch('name') || ''
+  def self.sanitatize_data_in_result(data)
+    data.map do |d|
+      d.delete_if { |e| e =~ /^@/ }
+      if d.is_a?(Hash)
+        new_d = {}
+        d.each do |k, v|
+          if v.is_a?(Hash)
+            if v.key?('@type')
+              type = v['@type']
+              if v.key?('@value')
+                value = v['@value']
+                case type
+                when "http://www.w3.org/2001/XMLSchema#dateTime"
+                  value = DateTime.parse(value)
+                when "http://www.w3.org/2001/XMLSchema#date"
+                  value = Date.parse(value)
+                when "http://www.w3.org/2006/time#DateTimeInterval"
+                  value = ISO8601::TimeInterval.parse(value)
+                when "http://www.w3.org/2001/XMLSchema#boolean"
+                  value = value == "true"
+                end
+                v = value
+              end
+              v = sanitize_result(v) if v.is_a?(Hash)
+            end
+            if v.is_a?(Hash)
+              new_d[k] = v.class.method_defined?(:value) ? v.value : sanitize_result(v)
+            else
+              new_d[k] = v.class.method_defined?(:value) ? v.value : v
+            end
+          elsif v.is_a?(Array)
+            new_d[k] = []
+            v.each do |vt|
+              if vt.is_a?(Hash)
+                if vt.key?('@value')
+                  new_d[k] << vt['@value']
+                else
+                  new_d[k] << (vt.is_a?(String) ? vt : sanitize_result(vt))
+                end
+              else
+                new_d[k] << (vt.is_a?(String) ? vt : sanitize_result(vt))
+              end
+            end
+            new_d[k].flatten!
+          else
+            new_d[k] = v.class.method_defined?(:value) ? v.value : v
+          end
+        end
+        d = new_d
+      end
+      d
+    end
+  rescue StandardError => e
+    Solis::LOGGER.error(e.message)
+    data
   end
 end

data/lib/solis/shape/reader/sheet.rb

@@ -289,7 +289,7 @@ hide empty members
                   graph_prefix = data[:ontologies][:base][:prefix]
                   graph_name = data[:ontologies][:base][:uri]
 
-                  description = metadata[:comment]
+                  description = metadata[:description]
                   label = metadata[:label]
                   target_class = "#{graph_prefix}:#{entity_name}"
                   node = metadata[:sub_class_of]
@@ -454,9 +454,19 @@ hide empty members
 
               datas.each do |data|
                 data[:entities].select { |_k, v| !v[:same_as].empty? }.each do |k, v|
-                  prefix, verb = v[:same_as].split(':')
-                  rdf_vocabulary = RDF::Vocabulary.from_sym(prefix.upcase)
-                  rdf_verb = rdf_vocabulary[verb.to_sym]
+                  same_as_value = v[:same_as].strip
+
+                  if same_as_value.start_with?('<') && same_as_value.end_with?('>')
+                    # Full URI format: <http://xmlns.com/foaf/0.1/Person>
+                    uri_string = same_as_value[1...-1]
+                    rdf_verb = RDF::URI(uri_string)
+                  else
+                    # Prefixed name format: foaf:Person
+                    prefix, verb = same_as_value.split(':')
+                    rdf_vocabulary = RDF::Vocabulary.from_sym(prefix.upcase)
+                    rdf_verb = rdf_vocabulary[verb.to_sym]
+                  end
+
                   graph << RDF::Statement.new(rdf_verb, RDF::RDFV.type, RDF::OWL.Class)
                   graph << RDF::Statement.new(rdf_verb, RDF::Vocab::OWL.sameAs, o[k.to_sym])
                 rescue StandardError => e

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.98.0"
+  VERSION = "0.100.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.98.0
+  version: 0.100.0
 platform: ruby
 authors:
 - Mehmet Celik
@@ -299,7 +299,6 @@ files:
 - lib/solis/query.rb
 - lib/solis/query/construct.rb
 - lib/solis/query/filter.rb
-- lib/solis/query/result_transformer.rb
 - lib/solis/query/run.rb
 - lib/solis/resource.rb
 - lib/solis/shape.rb

data/lib/solis/query/result_transformer.rb

@@ -1,130 +0,0 @@
-class Solis::Query::ResultTransformer
-  def initialize(model)
-    @model = model
-    @type_mappings = load_type_mappings
-    @cardinality_map = build_cardinality_map
-  end
-
-  def transform(data)
-    items = data.key?('@graph') ? data['@graph'] : [data]
-    items.map { |item| transform_item(item) }
-  end
-
-  private
-
-  def transform_item(item)
-    clean_item = remove_json_ld_metadata(item)
-    cast_and_shape(clean_item)
-  end
-
-  def cast_and_shape(item)
-    item.each_with_object({}) do |(key, value), result|
-      value = cast_value(value)
-      result[key] = enforce_cardinality(key, value)
-    end
-  end
-
-  # def cast_and_shape(item)
-  #   item.each_with_object({}) do |(key, value), result|
-  #     value = cast_value(value)
-  #     value = enforce_cardinality(key, value)
-  #     value = transform_nested_entity(key, value)
-  #     result[key] = value
-  #   end
-  # end
-
-  def transform_nested_entity(property_key, value)
-    return value if @model.nil?
-
-    metadata = @cardinality_map[property_key]
-    return value if metadata.nil?
-
-    datatype = metadata[:datatype]
-    node = metadata[:node]
-
-    # Check if datatype points to another entity (has a node)
-    if node.is_a?(RDF::URI) && value.is_a?(Hash)
-      # Recursively transform nested entity if we have its model
-      # You'd need a way to resolve the node URI to the model class
-      nested_model = resolve_model_from_node(datatype)
-      Solis::Query::ResultTransformer.new(nested_model).transform(value) if nested_model
-    elsif value.is_a?(Array) && value.all?(Hash)
-      # Transform array of nested entities
-      value.map { |v| transform_nested_entity(property_key, v) }
-    else
-      value
-    end
-  end
-
-  def resolve_model_from_node(datatype_node)
-    @model.graph.shape_as_model(datatype_node.to_s)
-  end
-
-
-  def remove_json_ld_metadata(item)
-    item.reject { |key| key.start_with?('@') }
-  end
-
-  def cast_value(value)
-    case value
-    when Hash
-      handle_typed_value(value)
-    when Array
-      value.map { |v| cast_value(v) }
-    else
-      value
-    end
-  end
-
-  def handle_typed_value(value)
-    return value unless value.key?('@type') && value.key?('@value')
-
-    type = value['@type']
-    raw_value = value['@value']
-
-    cast_by_type(type, raw_value)
-  end
-
-  def cast_by_type(type, value)
-    caster = @type_mappings[type]
-    caster ? caster.call(value) : value
-  end
-
-  def enforce_cardinality(property_key, value)
-    return value if @model.nil?
-
-    metadata = @cardinality_map[property_key]
-    return value if metadata.nil?
-
-    maxcount = metadata[:maxcount]
-
-    # If maxcount is nil or > 1, ensure it's an array
-    if maxcount.nil? || maxcount > 1
-      value.is_a?(Array) ? value : [value]
-      # If maxcount is 0 or 1, ensure it's a single value
-    else
-      value.is_a?(Array) ? value.first : value
-    end
-  end
-
-  def build_cardinality_map
-    return {} if @model.nil? || @model.metadata.nil?
-
-    attributes = @model.metadata[:attributes] || {}
-
-    attributes.each_with_object({}) do |(property_name, property_metadata), map|
-      map[property_name.to_s] = property_metadata
-    end
-  end
-
-  def load_type_mappings
-    {
-      "http://www.w3.org/2001/XMLSchema#dateTime" => ->(v) { DateTime.parse(v) },
-      "http://www.w3.org/2001/XMLSchema#date" => ->(v) { Date.parse(v) },
-      "http://www.w3.org/2006/time#DateTimeInterval" => ->(v) { ISO8601::TimeInterval.parse(v) },
-      "http://www.w3.org/2001/XMLSchema#boolean" => ->(v) { v == "true" },
-      "http://www.w3.org/2001/XMLSchema#integer" => ->(v) { v.to_i },
-      "http://www.w3.org/2001/XMLSchema#decimal" => ->(v) { BigDecimal(v) }
-    }
-  end
-end