rasti-db 0.1.0

data/lib/rasti/db/query.rb

@@ -0,0 +1,113 @@
+module Rasti
+  module DB
+    class Query
+
+      DATASET_CHAINED_METHODS = [:where, :exclude, :and, :or, :order, :reverse_order, :limit, :offset].freeze
+
+      include Enumerable
+      include Helpers::WithSchema
+
+      def initialize(collection_class, dataset, relations=[], schema=nil)
+        @collection_class = collection_class
+        @dataset = dataset
+        @relations = relations
+        @schema = schema
+      end
+
+      def raw
+        dataset.all
+      end
+
+      def pluck(*attributes)
+        ds = dataset.select(*attributes.map { |attr| Sequel.qualify(collection_class.collection_name, attr) })
+        attributes.count == 1 ? ds.map { |r| r[attributes.first] } : ds.map(&:values)
+      end
+
+      def primary_keys
+        pluck collection_class.primary_key
+      end
+
+      def all
+        with_relations(dataset.all).map do |row| 
+          collection_class.model.new row
+        end
+      end
+      alias_method :to_a, :all
+
+      def each(&block)
+        all.each &block
+      end
+
+      DATASET_CHAINED_METHODS.each do |method|
+        define_method method do |*args, &block|
+          Query.new collection_class, 
+                    dataset.send(method, *args, &block), 
+                    relations, 
+                    schema
+        end
+      end
+
+      def graph(*rels)
+        Query.new collection_class, 
+                  dataset, 
+                  (relations | rels), 
+                  schema
+      end
+
+      def count
+        dataset.count
+      end
+
+      def any?
+        count > 0
+      end
+
+      def empty?
+        !any?
+      end
+
+      def first
+        instance = with_relations dataset.first
+        instance ? collection_class.model.new(instance) : nil
+      end
+
+      def last
+        instance = with_relations dataset.last
+        instance ? collection_class.model.new(instance) : nil
+      end
+
+      def to_s
+        "#<#{self.class.name}: \"#{dataset.sql}\">"
+      end
+      alias_method :inspect, :to_s
+
+      private
+
+      def chainable(&block)
+        ds = instance_eval &block
+        Query.new collection_class, ds, relations, schema
+      end
+
+      def with_relations(data)
+        rows = data.is_a?(Array) ? data : [data]
+        Relations.graph_to rows, relations, collection_class, dataset.db, schema
+        data
+      end
+
+      def method_missing(method, *args, &block)
+        if collection_class.queries.key?(method)
+          instance_exec *args, &collection_class.queries[method]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private=false)
+        collection_class.queries.key?(method) || super
+      end
+
+      attr_reader :collection_class, :dataset, :relations, :schema
+
+    end
+  end
+end

data/lib/rasti/db/relations.rb

@@ -0,0 +1,159 @@
+module Rasti
+  module DB
+    module Relations
+
+      class << self
+
+        def graph_to(rows, relations, collection_class, db, schema=nil)
+          return if rows.empty?
+
+          parse(relations).each do |relation, nested_relations|
+            raise "Undefined relation #{relation} for #{collection_class}" unless collection_class.relations.key? relation
+            collection_class.relations[relation].graph_to rows, db, schema, nested_relations
+          end
+        end
+
+        private
+
+        def parse(relations)
+          relations.each_with_object({}) do |relation, hash|
+            tail = relation.to_s.split '.'
+            head = tail.shift.to_sym
+            hash[head] ||= []
+            hash[head] << tail.join('.') unless tail.empty?
+          end
+        end
+
+      end
+
+
+      class Base
+
+        include Sequel::Inflections
+
+        attr_reader :name, :source_collection_class
+
+        def initialize(name, source_collection_class, options={})
+          @name = name
+          @source_collection_class = source_collection_class
+          @options = options
+        end
+
+        def target_collection_class
+          @target_collection_class ||= @options[:collection].is_a?(Class) ? @options[:collection] : Consty.get(@options[:collection] || camelize(pluralize(name)), source_collection_class)
+        end
+
+        def one_to_many?
+          is_a? OneToMany
+        end
+
+        def many_to_one?
+          is_a? ManyToOne
+        end
+
+        def many_to_many?
+          is_a? ManyToMany
+        end
+
+        private
+
+        attr_reader :options
+
+      end
+      
+
+      class OneToMany < Base
+
+        def foreign_key
+          @foreign_key ||= @options[:foreign_key] || source_collection_class.implicit_foreign_key_name
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_rows = target_collection.where(foreign_key => pks)
+                                           .graph(*relations)
+                                           .group_by { |r| r.public_send(foreign_key) }
+
+          rows.each do |row| 
+            row[name] = relation_rows.fetch row[source_collection_class.primary_key], []
+          end
+        end
+
+      end
+
+
+      class ManyToOne < Base
+
+        def foreign_key
+          @foreign_key ||= @options[:foreign_key] || target_collection_class.implicit_foreign_key_name
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          fks = rows.map { |row| row[foreign_key] }.uniq
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_rows = target_collection.where(source_collection_class.primary_key => fks)
+                                           .graph(*relations)
+                                           .each_with_object({}) do |row, hash| 
+                                              hash[row.public_send(source_collection_class.primary_key)] = row
+                                            end
+          
+          rows.each do |row| 
+            row[name] = relation_rows[row[foreign_key]]
+          end
+        end
+
+      end
+
+
+      class ManyToMany < Base
+
+        def source_foreign_key
+          @source_foreign_key ||= @options[:source_foreign_key] || source_collection_class.implicit_foreign_key_name
+        end
+
+        def target_foreign_key
+          @target_foreign_key ||= @options[:target_foreign_key] || target_collection_class.implicit_foreign_key_name
+        end
+
+        def relation_collection_name
+          @relation_collection_name ||= @options[:relation_collection_name] || [source_collection_class.collection_name, target_collection_class.collection_name].sort.join('_').to_sym
+        end
+
+        def qualified_relation_collection_name(schema=nil)
+          schema.nil? ? relation_collection_name : Sequel.qualify(schema, relation_collection_name)
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          pks = rows.map { |row| row[source_collection_class.primary_key] }
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_name = qualified_relation_collection_name schema
+
+          join_rows = target_collection.dataset
+                                       .join(relation_name, target_foreign_key => target_collection_class.primary_key)
+                                       .where(Sequel.qualify(relation_name, source_foreign_key) => pks)
+                                       .all
+
+          Relations.graph_to join_rows, relations, target_collection_class, db, schema
+
+          relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash| 
+            attributes = row.select { |attr,_| target_collection_class.model.attributes.include? attr }
+            hash[row[source_foreign_key]] << target_collection_class.model.new(attributes)
+          end
+
+          rows.each do |row| 
+            row[name] = relation_rows.fetch row[target_collection_class.primary_key], []
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rasti/db/type_converter.rb

