nobrainer 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 572e2605dd72110fd1289cd62b1faa0bf34ae8ef
+  data.tar.gz: 55e77059966a3a7cd4d7e95925572304421b20cc
+SHA512:
+  metadata.gz: f55312ff9a9617ac05f987a27b4318fe6b039f71e3d52025079c8649d1d41517ed3b3e24023ae29c3f0dc2f16402c9f5d5e5075fdc6553d8184de64c614c0a42
+  data.tar.gz: 5337d0ae57e1de9303483df505b02c708ac06e735f44ff794a9c72ac0a8b06e972599ba15735744a82e9286942a9de7ae137c99d6b358c3285bf4f6651a5576d

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (C) 2012 Nicolas Viennot
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+NoBrainer
+===========
+
+NoBrainer is a Ruby ORM for [RethinkDB](http://www.rethinkdb.com/).
+
+The documentation can be found on [http://nobrainer.io](http://nobrainer.io).

data/lib/no_brainer/autoload.rb

@@ -0,0 +1,14 @@
+module NoBrainer::Autoload
+  include ActiveSupport::Autoload
+
+  def autoload(*args)
+    args.each { |mod| super mod }
+  end
+
+  def autoload_and_include(*mods)
+    mods.each do |mod|
+      autoload mod
+      include const_get mod
+    end
+  end
+end

data/lib/no_brainer/config.rb

@@ -0,0 +1,61 @@
+module NoBrainer::Config
+  class << self
+    mattr_accessor :rethinkdb_url, :logger, :warn_on_active_record,
+                   :auto_create_databases, :auto_create_tables,
+                   :cache_documents, :auto_include_timestamps,
+                   :max_reconnection_tries, :include_root_in_json,
+                   :durability, :colorize_logger
+
+    def apply_defaults
+      self.rethinkdb_url           = default_rethinkdb_url
+      self.logger                  = default_logger
+      self.warn_on_active_record   = true
+      self.auto_create_databases   = true
+      self.auto_create_tables      = true
+      self.cache_documents         = true
+      self.auto_include_timestamps = true
+      self.max_reconnection_tries  = 10
+      self.include_root_in_json    = false
+      self.durability              = default_durability
+      self.colorize_logger         = true
+    end
+
+    def reset!
+      @configured = false
+      apply_defaults
+    end
+
+    def configure(&block)
+      apply_defaults unless configured?
+      block.call(self) if block
+      @configured = true
+
+      NoBrainer.disconnect_if_url_changed
+    end
+
+    def configured?
+      !!@configured
+    end
+
+    def default_rethinkdb_url
+      return ENV['RETHINKDB_URL'] if ENV['RETHINKDB_URL']
+
+      if defined?(Rails)
+        host = ENV['RETHINKDB_HOST'] || 'localhost'
+        port = ENV['RETHINKDB_PORT']
+        auth = ENV['RETHINKDB_AUTH']
+        db_name = "#{Rails.application.class.parent_name.underscore}_#{Rails.env}"
+
+        "rethinkdb://#{":#{auth}@" if auth}#{host}#{":#{port}" if port}/#{db_name}"
+      end
+    end
+
+    def default_logger
+      defined?(Rails) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
+    end
+
+    def default_durability
+      (defined?(Rails) && (Rails.env.test? || Rails.env.development?)) ? :soft : :hard
+    end
+  end
+end

data/lib/no_brainer/connection.rb

@@ -0,0 +1,53 @@
+require 'rethinkdb'
+
+class NoBrainer::Connection
+  # A connection is bound to a specific database.
+
+  attr_accessor :uri, :host, :port, :database_name, :auth_key
+
+  def initialize(uri)
+    self.uri = uri
+    parse_uri
+  end
+
+  def raw
+    @raw ||= RethinkDB::Connection.new(:host => host, :port => port, :db => database_name, :auth_key => auth_key)
+  end
+
+  delegate :reconnect, :close, :run, :to => :raw
+  alias_method :connect, :raw
+  alias_method :disconnect, :close
+
+  [:db_create, :db_drop, :db_list].each do |cmd|
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{cmd}(*args)
+        NoBrainer.run { |r| r.#{cmd}(*args) }
+      end
+    RUBY
+  end
+
+  def database
+    @database ||= NoBrainer::Database.new(self)
+  end
+
+  private
+
+  def parse_uri
+    require 'uri'
+    parsed_uri = URI.parse(uri)
+
+    if parsed_uri.scheme != 'rethinkdb'
+      raise NoBrainer::Error::Connection,
+        "Invalid URI. Expecting something like rethinkdb://host:port/database. Got #{uri}"
+    end
+
+    apply_connection_settings!(parsed_uri)
+  end
+
+  def apply_connection_settings!(uri)
+    self.host = uri.host
+    self.port = uri.port || 28015
+    self.database_name = uri.path.gsub(/^\//, '')
+    self.auth_key = uri.password
+  end
+end

data/lib/no_brainer/criteria.rb

@@ -0,0 +1,20 @@
+require 'rethinkdb'
+
+class NoBrainer::Criteria
+  # The disctinction between Chainable and Termination is purely cosmetic.
+  module Chainable
+    extend NoBrainer::Autoload
+    extend ActiveSupport::Concern
+    autoload_and_include :Core, :Scope, :Raw, :Where, :OrderBy, :Limit
+  end
+
+  module Termination
+    extend NoBrainer::Autoload
+    extend ActiveSupport::Concern
+    autoload_and_include :Count, :Delete, :Enumerable, :First, :EagerLoading,
+                         :Inc, :Update, :Cache
+  end
+
+  include Chainable
+  include Termination
+end

data/lib/no_brainer/criteria/chainable/core.rb

@@ -0,0 +1,67 @@
+module NoBrainer::Criteria::Chainable::Core
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :options }
+
+  def initialize(options={})
+    self.options = options
+  end
+
+  def klass
+    options[:klass]
+  end
+
+  def to_rql
+    compile_criteria.__send__(:compile_rql)
+  end
+
+  def inspect
+    # rescue super because sometimes klass is not set.
+    str = to_rql.inspect rescue super
+    if str =~ /Erroneous_Portion_Constructed/
+      # Need to fix the rethinkdb gem.
+      str = "the rethinkdb gem is flipping out with Erroneous_Portion_Constructed"
+    end
+    str
+  end
+
+  def run(rql=nil)
+    NoBrainer.run(rql || to_rql)
+  end
+
+  def merge!(criteria)
+    self.options = self.options.merge(criteria.options)
+    self
+  end
+
+  def merge(criteria)
+    dup.tap { |new_criteria| new_criteria.merge!(criteria) }
+  end
+
+  def ==(other)
+    return super if other.is_a?(NoBrainer::Criteria)
+    return to_a == other if other.is_a?(Enumerable) && other.first.is_a?(NoBrainer::Document)
+    super
+  end
+
+  private
+
+  def chain(&block)
+    tmp = self.class.new(options) # we might want to optimize that thing
+    block.call(tmp)
+    merge(tmp)
+  end
+
+  def compile_criteria
+    # This method is overriden by other modules.
+    # compile_criteria returns a criteria that will be used to generate the RQL.
+    # This is useful to apply the class default scope at the very end of the chain.
+    self
+  end
+
+  def compile_rql
+    # This method is overriden by other modules.
+    raise "Criteria not bound to a class" unless klass
+    klass.rql_table
+  end
+end

data/lib/no_brainer/criteria/chainable/limit.rb

@@ -0,0 +1,31 @@
+module NoBrainer::Criteria::Chainable::Limit
+  # TODO Test these guys
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_skip, :_limit }
+
+  def limit(value)
+    chain { |criteria| criteria._limit = value }
+  end
+
+  def skip(value)
+    chain { |criteria| criteria._skip = value }
+  end
+  alias_method :offset, :skip
+
+  def merge!(criteria)
+    super
+    self._skip = criteria._skip if criteria._skip
+    self._limit = criteria._limit if criteria._limit
+    self
+  end
+
+  private
+
+  def compile_rql
+    rql = super
+    rql = rql.skip(_skip) if _skip
+    rql = rql.limit(_limit) if _limit
+    rql
+  end
+end

data/lib/no_brainer/criteria/chainable/order_by.rb

@@ -0,0 +1,76 @@
+module NoBrainer::Criteria::Chainable::OrderBy
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :order, :_reverse_order }
+
+  def initialize(options={})
+    super
+    self.order = {}
+  end
+
+  def order_by(*rules, &block)
+    # Note: We are relying on the fact that Hashes are ordered (since 1.9)
+    rules = [*rules, block].compact.map do |rule|
+      case rule
+      when Hash then
+        bad_rule = rule.values.reject { |v| v.in? [:asc, :desc] }.first
+        raise_bad_rule(bad_rule) if bad_rule
+        rule
+      when Symbol then { rule => :asc }
+      when Proc   then { rule => :asc }
+      else raise_bad_rule(rule)
+      end
+    end.reduce({}, :merge)
+
+    chain do |criteria|
+      criteria.order = rules
+      criteria._reverse_order = false
+    end
+  end
+
+  def merge!(criteria)
+    super
+    # The latest order_by() wins
+    self.order = criteria.order if criteria.order.present?
+    self._reverse_order = criteria._reverse_order unless criteria._reverse_order.nil?
+    self
+  end
+
+  def reverse_order
+    chain { |criteria| criteria._reverse_order = !self._reverse_order }
+  end
+
+  private
+
+  def effective_order
+    self.order.present? ? self.order : {:id => :asc}
+  end
+
+  def reverse_order?
+    !!self._reverse_order
+  end
+
+  def compile_rql
+    rql_rules = effective_order.map do |k,v|
+      case v
+      when :asc  then reverse_order? ? RethinkDB::RQL.new.desc(k) : RethinkDB::RQL.new.asc(k)
+      when :desc then reverse_order? ? RethinkDB::RQL.new.asc(k)  : RethinkDB::RQL.new.desc(k)
+      end
+    end
+
+    options = {}
+    unless without_index?
+      first_key = effective_order.first[0]
+      first_key = nil if first_key == :id # FIXME For some reason, using the id index doesn't work.
+      if (first_key.is_a?(Symbol) || first_key.is_a?(String)) && klass.has_index?(first_key)
+        options[:index] = rql_rules.shift
+      end
+    end
+
+    super.order_by(*rql_rules, options)
+  end
+
+  def raise_bad_rule(rule)
+    raise "Please pass something like ':field1 => :desc, :field2 => :asc', not #{rule}"
+  end
+end

data/lib/no_brainer/criteria/chainable/raw.rb

@@ -0,0 +1,25 @@
+module NoBrainer::Criteria::Chainable::Raw
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :_raw }
+
+  def raw
+    chain { |criteria| criteria._raw = true }
+  end
+
+  def merge!(criteria)
+    super
+    self._raw = criteria._raw unless criteria._raw.nil?
+    self
+  end
+
+  private
+
+  def raw?
+    !!_raw
+  end
+
+  def instantiate_doc(attrs)
+    raw? ? attrs : klass.new_from_db(attrs)
+  end
+end

