nobrainer 0.15.0 → 0.16.0

data/lib/no_brainer/document.rb

@@ -4,9 +4,10 @@ module NoBrainer::Document
   extend ActiveSupport::Concern
   extend NoBrainer::Autoload
 
-  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly, :Validation, :Types,
-                       :Persistance, :Uniqueness, :Callbacks, :Dirty, :Id, :Association, :Serialization,
-                       :Criteria, :Polymorphic, :Index
+  autoload_and_include :Core, :StoreIn, :InjectionLayer, :Attributes, :Readonly,
+                       :Validation, :Persistance, :Types, :Uniqueness, :Callbacks, :Dirty, :Id,
+                       :Association, :Serialization, :Criteria, :Polymorphic, :Index, :Aliases,
+                       :MissingAttributes, :LazyFetch
 
   autoload :DynamicAttributes, :Timestamps
 

data/lib/no_brainer/document/aliases.rb

@@ -0,0 +1,55 @@
+module NoBrainer::Document::Aliases
+  extend ActiveSupport::Concern
+
+  # Index aliases are built-in index.rb
+
+  included do
+    # We ignore polymorphism for aliases.
+    cattr_accessor :alias_map, :alias_reverse_map, :instance_accessor => false
+    self.alias_map = {}
+    self.alias_reverse_map = {}
+  end
+
+  module ClassMethods
+    def _field(attr, options={})
+      if options[:as]
+        self.alias_map[attr.to_s] = options[:as].to_s
+        self.alias_reverse_map[options[:as].to_s] = attr.to_s
+      end
+      super
+    end
+
+    def _remove_field(attr, options={})
+      super
+
+      self.alias_map.delete(attr.to_s)
+      self.alias_reverse_map.delete(attr.to_s)
+    end
+
+    def reverse_lookup_field_alias(attr)
+      alias_reverse_map[attr.to_s] || attr
+    end
+
+    def lookup_field_alias(attr)
+      alias_map[attr.to_s] || attr
+    end
+
+    def with_fields_reverse_aliased(attrs)
+      case attrs
+      when Array then attrs.map { |k| reverse_lookup_field_alias(k) }
+      when Hash  then Hash[attrs.map { |k,v| [reverse_lookup_field_alias(k), v] }]
+      end
+    end
+
+    def with_fields_aliased(attrs)
+      case attrs
+      when Array then attrs.map { |k| lookup_field_alias(k) }
+      when Hash  then Hash[attrs.map { |k,v| [lookup_field_alias(k), v] }]
+      end
+    end
+
+    def persistable_key(k)
+      lookup_field_alias(super)
+    end
+  end
+end

data/lib/no_brainer/document/association.rb

@@ -16,8 +16,8 @@ module NoBrainer::Document::Association
 
   module ClassMethods
     def inherited(subclass)
-      super
       subclass.association_metadata = self.association_metadata.dup
+      super
     end
 
     METHODS.each do |association|

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

@@ -2,7 +2,7 @@ class NoBrainer::Document::Association::BelongsTo
   include NoBrainer::Document::Association::Core
 
   class Metadata
-    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :index, :validates, :required]
+    VALID_OPTIONS = [:primary_key, :foreign_key, :class_name, :foreign_key_as, :index, :validates, :required]
     include NoBrainer::Document::Association::Core::Metadata
     extend NoBrainer::Document::Association::EagerLoader::Generic
 
@@ -29,7 +29,7 @@ class NoBrainer::Document::Association::BelongsTo
       # This would have the effect of loading all the models because they
       # are likely to be related to each other. So we don't know the type
       # of the primary key of the target.
-      owner_klass.field(foreign_key, :index => options[:index])
+      owner_klass.field(foreign_key, :as => options[:foreign_key_as], :index => options[:index])
       owner_klass.validates(target_name, { :presence => true }) if options[:required]
       owner_klass.validates(target_name, options[:validates]) if options[:validates]
 

data/lib/no_brainer/document/attributes.rb

@@ -1,5 +1,6 @@
 module NoBrainer::Document::Attributes