@@ -0,0 +1,52 @@
+module Rasti
+  module DB
+    class TypeConverter
+
+      CONVERTIONS = {
+        postgres: {
+          /^json$/         => ->(value, match) { Sequel.pg_json value },
+          /^hstore$/       => ->(value, match) { Sequel.hstore value },
+          /^hstore\[\]$/   => ->(value, match) { Sequel.pg_array value.map { |v| Sequel.hstore v }, 'hstore' },
+          /^([a-z]+)\[\]$/ => ->(value, match) { Sequel.pg_array value, match.captures[0] }
+        }
+      }
+
+      def initialize(db, collection_name)
+        @db = db
+        @collection_name = collection_name
+      end
+
+      def apply_to(attributes)
+        convertions = self.class.convertions_for @db, @collection_name
+
+        return attributes if convertions.empty?
+
+        (attributes.is_a?(Array) ? attributes : [attributes]).each do |attrs|
+          convertions.each do |name, convertion|
+            attrs[name] = convertion[:block].call attrs[name], convertion[:match] if attrs.key? name
+          end
+        end
+
+        attributes
+      end
+
+      @cache ||= {}
+
+      def self.convertions_for(db, collection_name)
+        key = [db.database_type, collection_name]
+        if !@cache.key?(key)
+          columns = Hash[db.schema(collection_name)]
+          @cache[key] = columns.each_with_object({}) do |(name, schema), hash| 
+            CONVERTIONS.fetch(db.database_type, {}).each do |type, convertion|
+              if !hash.key?(name) && match = type.match(schema[:db_type])
+                hash[name] = {match: match, block: convertion}
+              end
+            end
+          end
+        end
+        @cache[key]
+      end
+
+    end
+  end
+end

data/lib/rasti/db/version.rb

@@ -0,0 +1,5 @@
+module Rasti
+  module DB
+    VERSION = '0.1.0'
+  end
+end

data/lib/rasti/db.rb

@@ -0,0 +1,10 @@
+require 'sequel'
+require 'consty'
+
+require_relative 'db/version'
+require_relative 'db/helpers'
+require_relative 'db/query'
+require_relative 'db/collection'
+require_relative 'db/model'
+require_relative 'db/relations'
+require_relative 'db/type_converter'

data/lib/rasti-db.rb

@@ -0,0 +1 @@
+require_relative 'rasti/db'

data/rasti-db.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rasti/db/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rasti-db'
+  spec.version       = Rasti::DB::VERSION
+  spec.authors       = ['Gabriel Naiman']
+  spec.email         = ['gabynaiman@gmail.com']
+  spec.summary       = 'Database collections and relations'
+  spec.description   = 'Database collections and relations'
+  spec.homepage      = 'https://github.com/gabynaiman/rasti-db'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'sequel', '~> 4.38'
+  spec.add_runtime_dependency 'consty', '~> 1.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest-colorin', '~> 0.1'
+  spec.add_development_dependency 'minitest-line', '~> 0.6'
+  spec.add_development_dependency 'simplecov', '~> 0.12'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'pry-nav', '~> 0.2'
+
+  if RUBY_ENGINE == 'jruby'
+    spec.add_development_dependency 'jdbc-sqlite3', '~> 3.8'
+  else
+    spec.add_development_dependency 'sqlite3', '~> 1.3'
+  end
+
+  if RUBY_VERSION < '2'
+    spec.add_development_dependency 'term-ansicolor', '~> 1.3.0'
+    spec.add_development_dependency 'tins', '~> 1.6.0'
+    spec.add_development_dependency 'json', '~> 1.8'
+  end
+end