nobrainer 0.8.0

data/lib/no_brainer/document/injection_layer.rb

@@ -0,0 +1,12 @@
+module NoBrainer::Document::InjectionLayer
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def inject_in_layer(name, code=nil, file=nil, line=nil, &block)
+      mod = class_eval "module NoBrainer; module #{name.to_s.camelize}; self; end; end"
+      mod.module_eval(code, file, line) if code
+      mod.module_exec(&block) if block
+      include mod
+    end
+  end
+end

data/lib/no_brainer/document/persistance.rb

@@ -0,0 +1,124 @@
+module NoBrainer::Document::Persistance
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create, :update, :save, :destroy, :terminator => 'false'
+  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 reload(options={})
+    unless options[:keep_ivars]
+      id = self.id
+      instance_variables.each { |ivar| remove_instance_variable(ivar) }
+      @attributes = {}
+      self.id = id
+    end
+    assign_attributes(selector.raw.first!, :pristine => true, :from_db => true)
+    self
+  end
+
+  def _create(options={})
+    run_callbacks :create do
+      if options[:validate] && !valid?
+        false
+      else
+        keys = self.class.insert_all(attributes)
+        self.id ||= keys.first
+        @new_record = false
+        true
+      end
+    end
+  end
+
+  def update(options={}, &block)
+    run_callbacks :update do
+      if options[:validate] && !valid?
+        false
+      else
+        selector.update_all(&block)
+        true
+      end
+    end
+  end
+
+  def replace(options={}, &block)
+    run_callbacks :update do
+      if options[:validate] && !valid?
+        false
+      else
+        selector.replace_all(&block)
+        true
+      end
+    end
+  end
+
+  def save(options={})
+    options = options.reverse_merge(:validate => true)
+    run_callbacks :save do
+      new_record? ? _create(options) : replace(options) { attributes }
+    end
+  end
+
+  def save!(*args)
+    save(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  end
+
+  def update_attributes(attrs, options={})
+    assign_attributes(attrs, options)
+    save(options)
+  end
+
+  def update_attributes!(*args)
+    update_attributes(*args) or raise NoBrainer::Error::DocumentInvalid, self
+  end
+
+  def delete
+    unless @destroyed
+      selector.delete_all
+      @destroyed = true
+    end
+    # TODO freeze attributes
+    true
+  end
+
+  def destroy
+    run_callbacks(:destroy) { delete }
+  end
+
+  module ClassMethods
+    def create(attrs={}, options={})
+      new(attrs, options).tap { |doc| doc.save(options) }
+    end
+
+    def create!(attrs={}, options={})
+      new(attrs, options).tap { |doc| doc.save!(options) }
+    end
+
+    def insert_all(*attrs)
+      result = NoBrainer.run(rql_table.insert(*attrs))
+      result['generated_keys'].to_a
+    end
+
+    def sync
+      NoBrainer.run(rql_table.sync)['synced'] == 1
+    end
+  end
+end

data/lib/no_brainer/document/polymorphic.rb

@@ -0,0 +1,43 @@
+module NoBrainer::Document::Polymorphic
+  extend ActiveSupport::Concern
+  include ActiveSupport::DescendantsTracker
+
+  included do
+    class_attribute :root_class
+    self.root_class = self
+  end
+
+  def assign_attributes(*args)
+    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
+
+    def all
+      criterion = super
+      criterion = criterion.where(:_type.in => descendants_type_values) unless is_root_class?
+      criterion
+    end
+  end
+end

data/lib/no_brainer/document/serialization.rb

@@ -0,0 +1,9 @@
+module NoBrainer::Document::Serialization
+  extend ActiveSupport::Concern
+
+  include ActiveModel::Serialization
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Serializers::Xml
+
+  included { self.include_root_in_json = NoBrainer::Config.include_root_in_json }
+end

data/lib/no_brainer/document/store_in.rb

@@ -0,0 +1,33 @@
+module NoBrainer::Document::StoreIn
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :store_in_options
+    self.store_in_options = {}
+  end
+
+  module ClassMethods
+    def store_in(options)
+      raise "store_in() must be called on the parent class" unless root_class?
+      self.store_in_options.merge!(options)
+    end
+
+    def database_name
+      db = self.store_in_options[:database]
+      db.is_a?(Proc) ? db.call : db
+    end
+
+    def table_name
+      table = store_in_options[:table]
+      table_name = table.is_a?(Proc) ? table.call : table
+      table_name || root_class.name.underscore.gsub('/', '__').pluralize
+    end
+
+    def rql_table
+      db = self.database_name
+      rql = RethinkDB::RQL.new
+      rql = rql.db(db) if db
+      rql.table(table_name)
+    end
+  end
+end

data/lib/no_brainer/document/timestamps.rb

@@ -0,0 +1,18 @@
+module NoBrainer::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/no_brainer/document/validation.rb

@@ -0,0 +1,35 @@
+module NoBrainer::Document::Validation
+  extend ActiveSupport::Concern
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+
+  # TODO Test that thing
+  def valid?(context=nil)
+    super(context || (new_record? ? :create : :update))
+  end
+
+  module ClassMethods
+    def validates_uniqueness_of(*attr_names)
+      validates_with UniquenessValidator, _merge_attributes(attr_names)
+    end
+  end
+
+  class UniquenessValidator < ActiveModel::EachValidator
+    def validate_each(doc, attr, value)
+      criteria = doc.root_class.unscoped.where(attr => value)
+      criteria = apply_scopes(criteria, doc)
+      criteria = exclude_doc(criteria, doc) if doc.persisted?
+      is_unique = criteria.count == 0
+      doc.errors.add(attr, :taken, options.except(:scope).merge(:value => value)) unless is_unique
+      is_unique
+    end
+
+    def apply_scopes(criteria, doc)
+      criteria.where([*options[:scope]].map { |k| {k => doc.read_attribute(k)} })
+    end
+
+    def exclude_doc(criteria, doc)
+      criteria.where(:id.ne => doc.id)
+    end
+  end
+end

data/lib/no_brainer/error.rb

@@ -0,0 +1,10 @@
+module NoBrainer::Error
+  class Connection          < StandardError; end
+  class DocumentNotFound    < StandardError; end
+  class DocumentInvalid     < StandardError; end
+  class DocumentNotSaved    < StandardError; end
+  class ChildrenExist       < StandardError; end
+  class CannotUseIndex      < StandardError; end
+  class InvalidType         < StandardError; end
+  class AssociationNotSaved < StandardError; end
+end

data/lib/no_brainer/fork.rb

@@ -0,0 +1,14 @@
+module NoBrainer::Fork
+  def self.hook
+    Kernel.module_eval do
+      alias_method :fork_without_nobrainer, :fork
+
+      def fork(&block)
+        NoBrainer.disconnect
+        fork_without_nobrainer(&block)
+      end
+
+      module_function :fork
+    end
+  end
+end

data/lib/no_brainer/index_manager.rb

@@ -0,0 +1,6 @@
+module NoBrainer::IndexManager
+  def self.update_indexes(options={})
+    Rails.application.eager_load! if defined?(Rails)
+    NoBrainer::Document.all.each { |model| model.perform_update_indexes(options) }
+  end
+end

data/lib/no_brainer/loader.rb

@@ -0,0 +1,5 @@
+module NoBrainer::Loader
+  def self.cleanup
+    NoBrainer::Document.all.clear
+  end
+end

data/lib/no_brainer/locale/en.yml

@@ -0,0 +1,4 @@
+en:
+  errors:
+    messages:
+      taken: "is already taken"

data/lib/no_brainer/query_runner.rb

@@ -0,0 +1,37 @@
+require 'middleware'
+require 'rethinkdb'
+
+module NoBrainer::QueryRunner
+  extend NoBrainer::Autoload
+
+  class Middleware
+    def initialize(runner)
+      @runner = runner
+    end
+  end
+
+  autoload :Driver, :DatabaseOnDemand, :TableOnDemand, :WriteError,
+           :Connection, :Selection, :RunOptions, :Logger
+
+  class << self
+    attr_accessor :stack
+
+    def run(*args, &block)
+      options = args.extract_options!
+      raise ArgumentError unless args.size == 1 || block
+      query = args.first || block.call(RethinkDB::RQL.new)
+      stack.call(:query => query, :options => options)
+    end
+  end
+
+  # thread-safe, since require() is ran with a mutex.
+  self.stack = ::Middleware::Builder.new do
+    use RunOptions
+    use Connection
+    use WriteError
+    use DatabaseOnDemand
+    use TableOnDemand
+    use Logger
+    use Driver
+  end
+end

data/lib/no_brainer/query_runner/connection.rb

@@ -0,0 +1,17 @@
+class NoBrainer::QueryRunner::Connection < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env)
+  rescue RuntimeError, NoBrainer::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) < NoBrainer::Config.max_reconnection_tries
+    end
+    raise e
+  end
+end

