solis 0.70.0 → 0.72.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8643fbce6b423cf64728ed433be0208ee53db367afecb93b8e63c131fc7fbcd
-  data.tar.gz: 22679c04f9d67219a0b6f5598029462b7e067b3c9218132b076b58b23d514f88
+  metadata.gz: fa7c729b1acbe8c1881ebf3cc00ac228830bf04d269447f55b2f029c7eef703c
+  data.tar.gz: 81ceb99f9f6284b8c4163bfe4d263f6703edbe1733eb42fcc6c31530be2c8d91
 SHA512:
-  metadata.gz: c2a8ec6b308230459b5a2a4ad4271ebc31305c776deedaf7bb631c6051df1e6b84c2a6cf5bef4d705fe175c0a300ab3a7fe07f0586a232f3c8fe70035ecaf542
-  data.tar.gz: 50c09efc0aa5ae63cdd45c5e9a9923461a8231dda52d6fe3600548c770eec871e3df684bbe36d3817081892fe7af3391b190257cdd1d19d7d88c4a631e0714da
+  metadata.gz: 6a5fe949952a2931c1189644690446ddc0b63ca719eb2f4b15f5cab83779d81b50872c3b57d4b677278cc4c6ca1e54ff8f14ff4b8c09ce842e8e5a3226835177
+  data.tar.gz: 03af55e0505d6e987522e8d799450be43a83b9968c60f7741b7c5bb2d75f0874d7d127b955f31ad028a35b2993b2ecdefb91653edf5e9941c4e7dfc796658696

data/lib/solis/config_file.rb

@@ -51,12 +51,17 @@ class ConfigFile
     @config
   end
 
+  def self.keys
+    init
+    @config.keys
+  end
+
   private
 
   def self.init
     discover_config_file_path
     if @config.empty?
-      config = YAML::load_file("#{path}/#{name}")
+      config = YAML::load_file("#{path}/#{name}", aliases: true)
       @config = process(config)
     end
   end

data/lib/solis/graph.rb

@@ -79,6 +79,9 @@ module Solis
       unless @inflections.nil?
         raise "Inflection file not found #{File.absolute_path(@inflections)}" unless File.exist?(@inflections)
         JSON.parse(File.read(@inflections)).each do |s, p|
+          raise "No plural found" if s.nil? && p.nil?
+          raise "No plural found for #{p}" if s.nil?
+          raise "No plural found for #{s}" if p.nil?
           ActiveSupport::Inflector.inflections.irregular(s, p)
         end
       end
@@ -89,6 +92,7 @@ module Solis
           LOGGER.warn("Dangling entity found #{_[:target_class].to_s} removing")
           next
         end
+        #@shapes[shape_name][:attributes].select { |_, metadata| metadata.key?(:node_kind) && !metadata[:node_kind].nil? }.values.map { |m| m[:datatype].to_s.split('#').last }
         @shapes[shape_name][:attributes].select { |_, metadata| metadata.key?(:node_kind) && !metadata[:node_kind].nil? }.values.map { |m| m[:datatype].to_s }
       end
       shape_keys += @shapes.keys
@@ -221,6 +225,10 @@ module Solis
       relations.each_key do |k|
         next if relations[k][:node_kind].is_a?(RDF::URI) && relations[k][:class].value.gsub(@graph_name, '').gsub('Shape', '').eql?(shape_name)
         relation_shape = relations[k][:class].value.gsub(@graph_name, '').gsub('Shape', '')
+        if relation_shape =~ /\//
+          relation_shape = relations[k][:class].value.split('/').last.gsub('Shape','')
+        end
+
         shape_as_resource(relation_shape, stack_level << relation_shape) unless stack_level.include?(relation_shape)
       end
 

data/lib/solis/model.rb

@@ -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 exists?(sparql)
+        data = Model.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,14 +174,12 @@ module Solis
       updated_klass = original_klass.deep_dup
 
       attributes.each_pair do |key, value|
-        updated_klass.send(:"#{key}=", value)
+        updated_klass.instance_variable_set("@#{key}", value)
       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)
 
       where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{self.name.tableize}/#{id}"), data: RDF::Repository.new)
 
@@ -176,16 +193,16 @@ module Solis
 
       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
+      puts delete_insert_query
       data = sparql.query(delete_insert_query)
