solis 0.71.0 → 0.73.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16ed244eaf62cd747c1e2c2ea369066dcd6a03e529d3932916b4f7791a29b956
-  data.tar.gz: ef2a72fd541967ccf54ae75ca4f18abb21727cf9398c4da38b9aff3a8b9b5ca7
+  metadata.gz: a91e5038f9e0a152b51ad35d25c6bdd99ef383bfb0da8fb7baf1d08baddbf49a
+  data.tar.gz: b4b1a434aae6a337358815e8b0dc5ff37edea7e0ffb56d85a9d7d1590677ea92
 SHA512:
-  metadata.gz: b955562d76f6ca7942d634098b430c4e19c21c64323c8c676fcacbc494949b9d38aaf6d271c197fd3e8ed49bf200534c1ab473fd56aa883d3bbeda9136482427
-  data.tar.gz: f80157b099693522c7afa1a0ce607d174ab164a76ad94a69f359a8331588a858710b3a98ee2360cc6d10ef8e7c1299383eb7a129eac7c94773295bc95604fae1
+  metadata.gz: 35f713d36e731ac83203fec6f3d82bd6ad5f321c68ccf1424fd8f0c6b82183392e2c76d62cdd7eac6542318810c62940d9a4e1badb5dd817177509bf65753c9e
+  data.tar.gz: 5a9efc223d46e01936aed52e649e856344c7847307f6a39d7b094b48d2b553542a8059ce846bd483634cfb7046f9ab9646ed2130bab81de5c196b43af48b95c2

data/lib/solis/model.rb

@@ -71,9 +71,9 @@ module Solis
     def query
       raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
 
-      #before_read_proc&.call(self)
+      # before_read_proc&.call(self)
       result = Solis::Query.new(self)
-      #after_read_proc&.call(result)
+      # after_read_proc&.call(result)
       result
     end
 
@@ -108,30 +108,49 @@ module Solis
 
     def destroy
       raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
-      before_delete_proc&.call(self)
-
       sparql = SPARQL::Client.new(self.class.sparql_endpoint)
-      graph = as_graph(klass = self, resolve_all = false)
-      Solis::LOGGER.info graph.dump(:ttl) if ConfigFile[:debug]
 
-      result = sparql.delete_data(graph, graph: graph.name)
+      raise Solis::Error::QueryError, "#{self.id} is still referenced, refusing to delete" if is_referenced?(sparql)
+      # sparql.query('delete{}')
+      before_delete_proc&.call(self)
+      #      graph = as_graph(self, false)
+      #      Solis::LOGGER.info graph.dump(:ttl) if ConfigFile[:debug]
+
+      query = %(
+with <#{self.class.graph_name}>
+delete {?s ?p ?o}
+where {
+values ?s {<#{self.graph_id}>}
+?s ?p ?o }
+      )
+      result = sparql.query(query)
+
+      #      result = sparql.delete_data(graph, graph: graph.name)
       after_delete_proc&.call(result)
       result
     end
 
     def save(validate_dependencies = true)
       raise "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
+      sparql = SPARQL::Client.new(self.class.sparql_endpoint)
 
       before_create_proc&.call(self)
-      sparql = SPARQL::Client.new(self.class.sparql_endpoint)
-      graph = as_graph(self, validate_dependencies)
 
-      # File.open('/Users/mehmetc/Dropbox/AllSources/LP/graphiti-api/save.ttl', 'wb') do |file|
-      #   file.puts graph.dump(:ttl)
-      # end
-      Solis::LOGGER.info SPARQL::Client::Update::InsertData.new(graph, graph: graph.name).to_s if ConfigFile[:debug]
+      if self.exists?(sparql)
+        data = properties_to_hash(self)
+
+        result = update(data)
+      else
+        graph = as_graph(self, validate_dependencies)
+
+        # File.open('/Users/mehmetc/Dropbox/AllSources/LP/graphiti-api/save.ttl', 'wb') do |file|
+        #   file.puts graph.dump(:ttl)
+        # end
+        Solis::LOGGER.info SPARQL::Client::Update::InsertData.new(graph, graph: graph.name).to_s if ConfigFile[:debug]
+
+        result = sparql.insert_data(graph, graph: graph.name)
+      end
 
-      result = sparql.insert_data(graph, graph: graph.name)
       after_create_proc&.call(result)
       result
     rescue StandardError => e
@@ -144,7 +163,7 @@ module Solis
       raise Solis::Error::GeneralError, "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
 
       attributes = data.include?('attributes') ? data['attributes'] : data
-      raise "id is mandatory in attributes" unless attributes.keys.include?('id')
+      raise "id is mandatory when updating" unless attributes.keys.include?('id')
 
       id = attributes.delete('id')
 
@@ -155,48 +174,139 @@ module Solis
       updated_klass = original_klass.deep_dup
 
       attributes.each_pair do |key, value|
-        updated_klass.send(:"#{key}=", value)
+        if value.is_a?(Hash)
+          embedded = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s).new(value)
+          if embedded.exists?(sparql)
+            embedded_data = properties_to_hash(embedded)
+            embedded.update(embedded_data)
+          else
+            embedded.save
+          end
+        end
+
+        updated_klass.instance_variable_set("@#{key}", value)
       end
 
