custom_fields 1.0.0.beta.21 → 1.0.0.beta.22

data/lib/custom_fields/proxy_class_enabler.rb

@@ -83,6 +83,14 @@ module CustomFields
             self.custom_fields.detect { |f| f._name == name }
           end
 
+          def self.custom_field_alias_to_name(value)
+            self.custom_fields.detect { |f| f._alias == value }._name
+          end
+
+          def self.custom_field_name_to_alias(value)
+            self.custom_fields.detect { |f| f._name == value }._alias
+          end
+
           def self.hereditary?
             false
           end

data/lib/custom_fields/types/has_many/proxy_collection.rb

@@ -0,0 +1,92 @@
+module CustomFields
+  module Types
+    module HasMany
+
+      class ProxyCollection
+
+        attr_accessor :parent, :target_klass, :field_name, :ids, :values
+
+        def initialize(parent, target_klass, field_name, options = {})
+          self.parent = parent
+
+          self.target_klass = target_klass
+
+          self.field_name = field_name
+
+          self.ids, self.values = [], []
+        end
+
+        def find(id)
+          id = BSON::ObjectId(id) unless id.is_a?(BSON::ObjectId)
+          self.values.detect { |obj_id| obj_id == id }
+        end
+
+        def update(values)
+          values = [] if values.blank? || self.target_klass.nil?
+
+          self.ids = values.collect { |obj| self.id_for_sure(obj) }.compact
+          self.values = values.collect { |obj| self.object_for_sure(obj) }.compact
+        end
+
+        # just before the parent gets saved, reflect the changes to the parent object
+        def store_values
+          self.parent.write_attribute(self.field_name, self.ids)
+        end
+
+        # once the parent object gets saved, call this method, kind of hook or callback
+        def persist
+          true
+        end
+
+        def <<(*args)
+          args.flatten.compact.each do |obj|
+            self.ids << self.id_for_sure(obj)
+            self.values << self.object_for_sure(obj)
+          end
+        end
+
+        alias :push :<<
+
+        def size
+          self.values.size
+        end
+
+        alias :length :size
+
+        def method_missing(name, *args, &block)
+          self.values.send(name, *args, &block)
+        end
+
+        protected
+
+        def id_for_sure(id_or_object)
+          id_or_object.respond_to?(:_id) ? id_or_object._id : id_or_object
+        end
+
+        def object_for_sure(id_or_object)
+          if id_or_object.respond_to?(:_id)
+            id_or_object
+          else
+            self.collection.find(id_or_object)
+          end
+        rescue # target_klass does not exist anymore or the target element has been removed since
+          nil
+        end
+
+        def collection(reload_embedded = false)
+          if self.target_klass.embedded?
+            parent_target_klass = self.target_klass._parent
+
+            parent_target_klass = parent_target_klass.reload if reload_embedded
+
+            parent_target_klass.send(self.target_klass.association_name)
+          else
+            self.target_klass
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/custom_fields/types/has_many/reverse_lookup_proxy_collection.rb

