solis 0.71.0 → 0.72.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16ed244eaf62cd747c1e2c2ea369066dcd6a03e529d3932916b4f7791a29b956
-  data.tar.gz: ef2a72fd541967ccf54ae75ca4f18abb21727cf9398c4da38b9aff3a8b9b5ca7
+  metadata.gz: fa7c729b1acbe8c1881ebf3cc00ac228830bf04d269447f55b2f029c7eef703c
+  data.tar.gz: 81ceb99f9f6284b8c4163bfe4d263f6703edbe1733eb42fcc6c31530be2c8d91
 SHA512:
-  metadata.gz: b955562d76f6ca7942d634098b430c4e19c21c64323c8c676fcacbc494949b9d38aaf6d271c197fd3e8ed49bf200534c1ab473fd56aa883d3bbeda9136482427
-  data.tar.gz: f80157b099693522c7afa1a0ce607d174ab164a76ad94a69f359a8331588a858710b3a98ee2360cc6d10ef8e7c1299383eb7a129eac7c94773295bc95604fae1
+  metadata.gz: 6a5fe949952a2931c1189644690446ddc0b63ca719eb2f4b15f5cab83779d81b50872c3b57d4b677278cc4c6ca1e54ff8f14ff4b8c09ce842e8e5a3226835177
+  data.tar.gz: 03af55e0505d6e987522e8d799450be43a83b9968c60f7741b7c5bb2d75f0874d7d127b955f31ad028a35b2993b2ecdefb91653edf5e9941c4e7dfc796658696

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

@@ -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.72.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.72.0
 platform: ruby
 authors:
 - Mehmet Celik
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-22 00:00:00.000000000 Z
+date: 2024-02-28 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, ...