+      # attributes.each_pair do |key, value|
+      #   updated_klass.instance_variable_set("@#{key}", value)
+      # end
+      # properties_original_klass=Model.properties_to_hash(original_klass)
+      # properties_updated_klass = Model.properties_to_hash(updated_klass)
+      # changes = Hashdiff.diff(properties_original_klass, properties_updated_klass)
+      # pp changes
+      #
+      # #a=self.class.graph.shape_as_model('Identificatienummer').new
+      # changes.each do |change|
+      #   change_type = change[0]
+      #   original_change_entity = change[1]
+      #   change_entity = original_change_entity.split('.').last
+      #   change[1] = change_object
+      #   data = change[2]
+      #
+      #   case change_type
+      #   when '+' # new
+      #     new_entity_hash = {} #self.class.graph.shape_as_model(change_object.classify).new
+      #     Hashdiff.patch!(new_entity_hash, [change])
+      #
+      #     new_entity = self.class.graph.shape_as_model(change_entity.classify).new(new_entity_hash[change_entity])
+      #     new_entity.save
+      #   when '-' # delete
+      #   when '~' # change
+      #   else
+      #     raise RuntimeError, "Unknown change type(#{change_type}) for #{change[1]}"
+      #   end
+      #
+      # end
+
+      # attributes.each_pair do |key, value|
+      #   updated_klass.instance_variable_set("@#{key}", value)
+      #   unless original_klass.class.metadata[:attributes][key][:node_kind].nil?
+      #     inner_model = self.class.graph.shape_as_model(original_klass.class.metadata[:attributes][key][:datatype].to_s)
+      #     if value.is_a?(Hash)
+      #       value.each_pair do |inner_key, inner_value|
+      #         next unless inner_model.metadata[:attributes][inner_key][:node_kind].is_a?(RDF::URI)
+      #         inner_inner_model = self.class.graph.shape_as_model(inner_model.metadata[:attributes][inner_key][:datatype].to_s)
+      #         # if inner_inner_model.class.ancestors.include?(Codetabel) && inner_value.key?('id')
+      #         #   inner_data = inner_inner_model.query.filter({ language: nil, filters: { id: [inner_value['id']] } }).find_all.map { |m| m }&.first
+      #         # else
+      #         inner_value = inner_value.first if inner_value.is_a?(Array)
+      #           inner_data = inner_inner_model.new(inner_value)
+      #           inner_data.save
+      #         # end
+      #       end
+      #     elsif value.is_a?(Array)
+      #       data = value.map do |m|
+      #         if m.is_a?(Hash)
+      #           m.each do |inner_key, inner_value|
+      #             #next if inner_model.metadata[:attributes][inner_key][:class].nil?
+      #             next unless inner_model.metadata[:attributes][inner_key][:node_kind].is_a?(RDF::URI)
+      #             inner_inner_model = self.class.graph.shape_as_model(inner_model.class.metadata[:attributes][inner_key][:datatype].to_s)
+      #             # if inner_inner_model.class.ancestors.include?(Codetabel) && inner_value.key?('id')
+      #             #   inner_data = inner_inner_model.query.filter({ language: nil, filters: { id: [inner_value['id']] } }).find_all.map { |m| m }&.first
+      #             # else
+      #               inner_value = inner_value.first if inner_value.is_a?(Array)
+      #               inner_data = inner_inner_model.new(inner_value)
+      #               inner_data.save
+      #             # end
+      #
+      #             inner_data
+      #           end
+      #         else
+      #           m
+      #         end
+      #       end
+      #     elsif value.is_a?(Object)
+      #       value.save
+      #     end
+      #   end
+      # end
+
       before_update_proc&.call(original_klass, updated_klass)
 