@@ -0,0 +1,93 @@
+module CustomFields
+  module Types
+    module HasMany
+
+      class ReverseLookupProxyCollection < ProxyCollection
+
+        attr_accessor :reverse_lookup_field, :previous_state
+
+        def initialize(parent, target_klass, field_name, options = {})
+          super
+
+          self.reverse_lookup_field = options[:reverse_lookup_field].to_sym
+
+          if self.parent.new_record?
+            self.previous_state = { :ids => [], :values => [] }
+          else
+            self.reload
+          end
+        end
+
+        def store_values
+          true # do nothing
+        end
+
+        def persist
+          (self.previous_state[:ids] - self.ids).each do |id|
+            self.set_foreign_key_and_position(id, nil)
+          end
+
+          self.ids.each_with_index do |id, position|
+            self.set_foreign_key_and_position(id, self.parent._id, position)
+          end
+
+          if self.target_klass.embedded?
+            self.target_klass._parent.save!(:validate => false)
+          end
+
+          self.reset_previous_state
+        end
+
+        def <<(id_or_object)
+          object = self.object_for_sure(id_or_object)
+
+          foreign_key = object.send(self.reverse_lookup_field)
+
+          if foreign_key && foreign_key != self.parent._id
+            raise ArgumentError, "Object #{object} cannot be added: already has a different foreign key"
+          end
+
+          self.ids << self.id_for_sure(object._id)
+          self.values << self.object_for_sure(object)
+        end
+
+        def reload
+          self.update(self.reverse_collection)
+
+          self.reset_previous_state
+        end
+
+        protected
+
+        def reverse_collection
+          self.collection.where(self.reverse_lookup_field => self.parent._id).order_by([[:"#{self.reverse_lookup_field}_position", :asc]])
+        end
+
+        def set_foreign_key_and_position(object_id, value, position = nil)
+          if self.target_klass.embedded?
+            object = self.collection.find(object_id)
+          else
+            object = self.previous_state[:values].detect { |o| o._id == object_id }
+          end
+
+          object.send("#{self.reverse_lookup_field}=".to_sym, value)
+
+          object.send("#{self.reverse_lookup_field}_position=".to_sym, position)
+
+          if self.target_klass.embedded?
+            object.save(:validate => false)
+          end
+        end
+
+        def reset_previous_state
+          self.previous_state = {
+            :ids    => self.ids.clone,
+            :values => self.values.clone
+          }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/custom_fields/types/has_many.rb

@@ -6,6 +6,7 @@ module CustomFields
 
       included do
         field :target
+        field :reverse_lookup
 
         validates_presence_of :target, :if => :has_many?
 
@@ -14,21 +15,43 @@ module CustomFields
 
       module InstanceMethods
 
+        def target_klass
+          self.target.constantize rescue nil
+        end
+
+        def reverse_has_many?
+          self.reverse_lookup && !self.reverse_lookup.strip.blank?
+        end
+
+        def safe_reverse_lookup
+          if self.reverse_lookup =~ /^custom_field_[0-9]+$/
+            self.reverse_lookup
+          else
+            self.target_klass.custom_field_alias_to_name(self.reverse_lookup)
+          end
+        end
+
+        def reverse_lookup_alias
+          self.target_klass.custom_field_name_to_alias(self.reverse_lookup)
+        end
+
         def apply_has_many_type(klass)
           klass.class_eval <<-EOF
 
             before_validation :store_#{self.safe_alias.singularize}_ids
 
+            after_save :persist_#{self.safe_alias}
+
             def #{self.safe_alias}=(ids_or_objects)
-              if @_#{self._name}.nil?
-                @_#{self._name} = ProxyCollection.new('#{self.target.to_s}', ids_or_objects)
-              else
-                @_#{self._name}.update(ids_or_objects)
-              end
+              self.#{self.safe_alias}.update(ids_or_objects)
             end
 
             def #{self.safe_alias}
-              @_#{self._name} ||= ProxyCollection.new('#{self.target.to_s}', read_attribute(:#{self._name}))
+              @_#{self._name} ||= build_#{self.safe_alias.singularize}_proxy_collection
+            end
+
+            def #{self.safe_alias}_klass
+              '#{self.target.to_s}'.constantize rescue nil
             end
 
             def #{self.safe_alias.singularize}_ids
@@ -36,84 +59,42 @@ module CustomFields
             end
 
             def store_#{self.safe_alias.singularize}_ids