-      pp data
+      #pp data
       #end
 
       #      sparql.delete_insert(delete_graph, insert_graph, where_graph, graph: insert_graph.name)
@@ -207,10 +224,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
@@ -410,7 +440,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
@@ -422,6 +452,8 @@ module Solis
               #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
@@ -573,5 +605,21 @@ module Solis
       hierarchy.pop
       id
     end
+
+    def self.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

@@ -11,33 +11,41 @@ module Solis
         def self.read(key, spreadsheet_id, options = {})
           class << self
             def validate(sheets)
-              raise "Please make sure the sheet contains '_PREFIXES', '_METADATA', '_ENTITIES' tabs" unless (%w[
-                _PREFIXES _METADATA _ENTITIES
-              ] - sheets.keys).length == 0
+              #raise "Please make sure the sheet contains '_PREFIXES', '_METADATA', '_ENTITIES' tabs" unless (%w[_PREFIXES _METADATA _ENTITIES] - sheets.keys).length == 0
 
               prefixes = sheets['_PREFIXES']
               metadata = sheets['_METADATA']
-              entities = sheets['_ENTITIES']
-
-              raise "_PREFIXES tab must have ['base', 'prefix', 'uri'] as a header at row 1" unless (%w[base prefix
-                                                                                                        uri] - prefixes.header).length == 0
-              raise "_METADATA tab must have ['key', 'value'] as a header at row 1" unless (%w[key
-                                                                                               value] - metadata.header).length == 0
-              raise "_ENTITIES tab must have ['name', 'nameplural', 'description', 'subclassof', 'sameas'] as a header at row 1" unless (%w[
-                name nameplural description subclassof sameas
-              ] - entities.header).length == 0
 
+              raise "_PREFIXES tab must have ['base', 'prefix', 'uri'] as a header at row 1" unless (%w[base prefix uri] - prefixes.header).length == 0
               raise '_PREFIXES.base can only have one base URI' if prefixes.map { |m| m['base'] }.grep(/\*/).count != 1
+
+              raise "_METADATA tab must have ['key', 'value'] as a header at row 1" unless (%w[key value] - metadata.header).length == 0
+
+              if sheets.key?('_ENTITIES')
+                entities = sheets['_ENTITIES']
+                raise "_ENTITIES tab must have ['name', 'nameplural', 'description', 'subclassof', 'sameas'] as a header at row 1" unless (%w[name nameplural description subclassof sameas] - entities.header).length == 0
+
+                entities.each do |entity|
+                  raise "Plural not found for #{entity['name']}" if entity['nameplural'].nil? || entity['nameplural'].empty?
+                end
+              end
+
+              if sheets.key?('_REFERENCES')
+                references = sheets['_REFERENCES']
+                raise "_REFERENCES tab must have ['sheeturl', 'description', 'entityrange'] as a header at row 1" unless (%w[sheeturl description entityrange] - references.header).length == 0
+              end
+
             end
 
             def read_sheets(key, spreadsheet_id, options)
               data = nil
 
-              cache_dir = ConfigFile.include?(:solis) && ConfigFile[:solis].include?(:cache) ? ConfigFile[:solis][:cache] : '/tmp'
+              cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
 
               if ::File.exist?("#{cache_dir}/#{spreadsheet_id}.json") && (options.include?(:from_cache) && options[:from_cache])
                 Solis::LOGGER.info("from cache #{cache_dir}/#{spreadsheet_id}.json")
                 data = JSON.parse(::File.read("#{cache_dir}/#{spreadsheet_id}.json"), { symbolize_names: true })
+                return data
               else
                 Solis::LOGGER.info("from source #{spreadsheet_id}")
                 session = SimpleSheets.new(key, spreadsheet_id)
@@ -49,66 +57,69 @@ module Solis
                 end
 
                 validate(sheets)
+              end
+              sheets
+            end
 
-                entities = {}
-                prefixes = {}
-                ontology_metadata = {}
+            def process_sheet(key, sheet_id, sheets, options = {follow: true})
+              entities = {}
+              prefixes = {}
+              ontology_metadata = {}
 
