rethinker 0.1

data/lib/rethinker/error.rb

@@ -0,0 +1,6 @@
+module Rethinker::Error
+  class Connection       < StandardError; end
+  class DocumentNotFound < StandardError; end
+  class DocumentInvalid  < StandardError; end
+  class DocumentNotSaved < StandardError; end
+end

data/lib/rethinker/query_runner.rb

@@ -0,0 +1,32 @@
+require 'middleware'
+
+module Rethinker::QueryRunner
+  extend Rethinker::Autoload
+
+  class Middleware
+    def initialize(runner)
+      @runner = runner
+    end
+  end
+
+  autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
+           :Connection, :Selection
+
+  class << self
+    attr_accessor :stack
+
+    def run(options={}, &block)
+      stack.call(:query => yield, :options => options)
+    end
+  end
+
+  # thread-safe, since require() is ran with a mutex.
+  self.stack = ::Middleware::Builder.new do
+    use Selection
+    use Connection
+    use WriteError
+    use TableOnDemand
+    use DatabaseOnDemand
+    use Driver
+  end
+end

data/lib/rethinker/query_runner/connection.rb

@@ -0,0 +1,17 @@
+class Rethinker::QueryRunner::Connection < Rethinker::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env)
+  rescue RuntimeError, Rethinker::Error::DocumentNotSaved => e
+    if e.message =~ /cannot perform (read|write): lost contact with master/
+      env[:connection_retries] ||= 0
+      # TODO sleep in between? timing out should be time based?
+
+      # XXX Possibly dangerous, as we could reexecute a non idempotent operation
+      # Check the semantics of the db
+
+      # TODO Unit test
+      retry if (env[:connection_retries] += 1) < 10
+    end
+    raise e
+  end
+end

data/lib/rethinker/query_runner/database_on_demand.rb

@@ -0,0 +1,16 @@
+class Rethinker::QueryRunner::DatabaseOnDemand < Rethinker::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env)
+  rescue RuntimeError => e
+    if e.message =~ /^Database `(.+)` does not exist\.$/
+      # RethinkDB may return an FIND_DB not found immediately
+      # after having created the new database, Be patient.
+      # TODO Unit test that thing
+      # Also, should we be counter based, or time based for the timeout ?
+      Rethinker.db_create $1 unless env[:db_find_retries]
+      env[:db_find_retries] ||= 0
+      retry if (env[:db_find_retries] += 1) < 10
+    end
+    raise e
+  end
+end

data/lib/rethinker/query_runner/driver.rb

@@ -0,0 +1,10 @@
+class Rethinker::QueryRunner::Driver < Rethinker::QueryRunner::Middleware
+  def call(env)
+    # TODO have a logger
+    puts env[:query].inspect if ENV['DEBUG']
+    env[:query].run(Rethinker.connection, env[:options])
+  rescue NoMethodError => e
+    raise "Rethinker is not connected to a RethinkDB instance" unless Rethinker.connection
+    raise e
+  end
+end

data/lib/rethinker/query_runner/selection.rb

@@ -0,0 +1,8 @@
+class Rethinker::QueryRunner::Selection < Rethinker::QueryRunner::Middleware
+  def call(env)
+    if env[:query].is_a? Rethinker::Selection
+      env[:selection], env[:query] = env[:query], env[:query].query
+    end
+    @runner.call(env)
+  end
+end

data/lib/rethinker/query_runner/table_on_demand.rb

@@ -0,0 +1,12 @@
+class Rethinker::QueryRunner::TableOnDemand < Rethinker::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env)
+  rescue RuntimeError => e
+    if e.message =~ /^Table `(.+)` does not exist\.$/
+      # TODO Lookup the Model, and get the primary key name
+      Rethinker.table_create $1
+      retry
+    end
+    raise e
+  end
+end

data/lib/rethinker/query_runner/write_error.rb

@@ -0,0 +1,34 @@
+class Rethinker::QueryRunner::WriteError < Rethinker::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env).tap do |result|
+      # TODO Fix rethinkdb driver: Their classes Term, Query, Response are
+      # not scoped to the RethinkDB module! (that would prevent a user from
+      # creating a Response model for example).
+
+      if is_write_query?(env) && (result['errors'].to_i != 0 || result['skipped'].to_i != 0)
+        raise_write_error(env, result['first_error'])
+      end
+    end
+  rescue RethinkDB::RqlRuntimeError => e
+    raise unless is_write_query?(env)
+
+    error_msg = e.message.split("\nBacktrace").first
+    error_msg = "Non existent document" if e.message =~ /Expected type OBJECT but found NULL/
+    raise_write_error(env, error_msg)
+  end
+
+  private
+
+  def is_write_query?(env)
+    env[:query].body.type.in?([Term::TermType::UPDATE,
+                               Term::TermType::DELETE,
+                               Term::TermType::REPLACE,
+                               Term::TermType::INSERT])
+  end
+
+  def raise_write_error(env, error_msg)
+    error_msg ||= "Unknown error"
+    error_msg += "\nQuery was: #{env[:query].inspect[0..1000]}"
+    raise Rethinker::Error::DocumentNotSaved, error_msg
+  end
+end