-              write_attribute(:#{self._name}, #{self.safe_alias.singularize}_ids)
+              self.#{self.safe_alias}.store_values
             end
-          EOF
-        end
-
-        def add_has_many_validation(klass)
-          if self.required?
-            klass.validates_length_of self.safe_alias.to_sym, :minimum => 1, :too_short => :blank
-          end
-        end
-
-      end
-
-      class ProxyCollection
-
-        attr_accessor :target_klass, :ids, :values
 
-        def initialize(target_klass_name, array = [])
-          self.target_klass = target_klass_name.constantize rescue nil
-
-          array = [] if self.target_klass.nil?
-
-          self.update(array || [])
-        end
-
-        def find(id)
-          id = BSON::ObjectId(id) unless id.is_a?(BSON::ObjectId)
-          self.values.detect { |obj_id| obj_id == id }
-        end
-
-        def update(values)
-          values = [] if values.blank?
+            def persist_#{self.safe_alias}
+              self.#{self.safe_alias}.persist
+            end
 
-          self.ids = values.collect { |obj| self.id_for_sure(obj) }.compact
-          self.values = values.collect { |obj| self.object_for_sure(obj) }.compact
-        end
+          EOF
 
-        def <<(*args)
-          args.flatten.compact.each do |obj|
-            self.ids << self.id_for_sure(obj)
-            self.values << self.object_for_sure(obj)
+          if reverse_has_many?
+            klass.class_eval <<-EOF
+              def build_#{self.safe_alias.singularize}_proxy_collection
+                ::CustomFields::Types::HasMany::ReverseLookupProxyCollection.new(self, self.#{self.safe_alias}_klass, '#{self._name}', {
+                  :reverse_lookup_field => '#{self.safe_reverse_lookup}'
+                })
+              end
+            EOF
+          else
+            klass.class_eval <<-EOF
+              def build_#{self.safe_alias.singularize}_proxy_collection
+                ::CustomFields::Types::HasMany::ProxyCollection.new(self, self.#{self.safe_alias}_klass, '#{self._name}').tap do |collection|
+                  collection.update(self.#{self._name})
+                end
+              end
+            EOF
           end
         end
 
-        alias :push :<<
-
-        def size
-          self.values.size
-        end
-
-        alias :length :size
-
-        def method_missing(name, *args, &block)
-          self.values.send(name, *args, &block)
-        end
-
-        protected
-
-        def id_for_sure(id_or_object)
-          id_or_object.respond_to?(:_id) ? id_or_object._id : id_or_object
-        end
-
-        def object_for_sure(id_or_object)
-          if id_or_object.respond_to?(:_id)
-            id_or_object
-          else
-            if self.target_klass.embedded?
-              self.target_klass._parent.reload.send(self.target_klass.association_name).find(id_or_object)
-            else
-              self.target_klass.find(id_or_object)
-            end
+        def add_has_many_validation(klass)
+          if self.required?
+            klass.validates_length_of self.safe_alias.to_sym, :minimum => 1, :too_short => :blank
           end
-        rescue # target_klass does not exist anymore or the target element has been removed since
-          nil
         end
 
       end
 
     end
   end
-end
+end

data/lib/custom_fields/types/has_one.rb

@@ -15,6 +15,9 @@ module CustomFields
       module InstanceMethods
 
         def apply_has_one_type(klass)
+
+          klass.field :"#{self._name}_position", :type => Integer, :default => 0 # needed by the has_many reverse
+
           klass.class_eval <<-EOF
 
             def #{self.safe_alias}=(id_or_object)

data/lib/custom_fields/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module CustomFields
-    VERSION = "1.0.0.beta.21"
+    VERSION = "1.0.0.beta.22"
   end
 end

data/lib/custom_fields.rb

@@ -31,6 +31,8 @@ require 'custom_fields/types/boolean'
 require 'custom_fields/types/date'
 require 'custom_fields/types/file'
 require 'custom_fields/types/has_one'
+require 'custom_fields/types/has_many/proxy_collection'
+require 'custom_fields/types/has_many/reverse_lookup_proxy_collection'
 require 'custom_fields/types/has_many'
 require 'custom_fields/proxy_class_enabler'
 require 'custom_fields/field'

metadata

@@ -2,7 +2,7 @@
 name: custom_fields
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 1.0.0.beta.21
+  version: 1.0.0.beta.22
 platform: ruby
 authors: 
 - Didier Lafforgue
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-03 00:00:00 +02:00
+date: 2011-08-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,8 @@ files:
 - lib/custom_fields/types/date.rb
 - lib/custom_fields/types/default.rb
 - lib/custom_fields/types/file.rb
+- lib/custom_fields/types/has_many/proxy_collection.rb
+- lib/custom_fields/types/has_many/reverse_lookup_proxy_collection.rb
 - lib/custom_fields/types/has_many.rb
 - lib/custom_fields/types/has_one.rb
 - lib/custom_fields/types/string.rb
@@ -85,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3396321950106991976
+      hash: -2478047520408348975
       segments: 
       - 0
       version: "0"