-                sheets['_PREFIXES'].each do |e|
-                  prefixes.store(e['prefix'].to_sym, { uri: e['uri'], base: e['base'].eql?('*') })
+              sheets['_PREFIXES'].each do |e|
+                prefixes.store(e['prefix'].to_sym, { uri: e['uri'], base: e['base'].eql?('*') })
+              end
+              sheets['_METADATA'].each { |e| ontology_metadata.store(e['key'].to_sym, e['value']) }
+
+              base_uri = prefixes.select { |_k, v| v[:base] }.select { |s| !s.empty? }
+
+              graph_prefix = base_uri.keys.first
+              graph_name = base_uri.values.first[:uri]
+
+              sheets['_ENTITIES'].each do |e|
+
+                top_class = e['name'].to_s
+                #if prefixes[graph_prefix][:data].nil? || prefixes[graph_prefix][:data].empty?
+                  entity_data = parse_entity_data(e['name'].to_s, graph_prefix, graph_name, sheets[top_class], { key: key, prefixes: prefixes, follow: options[:follow] })
+                #  prefixes[graph_prefix][:data] = entity_data
+                #else
+                #  entity_data = prefixes[graph_prefix][:data]
+                #end
+
+                if entity_data.empty?
+                  entity_data[:id] = {
+                    datatype: 'xsd:string',
+                    path: "#{graph_prefix}:id",
+                    cardinality: { min: '1', max: '1' },
+                    same_as: '',
+                    description: 'systeem UUID'
+                  }
                 end
-                sheets['_METADATA'].each { |e| ontology_metadata.store(e['key'].to_sym, e['value']) }
-
-                base_uri = prefixes.select { |_k, v| v[:base] }.select { |s| !s.empty? }
-
-                graph_prefix = base_uri.keys.first
-                graph_name = base_uri.values.first[:uri]
-
-                sheets['_ENTITIES'].each do |e|
-
-                  top_class = e['name'].to_s
-                  # subclassof = e['subclassof'].empty? ? nil : e['subclassof'].split(':').last
-                  # while subclassof                                        
-                  #   candidate_sco = sheets['_ENTITIES'].select{|t| t['name'].eql?(subclassof)}.first
-                  #   subclassof = candidate_sco['subclassof'].empty? ? nil : candidate_sco['subclassof'].split(':').last
-                  #   top_class = candidate_sco['name'].to_s if candidate_sco['subclassof'].empty?
-                  # end
-
-                  entity_data = parse_entity_data(e['name'].to_s, graph_prefix, graph_name, sheets[top_class])
 
-                  if entity_data.empty?
-                    entity_data[:id] = {
-                      datatype: 'xsd:string',
-                      path: "#{graph_prefix}:id",
-                      cardinality: { min: '1', max: '1' },
-                      same_as: '',
-                      description: 'systeem UUID'
-                    }
-                  end
-
-                  entities.store(e['name'].to_sym, { description: e['description'],
-                                                     plural: e['nameplural'],
-                                                     label: e['name'].to_s.strip,
-                                                     sub_class_of: e['subclassof'].nil? || e['subclassof'].empty? ? [] : [e['subclassof']],
-                                                     same_as: e['sameas'],
-                                                     properties: entity_data })
-                end
+                entities.store(e['name'].to_sym, { description: e['description'],
+                                                   plural: e['nameplural'],
+                                                   label: e['name'].to_s.strip,
+                                                   sub_class_of: e['subclassof'].nil? || e['subclassof'].empty? ? [] : [e['subclassof']],
+                                                   same_as: e['sameas'],
+                                                   properties: entity_data })
+              end
 
-                data = {
-                  entities: entities,
-                  ontologies: {
-                    all: prefixes,
-                    base: {
-                      prefix: graph_prefix,
-                      uri: graph_name
-                    }
-                  },
-                  metadata: ontology_metadata
-                }
+              data = {
+                entities: entities,
+                ontologies: {
+                  all: prefixes,
+                  base: {
+                    prefix: graph_prefix,
+                    uri: graph_name
+                  }
+                },
+                metadata: ontology_metadata
+              }
 
-                ::File.open("#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json", 'wb') do |f|
-                  f.puts data.to_json
-                end
+              cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
+              # ::File.open("#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json", 'wb') do |f|
+              ::File.open("#{::File.absolute_path(cache_dir)}/#{sheet_id}.json", 'wb') do |f|
+                f.puts data.to_json
               end
 
               data
@@ -116,11 +127,12 @@ module Solis
               raise Solis::Error::GeneralError, e.message
             end
 
