nobrainer 0.8.0

data/lib/no_brainer/criteria/termination/cache.rb

@@ -0,0 +1,71 @@
+module NoBrainer::Criteria::Termination::Cache
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_with_cache }
+
+  def with_cache
+    chain { |criteria| criteria._with_cache = true }
+  end
+
+  def without_cache
+    chain { |criteria| criteria._with_cache = false }
+  end
+
+  def inspect
+    msg = super
+    msg = "#{msg} \e[1;37m# #{@cache.size} results cached\e[0m" if @cache && with_cache?
+    msg
+  end
+
+  def merge!(criteria)
+    super
+    self._with_cache = criteria._with_cache unless criteria._with_cache.nil?
+    self.reload
+    self
+  end
+
+  def with_cache?
+    @_with_cache.nil? ?  NoBrainer::Config.cache_documents : @_with_cache
+  end
+
+  def reload
+    @cache = nil
+  end
+
+  def each(options={}, &block)
+    return super unless with_cache? && !options[:no_cache] && block
+    return @cache.each(&block) if @cache
+
+    cache = []
+    super(options.merge(:no_cache => true)) do |instance|
+      block.call(instance)
+      cache << instance
+    end
+    @cache = cache
+    self
+  end
+
+  def _override_cache(cache)
+    @cache = cache
+  end
+
+  def self.reload_on(*methods)
+    methods.each do |method|
+      define_method(method) do |*args, &block|
+        reload
+        super(*args, &block).tap { reload }
+      end
+    end
+  end
+
+  def self.use_cache_for(*methods)
+    methods.each do |method|
+      define_method(method) do |*args, &block|
+        @cache ?  @cache.__send__(method, *args, &block) : super(*args, &block)
+      end
+    end
+  end
+
+  use_cache_for :first, :last, :count, :empty?, :any?
+  reload_on :update_all, :destroy_all, :delete_all
+end

data/lib/no_brainer/criteria/termination/count.rb

@@ -0,0 +1,19 @@
+module NoBrainer::Criteria::Termination::Count
+  extend ActiveSupport::Concern
+
+  def count
+    run(to_rql.count)
+  end
+
+  def empty?
+    count == 0
+  end
+
+  def any?
+    if block_given?
+      to_a.any? { |*args| yield(*args) }
+    else
+      !empty?
+    end
+  end
+end

data/lib/no_brainer/criteria/termination/delete.rb

@@ -0,0 +1,11 @@
+module NoBrainer::Criteria::Termination::Delete
+  extend ActiveSupport::Concern
+
+  def delete_all
+    run(to_rql.delete)['deleted']
+  end
+
+  def destroy_all
+    to_a.each { |doc| doc.destroy }
+  end
+end

data/lib/no_brainer/criteria/termination/eager_loading.rb

@@ -0,0 +1,64 @@
+module NoBrainer::Criteria::Termination::EagerLoading
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_includes }
+
+  def initialize(options={})
+    super
+    self._includes = []
+  end
+
+  def includes(*values)
+    raise "Please enable caching with NoBrainer::Config.cache_documents = true" unless NoBrainer::Config.cache_documents
+    chain { |criteria| criteria._includes = values }
+  end
+
+  def merge!(criteria)
+    super
+    self._includes = self._includes + criteria._includes
+  end
+
+  def each(options={}, &block)
+    return super unless should_eager_load? && !options[:no_eager_loading] && block
+
+    docs = []
+    super(options.merge(:no_eager_loading => true)) { |doc| docs << doc }
+    eager_load(docs, self._includes)
+    docs.each(&block)
+    self
+  end
+
+  private
+
+  def should_eager_load?
+    self._includes.present? && !raw?
+  end
+
+  def get_one(criteria)
+    super.tap { |doc| eager_load([doc], self._includes) if should_eager_load? }
+  end
+
+  def eager_load_association(docs, association_name, criteria=nil)
+    docs = docs.compact
+    return if docs.empty?
+    association = docs.first.root_class.association_metadata[association_name.to_sym]
+    raise "Unknown association #{association_name}" unless association
+    association.eager_load(docs, criteria)
+  end
+
+  def eager_load(docs, includes)
+    case includes
+    when Hash  then includes.each do |k,v|
+      if v.is_a?(NoBrainer::Criteria)
+        v = v.dup
+        nested_includes, v._includes = v._includes, []
+        eager_load(eager_load_association(docs, k, v), nested_includes)
+      else
+        eager_load(eager_load_association(docs, k), v)
+      end
+    end
+    when Array then includes.each { |v| eager_load(docs, v) }
+    else eager_load_association(docs, includes)
+    end
+  end
+end

data/lib/no_brainer/criteria/termination/enumerable.rb

