solis 0.64.0

data/lib/solis/config_file.rb

@@ -0,0 +1,91 @@
+#encoding: UTF-8
+
+require 'yaml'
+
+module Solis
+class ConfigFile
+  @config = {}
+  @config_file_path = ''
+  @config_file_name = 'config.yml'
+
+  def self.version
+    "0.0.4"
+  end
+
+  def self.name
+    @config_file_name
+  end
+
+  def self.name=(config_file_name)
+    @config_file_name = config_file_name
+  end
+
+  def self.path
+    @config_file_path
+  end
+
+  def self.path=(config_file_path)
+    @config_file_path = File.absolute_path(config_file_path)
+  end
+
+  def self.[](key)
+    init
+    @config[key]
+  end
+
+  def self.[]=(key,value)
+    init
+    @config[key] = value
+    File.open("#{path}/#{name}", 'w') do |f|
+      f.puts @config.to_yaml
+    end
+  end
+
+  def self.include?(key)
+    init
+    @config.include?(key)
+  end
+
+  def self.config
+    init
+    @config
+  end
+
+  private
+
+  def self.init
+    discover_config_file_path
+    if @config.empty?
+      config = YAML::load_file("#{path}/#{name}")
+      @config = process(config)
+    end
+  end
+
+  def self.discover_config_file_path
+    @config_file_path = ENV['CONFIG_FILE_PATH'] || '' if path.nil? || path.empty?
+    if @config_file_path.nil? || @config_file_path.empty?
+      if File.exist?(@config_file_name)
+        @config_file_path = '.'
+      elsif File.exist?("config/#{@config_file_name}")
+        @config_file_path = 'config'
+      end
+    end
+
+    #puts "#{@config_file_name} found at #{@config_file_path}"
+  end
+
+  def self.process(config)
+    new_config = {}
+    config.each do |k,v|
+
+      if config[k].is_a?(Hash)
+        v = process(v)
+      end
+#      config.delete(k)      
+      new_config.store(k.to_sym, v)
+    end
+
+    new_config
+  end
+end
+end

data/lib/solis/error/cursor_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class CursorError < StandardError
+    end
+  end
+end

data/lib/solis/error/general_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class GeneralError < StandardError
+    end
+  end
+end

data/lib/solis/error/invalid_attribute_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class InvalidAttributeError < StandardError
+    end
+  end
+end

data/lib/solis/error/invalid_datatype_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class InvalidDatatypeError < StandardError
+    end
+  end
+end

data/lib/solis/error/not_found_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class NotFoundError < StandardError
+    end
+  end
+end

data/lib/solis/error/query_error.rb

@@ -0,0 +1,6 @@
+module Solis
+  module Error
+    class QueryError < StandardError
+    end
+  end
+end

data/lib/solis/error.rb

@@ -0,0 +1,3 @@
+Dir.glob("#{File.dirname(__FILE__)}/error/**.rb") do |dir|
+  require dir
+end

data/lib/solis/graph.rb

