kalimba-redlander 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45a19d6326c2d8dca3240b19980c34f25d4c51cc
+  data.tar.gz: 3d8efb8bc5173956a0ecac4a75bf28452cc4fff8
+SHA512:
+  metadata.gz: d82e2a8077e043f9d37cc15c2e1b3da5bdff50f707fe484e5869792c521ad9b229a02585d15022e8bc167b62b2257efa9cef6b274ec2e563f72d1533d714ccfd
+  data.tar.gz: 74fd9991804fbfa4cb9f30a1fcd65cb8d259e9cf10850be9f184a092b79a0fed4e0d4ba5ad5c65f2fc39e7b1df64568001adf9716ed02aa4b26b8bb88b2a99d1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012, 2013 Slava Kravchenko
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/kalimba/persistence/redlander.rb

@@ -0,0 +1,261 @@
+require "redlander"
+require "kalimba/persistence"
+
+module Kalimba
+  module Persistence
+    # Mapping of database options from Rails' database.yml
+    # to those that Redland::Model expects
+    REPOSITORY_OPTIONS_MAPPING = {
+      "adapter" => :storage,
+      "database" => :name
+    }
+
+    class << self
+      def backend
+        Kalimba::Persistence::Redlander
+      end
+
+      def repository(options = {})
+        ::Redlander::Model.new(remap_options(options))
+      end
+
+      private
+
+      def remap_options(options = {})
+        options = Hash[options.map {|k, v| [REPOSITORY_OPTIONS_MAPPING[k] || k, v] }].symbolize_keys
+        options[:storage] =
+          case options[:storage]
+          when "sqlite3"
+            "sqlite"
+          else
+            options[:storage]
+          end
+
+        options
+      end
+    end
+
+    # Redlander-based persistence module
+    module Redlander
+      extend ActiveSupport::Concern
+      include Kalimba::Persistence
+
+      module ClassMethods
+        def find_each(options = {})
+          if block_given?
+            attributes = (options[:conditions] || {}).stringify_keys
+
+            q = "SELECT ?subject WHERE { #{resource_definition} . #{attributes_to_graph_query(attributes)} }"
+            q << " LIMIT #{options[:limit]}" if options[:limit]
+
+            logger.debug(q) if logger
+
+            Kalimba.repository.query(q) do |binding|
+              yield self.for(binding["subject"].uri.fragment)
+            end
+          else
+            enum_for(:find_each, options)
+          end
+        end
+
+        def find_by_id(id_value)
+          record = self.for(id_value)
+          record.new_record? ? nil : record
+        end
+
+        def exist?(attributes = {})
+          attributes = attributes.stringify_keys
+          q = "ASK { #{resource_definition} . #{attributes_to_graph_query(attributes)} }"
+          logger.debug(q) if logger
+          Kalimba.repository.query(q)
+        end
+
+        def create(attributes = {})
+          record = new(attributes)
+          record.save
+          record
+        end
+
+        def destroy_all
+          logger.debug("destroying all #{self.name.pluralize}") if logger
+          Kalimba.repository.transaction do
+            Kalimba.repository.statements.each(:predicate => NS::RDF["type"], :object => type) do |statement|
+              Kalimba.repository.statements.delete_all(:subject => statement.subject)
+            end
+          end
+        end
+
+        def count(attributes = {})
+          q = "SELECT (COUNT(?subject) AS _count) WHERE { #{resource_definition} . #{attributes_to_graph_query(attributes.stringify_keys)} }"
+          logger.debug(q) if logger
+
+          # using SPARQL 1.1, because SPARQL 1.0 does not support COUNT
+          c = Kalimba.repository.query(q, :language => "sparql")[0]
+          c ? c["_count"].value : 0
+        end
+
+
+        private
+
+        def resource_definition
+          if type
+            [ "?subject", ::Redlander::Node.new(NS::RDF['type']), ::Redlander::Node.new(type) ].join(" ")
+          else
+            raise KalimbaError, "resource is missing type declaration"
+          end
+        end
+
+        def attributes_to_graph_query(attributes = {})
+          attributes.map { |name, value|
+            if value.is_a?(Enumerable)
+              value.map { |v| attributes_to_graph_query(name => v) }.join(" . ")
+            else
+              [ "?subject",
+                ::Redlander::Node.new(properties[name][:predicate]),
+                ::Redlander::Node.new(value)
+              ].join(" ")
+            end
+          }.join(" . ")
+        end
+      end
+
+      def new_record?
+        !(destroyed? || persisted?)
+      end
+
+      def persisted?
+        !subject.nil? && Kalimba.repository.statements.exist?(:subject => subject)
+      end
+
+      def reload
+        logger.debug("reloading #{self.inspect}") if logger
+        self.class.properties.each { |name, _| attributes[name] = retrieve_attribute(name) }
+        self
+      end
+
+      def destroy
+        if !destroyed? && persisted?
+          Kalimba.repository.transaction do
+            logger.debug("destroying #{self.inspect}") if logger
+            Kalimba.repository.statements.delete_all(:subject => subject)
+          end
+          super
+        else
+          false
+        end
+      end
+
+      def save(options = {})
+        @subject ||= generate_subject
+        logger.debug("saving #{self.inspect}") if logger
+        Kalimba.repository.transaction do
+          store_type && store_attributes(options) && super
+        end
+      end
+
+      private
+
+      def read_attribute(name, *args)
+        if changed.include?(name) || !persisted?
+          super
+        else
+          attributes[name] = retrieve_attribute(name)
+        end
+      end
+      alias_method :attribute, :read_attribute
+
+      def write_attribute(name, value)
+        unless changed_attributes.include?(name)
+          orig_value = read_attribute(name)
+          unless value == orig_value
+            orig_value = orig_value.duplicable? ? orig_value.clone : orig_value
+            changed_attributes[name] = orig_value
+          end
+        end
+        attributes[name] = value
+      end
+
+      def store_type
+        st = ::Redlander::Statement.new(subject: subject, predicate: NS::RDF["type"], object: self.class.type)
+        Kalimba.repository.statements.add(st)
+      end
+
+      def store_attributes(options = {})
+        if new_record?
+          attributes.all? { |name, value| value.blank? || store_attribute(name, options) }
+        else
+          changes.all? { |name, _| store_attribute(name, options) }
+        end
+      end
+
+      def retrieve_attribute(name)
+        predicate = self.class.properties[name][:predicate]
+        datatype = self.class.properties[name][:datatype]
+
+        if self.class.properties[name][:collection]
+          Kalimba.repository.statements
+            .all(:subject => subject, :predicate => predicate)
+            .map { |statement| type_cast_from_rdf(statement.object.value, datatype) }
+        else
+          if self.class.localizable_property?(name)
+            retrieve_localizable_property(name, predicate)
+          else
+            statement = Kalimba.repository.statements.first(:subject => subject, :predicate => predicate)
+            statement && type_cast_from_rdf(statement.object.value, datatype)
+          end
+        end
+      end
+
+      def store_attribute(name, options = {})
+        predicate = self.class.properties[name][:predicate]
+
+        Kalimba.repository.statements.delete_all(:subject => subject, :predicate => predicate)
+
+        value = read_attribute(name)
+        if value
+          datatype = self.class.properties[name][:datatype]
+          if self.class.localizable_property?(name)
+            store_localizable_property(name, value, predicate, datatype)
+          elsif self.class.properties[name][:collection]
+            value.to_set.all? { |v| store_single_value(v, predicate, datatype, options) }
+          else
+            store_single_value(value, predicate, datatype, options)
+          end
+        else
+          true
+        end
+      end
+
+      def store_single_value(value, predicate, datatype, options = {})
+        value =
+          # TODO: check for the types that are acceptable by the property,
+          # not the types of values themselves!
+          if value.is_a?(Kalimba::Resource)
+            store_single_resource(value, options)
+          else
+            type_cast_to_rdf(value, datatype)
+          end
+        if value
+          statement = ::Redlander::Statement.new(:subject => subject, :predicate => predicate, :object => ::Redlander::Node.new(value))
+          Kalimba.repository.statements.add(statement)
+        else
+          # if value turned into nil or false upon conversion/typecasting to RDF,
+          # do not count this as an error
+          true
+        end
+      end
+
+      def store_single_resource(resource, options)
+        # avoid cyclic saves
+        if options[:parent_subject] != resource.subject &&
+            must_be_persisted?(resource)
+          resource.save(:parent_subject => subject)
+        end
+      end
+
+      def must_be_persisted?(resource)
+        resource.changed? || resource.new_record?
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: kalimba-redlander
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Slava Kravchenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kalimba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redlander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+description: Redlander adapter for Kalimba. It provides the RDF storage backend for
+  Kalimba.
+email:
+- slava.kravchenko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/kalimba/persistence/redlander.rb
+- LICENSE
+homepage: https://github.com/cordawyn/kalimba-redlander
+licenses:
+- The MIT License (MIT)
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Redlander adapter for Kalimba
+test_files: []
+has_rdoc: