epiphy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c60ab2f9d0a39156bab381f3217ad2c8fd210d8
+  data.tar.gz: 24fde7963aa8d74479e2a90030928b7fc8fc7d89
+SHA512:
+  metadata.gz: 1e18a93aef681e795efd164d3467f7136fe6f938bea9d08448cfe854b4a2a4a50dd4b5ea4bc46c54a18f0bd6996c902c747449dd9448a0f3fd83cf1694ab39e5
+  data.tar.gz: f3549f8a25a32cc5bc2f5a6c565e2a081dd029653d499be1aa28743e293fa975de93c7f8b1a12b0915bb3e9d1153d5e25cbc156ada19fa2fc8c656a9c70f5b8c

data/README.md

@@ -0,0 +1,109 @@
+# Epiphy [![wercker status](https://app.wercker.com/status/63dd458158948712a03a00d69a96f67b/m "wercker status")](https://app.wercker.com/project/bykey/63dd458158948712a03a00d69a96f67b)
+
+## [Simply RethinkDB](http://leanpub.com/simplyrethink)
+
+I also write this book to practice RethinkDB. Please consider buying a
+copy if you want to support the author.
+
+# Introduction
+
+A persistence framework for [RethinkDB](http://rethinkdb.com). The library is used on [phim365.today](http://phim365.today). Its API is based on Lotus::Model.
+
+I love Lotus::Model so much because it's lightweight, does the job, no
+magic. I also should fork Lotus and add RethinkDB adapter. However, I want
+to learn more Ruby and reinvent the wheel because I didn't know how the
+wheel was created. More than that, my bad code will not be able to make
+it to Lotus::Model.
+
+It delivers a convenient public API to execute queries and commands against a database.
+The architecture eases keeping the business logic (entities) separated from details such as persistence or validations.
+
+It implements the following concepts:
+
+  * [Entity](#entities) - An object defined by its identity.
+  * [Repository](#repositories) - An object that mediates between the entities and the persistence layer.
+  * [Adapter](#adapter) – A database adapter.
+  * [Query](#query) - An object that represents a database query.
+
+`Epiphy` is name after `Epiphyllum`, my spouse's name.
+
+# Install
+
+```
+gem install epiphy
+```
+
+or add
+
+```
+gem 'epiphy'
+```
+
+to your `Gemfile` if you use Bundle. Run `bundle install`
+
+
+# Testing
+
+`Minitest` is used for testing.
+
+Make sure you have a working RethinkDB with default connection
+information that is localhost, port 28015, without authentication key
+and run
+
+```
+$ bundle install
+$ rake test
+```
+
+A testing database will be created during the testing. The testing data
+will hit your RethinkDB. Depend on your storge system, test can fast or
+slow.
+
+# Example
+
+```ruby
+connection = Epiphy::Connection.create
+adapter    = Epiphy::Adapter::RethinkDB.new connection
+RethinkDB::Repository.configure do |r|
+  r.adapter = adapter 
+end
+
+class Movie
+  include Epiphy::Entity
+  include Epiphy::Entity::Timestamp
+
+  attributes :title, :url
+end
+
+class MovieRepository
+  include Epiphy::Repository  
+end
+
+movie = MovieRepository.find id # Find by id
+
+movie = MovieRepository.first
+movie = MovieRepository.last
+
+movie = Movie.new
+movie.title = "A movie"
+MovieRepository.create movie
+MovieRepository.update movie
+
+
+
+```
+
+# Contributing to epiphy
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+# Copyright
+
+Copyright (c) 2014 kureikain. See LICENSE.txt for
+further details.

data/lib/epiphy.rb

@@ -0,0 +1,2 @@
+require 'rethinkdb'
+require 'epiphy/model'

data/lib/epiphy/adapter/error.rb

@@ -0,0 +1,7 @@
+module Epiphy
+  module Adapter
+    class MissingDatabaseError < ::StandardError
+
+    end
+  end
+end

data/lib/epiphy/adapter/helper.rb

@@ -0,0 +1,114 @@
+module Epiphy
+  module Adapter
+    class Rethinkdb
+      # RethinkDB method related. Should be in its helper
+      def insert_object
+        get_table.insert(
+          safe_params.merge(
+            id: params[:id],
+            created_at: Time.now,
+            updated_at: Time.now
+          ).merge(parents)
+        ).run(@connection)
+        :created
+      end
+
+      def update_object
+        get_table.update(
+          safe_params.merge(
+            id: params[:id],
+            updated_at: Time.now
+          )
+        ).run(@connection)
+        :ok
+      end
+
+      def replace_object
+        get_table.replace(
+          safe_params.merge(
+            id: params[:id],
+            created_at: Time.now,
+            updated_at: Time.now
+          ).merge(parents)
+        ).run(@connection)
+        :ok
+      end
+
+      def delete_object
+        get_table.get(params[:id]).delete(
+          :durability => "hard", :return_vals => false
+        ).run(@connection)
+        :no_content
+      end
+
+      def sort(qry)
+        ordering = params[:sort].split(",").map do |attr|
+          if attr[0] == "-"
+            r.desc(attr[1..-1].to_sym)
+          else
+            r.asc(attr.to_sym)
+          end
+        end
+
+        qry.order_by(*ordering)
+      end
+
+      def select(qry)
+        qry = qry.get_all(*params[:ids].split(",")) if params[:ids]
+        qry
+      end
+
+      def parents
+        params.select {|k,v| k.match(/\A[a-z0-9_]+_id\z/i) }.compact
+      end
+
+      def filter(qry)
+        parents.empty? ? qry : qry.filter(parents)
+      end
+
+      def attrs
+        [ :id ]
+      end
+
+      def get_range(qry)
+        begin
+          rhdr = request.headers[:HTTP_RANGE].split("=")
+
+          if rhdr[0] == collection
+            qry = qry[Range.new(*rhdr[1].split("-").map(&:to_i))]
+          end
+        rescue Exception => e
+          puts e.message
+          raise Exception.new(:bad_request)
+        end
+        qry
+      end
+
+      def get_records
+        qry = get_table
+        qry = sort(qry) if params[:sort]
+
+        fields = if params[:fields]
+                   params[:fields].split(",").map {|f| f.to_sym }.select do |field|
+                     attrs.include? field
+                   end
+                 else
+                   attrs
+                 end
+
+        qry = filter(select(qry)).pluck(fields)
+        qry = get_range(qry) if request.headers[:HTTP_RANGE]
+
+        qry.run(@connection).map do |record|
+          record.merge(href: some_url(record["id"]))
+        end
+      end
+
+      def get_object
+        get_table.filter(parents.merge({id: params[:id]})).pluck(attrs).run(@connection).first
+      end
+
+    end
+  end
+end
+

data/lib/epiphy/adapter/model.rb

@@ -0,0 +1,99 @@
+require 'errors'
+
+class Rethink
+  include RethinkDB::Shortcuts
+  include RethinkdbHelper
+  include Errors
+
+  def initialize
+    create_connect_if_need 
+    @r = @@r.table(self.class.name.downcase)
+  end
+
+  def all
+    self
+  end
+
+  # Get a single element by primary key
+  def single(id)
+    @r = @r.get(id)
+    self
+  end
+
+  # Return raw RethinkDB object
+  def raw_query
+    @r
+  end
+  
+  def reset
+    @r = @@r.table self.class.name.downcase
+  end
+
+  # Run a RQL
+  def get(r=nil)
+    if r.nil?
+      r = @r
+    end
+    r.run(@@rdb_connection)
+  end
+
+  [:update, "get_all", :limit, :order_by, :slice, :count, :filter].each do |name|
+    define_method(name) do |*arg, &block|
+      @r = @r.send(name, *arg, &block)
+      self
+    end
+  end 
+  
+  # Command work ona single object
+  #{:destroy => :delete}.each do |public_name, name| 
+    #define_method(public_name) do |*arg, &block|
+      #r = @@r.table self.class.name.downcase
+      #r.get(*arg)
+      #r.send(name, *arg, &block)
+      #r.run @@rdb_connection
+    #end
+  #end
+  
+  def destroy(id)
+    r = @@r.table self.class.name.downcase
+    r.get(id)
+      .delete()
+      .run(@@rdb_connection)
+  end
+
+  # Validation
+  def self.validate(args)
+    if args.has_key? :errors
+      raise ValidationError.new('Bad request', args[:errors])
+    end
+
+    args
+  end
+
+  def self.validate_present(args, *keys)
+    for k in keys
+      unless args.has_key?(k) and args[k].present?
+        args[:errors] ||= {}
+        args[:errors][k] ||= []
+        args[:errors][k] << "can't be blank."
+      end
+    end
+    args
+  end
+
+  def self.validate_email(args)
+    if args.has_key? :email
+      args[:email].downcase!
+
+      unless args[:email].present? and
+        args[:email].match EMAIL_REGEX
+
+        args[:errors] ||= {}
+        args[:errors][:email] ||= []
+        args[:errors][:email] << "is invalid."
+      end
+    end
+    args
+  end
+end
+

data/lib/epiphy/adapter/rethinkdb.rb

@@ -0,0 +1,326 @@
+require 'epiphy/adapter/error'
+#require 'epiphy/adapter/helper'
+module Epiphy
+  module Adapter
+    class Rethinkdb
+      include RethinkDB::Shortcuts
+      # Create an adapter object, with the option to pass a connection
+      # object as dependency.
+      #
+      # Without the dattabase string, Epiphy will assumes a `test`
+      # database just as RethinkDB do by default.
+      #
+      # @example
+      #   connection = Epiphy::Connection.create  
+      #   adapter = Epiphy::Adapter::Rethinkdb.new(connection,
+      #   default_database)
+      #    
+      # @param connection [RethinkDB::Connection]
+      # @param database   [String] database name
+      #
+      # @api public
+      # @since 0.0.1
+      #
+      #
+      def initialize(conn, database: 'test')
+        self.connection=(conn)
+        self.database=(database) unless database.nil?
+      end
+
+      # Assign a RethinkDB connection for this adapter.
+      # 
+      # @param connection [RethinkDB::Connection]
+      # @return [Object] the current adapter. enable us to continue
+      # chain it
+      #
+      # @api public
+      # @since 0.1.0
+      def connection= (connection)
+        @connection = connection
+      end
+      
+      # Set the current, default database for this connection. 
+      #
+      # At, any time, you can re-set this to change the database. 
+      # Doing so will trigger the adapter to switch to the new 
+      # database.
+      # 
+      # At RethinkDB level, this is similar with what we do with 
+      # r.db('foo')
+      #
+      # @example
+      #   adapter.database("test")
+      #   # Subsequent query will be run on `test` database
+      #   adapter.database("foo")
+      #   # Subsequent query will be run on `foo` database
+      #
+      #
+      def database= (db)
+        @database = db 
+      end
+
+      # Execute a ReQL query. The database and table is passed as
+      # parameter and the query is build by a block.
+      #
+      # The table param can be omitted so we can run the drop, create
+      # table
+      #
+      # With a valid database param, only this query will be run on it. To set
+      # a persitent different database for subsequent queries, consider
+      # set a different database.
+      #
+      # The block is passed 2 object. The first is the ReQL at the
+      # table() level. The second is the ReQL at top name space level
+      #
+      # @see Epiphy::Adapter::Rethinkdb#database=
+      #
+      # @example
+      #   # To create a table
+      #   adapter.query do |r, rt|
+      #     r.table_create('table_name')
+      #   end  
+      #
+      #   # To filter
+      #   adapter.query table: 'movie' do |r|
+      #     r.filter({category: 'romantic'})
+      #   end
+      #
+      #   # To Drop a database
+      #   adapter.query do |t, r|
+      #     r.db_drop 'dbname'
+      #   end
+      #
+      # @param collection [Epiphy::Repository]
+      # @param table [String]
+      # @param database [String] 
+      #
+      # @return query result of RethinkDB::run
+      # 
+      # @since 0.0.1
+      # @api private 
+      def query(table: nil, database: nil)
+        raise ArgumentError, 'Missing query block' unless block_given? 
+        if block_given?
+          rql = get_table(table, database)
+          rql = yield(rql, r)
+        end
+        rql.run(@connection)
+      end
+      
+      # Creates or updates a record in the database for the given entity.
+      #
+      # @param collection [Symbol] the target collection (it must be mapped).
+      # @param entity [#id, #id=] the entity to persist
+      #
+      # @return [Object] the entity
+      #
+      # @api private
+      # @since 0.1.0
+      def persist(collection, entity)
+        if entity["id"]
+          update(collection, entity)
+        else
+          create(collection, entity)
+        end
+      end
+      
+      # Insert a document.
+      # @param collection [Symbol the target collection
+      # @param entity [#id, #id=] the entity to create
+      # @return [Object] the entity 
+      #
+      # @api private
+      # @since 0.0.1
+      def create(collection, entity)
+        begin
+          result = query table: collection do |r|
+            r.insert(entity)
+          end
+        rescue 
+          return false
+        end
+        
+        if result["inserted"]==1
+          result["generated_keys"].first
+        end
+      end
+
+      # Insert a document.
+      # @param collection [Symbol the target collection
+      # @param entity [#id, #id=] the entity to create
+      # @return [Object] the entity 
+      #
+      # @api private
+      # @since 0.0.1
+      def update(collection, entity)
+        begin
+          result = query table: collection do |r|
+            r.get(entity["id"]).update(entity)
+          end
+        rescue
+          return false
+        end
+        return result["replaced"]
+      end
+
+
+      # Returns all the records for the given collection
+      #
+      # @param collection [Symbol] the target collection (it must be mapped).
+      #
+      # @return [Array] all the records
+      #
+      # @api private
+      # @since 0.1.0
+      def all(collection)
+        # TODO consider to make this lazy (aka remove #all)
+        #query(collection).all
+        begin 
+          query table: collection do |r|
+            r
+          end
+        rescue
+          return false
+        end
+      end
+
+      # Returns an unique record from the given collection, with the given
+      # id.
+      #
+      # @param collection [Symbol] the target collection (it must be mapped).
+      # @param id [Object] the identity of the object.
+      #
+      # @return [Object] the entity
+      #
+      # @api private
+      # @since 0.1.0
+      def find(collection, id)
+        #begin
+          result = query table: collection do |r|
+            r.get(id)
+          end
+        #rescue
+        #end
+        result
+      end
+
+      # Remove the record from the given collection, with the given id
+      # 
+      # @param collection [Symbol] the target collection
+      # @param id [Object] the identity of the object
+      #
+      # @return [Object] the entity
+      #
+      # @api private
+      # @since 0.1.0
+      def delete(collection, id)
+        begin
+          result = query table: collection do |r|
+            r.get(id).delete()
+          end
+          if result["errors"] == 0
+            return result["deleted"]
+          end
+          return false
+        rescue
+          return false
+        end
+      end
+
+      # Delete all records from the table
+      # 
+      # @param collection [Symbol] the target collection
+      # @return how many entry we removed
+      #
+      # @since 0.0.1
+      # @api private
+      def clear(collection)
+        begin
+          result = query table: collection do |r|
+            r.delete()
+          end
+          if result["errors"] == 0
+            return result['deleted']
+          end
+          return false
+        rescue 
+          return false 
+        end
+      end
+
+      # Returns the first record in the given collection.
+      #
+      # @param collection [Symbol] the target collection (it must be mapped).
+      #
+      # @return [Object] the first entity
+      #
+      # @api private
+      # @since 0.1.0
+      def first(collection)
+        _first(
+          query(collection).asc(_identity(collection))
+        )
+      end
+
+      # Returns the last record in the given collection.
+      #
+      # @param collection [Symbol] the target collection (it must be mapped).
+      #
+      # @return [Object] the last entity
+      #
+      # @api private
+      # @since 0.1.0
+      def last(collection)
+        _first(
+          query(collection).desc(_identity(collection))
+        )
+      end
+
+      private
+      def _collection(name)
+        raise NotImplementedError
+      end
+
+      def _mapped_collection(name)
+        @mapper.collection(name)
+      end
+
+      def _find(collection, id)
+        identity = _identity(collection)
+        query(collection).where(identity => _id(collection, identity, id))
+      end
+
+      def _first(query)
+        query.limit(1).first
+      end
+
+      def _identity(collection)
+        _mapped_collection(collection).identity
+      end
+
+      def _id(collection, column, value)
+        _mapped_collection(collection).deserialize_attribute(column, value)
+      end
+
+      protected
+
+      # Return a ReQL wrapper of a table to start query chaining.
+      # 
+      # This is just a lighweight wrapper of `r.db().table()`
+      # @see
+      # @param database [string]. default to current database
+      # @param table [string]
+      # @api private
+      # @since 0.0.1
+      def get_table(table, database=nil)
+        database = @database if database.nil?
+        raise Epiphy::Adapter::MissingDatabaseError "Missing a default database name"  if database.nil?
+        rql = r.db(database)
+        rql = rql.table(table) unless table.nil?
+        rql
+      end
+
+
+    end    
+  end
+end