@@ -0,0 +1,360 @@
+require 'graphiti'
+require 'moneta'
+require 'active_support/all'
+require 'uri'
+
+require_relative 'shape'
+require_relative 'model'
+require_relative 'resource'
+require_relative 'options'
+
+module Solis
+  class Graph
+    attr_accessor :options, :default_before_read, :default_after_read, :default_before_create, :default_after_create, :default_before_update, :default_after_update, :default_before_delete, :default_after_delete
+
+    def initialize(graph, options = {})
+      raise "Please provide a graph_name, graph_prefix and sparql_endpoint option" if options.nil? || options.empty?
+      cloned_options = options.clone
+
+      Solis::Options.instance.set = options
+
+      @global_resource_stack = []
+      @graph = graph
+      @graph_name = cloned_options.delete(:graph_name) || '/'
+      @graph_prefix = cloned_options.delete(:graph_prefix) || 'pf0'
+      @sparql_endpoint = cloned_options.delete(:sparql_endpoint) || nil
+
+      if cloned_options&.key?(:hooks) && cloned_options[:hooks].is_a?(Hash)
+        hooks = cloned_options[:hooks]
+
+        if hooks.key?(:read)
+          if hooks[:read].key?(:before)
+            @default_before_read = hooks[:read][:before]
+          end
+
+          if hooks[:read].key?(:after)
+            @default_after_read = hooks[:read][:after]
+          end
+        end
+
+        if hooks.key?(:create)
+          if hooks[:create].key?(:before)
+            @default_before_create = hooks[:create][:before]
+          end
+
+          if hooks[:create].key?(:after)
+            @default_after_create = hooks[:create][:after]
+          end
+        end
+
+        if hooks.key?(:update)
+          if hooks[:update].key?(:before)
+            @default_before_update = hooks[:update][:before]
+          end
+
+          if hooks[:update].key?(:after)
+            @default_after_update = hooks[:update][:after]
+          end
+        end
+
+        if hooks.key?(:delete)
+          if hooks[:delete].key?(:before)
+            @default_before_delete = hooks[:delete][:before]
+          end
+          if hooks[:delete].key?(:after)
+            @default_after_delete = hooks[:delete][:after]
+          end
+        end
+      end
+
+      unless @sparql_endpoint.nil?
+        uri = URI.parse(@sparql_endpoint)
+        @sparql_endpoint = RDF::Repository.new(uri: RDF::URI(@graph_name), title: uri.host) if uri.scheme.eql?('repository')
+      end
+
+      @inflections = cloned_options.delete(:inflections) || nil
+      @shapes = Solis::Shape.from_graph(graph)
+      @language = cloned_options.delete(:language) || 'en'
+
+      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|
+          ActiveSupport::Inflector.inflections.irregular(s, p)
+        end
+      end
+
+      @shape_tree = {}
+      shape_keys = @shapes.map do |shape_name, _|
+        if shape_name.empty?
+          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 }
+      end
+      shape_keys += @shapes.keys
+      shape_keys = shape_keys.flatten.compact.sort.uniq
+
+      shape_keys.each do |shape_name|
+        d = @shape_tree.key?(shape_name) ? @shape_tree[shape_name] : 0
+        d += 1
+        @shape_tree[shape_name] = d
+      end
+
+      @shape_tree = @shape_tree.sort_by(&:last).reverse.to_h
+
+      shape_keys.each do |s|
+        shape_as_model(s)
+      end
+
+      @shape_tree.each do |shape_name, _|
+        shape_as_resource(shape_name)
+      end
+
+      Graphiti.configure do |config|
+        config.pagination_links = true
+        config.context_for_endpoint= ->(path, action) {
+          Solis::NoopEndpoint.new(path, action)
+        }
+      end
+
+      Graphiti.setup!
+    end
+
+    def list_shapes
+      @shapes.keys.sort
+    end
+
+    def shape?(key)
+      @shapes.key?(key)
+    end
+
+    def jsonapi_schema
+      Graphiti::Schema.generate.to_json
+    end
+
+    def shape_as_model(shape_name)
+      raise Solis::Error::NotFoundError, "'#{shape_name}' not found. Available classes are #{list_shapes.join(', ')}" unless shape?(shape_name)
+      return Object.const_get(shape_name) if Object.const_defined?(shape_name)
+
+      LOGGER.info("Creating model #{shape_name}")
+      attributes = @shapes[shape_name][:attributes].keys.map { |m| m.to_sym }
+
+      model = nil
+      parent_model = nil
+      if @shapes[shape_name].key?(:target_node) && @shapes[shape_name][:target_node].value =~ /^#{@graph_name}(.*)Shape$/
+        parent_shape_model = $1
+        parent_model = shape_as_model(parent_shape_model)
+
+        model = Object.const_set(shape_name, ::Class.new(parent_model) do
+          attr_accessor(*attributes)
+        end)
+      else
+        model = Object.const_set(shape_name, ::Class.new(Solis::Model) do
+          attr_accessor(*attributes)
+        end)
+      end
+
+      model.graph_name = @graph_name
+      model.graph_prefix = @graph_prefix
+      model.shapes = @shapes
+      model.metadata = @shapes[shape_name]
+      #model.language = Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || @language || 'en'
+      unless parent_model.nil?
+        parent_model.metadata[:attributes].each do |k, v|
+          unless model.metadata[:attributes].key?(k)
+            model.metadata[:attributes][k] = v
+          end
+        end
+      end
+      model.sparql_endpoint = @sparql_endpoint
+      model.graph = self
+
+      model.model_before_read do |original_class|
+        @default_before_read.call(original_class)
+      end if @default_before_read
+
+      model.model_after_read do |persisted_class|
+        @default_after_read.call(persisted_class)
+      end if @default_after_read
+
+      model.model_before_create do |original_class|
+        @default_before_create.call(original_class)
+      end if @default_before_create
+
+      model.model_after_create do |persisted_class|
+        @default_after_create.call(persisted_class)
+      end if @default_after_create
+
+      model.model_before_update do |original_class, updated_class|
+        @default_before_update.call(original_class, updated_class)
+      end if @default_before_update
+
+      model.model_after_update do |updated_class, persisted_class|
+        @default_after_update.call(updated_class, persisted_class)
+      end if @default_after_update
+
+      model.model_before_delete do |updated_class|
+        @default_before_delete.call(updated_class)
+      end if @default_before_delete
+
+      model.model_after_delete do |persisted_class|
+        @default_after_delete.call(persisted_class)
+      end if @default_after_delete
+
+      model
+    end
+
+    def shape_as_resource(shape_name, stack_level = [])
+      model = shape_as_model(shape_name)
+      resource_name = "#{shape_name}Resource"
+
+      raise Solis::Error::NotFoundError, "#{shape_name} not found. Available classes are #{list_shapes.join(', ')}" unless shape?(shape_name)
+      return Object.const_get(resource_name) if Object.const_defined?(resource_name)
+
+      LOGGER.info("Creating resource #{resource_name}")
+
+      attributes = @shapes[shape_name][:attributes].select { |_, metadata| metadata.key?(:node_kind) && metadata[:node_kind].nil? }
+
+      relations = @shapes[shape_name][:attributes].select { |_, metadata| metadata.key?(:node_kind) && !metadata[:node_kind].nil? }
+
+      @global_resource_stack << resource_name
+      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', '')
+        shape_as_resource(relation_shape, stack_level << relation_shape) unless stack_level.include?(relation_shape)
+      end
+
+      description = @shapes[shape_name][:comment]
+      parent_resource = Resource
+      descendants = ObjectSpace.each_object(Class).select { |klass| klass < model }.map { |m| "#{m.to_s}Resource" }
+
+      graph = self
+
+      #Resource
+      if Object.const_defined?(resource_name)
+        resource = Object.const_get(resource_name)
+      else
+        ###################
+        # Define new resource
+        resource = Object.const_set(resource_name, ::Class.new(Resource) do
+          if descendants.length > 0
+            self.polymorphic = descendants
+            self.polymorphic << resource_name
+            self.polymorphic.uniq!
+          end
+
+          self.model = model
+          self.type = model.name.demodulize.underscore.pluralize.to_sym
+          self.description = description
+
+          attributes.each do |key, metadata|
+            next if key.nil? || key.empty?
+            if key.eql?('id')
+              attribute key.to_sym, :uuid, description: metadata[:comment]
+            else
+              if (metadata[:maxcount] && metadata[:maxcount] > 1 || metadata[:maxcount].nil?) && ![:boolean, :hash, :array].include?(metadata[:datatype])
+                datatype = "array_of_#{metadata[:datatype]}s".to_sym
+              else
+                datatype = metadata[:datatype]
+              end
+              LOGGER.info "\t#{resource_name}.#{key}(#{datatype})"
+              attribute key.to_sym, datatype, description: metadata[:comment]
+            end
+          end
+        end)
+
+        relations.each do |key, value|
+          #          next if value[:datatype].to_s.classify.eql?(shape_name) #why skip self relations...
+          if (value[:mincount] && value[:mincount] > 1 || value[:mincount].nil?) || (value[:maxcount] && value[:maxcount] > 1 || value[:maxcount].nil?)
+            belongs_to_resource_name = value[:datatype].nil? ? value[:class].value.gsub(self.model.graph_name, '') : value[:datatype].to_s.tableize.classify
+            LOGGER.info "\t\t\t#{resource_name}(#{resource_name.gsub('Resource','').tableize.singularize}) belongs_to #{belongs_to_resource_name}(#{key})"
+            resource.belongs_to(key.to_sym, foreign_key: :id, resource: graph.shape_as_resource("#{belongs_to_resource_name}", stack_level << belongs_to_resource_name)) do
+              #resource.attribute key.to_sym, :string, only: [:filterable]
+
+              link do |resource|
+                remote_resources = resource.instance_variable_get("@#{key}")
+                if remote_resources
+                  remote_resources = [remote_resources] unless remote_resources.is_a?(Array)
+                  remote_resources = remote_resources.map do |remote_resource|
+                    resource_id = remote_resource.id =~ /^http/ ? remote_resource.id.split('/').last : remote_resource.id
+                    #"/#{key.tableize}/#{resource_id}"
+                    "#{resource.class.graph_name.gsub(/\/$/,'')}/#{belongs_to_resource_name.tableize}/#{resource_id}"
+                  end
+
+                  #    return remote_resources.length == 1 ? remote_resources.first : remote_resources
+                end
+
+                remote_resources.first if remote_resources #belongs_to
+              end
+            end
+          else
+            has_many_resource_name = value[:datatype].nil? ? value[:class].gsub(self.model.graph_name, '') : value[:datatype].to_s.classify
+            LOGGER.info "\t\t\t#{resource_name}(#{resource_name.gsub('Resource','').tableize.singularize}) has_many #{has_many_resource_name}(#{key})"
+            resource.has_many(key.to_sym, foreign_key: :id, primary_key: :id, resource: graph.shape_as_resource("#{has_many_resource_name}", stack_level << has_many_resource_name)) do
+
+              belongs_to_resource = graph.shape_as_resource("#{has_many_resource_name}")
+
+              belongs_to_resource.belongs_to(resource.model.name.tableize.singularize, foreign_key: :id, primary_key: :id, resource: graph.shape_as_resource(resource.model.name)) do
+                link do |resource|
+                  remote_resources = resource.instance_variable_get("@#{shape_name.tableize.singularize}")
+                  if remote_resources
+                    remote_resources = [remote_resources] unless remote_resources.is_a?(Array)
+                    remote_resources = remote_resources.map do |remote_resource|
+                      resource_id = remote_resource.id =~ /^http/ ? remote_resource.id.split('/').last : remote_resource.id
+                      #"/#{key.tableize}/#{resource_id}"
+                      "#{resource.class.graph_name.gsub(/\/$/,'')}/#{belongs_to_resource.name.tableize}/#{resource_id}"
+                    end
+
+                    # return remote_resources.length == 1 ? remote_resources.first : remote_resources
+                  end
+                  remote_resources if remote_resources #has_many_belongs_to
+                end
+              end
+              #
+              link do |resource|
+                remote_resources = resource.instance_variable_get("@#{key}")
+                if remote_resources
+                  remote_resources = [remote_resources] unless remote_resources.is_a?(Array)
+                  remote_resources = remote_resources.map do |remote_resource|
+                    resource_id = remote_resource.id =~ /^http/ ? remote_resource.id.split('/').last : remote_resource.id
+                    #"/#{key.tableize}/#{resource_id}"
+                    "#{resource.class.graph_name.gsub(/\/$/,'')}/#{remote_resource.name.tableize}/#{resource_id}"
+                  end
+
+                  #return remote_resources.length == 1 ? remote_resources.first : remote_resources
+                end
+                remote_resources.first if remote_resources
+              end
+            end
+          end
+
+          resource.filter :"#{key}_id", :string, single: true, only: [:eq, :not_eq] do
+            eq do |scope, filter_value|
+              scope[:filters][key.to_sym] = filter_value
+              scope
+            end
+
+            not_eq do |scope, filter_value|
+              scope[:filters][key.to_sym] = {value: [filter_value], operator: '=', is_not: true}
+              scope
+            end
+          end
+
+        end
+      end
+      resource.sparql_endpoint = @sparql_endpoint
+      resource.endpoint_namespace = "#{resource.model.graph_name.gsub(/\/$/,'')}#{Solis::Options.instance.get[:base_path]}"
+      resource
+    end
+
+    def flush_all(graph_name=nil, force = false)
+      raise Solis::Error::NotFoundError, "Supplied graph_name '#{graph_name}' does not equal graph name defined in config file '#{@graph_name}', set force to true" unless graph_name.eql?(@graph_name) && !force
+
+      @sparql_client = SPARQL::Client.new(@sparql_endpoint)
+      result = @sparql_client.query("with <#{graph_name}> delete {?s ?p ?o} where{?s ?p ?o}")
+      LOGGER.info(result.first.to_a.first.last.value)
+      true
+    end
+
+  end
+end