nobrainer 0.8.0

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

@@ -0,0 +1,68 @@
+class NoBrainer::Document::Association::HasMany
+  include NoBrainer::Document::Association::Core
+
+  class Metadata
+    VALID_HAS_MANY_OPTIONS = [:foreign_key, :class_name, :dependent]
+    include NoBrainer::Document::Association::Core::Metadata
+
+    def foreign_key
+      # TODO test :foreign_key
+      options[:foreign_key].try(:to_sym) || :"#{owner_klass.name.underscore}_id"
+    end
+
+    def target_klass
+      # TODO test :class_name
+      (options[:class_name] || target_name.to_s.singularize.camelize).constantize
+    end
+
+    def hook
+      super
+      options.assert_valid_keys(*VALID_HAS_MANY_OPTIONS)
+      add_callback_for(:before_destroy)
+    end
+
+    def eager_load(docs, criteria=nil)
+      target_criteria = target_klass.all
+      target_criteria = target_criteria.merge(criteria) if criteria
+      docs_ids = Hash[docs.map { |doc| [doc, doc.id] }]
+      fk_targets = target_criteria
+        .where(foreign_key.in => docs_ids.values)
+        .reduce({}) do |hash, doc|
+          fk = doc.read_attribute(foreign_key)
+          hash[fk] ||= []
+          hash[fk] << doc
+          hash
+        end
+      docs_ids.each { |doc, id| doc.association(self)._write(fk_targets[id]) if fk_targets[id] }
+      fk_targets.values.flatten(1)
+    end
+  end
+
+  def children_criteria
+    @children_criteria ||= target_klass.where(foreign_key => instance.id)
+  end
+
+  def read
+    children_criteria
+  end
+
+  def write(new_children)
+    raise "You can't assign the array of #{target_name}. Instead, you must modify delete and create #{target_klass} manually."
+  end
+
+  def _write(new_children)
+    children_criteria._override_cache(new_children)
+  end
+
+  def before_destroy_callback
+    criteria = children_criteria.unscoped
+    case metadata.options[:dependent]
+    when nil       then
+    when :destroy  then criteria.destroy_all
+    when :delete   then criteria.delete_all
+    when :nullify  then criteria.update_all(foreign_key => nil)
+    when :restrict then raise NoBrainer::Error::ChildrenExist unless criteria.count.zero?
+    else raise "Unrecognized dependent option: #{metadata.options[:dependent]}"
+    end
+  end
+end

data/lib/no_brainer/document/attributes.rb

@@ -0,0 +1,124 @@
+module NoBrainer::Document::Attributes
+  VALID_FIELD_OPTIONS = [:index, :default]
+  extend ActiveSupport::Concern
+
+  included do
+    # Not using class_attribute because we want to
+    # use our custom logic
+    class << self; attr_accessor :fields; end
+    self.fields = {}
+  end
+
+  def initialize(attrs={}, options={})
+    super
+    @attributes = {}
+    assign_attributes(attrs, options.reverse_merge(:pristine => true))
+  end
+
+  def attributes
+    @attributes.dup.freeze
+  end
+
+  def read_attribute(name)
+    __send__("#{name}")
+  end
+  def [](*args); read_attribute(*args); end
+
+  def write_attribute(name, value)
+    __send__("#{name}=", value)
+  end
+  def []=(*args); write_attribute(*args); end
+
+  def assign_defaults
+    self.class.fields.each do |name, field_options|
+      if field_options.has_key?(:default) && !@attributes.has_key?(name.to_s)
+        default_value = field_options[:default]
+        default_value = default_value.call if default_value.is_a?(Proc)
+        self.write_attribute(name, default_value)
+      end
+    end
+  end
+
+  def assign_attributes(attrs, options={})
+    # XXX We don't save field that are not explicitly set. The row will
+    # therefore not contain nil for unset attributes.
+    @attributes.clear if options[:pristine]
+
+    if options[:from_db]
+      # TODO Should we reject undeclared fields ?
+      #
+      # TODO Not using the getter/setters, the dirty tracking won't notice it,
+      # also we should start thinking about custom serializer/deserializer.
+      @attributes.merge! attrs
+    else
+      attrs.each { |k,v| self.write_attribute(k, v) }
+    end
+
+    assign_defaults if options[:pristine] || options[:from_db]
+    self
+  end
+  def attributes=(*args); assign_attributes(*args); end
+
+  # TODO test that thing
+  def inspect
+    attrs = self.class.fields.keys.map { |f| "#{f}: #{@attributes[f.to_s].inspect}" }
+    "#<#{self.class} #{attrs.join(', ')}>"
+  end
+
+  def to_s
+    inspect
+  end
+
+  module ClassMethods
+    def new_from_db(attrs, options={})
+      klass_from_attrs(attrs).new(attrs, options.reverse_merge(:from_db => true)) if attrs
+    end
+
+    def inherited(subclass)
+      super
+      subclass.fields = self.fields.dup
+    end
+
+    def field(name, options={})
+      name = name.to_sym
+
+      options.assert_valid_keys(*NoBrainer::Document::Attributes::VALID_FIELD_OPTIONS)
+      if name.in? NoBrainer::Criteria::Chainable::Where::RESERVED_FIELDS
+        raise "Cannot use a reserved field name: #{name}"
+      end
+
+      ([self] + descendants).each do |klass|
+        klass.fields[name] ||= {}
+        klass.fields[name].merge!(options)
+      end
+
+      # Using a layer so the user can use super when overriding these methods
+      inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}=(value)
+          @attributes['#{name}'] = value
+        end
+
+        def #{name}
+          @attributes['#{name}']
+        end
+      RUBY
+    end
+
+    def remove_field(name)
+      name = name.to_sym
+
+      ([self] + descendants).each do |klass|
+        klass.fields.delete(name)
+      end
+
+      inject_in_layer :attributes, <<-RUBY, __FILE__, __LINE__ + 1
+        undef #{name}=
+        undef #{name}
+      RUBY
+    end
+
+    def has_field?(name)
+      !!fields[name.to_sym]
+    end
+  end
+end

data/lib/no_brainer/document/core.rb

@@ -0,0 +1,20 @@
+module NoBrainer::Document::Core
+  extend ActiveSupport::Concern
+
+  class << self; attr_accessor :all; end
+  self.all = []
+
+  # 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
+
+    NoBrainer::Document::Core.all << self
+  end
+
+  def initialize(attrs={}, options={}); end
+end

data/lib/no_brainer/document/criteria.rb

@@ -0,0 +1,62 @@
+module NoBrainer::Document::Criteria
+  extend ActiveSupport::Concern
+
+  def selector
+    self.class.selector_for(id)
+  end
+
+  included do
+    class_attribute :default_scope_proc
+  end
+
+  module ClassMethods
+    delegate :to_rql,                        # Core
+             :limit, :offset, :skip,         # Limit
+             :order_by, :reverse_order,      # OrderBy
+             :scoped, :unscoped,             # Scope
+             :where, :with_index, :without_index, :used_index, :indexed?, # Where
+             :with_cache, :without_cache,    # Cache
+             :count, :empty?, :any?,         # Count
+             :delete_all, :destroy_all,      # Delete
+             :includes,                      # EagerLoading
+             :each, :to_a,                   # Enumerable
+             :first, :last, :first!, :last!, # First
+             :inc_all, :dec_all,             # Inc
+             :update_all, :replace_all,      # Update
+             :to => :all
+
+    def all
+      NoBrainer::Criteria.new(:klass => self)
+    end
+
+    def scope(name, criteria=nil, &block)
+      criteria ||= block
+      criteria_proc = criteria.is_a?(Proc) ? criteria : proc { criteria }
+      singleton_class.class_eval do
+        define_method(name) { |*args| criteria_proc.call(*args) }
+      end
+    end
+
+    def default_scope(criteria=nil, &block)
+      criteria ||= block
+      self.default_scope_proc = criteria.is_a?(Proc) ? criteria : proc { criteria }
+    end
+
+    def selector_for(id)
+      # TODO Pass primary key if not default
+      unscoped.where(:id => id)
+    end
+
+    # XXX this doesn't have the same semantics as
+    # other ORMs. the equivalent is find!.
+    def find(id)
+      selector_for(id).first
+    end
+
+    def find!(id)
+      find(id).tap do |doc|
+        raise NoBrainer::Error::DocumentNotFound, "#{self.class} id #{id} not found" unless doc
+      end
+    end
+  end
+end

data/lib/no_brainer/document/dirty.rb

@@ -0,0 +1,88 @@
+module NoBrainer::Document::Dirty
+  extend ActiveSupport::Concern
+
+  # We are not using ActiveModel::Dirty because it's using
+  # ActiveModel::AttributeMethods which gives pretty violent method_missing()
+  # capabilities, such as giving a getter/setter method for any keys within the
+  # attributes keys. We don't want that.
+
+  included do
+    attr_accessor :previous_changes
+    after_save { clear_dirtiness }
+  end
+
+  def changed_attributes
+    @changed_attributes ||= {}
+  end
+
+  def assign_attributes(attrs, options={})
+    clear_dirtiness if options[:pristine] || options[:from_db]
+    super
+  end
+
+  def clear_dirtiness
+    self.previous_changes = changes
+    self.changed_attributes.clear
+  end
+
+  def changed?
+    changed_attributes.present?
+  end
+
+  def changed
+    changed_attributes.keys
+  end
+
+  def changes
+    Hash[changed_attributes.map { |k,v| [k, [v, read_attribute(k)]] }]
+  end
+
+  def attribute_will_change!(attr, new_value)
+    return if changed_attributes.include?(attr)
+
+    # ActiveModel ignores TypeError and NoMethodError exception as if nothng
+    # happened. Why is that?
+    value = read_attribute(attr)
+    value = value.clone if value.duplicable?
+
+    return if value == new_value
+
+    changed_attributes[attr] = value
+  end
+
+  module ClassMethods
+    def field(name, options={})
+      super
+
+      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}_changed?
+          changed_attributes.include?(:#{name})
+        end
+
+        def #{name}_change
+          [changed_attributes[:#{name}], #{name}] if #{name}_changed?
+        end
+
+        def #{name}_was
+          #{name}_changed? ? changed_attributes[:#{name}] : #{name}
+        end
+
+        def #{name}=(value)
+          attribute_will_change!(:#{name}, value)
+          super
+        end
+      RUBY
+    end
+
+    def remove_field(name)
+      super
+
+      inject_in_layer :dirty_tracking, <<-RUBY, __FILE__, __LINE__ + 1
+        undef #{name}_changed?
+        undef #{name}_change
+        undef #{name}_was
+        undef #{name}=
+      RUBY
+    end
+  end
+end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -0,0 +1,12 @@
+module NoBrainer::Document::DynamicAttributes
+  extend ActiveSupport::Concern
+
+  def read_attribute(name)
+    self.respond_to?("#{name}") ? super : @attributes[name.to_s]
+  end
+
+  def write_attribute(name, value)
+    attribute_will_change!(name, value)
+    self.respond_to?("#{name}=") ? super : @attributes[name.to_s] = value
+  end
+end

data/lib/no_brainer/document/id.rb

@@ -0,0 +1,49 @@
+require 'thread'
+require 'socket'
+require 'digest/md5'
+
+module NoBrainer::Document::Id
+  extend ActiveSupport::Concern
+
+  included do
+    self.field :id, :default => ->{ NoBrainer::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/no_brainer/document/index.rb

@@ -0,0 +1,102 @@
+module NoBrainer::Document::Index
+  VALID_INDEX_OPTIONS = [:multi]
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :indexes
+    self.indexes = {}
+    self.index :id
+  end
+
+  module ClassMethods
+    def index(name, *args)
+      name = name.to_sym
+      options = args.extract_options!
+      options.assert_valid_keys(*NoBrainer::Document::Index::VALID_INDEX_OPTIONS)
+
+      raise "Too many arguments: #{args}" if args.size > 1
+
+      kind, what = case args.first
+        when nil   then [:single,   name.to_sym]
+        when Array then [:compound, args.first.map(&:to_sym)]
+        when Proc  then [:proc,     args.first]
+        else raise "Index argument must be a lambda or a list of fields"
+      end
+
+      # FIXME Primary key may not always be :id
+      if name.in?(NoBrainer::Criteria::Chainable::Where::RESERVED_FIELDS)
+        raise "Cannot use a reserved field name: #{name}"
+      end
+      if has_field?(name) && kind != :single
+        raise "Cannot reuse field name #{name}"
+      end
+
+      indexes[name] = {:kind => kind, :what => what, :options => options}
+    end
+
+    def remove_index(name)
+      indexes.delete(name.to_sym)
+    end
+
+    def has_index?(name)
+      !!indexes[name.to_sym]
+    end
+
+    def field(name, options={})
+      name = name.to_sym
+
+      if has_index?(name) && indexes[name][:kind] != :single
+        raise "Cannot reuse index name #{name}"
+      end
+
+      super
+
+      case options[:index]
+      when nil    then
+      when Hash   then index(name, options[:index])
+      when Symbol then index(name, options[:index] => true)
+      when true   then index(name)
+      when false  then remove_index(name)
+      end
+    end
+
+    def remove_field(name)
+      remove_index(name) if fields[name.to_sym][:index]
+      super
+    end
+
+    def perform_create_index(index_name, options={})
+      index_name = index_name.to_sym
+      index_args = self.indexes[index_name]
+
+      index_proc = case index_args[:kind]
+        when :single   then nil
+        when :compound then ->(doc) { index_args[:what].map { |field| doc[field] } }
+        when :proc     then index_args[:what]
+      end
+
+      NoBrainer.run(self.rql_table.index_create(index_name, index_args[:options], &index_proc))
+      NoBrainer.run(self.rql_table.index_wait(index_name)) if options[:wait]
+      STDERR.puts "Created index #{self}.#{index_name}" if options[:verbose]
+    end
+
+    def perform_drop_index(index_name, options={})
+      NoBrainer.run(self.rql_table.index_drop(index_name))
+      STDERR.puts "Dropped index #{self}.#{index_name}" if options[:verbose]
+    end
+
+    def perform_update_indexes(options={})
+      current_indexes = NoBrainer.run(self.rql_table.index_list).map(&:to_sym)
+      wanted_indexes = self.indexes.keys - [:id] # XXX Primary key?
+
+      (current_indexes - wanted_indexes).each do |index_name|
+        perform_drop_index(index_name, options)
+      end
+
+      (wanted_indexes - current_indexes).each do |index_name|
+        perform_create_index(index_name, options)
+      end
+    end
+    alias_method :update_indexes, :perform_update_indexes
+  end
+end