-      delete_graph = as_graph(original_klass, false)
-      # where_graph = RDF::Graph.new
-      # where_graph.name = RDF::URI(self.class.graph_name)
+      properties_orignal_klass = properties_to_hash(original_klass)
+      properties_updated_klsss = properties_to_hash(updated_klass)
+
+      if Hashdiff.best_diff(properties_orignal_klass, properties_updated_klsss).empty?
+        Solis::LOGGER.info("#{original_klass.class.name} unchanged, skipping")
+        data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+      else
+
+        delete_graph = as_graph(original_klass, false)
 
-      where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), data: RDF::Repository.new)
+        where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), data: RDF::Repository.new)
 
-      if id.is_a?(Array)
-        id.each do |i|
-          where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{i}"), :p, :o]
+        if id.is_a?(Array)
+          id.each do |i|
+            where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{i}"), :p, :o]
+          end
+        else
+          where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), :p, :o]
         end
-      else
-        where_graph << [RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), :p, :o]
-      end
 
-      insert_graph = as_graph(updated_klass, true)
+        insert_graph = as_graph(updated_klass, true)
 
-      #Solis::LOGGER.info delete_graph.dump(:ttl) if ConfigFile[:debug]
-      #Solis::LOGGER.info insert_graph.dump(:ttl) if ConfigFile[:debug]
-      #Solis::LOGGER.info where_graph.dump(:ttl) if ConfigFile[:debug]
+        # puts delete_graph.dump(:ttl) #if ConfigFile[:debug]
+        # puts insert_graph.dump(:ttl) #if ConfigFile[:debug]
+        # puts where_graph.dump(:ttl) #if ConfigFile[:debug]
 
-      #if ConfigFile[:debug]
-      delete_insert_query = SPARQL::Client::Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, graph: insert_graph.name).to_s
-      delete_insert_query.gsub!('_:p', '?p')
-      Solis::LOGGER.info delete_insert_query
-      data = sparql.query(delete_insert_query)
-      pp data
-      #end
+        # if ConfigFile[:debug]
+        delete_insert_query = SPARQL::Client::Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, graph: insert_graph.name).to_s
+        delete_insert_query.gsub!('_:p', '?p')
+        # puts delete_insert_query
+        data = sparql.query(delete_insert_query)
+        # pp data
+        # end
 
-      #      sparql.delete_insert(delete_graph, insert_graph, where_graph, graph: insert_graph.name)
+        #      sparql.delete_insert(delete_graph, insert_graph, where_graph, graph: insert_graph.name)
 
-      data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
-      if data.nil?
-        sparql.insert_data(insert_graph, graph: insert_graph.name)
         data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+        if data.nil?
