solis 0.64.0

data/lib/solis/sparql_adaptor.rb

@@ -0,0 +1,318 @@
+require 'graphiti'
+module Solis
+  class SparqlAdaptor < Graphiti::Adapters::Abstract
+    def self.sideloading_classes
+      {
+        has_many: HasMany,
+        belongs_to: BelongsTo,
+        has_one: ::Graphiti::Sideload::HasOne,
+        many_to_many: ::Graphiti::Sideload::ManyToMany,
+        polymorphic_belongs_to: ::Graphiti::Sideload::PolymorphicBelongsTo
+      }
+    end
+
+    def base_scope(*scope)
+      types = ObjectSpace.each_object(Class).select { |klass| klass < self.resource.model}.map{|m| m.name.tableize.pluralize.to_sym}
+      types <<  self.resource.model.name.tableize.pluralize.to_sym if types.empty?
+
+      { type: types, sort: {}, filters: {} }
+    rescue Exception => e
+      types = [self.resource.model.name.tableize.pluralize.to_sym]
+      { type: types, sort: {}, filters: {} }
+    end
+
+    def paginate(scope, current, per)
+      scope.merge!(current_page: current, per_page: per)
+    end
+
+    def count(scope, attr)
+      count = self.resource.model.new().query.paging(scope).filter(scope).sort(scope).count
+      scope[attr] = count
+    end
+
+    def order(scope, att, dir)
+      scope[:sort].merge!({ att => dir })
+      scope
+    end
+
+    def self.default_operators
+      {
+        string: [:eq, :not_eq, :contains],
+        lang_string: [:eq, :not_eq, :contains],
+        integer: [:eq, :not_eq, :gt, :lt],
+        float: [:eq, :not_eq, :gt, :lt],
+        big_decimal: [:eq, :not_eq, :gt, :lt],
+        date: [:eq, :not_eq, :gt, :lt],
+        boolean: [:eq, :not_eq],
+        uuid: [:eq, :not_eq],
+        enum: [:eq],
+        datetime: [:eq, :not_eq, :gt, :lt],
+      }
+    end
+
+
+    def filter(scope, attribute, value, is_not = false, operator = '=')
+      scope[:filters][attribute] = {value: value, operator: operator, is_not: is_not}
+      scope
+    end
+
+    alias :filter_eq :filter
+    alias :filter_string_eq :filter
+    alias :filter_integer_eq :filter
+    alias :filter_float_eq :filter
+    alias :filter_big_decimal_eq :filter
+    alias :filter_date_eq :filter
+    alias :filter_boolean_eq :filter
+    alias :filter_uuid_eq :filter
+    alias :filter_enum_eq :filter
+    alias :filter_datetime_eq :filter
+    alias :filter_lang_string_eq :filter
+
+    def filter_not_eq(scope, attribute, value)
+      filter_eq(scope, attribute, value, true, '=')
+    end
+
+    alias :filter_string_not_eq :filter_not_eq
+    alias :filter_integer_not_eq :filter_not_eq
+    alias :filter_float_not_eq :filter_not_eq
+    alias :filter_big_decimal_not_eq :filter_not_eq
+    alias :filter_date_not_eq :filter_not_eq
+    alias :filter_boolean_not_eq :filter_not_eq
+    alias :filter_uuid_not_eq :filter_not_eq
+    alias :filter_enum_not_eq :filter_not_eq
+    alias :filter_datetime_not_eq :filter_not_eq
+    alias :filter_lang_string_not_eq :filter_not_eq
+
+    def filter_contains(scope, attribute, value)
+      filter_eq(scope, attribute, value, false, '~')
+    end
+
+    alias :filter_string_contains :filter_contains
+    alias :filter_lang_string_contains :filter_contains
+
+    def filter_gt(scope, attribute, value)
+      filter_eq(scope, attribute, value, false, '>')
+    end
+
+    alias :filter_string_gt :filter_gt
+    alias :filter_integer_gt :filter_gt
+    alias :filter_float_gt :filter_gt
+    alias :filter_big_decimal_gt :filter_gt
+    alias :filter_date_gt :filter_gt
+    alias :filter_boolean_gt :filter_gt
+    alias :filter_uuid_gt :filter_gt
+    alias :filter_enum_gt :filter_gt
+    alias :filter_datetime_gt :filter_gt
+
+    def filter_not_gt(scope, attribute, value)
+      filter_eq(scope, attribute, value, true, '>')
+    end
+
+    alias :filter_string_not_gt :filter_not_gt
+    alias :filter_integer_not_gt :filter_not_gt
+    alias :filter_float_not_gt :filter_not_gt
+    alias :filter_big_decimal_not_gt :filter_not_gt
+    alias :filter_date_not_gt :filter_not_gt
+    alias :filter_boolean_not_gt :filter_not_gt
+    alias :filter_uuid_not_gt :filter_not_gt
+    alias :filter_enum_not_gt :filter_not_gt
+    alias :filter_datetime_not_gt :filter_not_gt
+
+    def filter_lt(scope, attribute, value)
+      filter_eq(scope, attribute, value, false, '<')
+    end
+
+    alias :filter_string_lt :filter_lt
+    alias :filter_integer_lt :filter_lt
+    alias :filter_float_lt :filter_lt
+    alias :filter_big_decimal_lt :filter_lt
+    alias :filter_date_lt :filter_lt
+    alias :filter_boolean_lt :filter_lt
+    alias :filter_uuid_lt :filter_lt
+    alias :filter_enum_lt :filter_lt
+    alias :filter_datetime_lt :filter_lt
+
+    def filter_not_lt(scope, attribute, value)
+      filter_eq(scope, attribute, value, true, '<')
+    end
+
+    alias :filter_string_not_lt :filter_not_lt
+    alias :filter_integer_not_lt :filter_not_lt
+    alias :filter_float_not_lt :filter_not_lt
+    alias :filter_big_decimal_not_lt :filter_not_lt
+    alias :filter_date_not_lt :filter_not_lt
+    alias :filter_boolean_not_lt :filter_not_lt
+    alias :filter_uuid_not_lt :filter_not_lt
+    alias :filter_enum_not_lt :filter_not_lt
+    alias :filter_datetime_not_lt :filter_not_lt
+
+    def transaction(*)
+      yield
+    end
+
+    # def destroy(model_instance)
+    #   super
+    # end
+
+    # def save(model_instance)
+    #   pp model_instance
+    # end
+    #
+    # def build(model_class)
+    #   model_class.new
+    # end
+    #
+    # def assign_attributes(model_instance, attributes)
+    #   attributes.each_pair do |key, value|
+    #     model_instance.send(:"#{key}=", value)
+    #   end
+    # end
+
+    # def associate(parent, child, association_name, association_type)
+    #   pp parent, children, association_name, association_type
+    #   super
+    # end
+    #
+    # def associate_all(parent, children, association_name, association_type)
+    #   pp parent, children, association_name, association_type
+    #   super
+    # end
+    #
+    # def disassociate(parent, child, association_name, association_type)
+    #   pp parent, children, association_name, association_type
+    #   super
+    # end
+
+    def resolve(scope)
+      self.resource.model.before_read_proc&.call(scope)
+      query = self.resource.model.new().query.paging(scope).filter(scope).sort(scope)
+      data = query.find_all.map { |m|
+        m
+      }
+      self.resource.model.after_read_proc&.call(data)
+      data
+    end
+
+    # def associate_all(parent, children, association_name, association_type)
+    #   children.each do |c|
+    #     associate(parent, c, association_name, association_type)
+    #   end
+    # end
+
+    # geeft fout als associate super gebruikt wordt
+    # http://127.0.0.1:9292/autocirculaties?filter%5Bgebruiker_id%5D%5Beq%5D=1221&include=uitleenformaat,wat_uitlenen
+    def associate(parent, child, association_name, association_type)
+      if activerecord_associate?(parent, child, association_name)
+        activerecord_adapter.associate \
+            parent, child, association_name, association_type
+      elsif [:has_many, :many_to_many].include?(association_type)
+        if parent.send(:"#{association_name}").nil?
+          parent.send(:"#{association_name}=", [child])
+        else
+          parent_child_data = parent.send(:"#{association_name}")
+
+          if parent_child_data.is_a?(Array)
+            parent_child_data = parent_child_data.map do |m|
+              m.id.eql?(child.id) ? child : m
+            end
+          else
+            if parent_child_data.id.eql?(child.id)
+              parent_child_data = [child]
+            # else
+            #   parent_child_data = nil
+            end
+          end
+
+          parent.send(:"#{association_name}=", parent_child_data)
+          #parent.send(:"#{association_name}") << child
+        end
+      else
+        parent_child_data = parent.send(:"#{association_name}")
+
+        if parent_child_data.is_a?(Array)
+          parent_child_data = parent_child_data.map do |m|
+            m.id.eql?(child.id) ? child : m
+          end
+        else
+          if parent_child_data&.id.eql?(child.id)
+            parent_child_data = [child]
+          else
+            parent_child_data = nil
+          end
+        end
+
+        parent.send(:"#{association_name}=", parent_child_data)
+      end
+    end
+  end
+
+  class BelongsTo < Graphiti::Sideload::BelongsTo
+    def load_params(parents, query)
+      query.hash.tap do |hash|
+        hash[:filter] ||= {}
+        unless hash[:filter].include?(:id)
+          all_ids = parents.map{|m| m.instance_variable_get("@#{query.association_name.to_s}")}.flatten.map{|m| m.instance_variable_get("@#{primary_key}")}.uniq.compact.join(',')
+
+          hash[:filter].merge!({primary_key => all_ids})
+        end
+      end
+    end
+
+    private
+
+    # relations are included here
+    def children_for(parent, map)
+      map.values
+    end
+
+    # def child_map(children)
+    #   children.index_by(&primary_key)
+    # end
+    #
+    # def children_for(parent, map)
+    #   fk = parent.send(name).send(foreign_key) rescue nil #TODO: this is bad
+    #   children = map[fk]
+    #   return children if children
+    #
+    #   keys = map.keys
+    #   if fk.is_a?(String) && keys[0].is_a?(Integer)
+    #     fk = fk.to_i
+    #   elsif fk.is_a?(Integer) && keys[0].is_a?(String)
+    #     fk = fk.to_s
+    #   end
+    #   map[fk] || []
+    # end
+  end
+
+
+  class HasMany  < Graphiti::Sideload::HasMany
+    def inverse_filter
+      @inverse_filter || foreign_key
+    end
+
+    def load_params(parents, query)
+      query.hash.tap do |hash|
+        hash[:filter] ||= {}
+        unless hash[:filter].include?(:id)
+          all_ids = parents.map{|m| m.instance_variable_get("@#{query.association_name.to_s}")}.flatten.map{|m| m.instance_variable_get("@#{primary_key}")}.uniq.compact.join(',')
+
+          hash[:filter].merge!({primary_key => all_ids})
+        end
+      end
+    end
+
+    def children_for(parent, map)
+      map.values.flatten
+    end
+
+    def link_filter(parents)
+      {inverse_filter => parent_filter(parents)}
+    end
+
+    private
+
+    def parent_filter(parents)
+      ids_for_parents(parents).join(",")
+    end
+  end
+end