-  VALID_FIELD_OPTIONS = [:index, :default, :type, :validates, :required, :unique, :in, :readonly, :primary_key]
+  VALID_FIELD_OPTIONS = [:index, :default, :type, :real_type, :validates, :required, :unique,
+                         :in, :readonly, :primary_key, :as, :lazy_fetch]
   RESERVED_FIELD_NAMES = [:index, :default, :and, :or, :selector, :associations, :pk_value] \
                           + NoBrainer::DecoratedSymbol::MODIFIERS.keys
   extend ActiveSupport::Concern
@@ -34,9 +35,18 @@ module NoBrainer::Document::Attributes
   end
   def []=(*args); write_attribute(*args); end
 
-  def assign_defaults
+  def assign_defaults(options)
     self.class.fields.each do |name, field_options|
-      if field_options.has_key?(:default) && !@_attributes.has_key?(name)
+      if field_options.has_key?(:default) &&
+         !@_attributes.has_key?(name)
+
+         if opt = options[:missing_attributes]
+           if (opt[:pluck] && !opt[:pluck][name]) ||
+              (opt[:without] && opt[:without][name])
+             next
+           end
+         end
+
         default_value = field_options[:default]
         default_value = default_value.call if default_value.is_a?(Proc)
         self.write_attribute(name, default_value)
@@ -45,15 +55,23 @@ module NoBrainer::Document::Attributes
   end
 
   def assign_attributes(attrs, options={})
-    @_attributes.clear if options[:pristine]
+    if options[:pristine]
+      if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
+        options[:missing_attributes][:pluck].keys.each { |k| @_attributes.delete(k) }
+      else
+        @_attributes.clear
+      end
+    end
+
     if options[:from_db]
+      attrs = self.class.with_fields_reverse_aliased(attrs)
       @_attributes.merge!(attrs)
-      clear_dirtiness
+      clear_dirtiness(options)
     else
-      clear_dirtiness if options[:pristine]
+      clear_dirtiness(options) if options[:pristine]
       attrs.each { |k,v| self.write_attribute(k,v) }
     end
-    assign_defaults if options[:pristine]
+    assign_defaults(options) if options[:pristine]
     self
   end
 
@@ -77,8 +95,8 @@ module NoBrainer::Document::Attributes
     end
 
     def inherited(subclass)
-      super
       subclass.fields = self.fields.dup
+      super
     end
 
     def _field(attr, options={})

data/lib/no_brainer/document/criteria.rb

@@ -9,17 +9,21 @@ module NoBrainer::Document::Criteria
 
   module ClassMethods
     delegate :to_rql,                        # Core
+             :raw,                           # Raw
              :limit, :offset, :skip,         # Limit
-             :order_by, :reverse_order, :without_ordering, # OrderBy
+             :order_by, :reverse_order, :without_ordering, :order_by_indexed?, :order_by_index_name, # OrderBy
              :scoped, :unscoped,             # Scope
-             :where, :with_index, :without_index, :used_index, :indexed?, # Where
+             :where, :where_indexed?, :where_index_name, :where_index_type, # Where
+             :with_index, :without_index, :used_index, # Index
              :with_cache, :without_cache,    # Cache
              :count, :empty?, :any?,         # Count
              :delete_all, :destroy_all,      # Delete
              :includes, :preload,            # Preload
              :each, :to_a,                   # Enumerable
              :first, :last, :first!, :last!, :sample, # First
+             :min, :max, :sum, :avg,         # Aggregate
              :update_all, :replace_all,      # Update
+             :pluck, :without, :lazy_fetch, :without_plucking, # Pluck
              :to => :all
 
     def all
@@ -44,8 +48,7 @@ module NoBrainer::Document::Criteria
       rql_table.get(pk)
     end
 
-    # XXX this doesn't have the same semantics as
-    # other ORMs. the equivalent is find!.
+    # XXX this doesn't have the same semantics as other ORMs. the equivalent is find!.
     def find(pk)
       attrs = NoBrainer.run { selector_for(pk) }
       new_from_db(attrs).tap { |doc| doc.run_callbacks(:find) } if attrs

data/lib/no_brainer/document/dirty.rb