+          sparql.insert_data(insert_graph, graph: insert_graph.name)
+          data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
+        end
       end
-
       after_update_proc&.call(updated_klass, data)
+
       data
     rescue StandardError => e
       original_graph = as_graph(original_klass, false)
@@ -207,10 +317,23 @@ module Solis
       raise e
     end
 
+    def graph_id
+      "#{self.class.graph_name}#{self.name.tableize}/#{self.id}"
+    end
+
+    def is_referenced?(sparql)
+      sparql.query("ASK WHERE { ?s ?p <#{self.graph_id}>. filter (!contains(str(?p), '_audit'))}")
+    end
+
+    def exists?(sparql)
+      sparql.query("ASK WHERE { <#{self.graph_id}> ?p ?o }")
+    end
+
     def self.make_id_for(model)
       id = model.instance_variable_get("@id")
       if id.nil? || (id.is_a?(String) && id&.empty?)
-        model.instance_variable_set("@id", SecureRandom.uuid)
+        id = SecureRandom.uuid
+        model.instance_variable_set("@id", id)
       end
       model
     end
@@ -356,7 +479,7 @@ module Solis
 
       graph << [id, RDF::RDFV.type, klass_metadata[:target_class]]
 
-      #load existing object and overwrite
+      # load existing object and overwrite
       original_klass = klass.query.filter({ filters: { id: [uuid] } }).find_all { |f| f.id == uuid }.first || nil
 
       if original_klass.nil?
@@ -381,11 +504,9 @@ module Solis
     def make_graph(graph, hierarchy, id, klass, klass_metadata, resolve_all)
       klass_metadata[:attributes].each do |attribute, metadata|
         data = klass.instance_variable_get("@#{attribute}")
-
-        raise Solis::Error::InvalidAttributeError,
-              "#{hierarchy.join('.')}.#{attribute} min=#{metadata[:mincount]} and max=#{metadata[:maxcount]}" if data.nil? &&
-          metadata[:mincount] > 0 &&
-          graph.query(RDF::Query.new({ attribute.to_sym => { RDF.type => metadata[:node] } })).size == 0
+        if data.nil? && metadata[:mincount] > 0 && graph.query(RDF::Query.new({ attribute.to_sym => { RDF.type => metadata[:node] } })).size == 0
+          raise Solis::Error::InvalidAttributeError, "#{hierarchy.join('.')}.#{attribute} min=#{metadata[:mincount]} and max=#{metadata[:maxcount]}"
+        end
 
         # skip if nil or an object that is empty
         next if data.nil? || ([Hash, Array, String].include?(data.class) && data&.empty?)
@@ -397,7 +518,7 @@ module Solis
           data = data.to_json
         end
 
-        #make it an object
+        # make it an object
         unless metadata[:node_kind].nil?
           model = self.class.graph.shape_as_model(metadata[:datatype].to_s)
           if data.is_a?(Hash)
@@ -410,7 +531,7 @@ module Solis
         data = [data] unless data.is_a?(Array)
 
         data.each do |d|