data/lib/no_brainer/query_runner/database_on_demand.rb

@@ -0,0 +1,26 @@
+class NoBrainer::QueryRunner::DatabaseOnDemand < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    @runner.call(env)
+  rescue RuntimeError => e
+    if NoBrainer::Config.auto_create_databases &&
+       e.message =~ /^Database `(.+)` does not exist\.$/
+      auto_create_database(env, $1)
+      retry
+    end
+    raise
+  end
+
+  private
+
+  def auto_create_database(env, database_name)
+    if env[:auto_create_database] == database_name
+      raise "Auto database creation is not working with #{database_name}"
+    end
+    env[:auto_create_database] = database_name
+
+    NoBrainer.db_create(database_name)
+  rescue RuntimeError => e
+    # We might have raced with another db_create
+    raise unless e.message =~ /Database `#{database_name}` already exists/
+  end
+end

data/lib/no_brainer/query_runner/driver.rb

@@ -0,0 +1,8 @@
+class NoBrainer::QueryRunner::Driver < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    env[:query].run(NoBrainer.connection, env[:options])
+  rescue NoMethodError => e
+    raise "NoBrainer is not connected to a RethinkDB instance" unless NoBrainer.connection
+    raise e
+  end
+end

data/lib/no_brainer/query_runner/logger.rb

