rasti-db 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa66e94f3945ca058846ce6031b4720516d58646
+  data.tar.gz: 87e086acc3972e6a553aea23e9741a8d74235022
+SHA512:
+  metadata.gz: 6d0add21909af7df516237b904484e65b68042ec9da5f792ecc4c517a63d175fc98a19389ee2ca063f8a028457e9fd0adab0c2f4a46ea323ea93ab3148be8030
+  data.tar.gz: db6e89b5c05617e65aaa07dab882de5376acf0dd3bda0d94001eaf5e24f482772b1fb3d8617c8647aeb72e26aeb5d62ccf15706ab3ea6617872adc0bccc696e7

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: jTZIGdJqN5w1Kph0muxBAXaxDr0C9VZAP

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+rasti-db

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.3.0

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - 2.4.0
+  - jruby
+before_install:
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rasti-db.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Gabriel Naiman
+
+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/README.md

@@ -0,0 +1,161 @@
+# Rasti::DB
+
+[![Gem Version](https://badge.fury.io/rb/rasti-db.svg)](https://rubygems.org/gems/rasti-db)
+[![Build Status](https://travis-ci.org/gabynaiman/rasti-db.svg?branch=master)](https://travis-ci.org/gabynaiman/rasti-db)
+[![Coverage Status](https://coveralls.io/repos/github/gabynaiman/rasti-db/badge.svg?branch=master)](https://coveralls.io/github/gabynaiman/rasti-db?branch=master)
+[![Code Climate](https://codeclimate.com/github/gabynaiman/rasti-db.svg)](https://codeclimate.com/github/gabynaiman/rasti-db)
+[![Dependency Status](https://gemnasium.com/gabynaiman/rasti-db.svg)](https://gemnasium.com/gabynaiman/rasti-db)
+
+Database collections and relations
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rasti-db'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rasti-db
+
+## Usage
+
+### Database connection
+
+```ruby
+DB = Sequel.connect ...
+```
+
+### Database schema
+
+```ruby
+DB.create_table :users do
+  primary_key :id
+  String :name, null: false, unique: true
+end
+
+DB.create_table :posts do
+  primary_key :id
+  String :title, null: false, unique: true
+  String :body, null: false
+  foreign_key :user_id, :users, null: false, index: true
+end
+
+DB.create_table :comments do
+  primary_key :id
+  String :text, null: false
+  foreign_key :user_id, :users, null: false, index: true
+  foreign_key :post_id, :posts, null: false, index: true
+end
+
+DB.create_table :categories do
+  primary_key :id
+  String :name, null: false, unique: true
+end
+
+DB.create_table :categories_posts do
+  foreign_key :category_id, :categories, null: false, index: true
+  foreign_key :post_id, :posts, null: false, index: true
+  primary_key [:category_id, :post_id]
+end
+```
+
+### Models
+
+```ruby
+User     = Rasti::DB::Model[:id, :name, :posts, :comments]
+Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
+Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
+Category = Rasti::DB::Model[:id, :name, :posts]
+```
+
+### Collections
+
+```ruby
+class Users < Rasti::DB::Collection
+  one_to_many :posts
+  one_to_many :comments
+end
+
+class Posts < Rasti::DB::Collection
+  many_to_one :user
+  many_to_many :categories
+  one_to_many :comments
+
+  query :created_by do |user_id| 
+    where user_id: user_id
+  end
+  
+  query :entitled, -> (title) { where title: title }
+
+  query :commented_by do |user_id|
+    chainable do
+      dataset.join(with_schema(:comments), post_id: :id)
+             .where(with_schema(:comments, :user_id) => user_id)
+             .select_all(with_schema(:posts))
+             .distinct
+    end
+  end
+end
+
+class Comments < Rasti::DB::Collection
+  many_to_one :user
+  many_to_one :post
+end
+
+class Categories < Rasti::DB::Collection
+  many_to_many :posts
+end
+
+users      = Users.new DB
+posts      = Posts.new DB
+comments   = Comments.new DB
+categories = Categories.new DB
+```
+
+### Persistence
+
+```ruby
+DB.transaction do
+  id = users.insert name: 'User 1'
+  users.update id, name: 'User updated'
+  users.delete id
+
+  users.bulk_insert [{name: 'User 1'}, {name: 'User 2'}]
+  users.bulk_update(name: 'User updated') { where id: [1,2] }
+  users.bulk_delete { where id: [1,2] }
+end
+```
+
+### Queries
+
+```ruby
+posts.all # => [Post, ...]
+posts.first # => Post
+posts.count # => 1
+posts.where(id: [1,2]) # => [Post, ...]
+posts.where{id > 1}.limit(10).offset(20) } # => [Post, ...]
+posts.graph(:user, :categories, 'comments.user') # => [Post(User, [Categories, ...], [Comments(User)]), ...]
+posts.created_by(1) # => [Post, ...]
+posts.created_by(1).entitled('...').commented_by(2) # => [Post, ...]
+posts.where(id: [1,2]).raw # => [{id:1, ...}, {id:2, ...}]
+posts.where(id: [1,2]).primary_keys # => [1,2]
+posts.where(id: [1,2]).pluck(:id) # => [1,2]
+posts.where(id: [1,2]).pluck(:id, :title) # => [[1, ...], [2, ...]]
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gabynaiman/rasti-db.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.libs << 'lib'
+  t.pattern = ENV['DIR'] ? File.join(ENV['DIR'], '**', '*_spec.rb') : 'spec/**/*_spec.rb'
+  t.verbose = false
+  t.warning = false
+  t.loader = nil if ENV['TEST']
+  ENV['TEST'], ENV['LINE'] = ENV['TEST'].split(':') if ENV['TEST'] && !ENV['LINE']
+  t.options = ''
+  t.options << "--name=/#{ENV['NAME']}/ " if ENV['NAME']
+  t.options << "-l #{ENV['LINE']} " if ENV['LINE'] && ENV['TEST']
+end
+
+task default: :spec
+
+desc 'Pry console'
+task :console do
+  require 'rasti-db'
+  require 'pry'
+  ARGV.clear
+  Pry.start
+end

data/lib/rasti/db/collection.rb

@@ -0,0 +1,263 @@
+module Rasti
+  module DB
+    class Collection
+
+      QUERY_METHODS = (Query::DATASET_CHAINED_METHODS + [:graph, :count, :all, :first]).freeze
+
+      include Helpers::WithSchema
+
+      class << self
+
+        include Sequel::Inflections
+
+        def collection_name
+          @collection_name ||= implicit_collection_name
+        end
+
+        def primary_key
+          @primary_key ||= :id
+        end
+
+        def model
+          if @model.is_a? Class
+            @model
+          elsif @model
+            @model = Consty.get @model, self
+          else
+            @model = Consty.get demodulize(singularize(name)), self
+          end
+        end
+
+        def relations
+          @relations ||= {}
+        end
+
+        def queries
+          @queries ||= {}
+        end
+
+        def implicit_collection_name
+          underscore(demodulize(name)).to_sym
+        end
+
+        def implicit_foreign_key_name
+          "#{singularize(collection_name)}_id".to_sym
+        end
+
+        private
+
+        def set_collection_name(collection_name)
+          @collection_name = collection_name.to_sym
+        end
+
+        def set_primary_key(primary_key)
+          @primary_key = primary_key
+        end
+
+        def set_model(model)
+          @model = model
+        end
+
+        def one_to_many(name, options={})
+          relations[name] = Relations::OneToMany.new name, self, options
+        end
+
+        def many_to_one(name, options={})
+          relations[name] = Relations::ManyToOne.new name, self, options
+        end
+
+        def many_to_many(name, options={})
+          relations[name] = Relations::ManyToMany.new name, self, options
+        end
+
+        def query(name, lambda=nil, &block)
+          queries[name] = lambda || block
+          
+          define_method name do |*args|
+            query.instance_exec *args, &self.class.queries[name]
+          end
+        end
+
+      end
+
+      attr_reader :db, :schema
+
+      def initialize(db, schema=nil)
+        @db = db
+        @schema = schema
+      end
+
+      def dataset
+        db[qualified_collection_name]
+      end
+
+      def insert(attributes)
+        db.transaction do
+          db_attributes = type_converter.apply_to attributes
+          collection_attributes, relations_primary_keys = split_related_attributes db_attributes
+          primary_key = dataset.insert collection_attributes
+          save_relations primary_key, relations_primary_keys
+          primary_key
+        end
+      end
+
+      def bulk_insert(attributes, options={})
+        db_attributes = type_converter.apply_to attributes
+        dataset.multi_insert db_attributes, options
+      end
+
+      def insert_relations(primary_key, relations)
+        relations.each do |relation_name, relation_primary_keys|
+          relation = self.class.relations[relation_name]
+          insert_relation_table relation, primary_key, relation_primary_keys
+        end
+        nil
+      end
+
+      def update(primary_key, attributes)
+        db.transaction do
+          db_attributes = type_converter.apply_to attributes
+          collection_attributes, relations_primary_keys = split_related_attributes db_attributes
+          dataset.where(self.class.primary_key => primary_key).update(collection_attributes) unless collection_attributes.empty?
+          save_relations primary_key, relations_primary_keys
+        end
+        nil
+      end
+
+      def bulk_update(attributes, &block)
+        db_attributes = type_converter.apply_to attributes
+        build_query(&block).instance_eval { dataset.update db_attributes }
+        nil
+      end
+
+      def delete(primary_key)
+        dataset.where(self.class.primary_key => primary_key).delete
+        nil
+      end
+
+      def bulk_delete(&block)
+        build_query(&block).instance_eval { dataset.delete }
+        nil
+      end
+
+      def delete_relations(primary_key, relations)
+        db.transaction do
+          relations.each do |relation_name, relation_primary_keys|
+            relation = self.class.relations[relation_name]
+            delete_relation_table relation, primary_key, relation_primary_keys
+          end
+        end
+        nil
+      end
+
+      def delete_cascade(*primary_keys)
+        db.transaction do
+          delete_cascade_relations primary_keys
+          bulk_delete { |q| q.where self.class.primary_key => primary_keys }
+        end
+        nil
+      end
+
+      def find(primary_key)
+        where(self.class.primary_key => primary_key).first
+      end
+
+      def find_graph(primary_key, *relations)
+        where(self.class.primary_key => primary_key).graph(*relations).first
+      end
+
+      def query
+        Query.new self.class, dataset, [], schema
+      end
+
+      QUERY_METHODS.each do |method|
+        define_method method do |*args, &block|
+          query.public_send method, *args, &block
+        end
+      end
+
+      def exists?(filter=nil, &block)
+        build_query(filter, &block).count > 0
+      end
+
+      def detect(filter=nil, &block)
+        build_query(filter, &block).first
+      end
+
+      private
+
+      def type_converter
+        @type_converter ||= TypeConverter.new db, qualified_collection_name
+      end
+
+      def qualified_collection_name
+        schema.nil? ? self.class.collection_name : Sequel.qualify(schema, self.class.collection_name)
+      end
+      
+      def build_query(filter=nil, &block)
+        raise ArgumentError, 'must specify filter hash or block' if filter.nil? && block.nil?
+        if filter
+          query.where filter
+        else
+          block.arity == 0 ? query.instance_eval(&block) : block.call(query)
+        end
+      end
+
+      def split_related_attributes(attributes)
+        relation_names = self.class.relations.values.select(&:many_to_many?).map(&:name)
+
+        collection_attributes = attributes.reject { |n,v| relation_names.include? n }
+        relations_ids = attributes.select { |n,v| relation_names.include? n }
+
+        [collection_attributes, relations_ids]
+      end
+      
+      def save_relations(primary_key, relations_primary_keys)
+        relations_primary_keys.each do |relation_name, relation_primary_keys|
+          relation = self.class.relations[relation_name]
+          delete_relation_table relation, [primary_key]
+          insert_relation_table relation, primary_key, relation_primary_keys
+        end
+      end
+
+      def delete_cascade_relations(primary_keys)
+        relations = self.class.relations.values
+
+        relations.select(&:many_to_many?).each do |relation|
+          delete_relation_table relation, primary_keys
+        end
+
+        relations.select(&:one_to_many?).each do |relation|
+          relation_collection_name = with_schema(relation.target_collection_class.collection_name)
+          relations_ids = db[relation_collection_name].where(relation.foreign_key => primary_keys)
+                                                      .select(relation.target_collection_class.primary_key)
+                                                      .map(relation.target_collection_class.primary_key)
+
+          target_collection = relation.target_collection_class.new db, schema
+          target_collection.delete_cascade *relations_ids unless relations_ids.empty?
+        end
+      end
+
+      def insert_relation_table(relation, primary_key, relation_primary_keys)
+        relation_collection_name = relation.qualified_relation_collection_name(schema)
+
+        values = relation_primary_keys.map do |relation_pk| 
+          {
+            relation.source_foreign_key => primary_key, 
+            relation.target_foreign_key => relation_pk
+          }
+        end
+
+        db[relation_collection_name].multi_insert values
+      end
+
+      def delete_relation_table(relation, primary_keys, relation_primary_keys=nil)
+        relation_collection_name = relation.qualified_relation_collection_name(schema)
+        ds = db[relation_collection_name].where(relation.source_foreign_key => primary_keys)
+        ds = ds.where(relation.target_foreign_key => relation_primary_keys) if relation_primary_keys
+        ds.delete
+      end
+
+    end
+  end
+end

data/lib/rasti/db/helpers.rb

@@ -0,0 +1,18 @@
+module Rasti
+  module DB
+    module Helpers
+    
+      module WithSchema
+
+        private
+
+        def with_schema(table, field=nil)
+          qualified_table = schema ? Sequel.qualify(schema, table) : table
+          field ? Sequel.qualify(qualified_table, field) : qualified_table
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rasti/db/model.rb

@@ -0,0 +1,105 @@
+module Rasti
+  module DB
+    class Model
+
+      class UninitializedAttributeError < StandardError
+
+        attr_reader :attribute
+
+        def initialize(attribute)
+          @attribute = attribute
+          super "Uninitialized attribute #{attribute}"
+        end
+
+      end
+
+
+      class << self
+
+        def [](*attribute_names)
+          Class.new(self) do
+            attribute *attribute_names
+
+            def self.inherited(subclass)
+              subclass.instance_variable_set :@attributes, attributes.dup
+            end
+          end
+        end
+
+        def attributes
+          @attributes ||= []
+        end
+
+        def model_name
+          name || self.superclass.name
+        end
+
+        def to_s
+          "#{model_name}[#{attributes.join(', ')}]"
+        end
+        alias_method :inspect, :to_s
+
+        private
+
+        def attribute(*names)
+          names.each do |name|
+            raise ArgumentError, "Attribute #{name} already exists" if attributes.include?(name)
+            
+            attributes << name
+
+            define_method name do
+              attributes.key?(name) ? attributes[name] : raise(UninitializedAttributeError, name)
+            end
+          end
+        end
+
+      end
+
+
+      def initialize(attributes)
+        invalid_attributes = attributes.keys - self.class.attributes
+        raise "#{self.class.model_name} invalid attributes: #{invalid_attributes.join(', ')}" unless invalid_attributes.empty?
+        @attributes = attributes
+      end
+
+      def eql?(other)
+        instance_of?(other.class) && to_h.eql?(other.to_h)
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) && to_h == other.to_h
+      end
+
+      def hash
+        attributes.map(&:hash).hash
+      end
+
+      def to_s
+        "#<#{self.class.model_name}[#{attributes.map { |n,v| "#{n}: #{v.inspect}" }.join(', ')}]>"
+      end
+      alias_method :inspect, :to_s
+
+      def to_h
+        self.class.attributes.each_with_object({}) do |name, hash|
+          if attributes.key? name
+            case attributes[name]
+            when Model
+              hash[name] = attributes[name].to_h
+            when Array
+              hash[name] = attributes[name].map do |e|
+                e.is_a?(Model) ? e.to_h : e
+              end
+            else
+              hash[name] = attributes[name]
+            end
+          end
+        end
+      end
+      
+      private
+
+      attr_reader :attributes
+      
+    end
+  end
+end