-            def parse_entity_data(name, graph_prefix, _graph_name, e)
+            def parse_entity_data(entity_name, graph_prefix, _graph_name, e, options = {})
               properties = {}
               entity_data = e
               if entity_data && !entity_data.nil? && (entity_data.count > 0)
                 entity_data.each do |p|
+                  property_name = I18n.transliterate(p['name'].strip)
                   min_max = {}
 
                   %w[min max].each do |n|
@@ -130,24 +142,54 @@ module Solis
                                    ''
                                  end
                   end
-                  puts "#{name}.#{p['name']}"
+                  puts "#{entity_name}.#{property_name}"
                   unless p.key?('name')
+                    puts "No 'name' property found"
                     pp p
                   end
-                  properties[p['name'].strip] = {
-                    datatype: p['datatype'],
-                    path: "#{graph_prefix}:#{p['name'].to_s.classify}",
-                    cardinality: { min: min_max['min'], max: min_max['max'] },
-                    same_as: p['sameAs'],
-                    description: p['description']
-                  }
+
+                  if properties.key?(property_name)
+                    puts "Found #{entity_name}.#{property_name}"
+                  else
+                    datatype_prefix, datatype_name = p['datatype'].split(':')
+                    properties[property_name] = {
+                      datatype: p['datatype'],
+                      path: "#{graph_prefix}:#{property_name.to_s.classify}",
+                      cardinality: { min: min_max['min'], max: min_max['max'] },
+                      same_as: p['sameas'],
+                      description: p['description']
+                    }
+
+                    # unless graph_prefix.eql?(datatype_prefix.to_sym)
+                    #   prefixes = options[:prefixes]
+                    #   if prefixes.key?(datatype_prefix.to_sym) && !prefixes[datatype_prefix.to_sym][:sheet_url].empty?
+                    #     tmp = URI(prefixes[datatype_prefix.to_sym][:sheet_url]).path.split('/')
+                    #     spreadsheet_id = tmp[tmp.index('d') + 1]
+                    #
+                    #     processed_remote_sheet = {}
+                    #     if prefixes[datatype_prefix.to_sym].key?(:data) && !prefixes[datatype_prefix.to_sym][:data].empty?
+                    #       processed_remote_sheet = prefixes[datatype_prefix.to_sym][:data]
+                    #     else
+                    #       if options[:follow]
+                    #         sleep 30
+                    #         remote_sheet = read_sheets(options[:key], spreadsheet_id, { from_cache: true })
+                    #         processed_remote_sheet = process_sheet(options[:key], remote_sheet, {follow: false})
+                    #         prefixes[datatype_prefix.to_sym][:data] = processed_remote_sheet
+                    #       end
+                    #     end
+                    #
+                    #     processed_remote_sheet
+                    #   end
+                    # end
+
+                  end
                 end
               end
 
               properties
             end
 
-            def build_plantuml(data)
+            def build_plantuml(datas)
               out = %(@startuml
 !pragma layout elk
 skinparam classFontSize 14
@@ -157,10 +199,11 @@ skinparam componentStyle uml2
 skinparam wrapMessageWidth 100
 skinparam ArrowColor #Maroon
 
-title #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}
+title #{datas.first[:metadata][:title]} - #{datas.first[:metadata][:version]} - #{Time.now}
               )
 
-              out += "\npackage #{data[:ontologies][:base][:prefix]} {\n"
+              out += "\npackage #{datas.first[:ontologies][:base][:prefix]} {\n"
+              datas.each do |data|
               data[:entities].each do |entity_name, metadata|
                 out += "\nclass #{entity_name}"
 
@@ -186,7 +229,7 @@ title #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}
                   out += "#{entity_name} --|> #{sub_class.split(':').last}\n" unless sub_class.empty?
                 end
               end
-
+              end
               out += %(
 hide circle
 hide methods
@@ -195,6 +238,8 @@ hide empty members
           )
 
               out
+            rescue StandardError => e
+              puts e.message
             end
 
             def datatype_lookup(datatype, as = :sql)
@@ -210,86 +255,14 @@ hide empty members
               datatypes[datatype][as]
             end
 