@@ -14,8 +14,14 @@ module NoBrainer::Document::Dirty
     super.tap { clear_dirtiness }
   end
 
-  def clear_dirtiness
-    @_old_attributes = {}.with_indifferent_access
+  def clear_dirtiness(options={})
+    if options[:keep_ivars] && options[:missing_attributes].try(:[], :pluck)
+      attrs = options[:missing_attributes][:pluck].keys
+      @_old_attributes = @_old_attributes.reject { |k,v| attrs.include?(k) }
+    else
+      @_old_attributes = {}.with_indifferent_access
+    end
+
     @_old_attributes_keys = @_attributes.keys # to track undefined -> nil changes
   end
 
@@ -38,7 +44,18 @@ module NoBrainer::Document::Dirty
     result
   end
 
-  def attribute_may_change(attr, current_value)
+  def attribute_may_change(*args)
+    attr = args.first
+    current_value = begin
+      case args.size
+      when 1 then assert_access_field(attr); read_attribute(attr)
+      when 2 then args.last
+      else raise
+      end
+    rescue NoBrainer::Error::MissingAttribute => e
+      e
+    end
+
     unless @_old_attributes.has_key?(attr)
       @_old_attributes[attr] = current_value.deep_dup
     end
@@ -74,7 +91,7 @@ module NoBrainer::Document::Dirty
         end
 
         define_method("#{attr}=") do |value|
-          attribute_may_change(attr, read_attribute(attr))
+          attribute_may_change(attr)
           super(value)
         end
       end

data/lib/no_brainer/document/dynamic_attributes.rb

@@ -5,6 +5,7 @@ module NoBrainer::Document::DynamicAttributes
     if self.respond_to?("#{name}") 
       super
     else
+      assert_access_field(name)
       @_attributes[name].tap { |value| attribute_may_change(name, value) if value.respond_to?(:size) }
     end
   end
@@ -13,8 +14,10 @@ module NoBrainer::Document::DynamicAttributes
     if self.respond_to?("#{name}=")
       super
     else
-      attribute_may_change(name, read_attribute(name))
+      attribute_may_change(name)
       @_attributes[name] = value
+      clear_missing_field(name)
+      value
     end
   end
 

data/lib/no_brainer/document/index.rb

@@ -1,5 +1,5 @@
 module NoBrainer::Document::Index
-  VALID_INDEX_OPTIONS = [:multi]
+  VALID_INDEX_OPTIONS = [:multi, :as]
   extend ActiveSupport::Concern
 
   included do
@@ -25,11 +25,17 @@ module NoBrainer::Document::Index
       if name.in?(NoBrainer::Document::Attributes::RESERVED_FIELD_NAMES)
         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}
+      as = options.delete(:as)
+      as ||= fields[name][:as] if has_field?(name)
+      as ||= name
+      as = as.to_sym
+
+      indexes[name] = {:kind => kind, :what => what, :as => as, :options => options}
     end
 
     def remove_index(name)
@@ -40,6 +46,10 @@ module NoBrainer::Document::Index
       !!indexes[name.to_sym]
     end
 
+    def lookup_index_alias(attr)
+      indexes[attr.to_sym].try(:[], :as) || attr
+    end
+
     def _field(attr, options={})
       if has_index?(attr) && indexes[attr][:kind] != :single
         raise "Cannot reuse index attr #{attr}"
@@ -47,11 +57,12 @@ module NoBrainer::Document::Index
 
       super
 
+      as = {:as => options[:as]}
       case options[:index]
       when nil    then
-      when Hash   then index(attr, options[:index])
-      when Symbol then index(attr, options[:index] => true)
-      when true   then index(attr)
+      when Hash   then index(attr, as.merge(options[:index]))
+      when Symbol then index(attr, as.merge(options[:index] => true))
+      when true   then index(attr, as)
       when false  then remove_index(attr)
       end
     end
@@ -66,23 +77,47 @@ module NoBrainer::Document::Index
       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 :single   then ->(doc) { doc[lookup_field_alias(index_name)] }
