rethinker 0.1

data/lib/rethinker/document/core.rb

@@ -0,0 +1,37 @@
+module Rethinker::Document::Core
+  extend ActiveSupport::Concern
+
+  # TODO This assume the primary key is id.
+  # RethinkDB can have a custom primary key. careful.
+  include ActiveModel::Conversion
+
+  included do
+    # TODO test these includes
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+  end
+
+  def initialize(attrs={}, options={}); end
+
+  module ClassMethods
+    def table_name
+      root_class.name.underscore.gsub('/', '__').pluralize
+    end
+
+    # Even though we are using class variables, it's threads-safe.
+    # It's still racy, but the race is harmless.
+    def table
+      root_class.class_eval do
+        @table ||= RethinkDB::RQL.new.table(table_name).freeze
+      end
+    end
+
+    # Thread safe because the operation is idempotent
+    # (no error if we try to create the table twice)
+    def ensure_table!
+      root_class.class_eval do
+        @table_created ||= !!self.count
+      end
+    end
+  end
+end

data/lib/rethinker/document/dynamic_attributes.rb

@@ -0,0 +1,12 @@
+module Rethinker::Document::DynamicAttributes
+  extend ActiveSupport::Concern
+
+  def [](name)
+    attributes[name.to_s]
+  end
+
+  def []=(name, value)
+    attributes[name.to_s] = value
+  end
+
+end

data/lib/rethinker/document/id.rb

@@ -0,0 +1,54 @@
+require 'thread'
+require 'socket'
+require 'digest/md5'
+
+module Rethinker::Document::Id
+  extend ActiveSupport::Concern
+
+  included do
+    self.field :id
+  end
+
+  def reset_attributes
+    super
+    self.id = Rethinker::Document::Id.generate
+  end
+
+  def ==(other)
+    return super unless self.class == other.class
+    !id.nil? && id == other.id
+  end
+  alias_method :eql?, :==
+
+  delegate :hash, :to => :id
+
+  # The following code is inspired by the mongo-ruby-driver
+
+  @machine_id = Digest::MD5.digest(Socket.gethostname)[0, 3]
+  @lock = Mutex.new
+  @index = 0
+
+  def self.get_inc
+    @lock.synchronize do
+      @index = (@index + 1) % 0xFFFFFF
+    end
+  end
+
+  # TODO Unit test that thing
+  def self.generate
+    oid = ''
+    # 4 bytes current time
+    oid += [Time.now.to_i].pack("N")
+
+    # 3 bytes machine
+    oid += @machine_id
+
+    # 2 bytes pid
+    oid += [Process.pid % 0xFFFF].pack("n")
+
+    # 3 bytes inc
+    oid += [get_inc].pack("N")[1, 3]
+
+    oid.unpack("C12").map {|e| v=e.to_s(16); v.size == 1 ? "0#{v}" : v }.join
+  end
+end

data/lib/rethinker/document/injection_layer.rb

@@ -0,0 +1,11 @@
+module Rethinker::Document::InjectionLayer
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def inject_in_layer(name, code, file, line)
+      class_eval <<-RUBY, file, line
+        include module RethinkerLayer; module #{name.to_s.camelize}; #{code}; self; end; end
+      RUBY
+    end
+  end
+end

data/lib/rethinker/document/persistence.rb

@@ -0,0 +1,79 @@
+module Rethinker::Document::Persistence
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create, :update, :save, :destroy
+  end
+
+  # TODO after_initialize, after_find callback
+  def initialize(attrs={}, options={})
+    super
+    @new_record = !options[:from_db]
+  end
+
+  def new_record?
+    @new_record
+  end
+
+  def destroyed?
+    !!@destroyed
+  end
+
+  def persisted?
+    !new_record? && !destroyed?
+  end
+
+  def _create
+    run_callbacks :create do
+      result = Rethinker.run { self.class.table.insert(attributes) }
+      self.id ||= result['generated_keys'].first
+      @new_record = false
+      true
+    end
+  end
+
+  def reload
+    assign_attributes(selector.run, :pristine => true)
+    self
+  end
+
+  def update(&block)
+    run_callbacks :update do
+      selector.update(&block)
+      true
+    end
+  end
+
+  def save(options={})
+    run_callbacks :save do
+      new_record? ? _create : update { attributes }
+    end
+  end
+
+  def update_attributes(attrs, options={})
+    assign_attributes(attrs, options)
+    save
+  end
+
+  def delete
+    selector.delete
+    @destroyed = true
+    # TODO freeze attributes
+    true
+  end
+
+  def destroy
+    run_callbacks(:destroy) { delete }
+  end
+
+  module ClassMethods
+    def create(*args)
+      new(*args).tap { |doc| doc.save }
+    end
+
+    def create!(*args)
+      new(*args).tap { |doc| doc.save! }
+    end
+  end
+end

data/lib/rethinker/document/polymorphic.rb

@@ -0,0 +1,37 @@
+module Rethinker::Document::Polymorphic
+  extend ActiveSupport::Concern
+  include ActiveSupport::DescendantsTracker
+
+  included do
+    class_attribute :root_class
+    self.root_class = self
+  end
+
+  def reset_attributes
+    super
+    self._type = self.class.type_value unless self.class.is_root_class?
+  end
+
+  module ClassMethods
+    def inherited(subclass)
+      super
+      subclass.field :_type if is_root_class?
+    end
+
+    def type_value
+      name
+    end
+
+    def descendants_type_values
+      ([self] + descendants).map(&:type_value)
+    end
+
+    def is_root_class?
+      self == root_class
+    end
+
+    def klass_from_attrs(attrs)
+      attrs['_type'].try(:constantize) || root_class
+    end
+  end
+end

data/lib/rethinker/document/relation.rb

@@ -0,0 +1,34 @@
+module Rethinker::Document::Relation
+  extend ActiveSupport::Concern
+
+  included do
+    class << self; attr_accessor :relations; end
+    self.relations = {}
+  end
+
+  def reset_attributes
+    super
+    @relations_cache = {}
+  end
+
+  module ClassMethods
+    def inherited(subclass)
+      super
+      subclass.relations = self.relations.dup
+    end
+
+    [:belongs_to, :has_many].each do |relation|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{relation}(target, options={})
+          target = target.to_sym
+          r = Rethinker::Relation::#{relation.to_s.camelize}.new(self, target, options)
+          r.hook
+
+          ([self] + descendants).each do |klass|
+            klass.relations[target] = r
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/rethinker/document/selection.rb

@@ -0,0 +1,49 @@
+module Rethinker::Document::Selection
+  extend ActiveSupport::Concern
+
+  def selector
+    self.class.selector_for(id)
+  end
+
+  module ClassMethods
+    def all
+      sel = Rethinker::Selection.new(Rethinker::Criterion.new(:table, table_name), :klass => self)
+
+      unless is_root_class?
+        # TODO use this: sel = sel.where(:_type.in(descendants_type_values))
+        sel = sel.where do |doc|
+          doc.has_fields(:_type) &
+          descendants_type_values.map    { |type| doc[:_type].eq(type) }
+                                 .reduce { |a,b| a | b }
+        end
+      end
+
+      sel
+    end
+
+    def scope(name, selection)
+      singleton_class.class_eval do
+        define_method(name) { |*args| selection.call(*args) }
+      end
+    end
+
+    delegate :count, :where, :order_by, :first, :last, :to => :all
+
+    def selector_for(id)
+      # TODO Pass primary key if not default
+      Rethinker::Selection.new([Rethinker::Criterion.new(:table, table_name), Rethinker::Criterion.new(:get, id)], :klass => self)
+    end
+
+    # XXX this doesn't have the same semantics as
+    # other ORMs. the equivalent is find!.
+    def find(id)
+      new_from_db(selector_for(id).run)
+    end
+
+    def find!(id)
+      find(id).tap do |doc|
+        doc or raise Rethinker::Error::DocumentNotFound, "#{self.class} id #{id} not found"
+      end
+    end
+  end
+end