@@ -0,0 +1,29 @@
+class NoBrainer::QueryRunner::Logger < NoBrainer::QueryRunner::Middleware
+  def call(env)
+    start_time = Time.now
+    res = @runner.call(env)
+    if NoBrainer.logger and NoBrainer.logger.debug?
+      duration = Time.now - start_time
+      msg = env[:query].inspect.gsub(/\n/, '').gsub(/ +/, ' ')
+
+      # Need to fix the rethinkdb gem.
+      if msg =~ /Erroneous_Portion_Constructed/
+        msg = "r.the_rethinkdb_gem_is_flipping_out_with_Erroneous_Portion_Constructed"
+      end
+
+      msg = "(#{env[:db_name]}) #{msg}" if env[:db_name]
+      msg = "[#{(duration * 1000.0).round(1)}ms] #{msg}"
+
+      if NoBrainer::Config.colorize_logger
+        case NoBrainer::Util.rql_type(env[:query])
+        when :write      then msg = "\e[1;31m#{msg}\e[0m" # red
+        when :read       then msg = "\e[1;32m#{msg}\e[0m" # green
+        when :management then msg = "\e[1;33m#{msg}\e[0m" # yellow
+        end
+      end
+
+      NoBrainer.logger.debug(msg)
+    end
+    res
+  end
+end