-            def build_plantuml_erd(data)
-              cardinality_min = { '0' => '|o', '' => '}o', '1' => '||' }
-              cardinality_max = { '0' => 'o|', '' => 'o{', '1' => '||' }
-
-              out = %(@startuml
-skinparam classFontSize 14
-!define LIGHTORANGE
-skinparam groupInheritance 1
-skinparam componentStyle uml2
-skinparam wrapMessageWidth 100
-skinparam ArrowColor #Maroon
-skinparam linetype ortho
-
-title #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}
-              )
-
-              out += "\npackage #{data[:ontologies][:base][:prefix]} {\n"
-              relations = []
-              data[:entities].each do |_entity_name, metadata|
-                table_name = metadata[:plural].to_s.underscore
-                # out += "\nentity \"#{entity_name}\" as #{table_name}"
-                out += "\nentity \"#{table_name}\" as #{table_name}"
-
-                properties = metadata[:properties]
-                # relations = []
-                unless properties.nil? || properties.empty?
-                  out += "{\n"
-                  properties.each do |property, property_metadata|
-                    if property.to_s.eql?('id')
-                      out += "\t *#{property} : #{datatype_lookup(property_metadata[:datatype], :sql)} <<generated>>\n"
-                      out += "--\n"
-                    else
-                      mandatory = property_metadata[:cardinality][:min].to_i > 0
-                      is_fk = property_metadata[:datatype].split(':').first.eql?(data[:ontologies][:base][:prefix].to_s) ? true : false
-                      out += "\t #{mandatory ? '*' : ''}#{property}#{is_fk ? '_id' : ''} : #{datatype_lookup(
-                        property_metadata[:datatype], :sql
-                      )} #{is_fk ? '<<FK>>' : ''} \n"
-                    end
-
-                    unless property_metadata[:datatype].split(':').first.eql?(data[:ontologies][:base][:prefix].to_s)
-                      next
-                    end
-
-                    cmin = cardinality_min[(property_metadata[:cardinality][:min]).to_s]
-                    cmax = cardinality_max[(property_metadata[:cardinality][:max]).to_s]
-
-                    # relations << " #{entity_name.to_s.underscore} #{cmin}--o{ #{property_metadata[:datatype].split(':').last.to_s.underscore} "
-                    # ref_table_name = property_metadata[:datatype].split(':').last.to_s.underscore
-                    ref_table_name = [property_metadata[:datatype].split(':').last.to_sym,
-                                      property_metadata[:path].split(':').last.classify.to_sym].map do |m|
-                      data[:entities][m].nil? ? nil : data[:entities][m][:plural].underscore
-                    end.compact.first
-
-                    relations << " #{table_name} #{cmin}--#{cmax} #{ref_table_name} "
-                  end
-                  out += "}\n"
-                end
-
-                out += "\n"
-                # out += "#{entity_name} }o-- #{metadata[:sub_class_of].split(':').last}\n" unless metadata[:sub_class_of].empty?
-              end
-              out += relations.join("\n")
-
-              out += %(
-hide circle
-hide methods
-hide empty members
-@enduml
-          )
-
-              out
-            end
-
-            def build_shacl(data)
-              shacl_prefix = data[:ontologies][:all].select { |_, v| v[:uri] =~ /shacl/ }.keys.first
+            def build_shacl(datas)
+              shacl_prefix = datas.first[:ontologies][:all].select { |_, v| v[:uri] =~ /shacl/ }.keys.first
               shacl_prefix = 'sh' if shacl_prefix.nil?
 
-              out = header(data)
+              out = header(datas.first)
 
-              data[:entities].each do |entity_name, metadata|
+              datas.each do |data|
+                data[:entities].each do |entity_name, metadata|
                 graph_prefix = data[:ontologies][:base][:prefix]
                 graph_name = data[:ontologies][:base][:uri]
 
@@ -301,7 +274,7 @@ hide empty members
                 if node && !node.empty?
                   node = node.first if node.is_a?(Array)
                   node = node.strip
-                  node += 'Shape' if node != /Shape$/ && node =~ /^#{graph_prefix}:/
+                  node += 'Shape' if node != /Shape$/ # && node =~ /^#{graph_prefix}:/
                 else
                   node = target_class
                 end
@@ -345,74 +318,78 @@ hide empty members
                 end
                 out += ".\n"
               end
-
+              end
               out
+            rescue StandardError => e
+              puts e.message
             end
 