data/lib/rethinker/document/serialization.rb

@@ -0,0 +1,41 @@
+module Rethinker::Document::Serialization
+  extend ActiveSupport::Concern
+
+  include ActiveModel::Serialization
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Serializers::Xml
+
+  included { self.include_root_in_json = false }
+
+  # XXX This is a giant copy paste from lib/active_model/serialization.rb
+  # The diff is:
+  # - attribute_names = attributes.keys.sort
+  # + attribute_names = self.class.fields.keys.sort
+  # That's all.
+  def serializable_hash(options = nil)
+    options ||= {}
+
+    attribute_names = self.class.fields.keys.sort
+    if only = options[:only]
+      attribute_names &= Array.wrap(only).map(&:to_s)
+    elsif except = options[:except]
+      attribute_names -= Array.wrap(except).map(&:to_s)
+    end
+
+    hash = {}
+    attribute_names.each { |n| hash[n] = read_attribute_for_serialization(n) }
+
+    method_names = Array.wrap(options[:methods]).select { |n| respond_to?(n) }
+    method_names.each { |n| hash[n] = send(n) }
+
+    serializable_add_includes(options) do |association, records, opts|
+      hash[association] = if records.is_a?(Enumerable)
+        records.map { |a| a.serializable_hash(opts) }
+      else
+        records.serializable_hash(opts)
+      end
+    end
+
+    hash
+  end
+end

data/lib/rethinker/document/timestamps.rb

@@ -0,0 +1,18 @@
+module Rethinker::Document::Timestamps
+  extend ActiveSupport::Concern
+
+  included do
+    self.field :created_at
+    self.field :updated_at
+
+    before_create { self.created_at = Time.now if self.respond_to?(:created_at=) }
+    before_save   { self.updated_at = Time.now if self.respond_to?(:updated_at=) }
+  end
+
+  module ClassMethods
+    def disable_timestamps
+      self.remove_field :created_at
+      self.remove_field :updated_at
+    end
+  end
+end

data/lib/rethinker/document/validation.rb

@@ -0,0 +1,62 @@
+module Rethinker::Document::Validation
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+
+  def save(options={})
+    options = options.reverse_merge(:validate => true)
+
+    if options[:validate]
+      valid? ? super : false
+    else
+      super
+    end
+  end
+
+  # TODO Test that thing
+  def valid?(context=nil)
+    super(context || (new_record? ? :create : :update))
+  end
+
+  [:save, :update_attributes].each do |method|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{method}!(*args)
+        #{method}(*args) or raise Rethinker::Error::DocumentInvalid, errors
+      end
+    RUBY
+  end
+
+  class UniquenessValidator < ActiveModel::EachValidator
+    # Validate the document for uniqueness violations.
+    #
+    # @example Validate the document.
+    #   validate_each(person, :title, "Sir")
+    #
+    # @param [ Document ] document The document to validate.
+    # @param [ Symbol ] attribute The field to validate on.
+    # @param [ Object ] value The value of the field.
+    #
+    # @return [ Boolean ] true if the attribute is unique.
+    def validate_each(document, attribute, value)
+      finder = document.class.where(attribute => value)
+      finder = apply_scopes(finder, document)
+      finder = exclude_document(finder, document) if document.persisted?
+      is_unique = finder.count == 0
+      unless is_unique
+        document.errors.add(attribute, 'is already taken')
+      end
+      is_unique
+    end
+
+    def apply_scopes(finder, document)
+      Array.wrap(options[:scope]).each do |scope_item|
+        finder = finder.where{|doc| doc[scope_item.to_s].eq(document.attributes[scope_item.to_s])}
+      end
+      finder
+    end
+
+    def exclude_document(finder, document)
+      finder.where{|doc| doc["id"].ne(document.attributes["id"])}
+    end
+  end
+end