data/lib/solis/store/sparql/client/query.rb

@@ -0,0 +1,35 @@
+module Solis
+  module Store
+    module Sparql
+      class Client
+        class Query
+          def initialize(client)
+            @client = client
+          end
+
+          def run(query)
+            result = @client.query(query)
+
+            if is_construct?(query)
+              repository = RDF::Repository.new
+              result.each { |s| repository << [s[:s], s[:p], s[:o]] }
+              result = SPARQL::Client.new(repository)
+            end
+
+            result
+          end
+
+          private
+
+          def is_construct?(query)
+            query =~ /construct/i
+          end
+
+          def is_insert?(query)
+            query =~ /insert/i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solis/store/sparql/client.rb

@@ -0,0 +1,41 @@
+require 'http'
+require 'connection_pool'
+require 'sparql'
+require_relative 'client/query'
+
+module Solis
+  module Store
+    module Sparql
+      class Client
+        def initialize(endpoint, graph_name)
+          @endpoint = endpoint
+          @graph_name = graph_name
+
+          @pool = ConnectionPool.new(size:5, timeout: 60) do
+            SPARQL::Client.new(@endpoint, graph: @graph_name)
+            #SPARQL::Client.new(@endpoint)
+          end
+        end
+
+        def up?
+          result = nil
+          @pool.with do |c|
+            result = c.query("ASK WHERE { ?s ?p ?o }")
+          end
+          result
+        rescue HTTP::Error => e
+          return false
+        end
+
+        def query(query)
+          raise Solis::Error::NotFoundError, "Server or graph(#{@graph_name} not found" unless up?
+          result = nil
+          @pool.with do |c|
+            result = Query.new(c).run(query)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/solis/version.rb