-          if defined?(d.name) && self.class.graph.shape?(d.name)
+          if defined?(d.name) && self.class.graph.shape?(d.name) && resolve_all
             if self.class.graph.shape_as_model(d.name.to_s).metadata[:attributes].select { |_, v| v[:node_kind].is_a?(RDF::URI) }.size > 0 &&
               hierarchy.select { |s| s =~ /^#{d.name.to_s}/ }.size == 0
               internal_resolve = false
@@ -419,9 +540,11 @@ module Solis
               internal_resolve = false
               d = build_ttl_objekt2(graph, d, hierarchy, internal_resolve)
             else
-              #d = "#{klass.class.graph_name}#{attribute.tableize}/#{d.id}"
+              # d = "#{klass.class.graph_name}#{attribute.tableize}/#{d.id}"
               d = "#{klass.class.graph_name}#{d.name.tableize}/#{d.id}"
             end
+          elsif defined?(d.name) && self.class.graph.shape?(d.name)
+            d = "#{klass.class.graph_name}#{d.name.tableize}/#{d.id}"
           end
 
           if d.is_a?(Array) && d.length == 1
@@ -522,7 +645,7 @@ module Solis
           end
 
           if model && d.is_a?(Hash)
-            #TODO: figure out in what use case we need the parent_model
+            # TODO: figure out in what use case we need the parent_model
             # model_instance = if parent_model
             #                     parent_model.new(d)
             #                  else
@@ -573,5 +696,21 @@ module Solis
       hierarchy.pop
       id
     end
+
+    def properties_to_hash(model)
+      n = {}
+      model.class.metadata[:attributes].each_key do |m|
+        if model.instance_variable_get("@#{m}").is_a?(Array)
+          n[m] = model.instance_variable_get("@#{m}").map { |iv| iv.class.ancestors.include?(Solis::Model) ? properties_to_hash(iv) : iv }
+        elsif model.instance_variable_get("@#{m}").class.ancestors.include?(Solis::Model)
+          n[m] = properties_to_hash(model.instance_variable_get("@#{m}"))
+        else
+          n[m] = model.instance_variable_get("@#{m}")
+        end
+      end
+
+      n.compact!
+      n
+    end
   end
 end

data/lib/solis/query/filter.rb

@@ -101,8 +101,13 @@ module Solis
               value[:value].each do |v|
                 if metadata[:datatype_rdf].eql?('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
                     filter  = "?concept <#{metadata[:path]}> ?__search#{i} "
-                    filter += "FILTER(langMatches( lang(?__search#{i}), \"#{v[:"@language"]}\" )). "
-                    search_for = v[:"@value"].is_a?(Array) ? v[:"@value"].first : v[:"@value"]
+                    if v.is_a?(Hash)
+                      filter += "FILTER(langMatches( lang(?__search#{i}), \"#{v[:"@language"]}\" )). "
+                      search_for = v[:"@value"].is_a?(Array) ? v[:"@value"].first : v[:"@value"]
+                    else
+                      search_for = v
+                    end
+
                     search_for = normalize_string(search_for)
                     filter += "FILTER(str(?__search#{i}) #{not_operator}#{value[:operator]} \"#{search_for}\"#{datatype}) .\n"
                 else

data/lib/solis/query.rb

@@ -43,8 +43,8 @@ module Solis
         end
         ids = ids.join(" ")
 
-
-        q = query.gsub(/{ ?{ ?VALUES ?} ?}/, "VALUES ?#{id_name} { #{ids} }")
+        language = Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || 'en'
+        q = query.gsub(/{ ?{ ?VALUES ?} ?}/, "VALUES ?#{id_name} { #{ids} }").gsub(/{ ?{ ?LANGUAGE ?} ?}/, "bind(\"#{language}\" as ?filter_language).")
 
         result = Solis::Query.run(entity, q)
       end

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

@@ -156,7 +156,7 @@ module Solis
                       datatype: p['datatype'],
                       path: "#{graph_prefix}:#{property_name.to_s.classify}",
                       cardinality: { min: min_max['min'], max: min_max['max'] },
-                      same_as: p['sameAs'],
+                      same_as: p['sameas'],
                       description: p['description']
                     }
 
@@ -337,50 +337,50 @@ hide empty members
               datas.first[:ontologies][:all].each { |k, v| all_prefixes[k] = v[:uri] }
 
               datas.each do |data|
-              data[:entities].each do |entity_name, metadata|
-                classes[entity_name] = {
-                  comment: metadata[:description],
-                  label: entity_name.to_s,
-                  type: 'owl:Class',
-                  subClassOf: metadata[:sub_class_of]
-                }
-
-                metadata[:properties].each do |property, property_metadata|
-                  attribute = property.to_s.strip
-                  description = property_metadata[:description]
-                  path = "#{graph_name}#{attribute}"
-                  datatype = property_metadata[:datatype]
-
-                  schema_data = datatype_properties[attribute] || {}
-                  domain = schema_data[:domain] || []
-                  domain << "#{graph_name}#{entity_name}"
-                  datatype_properties[attribute] = {
-                    domain: domain,
-                    comment: description,
-                    label: attribute.to_s,
-                    range: datatype,
-                    type: 'rdf:Property'
+                data[:entities].each do |entity_name, metadata|
+                  classes[entity_name] = {
+                    comment: metadata[:description],
+                    label: entity_name.to_s,
+                    type: 'owl:Class',
+                    subClassOf: metadata[:sub_class_of]
                   }
-                  unless property_metadata[:same_as].nil? || property_metadata[:same_as].empty?
-                    datatype_properties[attribute]['owl:sameAs'] =
-                      property_metadata[:same_as]
-                  end
 
-                  subclass_data = data[:entities][entity_name][:sub_class_of] || []
-                  unless property_metadata[:cardinality][:min].empty?
-                    subclass_data << RDF::Vocabulary.term(type: 'owl:Restriction',
-                                                          onProperty: path,
-                                                          minCardinality: property_metadata[:cardinality][:min])
-                  end
-                  unless property_metadata[:cardinality][:max].empty?
-                    subclass_data << RDF::Vocabulary.term(type: 'owl:Restriction',
-                                                          onProperty: path,
-                                                          maxCardinality: property_metadata[:cardinality][:max])
+                  metadata[:properties].each do |property, property_metadata|
+                    attribute = property.to_s.strip
+                    description = property_metadata[:description]
+                    path = "#{graph_name}#{attribute}"
+                    datatype = property_metadata[:datatype]
+
+                    schema_data = datatype_properties[attribute] || {}
+                    domain = schema_data[:domain] || []
+                    domain << "#{graph_name}#{entity_name}"
+                    datatype_properties[attribute] = {
+                      domain: domain,
+                      comment: description,
+                      label: attribute.to_s,
+                      range: datatype,
+                      type: 'rdf:Property'
+                    }
+                    unless property_metadata[:same_as].nil? || property_metadata[:same_as].empty?
+                      datatype_properties[attribute]['owl:sameAs'] =
+                        property_metadata[:same_as]
+                    end
+
+                    subclass_data = data[:entities][entity_name][:sub_class_of] || []
+                    unless property_metadata[:cardinality][:min].empty?
+                      subclass_data << RDF::Vocabulary.term(type: 'owl:Restriction',
+                                                            onProperty: path,
+                                                            minCardinality: property_metadata[:cardinality][:min])
+                    end
+                    unless property_metadata[:cardinality][:max].empty?
+                      subclass_data << RDF::Vocabulary.term(type: 'owl:Restriction',
+                                                            onProperty: path,
+                                                            maxCardinality: property_metadata[:cardinality][:max])
+                    end
+                    data[:entities][entity_name][:sub_class_of] = subclass_data
                   end
-                  data[:entities][entity_name][:sub_class_of] = subclass_data
                 end
               end
-              end
 
               lp = RDF::StrictVocabulary(graph_name)
               o = ::Class.new(lp) do

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.71.0"
+  VERSION = "0.73.0"
 end

data/solis.gemspec

@@ -40,6 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency  'uuidtools', '~> 2.2.0'
   spec.add_runtime_dependency  'dry-struct', '~> 1.6'
   spec.add_runtime_dependency  'psych', '~> 5.1'
+  #spec.add_runtime_dependency  'hashdiff', '~> 1.1'
 
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency  'minitest', '~> 5.19'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.71.0
+  version: 0.73.0
 platform: ruby
 authors:
 - Mehmet Celik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-22 00:00:00.000000000 Z
+date: 2024-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -295,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Turn any SHACL file into an API, ORM, documentation, ...