+        when :compound then ->(doc) { index_args[:what].map { |field| doc[lookup_field_alias(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_create(index_args[:as], index_args[:options], &index_proc))
       wait_for_index(index_name) unless options[:wait] == false
-      STDERR.puts "Created index #{self}.#{index_name}" if options[:verbose]
+
+      if options[:verbose]
+        if index_name == index_args[:as]
+          STDERR.puts "Created index #{self}.#{index_name}"
+        else
+          STDERR.puts "Created index #{self}.#{index_name} as #{index_args[:as]}"
+        end
+      end
     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]
+      aliased_name = self.indexes[index_name].try(:[], :as) || index_name
+      NoBrainer.run(self.rql_table.index_drop(aliased_name))
+
+      if options[:verbose]
+        if index_name == index_args[:as]
+          STDERR.puts "Dropped index #{self}.#{index_name}"
+        else
+          STDERR.puts "Dreated index #{self}.#{index_name} as #{index_args[:as]}"
+        end
+      end
+    end
+
+    def get_index_alias_reverse_map
+      Hash[self.indexes.map { |k,v| [v[:as], k] }].tap do |mapping|
+        raise "Detected clashing index aliases" if mapping.count != self.indexes.count
+      end
     end
 
     def perform_update_indexes(options={})
-      current_indexes = NoBrainer.run(self.rql_table.index_list).map(&:to_sym)
+      alias_mapping = self.get_index_alias_reverse_map
+      current_indexes = NoBrainer.run(self.rql_table.index_list).map do |index|
+        alias_mapping[index.to_sym] || index.to_sym
+      end
       wanted_indexes = self.indexes.keys - [self.pk_name]
 
       (current_indexes - wanted_indexes).each do |index_name|

data/lib/no_brainer/document/lazy_fetch.rb

@@ -0,0 +1,72 @@
+module NoBrainer::Document::LazyFetch
+  extend ActiveSupport::Concern
+
+  included do
+    singleton_class.send(:attr_accessor, :fields_to_lazy_fetch)
+    self.fields_to_lazy_fetch = Set.new
+  end
+
+  def assign_attributes(attrs, options={})
+    if options[:lazy_fetch].present?
+      lazy_fetch = options[:lazy_fetch]
+      lazy_fetch = lazy_fetch.keys if lazy_fetch.is_a?(Hash)
+      @lazy_fetch = Set.new(lazy_fetch.map(&:to_s))
+    end
+    super
+  end
+
+  def reload(options={})
+    lazy_fetch = self.class.fields_to_lazy_fetch.to_a
+    return super unless lazy_fetch.present?
+    return super if options[:pluck]
+    super(options.merge(:without => lazy_fetch, :lazy_fetch => lazy_fetch))
+  end
+
+  module ClassMethods
+    def inherited(subclass)
+      subclass.fields_to_lazy_fetch = self.fields_to_lazy_fetch.dup
+      super
+    end
+
+    def _field(attr, options={})
+      super
+      attr = attr.to_s
+      klass = self
+      inject_in_layer :lazy_fetch do
+        if options[:lazy_fetch]
+          klass.for_each_subclass { |_klass| _klass.fields_to_lazy_fetch << attr }
+        else
+          klass.for_each_subclass { |_klass|  _klass.fields_to_lazy_fetch.delete(attr) }
+        end
+
+        # Lazy loading can also specified through criteria.
+        define_method("#{attr}") do
+          return super() unless @lazy_fetch
+
+          begin
+            super()
+          rescue NoBrainer::Error::MissingAttribute => e
+            raise e unless attr.in?(@lazy_fetch)
+            reload(:pluck => attr, :keep_ivars => true)
+            @lazy_fetch.delete(attr)
+            retry
+          end
+        end
+      end
+    end
+
+    def _remove_field(attr, options={})
+      super
+      for_each_subclass { |klass| klass.fields_to_lazy_fetch.delete(attr) }
+      inject_in_layer :lazy_fetch do
+        remove_method("#{attr}") if method_defined?("#{attr}")
+      end
+    end
+
+    def all
+      criteria = super
+      criteria = criteria.lazy_fetch(*self.fields_to_lazy_fetch) if self.fields_to_lazy_fetch.present?
+      criteria
+    end
+  end
+end