@@ -0,0 +1,3 @@
+module Solis
+  VERSION = "0.64.0"
+end

data/lib/solis.rb

@@ -0,0 +1,13 @@
+require "bundler"
+Bundler.require
+
+require 'logger'
+require "solis/version"
+require 'solis/config_file'
+require "solis/error"
+require 'solis/graph'
+require 'solis/shape'
+
+module Solis
+  LOGGER = Logger.new(STDOUT)
+end

data/solis.gemspec

@@ -0,0 +1,50 @@
+require_relative 'lib/solis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'solis'
+  spec.version       = Solis::VERSION
+  spec.authors       = ['Mehmet Celik']
+  spec.email         = ['mehmet@celik.be']
+
+  spec.summary       = 'Creates a SHACL, RDF, PlantUML file from a Google sheet and a layer ontop of a data store(RDBMS, Triple store)'
+  spec.description   = 'The SUN in latin or is it SILOS spelled backwards. Creates a SHACL, RDF, PlantUML file from a Google sheet and a layer ontop of a data store(RDBMS, Triple store)'
+  spec.homepage      = 'https://github.com/mehmetc/solis'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/mehmetc/solis'
+  spec.metadata['changelog_uri'] = 'https://github.com/mehmetc/solis'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  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 '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 'google_drive', '~> 3.0'
+  spec.add_runtime_dependency 'json', '~> 2.5'
+  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  'uuidtools', '~> 2.2.0'
+  spec.add_runtime_dependency  'dry-struct', '~> 1.2'
+  spec.add_runtime_dependency  'psych', '< 4'
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency  'minitest', '~> 5.15.0'
+
+  #  spec.add_development_dependency  'rubocop'
+
+  #  spec.add_development_dependency 'webmock'
+end