solis 0.97.0 → 0.98.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f85c33684ee96790f112dc77b73fea1a959abc8bdf3a3964e41e4b45fe35245c
-  data.tar.gz: f36f6e68d649e5d09c3e542765e44102714d27c6e7e86202e0380d8bc57311e7
+  metadata.gz: 5b5f53e6ee613f19d1de7527908da768b55623f51f45bdc4ae31ab3ba338a5cc
+  data.tar.gz: d1dfade779a59ad0c36422a20bcc1b8b21fc7c74b75774e1b69be9488050c9ef
 SHA512:
-  metadata.gz: eafffc463e38e575c289e4f3014998111b280d4f3155f6a1dc0057845ec98e7cd2ad09ebe05b7f91dae0dd66da00a9f2160d4093799f62b6fd5508978df5d4a2
-  data.tar.gz: b707d9ff9eab9c56cef17597a9e9694e9df28fcab8133857f726996a063d619f0ba9cfa84cd66be2d567829d5d421ae2b3be4afcfb57c565dadad039dedf9926
+  metadata.gz: ec93a8f1b15c02a1b2b5b52e4f85d0d3058c2528ad73d33d15944e5a3c5609bbfe9e2e83e8ab15efc41c1e98350745903b089cf3902cd2157a3a2aaaeb0f5657
+  data.tar.gz: fd75bb60d80282d6c285b0bb004cdb466a0fa3d6ce2de9960732bb201e5d068c6c4256e7cf560dbf1b67b86371706659f562bc72bb149826285f22cefac6ba84

data/lib/solis/query/result_transformer.rb

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

data/lib/solis/query/run.rb

@@ -1,115 +1,75 @@
 require 'solis/store/sparql/client'
+require 'solis/query/result_transformer'
 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]
-        end
+  def self.run(entity, query, options = {})
+    sparql_client = Solis::Store::Sparql::Client.new(
+      Solis::Options.instance.get[:sparql_endpoint],
+      graph_name: graph_name
+    )
 
-        framed = nil
-        JSON::LD::API.fromRDF(g) do |e|
-          framed = JSON::LD::API.frame(e, context)
-        end
-        result = sanitize_result(framed)
-      else
-        t = []
-        r.each do |s|
-          t << s.to_h
-        end
-        result = sanitize_result({'@graph' => t})
-      end
-      result
-    rescue StandardError => e
-      puts e.message
-      raise e
-    end
+    raw_result = sparql_client.query(query, options)
+    model = options[:model] || nil
 
-    private
+    transform_result(raw_result, entity, model)
+  rescue StandardError => e
+    puts e.message
+    raise e
+  end
 
-    def self.sanitize_result(framed)
-      data = framed&.key?('@graph') ? framed['@graph'] : [framed]
+  private
 
-      sanitatize_data_in_result(data)
+  def self.transform_result(raw_result, entity, model)
+    if raw_result.is_a?(SPARQL::Client)
+      frame_and_transform(raw_result, entity, model)
+    else
+      transform_select_results(raw_result, model)
     end
+  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
-                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) #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
-                else
-                  new_d[k] << (vt.is_a?(String) ? vt : sanitize_result(vt))
-                end
-              end
-              new_d[k].flatten!
-            else
-              new_d[k] = v.class.method_defined?(:value) ? v.value : v
-            end
-          end
-          d = new_d
-        end
+  def self.frame_and_transform(sparql_result, entity, model)
+    graph = build_graph_from_result(sparql_result)
+    context = build_context(entity)
 
-        d
-      end
-    rescue StandardError => e
-      Solis::LOGGER.error(e.message)
-      data
+    framed = nil
+    JSON::LD::API.fromRDF(graph) do |expanded|
+      framed = JSON::LD::API.frame(expanded, context)
     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'] : ''
+    Solis::Query::ResultTransformer.new(model).transform(framed)
+  end
+
+  def self.transform_select_results(raw_result, model)
+    results = raw_result.map(&:to_h)
+    Solis::Query::ResultTransformer.new(model).transform({'@graph' => results})
+  end
+
+  def self.build_graph_from_result(sparql_result)
+    graph = RDF::Graph.new
+    sparql_result.query('select * where{?s ?p ?o}').each do |statement|
+      graph << [statement.s, statement.p, statement.o]
     end
+    graph
+  end
+
+  def self.build_context(entity)
+    JSON.parse(%(
+{
+  "@context": {
+    "@vocab": "#{graph_name}",
+    "id": "@id"
+  },
+  "@type": "#{entity}",
+  "@embed": "@always"
+}
+    ))
+  end
+
+  def self.graph_name
+    graphs = Solis::Options.instance.get[:graphs]
+    raise Solis::Error::NotFoundError, 'No graph name found' if graphs.nil?
+
+    graphs.find { |g| g['type'].eql?(:main) }&.fetch('name') || ''
+  end
 end

data/lib/solis/version.rb

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

metadata

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