data/lib/rethinker/railtie.rb

@@ -0,0 +1,16 @@
+require "rethinker"
+require "rails"
+
+class Rethinker::Railtie < Rails::Railtie
+  config.action_dispatch.rescue_responses.merge!(
+    "Rethinker::Errors::DocumentNotFound" => :not_found,
+    "Rethinker::Errors::DocumentInvalid"  => :unprocessable_entity,
+    "Rethinker::Errors::DocumentNotSaved" => :unprocessable_entity,
+  )
+
+  rake_tasks do
+    load "rethinker/railtie/database.rake"
+  end
+
+  #config.eager_load_namespaces << Rethinker
+end

data/lib/rethinker/railtie/database.rake

@@ -0,0 +1,37 @@
+namespace :db do
+  unless Rake::Task.task_defined?("db:drop")
+    desc 'Truncate all the tables'
+    task :drop => :environment do
+      Rethinker.purge!
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    desc 'Load the seed data from db/seeds.rb'
+    task :seed => :environment do
+      Rails.application.load_seed
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc 'Equivalent to db:seed'
+    task :setup => [ 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:reset")
+    desc 'Equivalent to db:drop + db:seed'
+    task :reset => [ 'db:drop', 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+end

data/lib/rethinker/relation.rb

@@ -0,0 +1,6 @@
+module Rethinker::Relation
+  extend Rethinker::Autoload
+
+  autoload :BelongsTo, :HasMany
+  # you also want to check Rethinker::Document::Relation
+end

data/lib/rethinker/relation/belongs_to.rb

@@ -0,0 +1,36 @@
+class Rethinker::Relation::BelongsTo < Struct.new(:children_klass, :parent_name, :options)
+  def foreign_key
+    # TODO test :foreign_key
+    @foreign_key ||= options[:foreign_key] || :"#{parent_name}_id"
+  end
+
+  def parent_klass_lazy
+    # TODO test :class_name
+    @parent_klass_lazy ||= options[:class_name] || parent_name.to_s.camelize
+  end
+
+  def hook
+    # TODO yell when some options are not recognized
+    children_klass.field foreign_key
+
+    children_klass.inject_in_layer :relations, <<-RUBY, __FILE__, __LINE__ + 1
+      def #{foreign_key}=(value)
+        super
+        @relations_cache[:#{parent_name}] = nil
+      end
+
+      def #{parent_name}=(new_parent)
+        # TODO raise when new_parent doesn't have the proper type
+        new_parent.save! if new_parent && !new_parent.persisted?
+        self.#{foreign_key} = new_parent.try(:id)
+        @relations_cache[:#{parent_name}] = new_parent
+      end
+
+      def #{parent_name}
+        if #{foreign_key}
+          @relations_cache[:#{parent_name}] ||= #{parent_klass_lazy}.find(#{foreign_key})
+        end
+      end
+    RUBY
+  end
+end

data/lib/rethinker/relation/has_many.rb

@@ -0,0 +1,30 @@
+class Rethinker::Relation::HasMany < Struct.new(:parent_klass, :children_name, :options)
+  extend ActiveSupport::Autoload
+  autoload :Selection
+
+  def foreign_key
+    # TODO test :foreign_key
+    @foreign_key ||= options[:foreign_key] || :"#{parent_klass.name.underscore}_id"
+  end
+
+  def children_klass
+    # TODO test :class_name
+    @children_klass ||= (options[:class_name] || children_name.to_s.singularize.camelize).constantize
+  end
+
+  def hook
+    # TODO yell when some options are not recognized
+    parent_klass.inject_in_layer :relations, <<-RUBY, __FILE__, __LINE__ + 1
+      def #{children_name}=(new_children)
+        #{children_name}.destroy
+        new_children.each { |child| #{children_name} << child }
+      end
+
+      def #{children_name}
+        # TODO Cache array
+        relation = self.class.relations[:#{children_name}]
+        ::Rethinker::Relation::HasMany::Selection.new(self, relation)
+      end
+    RUBY
+  end
+end

data/lib/rethinker/relation/has_many/selection.rb

@@ -0,0 +1,27 @@
+class Rethinker::Relation::HasMany::Selection < Rethinker::Selection
+  attr_accessor :parent_instance, :relation
+  delegate :foreign_key, :children_klass, :to => :relation
+
+  def initialize(parent_instance, relation)
+    self.relation = relation
+    self.parent_instance = parent_instance
+    super children_klass.where(foreign_key => parent_instance.id).criteria, klass: children_klass
+  end
+
+  def <<(child)
+    # TODO raise when child doesn't have the proper type
+    child.update_attributes(foreign_key => parent_instance.id)
+  end
+
+  def build(attrs={})
+    children_klass.new(attrs.merge(foreign_key => parent_instance.id))
+  end
+
+  def create(*args)
+    build(*args).tap { |doc| doc.save }
+  end
+
+  def create!(*args)
+    build(*args).tap { |doc| doc.save! }
+  end
+end

data/lib/rethinker/selection.rb

@@ -0,0 +1,6 @@
+class Rethinker::Selection
+  extend Rethinker::Autoload
+
+  autoload_and_include :Core, :Count, :Delete, :Enumerable, :First, :Inc,
+                       :Limit, :OrderBy, :Scope, :Update, :Where
+end

data/lib/rethinker/selection/core.rb

@@ -0,0 +1,39 @@
+module Rethinker::Selection::Core
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :context, :criteria
+    delegate :inspect, to: :query
+  end
+
+  def initialize(criteria = [], context = {})
+    # We are saving klass as a context
+    # so that the table_on_demand middleware can do its job
+    # TODO FIXME Sadly it gets funny with associations
+    self.context = context
+    self.criteria = [criteria].flatten
+    self
+  end
+
+  def klass
+    context[:klass]
+  end
+
+  def chain(criterion)
+    self.criteria.concat([criterion]).flatten! unless criterion.blank?
+    self
+  end
+
+  def run
+    Rethinker.run { self.query }
+  end
+
+  def query
+    chained_query = nil
+    self.criteria.each do |criterion|
+      chained_query = criterion.execute(chained_query, self.context)
+    end
+    chained_query
+  end
+
+end

data/lib/rethinker/selection/count.rb

@@ -0,0 +1,13 @@
+module Rethinker::Selection::Count
+  def count
+    chain(Rethinker::Criterion.new(:count)).run
+  end
+
+  def empty?
+    count == 0
+  end
+
+  def any?
+    !empty?
+  end
+end

data/lib/rethinker/selection/delete.rb

@@ -0,0 +1,9 @@
+module Rethinker::Selection::Delete
+  def delete
+    chain(Rethinker::Criterion.new(:delete)).run
+  end
+
+  def destroy
+    each { |doc| doc.destroy }
+  end
+end

data/lib/rethinker/selection/enumerable.rb

@@ -0,0 +1,22 @@
+module Rethinker::Selection::Enumerable
+  def each(&block)
+    return enum_for(:each) unless block
+
+    klass.ensure_table! # needed as soon as we get a Query_Result
+    run.each do |attrs|
+      yield klass.new_from_db(attrs)
+    end
+    self
+  end
+
+  # TODO test that
+  def respond_to?(name, include_private = false)
+    super || [].respond_to?(name)
+  end
+
+  # TODO Make something a bit more efficent ?
+  def method_missing(name, *args, &block)
+    return super unless [].respond_to?(name)
+    each.__send__(name, *args, &block)
+  end
+end

data/lib/rethinker/selection/first.rb

@@ -0,0 +1,20 @@
+module Rethinker::Selection::First
+  def first
+    self.context[:order] = :normal
+    get_one
+  end
+
+  def last
+    self.context[:order] = :reverse
+    get_one
+  end
+
+  private
+
+  def get_one
+    klass.ensure_table! # needed as soon as we get a Query_Result
+    order_by(:id) unless ordered?
+    attrs = chain(Rethinker::Criterion.new(:limit, 1)).run.first
+    klass.new_from_db(attrs)
+  end
+end

data/lib/rethinker/selection/inc.rb

@@ -0,0 +1,12 @@
+module Rethinker::Selection::Inc
+  def inc(field, value=1)
+    # TODO The useful inc() is on a model instance.
+    # But then do we want to postpone the inc() to the next save?
+    # It might make sense (because we don't have transactions).
+    update { |doc| { field => doc[field] + value } }
+  end
+
+  def dec(field, value=1)
+    inc(field, -value)
+  end
+end

data/lib/rethinker/selection/limit.rb

@@ -0,0 +1,15 @@
+module Rethinker::Selection::Limit
+  # TODO Test these guys
+
+  def limit(value)
+    chain Rethinker::Criterion.new(:limit, value)
+  end
+
+  def skip(value)
+    chain Rethinker::Criterion.new(:skip, value)
+  end
+
+  def [](sel)
+    chain Rethinker::Criterion.new(:[], sel)
+  end
+end