data/lib/no_brainer/criteria/chainable/scope.rb

@@ -0,0 +1,41 @@
+module NoBrainer::Criteria::Chainable::Scope
+  extend ActiveSupport::Concern
+
+  included { attr_accessor :use_default_scope }
+
+  def scoped
+    chain { |criteria| criteria.use_default_scope = true }
+  end
+
+  def unscoped
+    chain { |criteria| criteria.use_default_scope = false }
+  end
+
+  def merge!(criteria)
+    super
+    self.use_default_scope = criteria.use_default_scope unless criteria.use_default_scope.nil?
+    self
+  end
+
+  def respond_to?(name, include_private = false)
+    super || self.klass.respond_to?(name)
+  end
+
+  def method_missing(name, *args, &block)
+    return super unless self.klass.respond_to?(name)
+    criteria = self.klass.method(name).call(*args, &block)
+    raise "#{name} did not return a criteria" unless criteria.is_a?(NoBrainer::Criteria)
+    merge(criteria)
+  end
+
+  private
+
+  def compile_criteria
+    criteria = super
+    if klass.default_scope_proc && use_default_scope != false
+      criteria = klass.default_scope_proc.call.merge(criteria)
+      # XXX If default_scope.class != criteria.class, oops
+    end
+    criteria
+  end
+end