-            def build_schema(data)
+            def build_schema(datas)
               classes = {}
               datatype_properties = {}
               object_properties = {}
 
               format = :ttl
-              graph_prefix = data[:ontologies][:base][:prefix]
-              graph_name = data[:ontologies][:base][:uri]
+              graph_prefix = datas.first[:ontologies][:base][:prefix]
+              graph_name = datas.first[:ontologies][:base][:uri]
 
               all_prefixes = {}
-              data[:ontologies][:all].each { |k, v| all_prefixes[k] = v[:uri] }
-
-              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'
+              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]
                   }
-                  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
 
               lp = RDF::StrictVocabulary(graph_name)
               o = ::Class.new(lp) do
                 ontology(graph_name.to_sym, {
-                  "dc11:title": data[:metadata][:title].freeze,
-                  "dc11:description": data[:metadata][:description].freeze,
+                  "dc11:title": datas.first[:metadata][:title].freeze,
+                  "dc11:description": datas.first[:metadata][:description].freeze,
                   "dc11:date": Time.now.to_s.freeze,
-                  "dc11:creator": data[:metadata][:author].freeze,
-                  "owl:versionInfo": data[:metadata][:version].freeze,
+                  "dc11:creator": datas.first[:metadata][:author].freeze,
+                  "owl:versionInfo": datas.first[:metadata][:version].freeze,
                   type: 'owl:Ontology'.freeze
                 })
 
@@ -433,6 +410,7 @@ hide empty members
               graph = RDF::Graph.new
               graph.graph_name = RDF::URI(graph_name)
 
+              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)
@@ -442,178 +420,27 @@ hide empty members
               rescue StandardError => e
                 puts e.message
               end
+              end
 
               graph << o.to_enum
 
               graph.dump(format, prefixes: all_prefixes)
+            rescue StandardError => e
+              puts e.message
             end
 
-            def build_inflections(data)
+            def build_inflections(datas)
               inflections = {}
+              datas.each do |data|
               data[:entities].each do |entity, metadata|
                 inflections[entity] = metadata[:plural]
                 inflections[entity.to_s.underscore.to_sym] = metadata[:plural].underscore
               end
-
-              inflections.to_json
-            end
-
-            def build_sql(data)
-              graph_prefix = data[:ontologies][:base][:prefix]
-              out = "--\n-- #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}\n"
-              out += "-- description: #{data[:metadata][:description]}\n"
-              out += "-- author: #{data[:metadata][:author]}\n--\n\n"
-
-              out += %(CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-DROP SCHEMA IF EXISTS #{graph_prefix} CASCADE;
-CREATE SCHEMA #{graph_prefix};
-
-)
-              data[:entities].each do |entity_name, metadata|
-                table_name = metadata[:plural].to_s.underscore
-                out += "CREATE TABLE #{graph_prefix}.#{table_name}(\n"
-
-                properties = metadata[:properties]
-                properties.each_with_index do |(property, property_metadata), i|
-                  mandatory = property_metadata[:cardinality][:min].to_i > 0
-                  is_fk = property_metadata[:datatype].split(':').first.eql?(data[:ontologies][:base][:prefix].to_s) ? true : false
-                  if data[:entities][property_metadata[:datatype].split(':').last.to_sym].nil? && is_fk
-                    raise Solis::Error::NotFoundError,
-                          "#{entity_name}.#{property} Not found in _ENTITIES tab"
-                  end
-
-                  if is_fk
-                    references = data[:entities][property_metadata[:datatype].split(':').last.to_sym][:plural].to_s.underscore
-                  end
-
-                  out += ", \n" if i > 0
-                  if property.to_s.eql?('id')
-                    # out += "\t#{property} #{datatype_lookup(property_metadata[:datatype], :sql)}#{mandatory ? ' NOT NULL' : ''} PRIMARY KEY"
-                    out += "\t#{property} SERIAL#{mandatory ? ' NOT NULL' : ''} PRIMARY KEY"
-                  else
-                    out += "\t#{property}#{is_fk ? '_id' : ''} #{datatype_lookup(property_metadata[:datatype],
-                                                                                 :sql)}#{mandatory ? ' NOT NULL' : ''}#{is_fk ? " REFERENCES #{graph_prefix}.#{references}(id)" : ''}"
-                  end
-                end
-
-                out += ");\n\n"
-              end
-
-              out
-            end
-
-            def build_erd(data, type = :uml)
-              out = erd_header(data, type)
-              all_tables = {}
-              tables = {}
-              relations = []
-              references = {}
-              every_entity(data).each do |table|
-                case type
-                when :uml
-                  d = table[:table].call(type)
-                  out += d[:out]
-                  relations << d[:relations] unless d[:relations].empty?
-                  out += "\n\n"
-                  #references << d[:references]
-                when :sql
-                  all_tables[table[:name]] = table
-                  d = table[:table].call(type)
-                  tables[table[:name]] = d[:out]
-
-                  d[:references].each do |k, v|
-                    references[k] = (references.include?(k) ? references[k] : 0) + v
-                  end
-                end
-              end
-
-              references = references.sort_by { |k, v| -v }.to_h #each{|m| r[m[0]] = m[1]}
-
-              r = references.sort_by { |k, v|
-                k = k[0]
-                relation = all_tables.key?(k) ? all_tables[k][:properties].map { |s| s[:references] }.compact.first : nil
-
-                a = references.keys.index(k)
-                b = references.keys.index(relation)
-                b = 0 if b.nil?
-                a = 0 if a.nil?
-
-                b = a + b if b < a
-
-                b
-              }
-
-              references = r.to_h
-
-              if type.eql?(:sql)
-                all_keys = references.keys
-                t = tables.sort_by { |k, v| all_keys.include?(k) ? all_keys.index(k) : 0 }
-                out += t.map { |m| m[1] }.join("\n")
               end
 
