solis 0.97.0 → 0.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f85c33684ee96790f112dc77b73fea1a959abc8bdf3a3964e41e4b45fe35245c
-  data.tar.gz: f36f6e68d649e5d09c3e542765e44102714d27c6e7e86202e0380d8bc57311e7
+  metadata.gz: 9c57f5cfabe93ada0f5aa3c008ecafa1b130147dfc7ca5b77930362a330a3457
+  data.tar.gz: 7b9854033bb6e4677bde52c4557705f4f48adffe2e0988af33600890c4615984
 SHA512:
-  metadata.gz: eafffc463e38e575c289e4f3014998111b280d4f3155f6a1dc0057845ec98e7cd2ad09ebe05b7f91dae0dd66da00a9f2160d4093799f62b6fd5508978df5d4a2
-  data.tar.gz: b707d9ff9eab9c56cef17597a9e9694e9df28fcab8133857f726996a063d619f0ba9cfa84cd66be2d567829d5d421ae2b3be4afcfb57c565dadad039dedf9926
+  metadata.gz: 6f527bc987723ee900f250c8361a7570df65e3f6238c8ccc560c65097f94e0941a43540222e35e26196f4a70ed94d193040d55f0b2455f38f8ea2b2c39466e2f
+  data.tar.gz: 404047145bf332a80ee0bee495640071137682f009a1a17de7e21b8d531a2b3cf57aec7c704a423366f778c2cc2259267ed1e67f638fc092c38858c611f72a81

data/lib/solis/query/run.rb

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

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.97.0"
+  VERSION = "0.99.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.97.0
+  version: 0.99.0
 platform: ruby
 authors:
 - Mehmet Celik