data/lib/no_brainer/criteria/chainable/where.rb

@@ -0,0 +1,198 @@
+module NoBrainer::Criteria::Chainable::Where
+  extend ActiveSupport::Concern
+
+  RESERVED_FIELDS = [:index, :default, :and, :or] + NoBrainer::DecoratedSymbol::MODIFIERS.keys
+
+  included { attr_accessor :where_ast, :with_index_name }
+
+  def initialize(options={})
+    super
+    self.where_ast = MultiOperator.new(:and, [])
+  end
+
+  def where(*args, &block)
+    chain { |criteria| criteria.where_ast = parse_clause([*args, block].compact) }
+  end
+
+  def with_index(index_name)
+    chain { |criteria| criteria.with_index_name = index_name }
+  end
+
+  def without_index
+    with_index(false)
+  end
+
+  def used_index
+    IndexFinder.new(compile_criteria).tap { |finder| finder.find_index }.index_name
+  end
+
+  def indexed?
+    !!used_index
+  end
+
+  def merge!(criteria)
+    super
+    clauses = self.where_ast.clauses + criteria.where_ast.clauses
+    self.where_ast = MultiOperator.new(:and, clauses).simplify
+    self.with_index_name = criteria.with_index_name unless criteria.with_index_name.nil?
+    self
+  end
+
+  private
+
+  class MultiOperator < Struct.new(:op, :clauses)
+    def simplify
+      same_op_clauses, other_clauses = self.clauses.map(&:simplify)
+        .partition { |v| v.is_a?(MultiOperator) && self.op == v.op }
+      simplified_clauses = other_clauses + same_op_clauses.map(&:clauses).flatten(1)
+      MultiOperator.new(op, simplified_clauses.uniq)
+    end
+
+    def to_rql(doc)
+      case op
+      when :and then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a & b }
+      when :or  then clauses.map { |c| c.to_rql(doc) }.reduce { |a,b| a | b }
+      end
+    end
+  end
+
+  class BinaryOperator < Struct.new(:key, :op, :value)
+    def simplify
+      self
+    end
+
+    def to_rql(doc)
+      case op
+      when :between then (doc[key] >= value.min) & (doc[key] <= value.max)
+      when :in then value.map { |v| doc[key].eq(v) }.reduce { |a,b| a | b }
+      else doc[key].__send__(op, value)
+      end
+    end
+  end
+
+  class UnaryOperator < Struct.new(:op, :value)
+    def simplify
+      value.is_a?(UnaryOperator) && [self.op, value.op] == [:not, :not] ? value.value : self
+    end
+
+    def to_rql(doc)
+      case op
+      when :not then value.to_rql(doc).not
+      end
+    end
+  end
+
+  class Lambda < Struct.new(:value)
+    def simplify
+      self
+    end
+
+    def to_rql(doc)
+      value.call(doc)
+    end
+  end
+
+  def parse_clause(clause)
+    case clause
+    when Array then MultiOperator.new(:and, clause.map { |c| parse_clause(c) })
+    when Hash  then MultiOperator.new(:and, clause.map { |k,v| parse_clause_stub(k,v) })
+    when Proc  then Lambda.new(clause)
+    when NoBrainer::DecoratedSymbol
+      case clause.args.size
+      when 1 then parse_clause_stub(clause, clause.args.first)
+      else raise "Invalid argument: #{clause}"
+      end
+    else raise "Invalid clause: #{clause}"
+    end
+  end
+
+  def parse_clause_stub(key, value)
+    case key
+    when :and then MultiOperator.new(:and, value.map { |v| parse_clause(v) })
+    when :or  then MultiOperator.new(:or,  value.map { |v| parse_clause(v) })
+    when :not then UnaryOperator.new(:not, parse_clause(value))
+    when String, Symbol then parse_clause_stub(key.to_sym.eq, value)
+    when NoBrainer::DecoratedSymbol then
+      case key.modifier
+      when :ne then parse_clause(:not => { key.symbol => value })
+      when :eq then
+        case value
+        when Range  then BinaryOperator.new(key.symbol, :between, value)
+        when Regexp then BinaryOperator.new(key.symbol, :match, value.inspect[1..-2])
+        else BinaryOperator.new(key.symbol, key.modifier, value)
+        end
+      else BinaryOperator.new(key.symbol, key.modifier, value)
+      end
+    else raise "Invalid key: #{key}"
+    end
+  end
+
+  def without_index?
+    self.with_index_name == false
+  end
+
+  class IndexFinder < Struct.new(:criteria, :index_name, :indexed_values, :ast)
+    def get_candidate_clauses(*types)
+      Hash[criteria.where_ast.clauses
+        .select { |c| c.is_a?(BinaryOperator) && types.include?(c.op) }
+        .map { |c| [c.key, c] }]
+    end
+
+    def get_usable_indexes(*types)
+      indexes = criteria.klass.indexes
+      indexes = indexes.select { |k,v| types.include?(v[:kind]) } if types.present?
+      indexes = indexes.select { |k,v| k == criteria.with_index_name.to_sym } if criteria.with_index_name
+      indexes
+    end
+
+    def find_index_canonical
+      clauses = get_candidate_clauses(:eq, :in)
+      return unless clauses.present?
+
+      if index_name = (get_usable_indexes.keys & clauses.keys).first
+        clause = clauses[index_name]
+        self.index_name = index_name
+        self.indexed_values = clause.op == :in ? clause.value : [clause.value]
+        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - [clause])
+      end
+    end
+
+    def find_index_compound
+      clauses = get_candidate_clauses(:eq)
+      return unless clauses.present?
+
+      index_name, index_values = get_usable_indexes(:compound)
+        .map    { |name, option| [name, option[:what]] }
+        .select { |name, values| values & clauses.keys == values }
+        .first
+
+      if index_name
+        indexed_clauses = index_values.map { |field| clauses[field] }
+        self.index_name = index_name
+        self.indexed_values = [indexed_clauses.map { |c| c.value }]
+        self.ast = MultiOperator.new(:and, criteria.where_ast.clauses - indexed_clauses)
+      end
+    end
+
+    def find_index
+      return false if criteria.__send__(:without_index?)
+      could_find_index = find_index_canonical || find_index_compound
+      if criteria.with_index_name && !could_find_index
+        raise NoBrainer::Error::CannotUseIndex.new("Cannot use index #{criteria.with_index_name}")
+      end
+      !!could_find_index
+    end
+  end
+
+  def compile_rql
+    rql = super
+    ast = self.where_ast
+    finder = IndexFinder.new(self)
+    if finder.find_index
+      ast = finder.ast
+      rql = rql.get_all(*finder.indexed_values, :index => finder.index_name)
+    end
+    rql = rql.filter { |doc| ast.to_rql(doc) } if ast.clauses.present?
+    rql
+  end
+end