-              #              ::File.open("#{ConfigFile[:cache]}/test.json", 'wb') {|f| f.puts references.to_json}
-
-              out += relations.sort.uniq.join("\n")
-              out += erd_footer(data, type)
-
-              out
-            end
-
-            def erd_header(data, type)
-              header = ''
-
-              case type
-              when :uml
-                header = %(@startuml
-skinparam classFontSize 14
-!define LIGHTORANGE
-skinparam groupInheritance 1
-skinparam componentStyle uml2
-skinparam wrapMessageWidth 100
-skinparam ArrowColor #Maroon
-skinparam linetype ortho
-
-title #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}
-
-package #{data[:ontologies][:base][:prefix]} {
-)
-              when :sql
-                graph_prefix = data[:ontologies][:base][:prefix]
-                header = %(--
--- #{data[:metadata][:title]} - #{data[:metadata][:version]} - #{Time.now}
--- description: #{data[:metadata][:description]}
--- author: #{data[:metadata][:author]}
---
-
-
-CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-DROP SCHEMA IF EXISTS #{graph_prefix} CASCADE;
-CREATE SCHEMA #{graph_prefix};
-
-
-)
-              end
-
-              header
-            end
-
-            def erd_footer(_data, type = :uml)
-              footer = ''
-
-              case type
-              when :uml
-                footer = %(
-
-hide circle
-hide methods
-hide empty members
-@enduml
-)
-              when :sql
-                footer = ''
-              end
-
-              footer
+              inflections.to_json
+            rescue StandardError => e
+              puts e.message
             end
 
             def every_entity(data)
@@ -756,20 +583,53 @@ hide empty members
 
               "#{out}\n"
             end
+
+            def spreadsheet_id_from_url(sheet_url)
+              tmp = URI(sheet_url).path.split('/')
+              spreadsheet_id = tmp[tmp.index('d') + 1]
+            end
+          end
+
+          sheet_data = read_sheets(key, spreadsheet_id, options)
+
+          if sheet_data.is_a?(Hash)
+            raise "No _REFERENCES sheet found" unless sheet_data.key?("_REFERENCES")
+          #read other ontologies
+            Solis::LOGGER.info('Reading referenced ontologies')
+            references = sheet_data['_REFERENCES'].map do |reference|
+              {sheet_url: reference['sheeturl'], description: reference['description']}
+            end
+
+            cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
+            ::File.open("#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json", 'wb') do |f|
+              f.puts references.to_json
+            end
+          else
+            references = sheet_data
+          end
+
+          datas = []
+          references.each do |v|
+            sheet_id = spreadsheet_id_from_url(v[:sheet_url])
+
+            sheet_data = read_sheets(key, sheet_id, options)
+            if sheet_data.key?("_PREFIXES")
+              datas << process_sheet(key, sheet_id, sheet_data)
+              sleep 30
+            else
+              datas << sheet_data
+            end
           end
 