@@ -0,0 +1,24 @@
+module NoBrainer::Criteria::Termination::Enumerable
+  extend ActiveSupport::Concern
+
+  def each(options={}, &block)
+    return enum_for(:each, options) unless block
+    self.run.each { |attrs| block.call(instantiate_doc(attrs)) }
+    self
+  end
+
+  def to_a
+    each.to_a.freeze
+  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)
+    to_a.__send__(name, *args, &block)
+  end
+end

data/lib/no_brainer/criteria/termination/first.rb

@@ -0,0 +1,25 @@
+module NoBrainer::Criteria::Termination::First
+  extend ActiveSupport::Concern
+
+  def first
+    get_one(self)
+  end
+
+  def last
+    get_one(self.reverse_order)
+  end
+
+  def first!
+    first.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
+  end
+
+  def last!
+    last.tap { |doc| raise NoBrainer::Error::DocumentNotFound unless doc }
+  end
+
+  private
+
+  def get_one(criteria)
+    instantiate_doc(criteria.limit(1).run.first)
+  end
+end

data/lib/no_brainer/criteria/termination/inc.rb

@@ -0,0 +1,14 @@
+module NoBrainer::Criteria::Termination::Inc
+  extend ActiveSupport::Concern
+
+  def inc_all(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_all { |doc| { field => doc[field] + value } }
+  end
+
+  def dec_all(field, value=1)
+    inc_all(field, -value)
+  end
+end

data/lib/no_brainer/criteria/termination/update.rb

@@ -0,0 +1,13 @@
+module NoBrainer::Criteria::Termination::Update
+  extend ActiveSupport::Concern
+
+  def update_all(attrs={}, &block)
+    block = proc { attrs } unless block_given?
+    run(to_rql.update(&block))['replaced']
+  end
+
+  def replace_all(attrs={}, &block)
+    block = proc { attrs } unless block_given?
+    run(to_rql.replace(&block))['replaced']
+  end
+end

data/lib/no_brainer/database.rb

@@ -0,0 +1,41 @@
+class NoBrainer::Database
+  attr_accessor :connection
+
+  # FIXME This class is a bit weird as we don't use it to represent the current
+  # database.
+
+  delegate :database_name, :to => :connection
+
+  def initialize(connection)
+    self.connection = connection
+  end
+
+  def raw
+    @raw ||= RethinkDB::RQL.new.db(database_name)
+  end
+
+  def drop!
+    # FIXME Sad hack.
+    db = (Thread.current[:nobrainer_options] || {})[:db] || database_name
+    connection.db_drop(db)['dropped'] == 1
+  end
+
+  # Note that truncating each table (purge) is much faster than dropping the
+  # database (drop)
+  def purge!(options={})
+    table_list.each do |table_name|
+      NoBrainer.run { |r| r.table(table_name).delete }
+    end
+    true
+  rescue RuntimeError => e
+    raise e unless e.message =~ /No entry with that name/
+  end
+
+  [:table_create, :table_drop, :table_list].each do |cmd|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{cmd}(*args)
+        NoBrainer.run { |r| r.#{cmd}(*args) }
+      end
+    RUBY
+  end
+end

data/lib/no_brainer/decorated_symbol.rb

@@ -0,0 +1,15 @@
+class NoBrainer::DecoratedSymbol < Struct.new(:symbol, :modifier, :args)
+  MODIFIERS = { :ne => :ne, :not => :ne, :in => :in, :eq => :eq,
+                :gt => :gt, :ge => :ge, :gte => :ge,
+                :lt => :lt, :le => :le, :lte => :le}
+
+  def self.hook
+    Symbol.class_eval do
+      MODIFIERS.each do |modifier_name, modifier|
+        define_method modifier_name do |*args|
+          NoBrainer::DecoratedSymbol.new(self, modifier, args)
+        end
+      end
+    end
+  end
+end

data/lib/no_brainer/document.rb

@@ -0,0 +1,18 @@
+require 'active_model'
+
+module NoBrainer::Document
+  extend ActiveSupport::Concern
+  extend NoBrainer::Autoload
+
+  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Persistance, :Dirty,
+                       :Id, :Association, :Serialization, :Criteria, :Validation,
+                       :Polymorphic, :Index
+
+  autoload :DynamicAttributes, :Timestamps
+
+  included do
+    include Timestamps if NoBrainer::Config.auto_include_timestamps
+  end
+
+  singleton_class.delegate :all, :to => Core
+end

data/lib/no_brainer/document/association.rb

@@ -0,0 +1,41 @@
+module NoBrainer::Document::Association
+  extend NoBrainer::Autoload
+  autoload :Core, :BelongsTo, :HasMany
+
+  extend ActiveSupport::Concern
+
+  included do
+    class << self; attr_accessor :association_metadata; end
+    self.association_metadata = {}
+  end
+
+  def association(metadata)
+    @associations ||= {}
+    @associations[metadata] ||= metadata.new(self)
+  end
+
+  module ClassMethods
+    def inherited(subclass)
+      super
+      subclass.association_metadata = self.association_metadata.dup
+    end
+
+    [:belongs_to, :has_many].each do |association|
+      define_method(association) do |target, options={}|
+        target = target.to_sym
+
+        if r = self.association_metadata[target]
+          r.options.merge!(options)
+        else
+          metadata_klass = NoBrainer::Document::Association.const_get(association.to_s.camelize).const_get(:Metadata)
+          r = metadata_klass.new(self, target, options)
+          ([self] + descendants).each do |klass|
+            klass.association_metadata[target] = r
+          end
+        end
+        r.hook
+        r
+      end
+    end
+  end
+end

data/lib/no_brainer/document/association/belongs_to.rb

@@ -0,0 +1,64 @@
+class NoBrainer::Document::Association::BelongsTo
+  include NoBrainer::Document::Association::Core
+
+  class Metadata
+    VALID_BELONGS_TO_OPTIONS = [:foreign_key, :class_name, :index]
+    include NoBrainer::Document::Association::Core::Metadata
+
+    def foreign_key
+      # TODO test :foreign_key
+      options[:foreign_key].try(:to_sym) || :"#{target_name}_id"
+    end
+
+    def target_klass
+      # TODO test :class_name
+      (options[:class_name] || target_name.to_s.camelize).constantize
+    end
+
+    def hook
+      super
+      options.assert_valid_keys(*VALID_BELONGS_TO_OPTIONS)
+
+      owner_klass.field foreign_key, :index => options[:index]
+      delegate("#{foreign_key}=", :assign_foreign_key, :call_super => true)
+      add_callback_for(:after_validation)
+    end
+
+    def eager_load(docs, criteria=nil)
+      target_criteria = target_klass.all
+      target_criteria = target_criteria.merge(criteria) if criteria
+      docs_fks = Hash[docs.map { |doc| [doc, doc.read_attribute(foreign_key)] }]
+      fks = docs_fks.values.compact.uniq
+      fk_targets = Hash[target_criteria.where(:id.in => fks).map { |doc| [doc.id, doc] }]
+      docs_fks.each { |doc, fk| doc.association(self)._write(fk_targets[fk]) if fk_targets[fk] }
+      fk_targets.values
+    end
+  end
+
+  def assign_foreign_key(value)
+    @target = nil
+  end
+
+  def read
+    return @target if @target && NoBrainer::Config.cache_documents
+    if fk = instance.read_attribute(foreign_key)
+      @target = target_klass.find(fk)
+    end
+  end
+
+  def _write(target)
+    @target = target
+  end
+
+  def write(target)
+    assert_target_type(target)
+    instance.write_attribute(foreign_key, target.try(:id))
+    _write(target)
+  end
+
+  def after_validation_callback
+    if @target && !@target.persisted?
+      raise NoBrainer::Error::AssociationNotSaved.new("#{target_name} must be saved first")
+    end
+  end
+end

data/lib/no_brainer/document/association/core.rb

@@ -0,0 +1,64 @@
+module NoBrainer::Document::Association::Core
+  extend ActiveSupport::Concern
+
+  module Metadata
+    extend ActiveSupport::Concern
+
+    attr_accessor :owner_klass, :target_name, :options
+
+    def initialize(owner_klass, target_name, options={})
+      @owner_klass = owner_klass
+      @target_name = target_name
+      @options = options
+    end
+
+    def association_klass
+      @association_klass ||= self.class.name.deconstantize.constantize
+    end
+
+    def new(instance)
+      association_klass.new(self, instance)
+    end
+
+    def delegate(method_name, target, options={})
+      metadata = self
+      owner_klass.inject_in_layer :associations do
+        define_method(method_name) do |*args, &block|
+          super(*args, &block) if options[:call_super]
+          association(metadata).__send__(target, *args, &block)
+        end
+      end
+    end
+
+    def hook
+      delegate("#{target_name}=", :write)
+      delegate("#{target_name}", :read)
+    end
+
+    def add_callback_for(what)
+      instance_eval <<-RUBY, __FILE__, __LINE__+1
+        if !@added_#{what}
+          metadata = self
+          owner_klass.#{what} { association(metadata).#{what}_callback }
+          @added_#{what} = true
+        end
+      RUBY
+    end
+  end
+
+  included { attr_accessor :metadata, :instance }
+
+  delegate :foreign_key, :target_name, :target_klass, :to => :metadata
+
+  def initialize(metadata, instance)
+    @metadata = metadata
+    @instance = instance
+  end
+
+  def assert_target_type(value)
+    unless value.is_a?(target_klass) || value.nil?
+      msg = "Trying to use a #{value.class} as a #{target_name}"
+      raise NoBrainer::Error::InvalidType.new(msg)
+    end
+  end
+end