-          data = read_sheets(key, spreadsheet_id, options)
-
-          shacl = build_shacl(data)
-          plantuml = build_plantuml(data)
-          #plantuml_erd = build_plantuml_erd(data)
-          plantuml_erd = build_erd(data, :uml)
-          schema = build_schema(data)
-          inflections = build_inflections(data)
-          sql = build_erd(data, :sql)
-          #erd = build_erd(data, :uml)
-          { inflections: inflections, shacl: shacl, schema: schema, plantuml: plantuml,
-            plantuml_erd: plantuml_erd, sql: sql }
+          Solis::LOGGER.info('Generating SHACL')
+          shacl = build_shacl(datas)
+          Solis::LOGGER.info('Generating PLANTUML')
+          plantuml = build_plantuml(datas)
+          Solis::LOGGER.info('Generating SCHEMA')
+          schema = build_schema(datas)
+          Solis::LOGGER.info('Generating INFLECTIONS')
+          inflections = build_inflections(datas)
+          { inflections: inflections, shacl: shacl, schema: schema, plantuml: plantuml}
         end
       end
     end

data/lib/solis/shape.rb

@@ -69,6 +69,9 @@ module Solis
             end
           elsif datatype.nil? && node.is_a?(RDF::URI)
             node.value.split('/').last.gsub(/Shape$/, '').to_sym
+            # normalize ex."https://data.q.odis.be/person#Name" to Name
+            #node.value.split('/').last.gsub(/Shape$/, '').split('#').last.to_sym
+            #node.value.split('/').last.gsub(/Shape$/, '').gsub('#','').camelize.to_sym
           elsif datatype =~ /^http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns/
             case datatype
             when /http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#langString/

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.70.0"
+  VERSION = "0.72.0"
 end

data/solis.gemspec

@@ -27,22 +27,23 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'activesupport', '~> 6.1'
+  spec.add_runtime_dependency 'activesupport', '~> 7.0'
   spec.add_runtime_dependency 'http', '~> 5.1'
   spec.add_runtime_dependency 'graphiti', '~> 1.3'
-  spec.add_runtime_dependency 'moneta', '~> 1.4'
-  spec.add_runtime_dependency 'linkeddata', '~> 3.2'
+  spec.add_runtime_dependency 'moneta', '~> 1.6'
+  spec.add_runtime_dependency 'linkeddata', '~> 3.3'
   spec.add_runtime_dependency 'google_drive', '~> 3.0'
-  spec.add_runtime_dependency 'json', '~> 2.5'
+  spec.add_runtime_dependency 'json', '~> 2.6'
   spec.add_runtime_dependency 'hashdiff', '~> 1.0'
   spec.add_runtime_dependency  'iso8601', '~> 0.13.0'
-  spec.add_runtime_dependency  'connection_pool', '~> 2.2.5'
+  spec.add_runtime_dependency  'connection_pool', '~> 2.4'
   spec.add_runtime_dependency  'uuidtools', '~> 2.2.0'
-  spec.add_runtime_dependency  'dry-struct', '~> 1.2'
-  spec.add_runtime_dependency  'psych', '< 4'
+  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.15.0'
+  spec.add_development_dependency  'minitest', '~> 5.19'
 
   #  spec.add_development_dependency  'rubocop'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.70.0
+  version: 0.72.0
 platform: ruby
 authors:
 - Mehmet Celik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-05 00:00:00.000000000 Z
+date: 2024-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
@@ -58,28 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: linkeddata
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: google_drive
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.6'
 - !ruby/object:Gem::Dependency
   name: hashdiff
   requirement: !ruby/object:Gem::Requirement
@@ -142,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.5
+        version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.5
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: uuidtools
   requirement: !ruby/object:Gem::Requirement
@@ -170,28 +170,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: psych
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -212,14 +212,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.15.0
+        version: '5.19'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 5.15.0
+        version: '5.19'
 description: The SUN in latin or is it SILOS spelled backwards. Turn any SHACL file
   or Google sheet into an API, ORM, documentation on top of a data store
 email:
@@ -295,7 +295,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Turn any SHACL file into an API, ORM, documentation, ...