mongoid_alize 0.2.0 → 0.3.1

data/config/locales/en.yml

@@ -7,4 +7,5 @@ en:
             "%{name} does not exist on the %{inverse_klass} model."
           already_defined_field:
             "%{name} is already defined on the %{klass} model."
+          invalid_configuration:
 

data/lib/mongoid/alize/callback.rb

@@ -6,30 +6,34 @@ module Mongoid
 
       attr_accessor :klass
       attr_accessor :relation
-      attr_accessor :reflect
+      attr_accessor :metadata
 
       attr_accessor :inverse_klass
       attr_accessor :inverse_relation
+      attr_accessor :inverse_metadata
+
+      attr_accessor :debug
 
       def initialize(_klass, _relation, _fields)
+        self.debug = ENV["ALIZE_DEBUG"]
+
         self.klass = _klass
         self.relation = _relation
         self.fields = _fields
 
-        self.reflect = _klass.relations[_relation.to_s]
-        self.inverse_klass = self.reflect.klass
-        self.inverse_relation = self.reflect.inverse
-
-        self.klass.send(:attr_accessor, :force_denormalization)
-        self.inverse_klass.send(:attr_accessor, :force_denormalization)
+        self.metadata = _klass.relations[_relation.to_s]
+        if !(self.metadata.polymorphic? &&
+              self.metadata.stores_foreign_key?)
+          self.inverse_klass = self.metadata.klass
+          self.inverse_relation = self.metadata.inverse
+          self.inverse_metadata = self.inverse_klass.relations[inverse_relation.to_s]
+        end
       end
 
       def attach
         # implement in subclasses
       end
 
-      protected
-
       def callback_attached?(callback_type, callback_name)
         !!klass.send(:"_#{callback_type}_callbacks").
           map(&:raw_filter).include?(callback_name)
@@ -42,6 +46,7 @@ module Mongoid
       def alias_callback
         unless callback_defined?(aliased_callback_name)
           klass.send(:alias_method, aliased_callback_name, callback_name)
+          klass.send(:public, aliased_callback_name)
         end
       end
 
@@ -53,13 +58,27 @@ module Mongoid
         "denormalize_#{direction}_#{relation}"
       end
 
-      def joined_fields
-        (fields + [:_id]).map {|f| "'#{f}'" }.join(", ")
+      def define_fields_method
+        _fields = fields
+        if fields.is_a?(Proc)
+          klass.send(:define_method, fields_method_name) do |inverse|
+            _fields.bind(self).call(inverse).map(&:to_s)
+          end
+        else
+          klass.send(:define_method, fields_method_name) do |inverse|
+            _fields.map(&:to_s)
+          end
+        end
       end
 
-      def joined_field_values(source)
+      def fields_method_name
+        "#{callback_name}_fields"
+      end
+
+      def field_values(source, options={})
+        extras = options[:id] ? "['_id']" : "[]"
         <<-RUBY
-          [#{joined_fields}].inject({}) { |hash, name|
+          (#{fields_method_name}(#{source}) + #{extras}).inject({}) { |hash, name|
             hash[name] = #{source}.send(name)
             hash
           }
@@ -73,6 +92,22 @@ module Mongoid
       def force_check
         "force || self.force_denormalization"
       end
+
+      def fields_to_s
+        if fields.is_a?(Proc)
+          "Proc Given"
+        else
+          fields.join(", ")
+        end
+      end
+
+      def to_s
+        "#{self.class.name}" +
+        "\nModel: #{self.klass}, Relation: #{self.relation}" + (self.metadata.polymorphic? ?
+        "\nPolymorphic" :
+        "\nInverse: #{self.inverse_klass}, Relation: #{self.inverse_relation}") +
+        "\nFields: #{fields_to_s}"
+      end
     end
   end
 end

data/lib/mongoid/alize/callbacks/from/many.rb

@@ -9,10 +9,12 @@ module Mongoid
           def define_callback
             klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
               def #{callback_name}#{force_param}
-                self.#{prefixed_name} = self.#{relation}.map do |model|
-                  #{joined_field_values("model")}
+                self.#{prefixed_name} = self.#{relation}.map do |relation|
+                  #{field_values("relation", :id => true)}
                 end
+                true
               end
+
               protected :#{callback_name}
             CALLBACK
           end
@@ -22,10 +24,8 @@ module Mongoid
             klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
               field :#{prefixed_name}, :type => Array, :default => []
             CALLBACK
-          end
 
-          def prefixed_name
-            "#{relation}_fields"
+            define_fields_method
           end
         end
       end

data/lib/mongoid/alize/callbacks/from/one.rb

@@ -7,19 +7,18 @@ module Mongoid
           protected
 
           def define_callback
-            field_sets = ""
-            fields.each do |name|
-              field_sets << "self.send(:#{prefixed_field_name(name)}=,
-                               relation && relation.send(:#{name}))\n"
-            end
-
             klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
               def #{callback_name}#{force_param}
                 if #{force_check} ||
-                    #{!reflect.stores_foreign_key?} ||
-                    self.#{reflect.key}_changed?
-                  relation = self.#{relation}
-                  #{field_sets}
+                    #{!metadata.stores_foreign_key?} ||
+                      self.#{metadata.key}_changed?
+
+                  if relation = self.#{relation}
+                    self.#{self.prefixed_name} = #{field_values("relation")}
+                  else
+                    self.#{self.prefixed_name} = nil
+                  end
+
                 end
                 true
               end
@@ -29,28 +28,12 @@ module Mongoid
           end
 
           def define_fields
-            fields.each do |name|
-              prefixed_name = prefixed_field_name(name)
-              unless field_defined?(prefixed_name, klass)
-                klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-                  field :#{prefixed_name}, :type => #{inverse_field_type(name)}
-                CALLBACK
-              end
-            end
-          end
-
-          def prefixed_field_name(name)
-            "#{relation}_#{name}"
-          end
-
-          def inverse_field_type(name)
-            name = name.to_s
-
-            name = "_id" if name == "id"
-            name = "_type" if name == "type"
+            ensure_field_not_defined!(prefixed_name, klass)
+            klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+              field :#{prefixed_name}, :type => Hash, :default => nil
+            CALLBACK
 
-            field = inverse_klass.fields[name]
-            (field && field.options[:type]) ? field.type : String
+            define_fields_method
           end
         end
       end

data/lib/mongoid/alize/errors/invalid_configuration.rb

@@ -0,0 +1,16 @@
+module Mongoid
+  module Alize
+    module Errors
+
+      class InvalidConfiguration < AlizeError
+        def initialize(reason, klass, relation)
+          super(
+            translate("invalid_configuration.#{reason}",
+                        { :klass => klass, :relation => relation })
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/alize/from_callback.rb

@@ -10,8 +10,6 @@ module Mongoid
         set_callback
       end
 
-      protected
-
       def set_callback
         unless callback_attached?("save", aliased_callback_name)
           klass.set_callback(:save, :before, aliased_callback_name)
@@ -28,6 +26,10 @@ module Mongoid
         !!klass.fields[prefixed_name]
       end
 
+      def prefixed_name
+        "#{relation}_fields"
+      end
+
       def direction
         "from"
       end

data/lib/mongoid/alize/instance_helpers.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module Alize
+    module InstanceHelpers
+
+      attr_accessor :force_denormalization
+
+      def denormalize_from_all
+        run_alize_callbacks(self.class.alize_from_callbacks)
+      end
+
+      def denormalize_to_all
+        run_alize_callbacks(self.class.alize_to_callbacks)
+      end
+
+      private
+
+      def run_alize_callbacks(callbacks)
+        callbacks.each do |callback|
+          self.send(callback.aliased_callback_name)
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/alize/macros.rb

@@ -2,67 +2,90 @@ module Mongoid
   module Alize
     module Macros
 
-      def alize(relation, *fields)
-
-        fields = default_alize_fields(relation) if fields.empty?
-
-        one  = Mongoid::Relations::One
-        many = Mongoid::Relations::Many
+      attr_accessor :alize_from_callbacks, :alize_to_callbacks
 
-        def (many = many.dup).==(klass)
-          [Mongoid::Relations::Many,
-           Mongoid::Relations::Referenced::Many].map(&:name).include?(klass.name)
+      def alize(relation, *fields)
+        alize_from(relation, *fields)
+        metadata = self.relations[relation.to_s]
+        unless _alize_unknown_inverse?(metadata)
+          metadata.klass.alize_to(metadata.inverse, *fields)
         end
+      end
 
-        klass = self
-        reflect = klass.relations[relation.to_s]
+      def alize_from(relation, *fields)
+        one, many = _alize_relation_types
 
         from_one  = Mongoid::Alize::Callbacks::From::One
         from_many = Mongoid::Alize::Callbacks::From::Many
 
-        relation_superclass = reflect.relation.superclass
+        klass = self
+        metadata = klass.relations[relation.to_s]
+        relation_superclass = metadata.relation.superclass
+
         callback_klass =
           case [relation_superclass]
           when [one]  then from_one
           when [many] then from_many
           end
 
-        callback_klass.
-          new(klass, relation, fields).
-          attach
-
-        inverse_klass = reflect.klass
-        inverse_relation = reflect.inverse
-
-        if inverse_klass &&
-            (inverse_reflect = inverse_klass.relations[inverse_relation.to_s])
-
-          to_one_from_one   = Mongoid::Alize::Callbacks::To::OneFromOne
-          to_one_from_many  = Mongoid::Alize::Callbacks::To::OneFromMany
-          to_many_from_one  = Mongoid::Alize::Callbacks::To::ManyFromOne
-          to_many_from_many = Mongoid::Alize::Callbacks::To::ManyFromMany
-
-          inverse_relation_superclass = inverse_reflect.relation.superclass
-          inverse_callback_klass =
-            case [relation_superclass, inverse_relation_superclass]
-            when [one,  one]  then to_one_from_one
-            when [many, one]  then to_many_from_one
-            when [one,  many] then to_one_from_many
-            when [many, many] then to_many_from_many
-            end
-
-          inverse_callback_klass.
-            new(inverse_klass, inverse_relation, fields).
-            attach
+        options = fields.extract_options!
+        if options[:fields]
+          fields = options[:fields]
+        elsif fields.empty? && !_alize_unknown_inverse?(metadata)
+          fields = metadata.klass.default_alize_fields
+        end
+
+        (klass.alize_from_callbacks ||= []) << callback =
+          callback_klass.new(klass, relation, fields)
+        callback.attach
+
+      end
+
+      def alize_to(relation, *fields)
+        one, many = _alize_relation_types
+
+        klass = self
+        metadata = klass.relations[relation.to_s]
+        relation_superclass = metadata.relation.superclass
+
+        options = fields.extract_options!
+        if options[:fields]
+          fields = options[:fields]
+        elsif fields.empty?
+          fields = klass.default_alize_fields
         end
+
+        (klass.alize_to_callbacks ||= []) << callback =
+          Mongoid::Alize::ToCallback.new(klass, relation, fields)
+        callback.attach
+
       end
 
-      def default_alize_fields(relation)
-        self.relations[relation.to_s].klass.
-          fields.reject { |name, field|
+      def default_alize_fields
+        self.fields.reject { |name, field|
           name =~ /^_/
         }.keys
       end
+
+      private
+
+      def _alize_unknown_inverse?(metadata)
+        (metadata.polymorphic? && metadata.stores_foreign_key?) ||
+          metadata.klass.nil? ||
+          metadata.inverse.nil?
+      end
+
+      def _alize_relation_types
+        one  = Mongoid::Relations::One
+        many = Mongoid::Relations::Many
+
+        def (many = many.dup).==(klass)
+          [Mongoid::Relations::Many,
+           Mongoid::Relations::Referenced::Many].map(&:name).include?(klass.name)
+        end
+
+        [one, many]
+      end
     end
   end
 end

data/lib/mongoid/alize/to_callback.rb

@@ -3,6 +3,8 @@ module Mongoid
     class ToCallback < Callback
 
       def attach
+        define_fields
+
         define_callback
         alias_callback
         set_callback
@@ -12,7 +14,107 @@ module Mongoid
         set_destroy_callback
       end
 
-      protected
+      def define_callback
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+
+          def #{callback_name}#{force_param}
+
+            #{iterable_relation}.each do |relation|
+              next if relation.attributes.frozen?
+
+              is_one = #{is_one?}
+              if is_one
+                field_values = #{field_values("self")}
+              else
+                field_values = #{field_values("self", :id => true)}
+              end
+
+              prefixed_name = #{prefixed_name}
+              if is_one
+                relation.set(prefixed_name, field_values)
+              else
+                #{pull_from_inverse}
+                relation.push(prefixed_name, field_values)
+              end
+
+            end
+
+            #{debug ? "puts \"#{callback_name}\"": ""}
+            true
+          end
+          protected :#{callback_name}
+        CALLBACK
+      end
+
+      def define_destroy_callback
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+
+          def #{destroy_callback_name}
+            #{iterable_relation}.each do |relation|
+              next if relation.attributes.frozen?
+
+              is_one = #{is_one?}
+              prefixed_name = #{prefixed_name}
+              if is_one
+                relation.set(prefixed_name, nil)
+              else
+                #{pull_from_inverse}
+              end
+            end
+
+            #{debug ? "puts \"#{destroy_callback_name}\"": ""}
+            true
+          end
+          protected :#{destroy_callback_name}
+        CALLBACK
+      end
+
+      def pull_from_inverse
+        <<-RUBIES
+          relation.pull(prefixed_name, { "_id" => self.id })
+          if _f = relation.send(prefixed_name)
+            _f.reject! do |hash|
+              hash["_id"] == self.id
+            end
+          end
+        RUBIES
+      end
+
+      def prefixed_name
+        if inverse_relation
+          ":#{inverse_relation}_fields"
+        else
+          <<-RUBIES
+            (#{find_relation}[0].to_s + '_fields')
+          RUBIES
+        end
+      end
+
+      def is_one?
+        if inverse_relation
+          if self.inverse_metadata.relation.superclass == Mongoid::Relations::One
+            "true"
+          else
+            "false"
+          end
+        else
+          <<-RUBIES
+            (#{find_relation}[1].relation.superclass == Mongoid::Relations::One)
+          RUBIES
+        end
+      end
+
+      def find_relation
+        "relation.class.relations.find { |name, metadata| metadata.inverse == :#{relation} && metadata.class_name == self.class.name }"
+      end
+
+      def iterable_relation
+        "[self.#{relation}].flatten.compact"
+      end
+
+      def define_fields
+        define_fields_method
+      end
 
       def set_callback
         unless callback_attached?("save", aliased_callback_name)
@@ -29,6 +131,7 @@ module Mongoid
       def alias_destroy_callback
         unless callback_defined?(aliased_destroy_callback_name)
           klass.send(:alias_method, aliased_destroy_callback_name, destroy_callback_name)
+          klass.send(:public, aliased_destroy_callback_name)
         end
       end
 
@@ -40,14 +143,6 @@ module Mongoid
         "_#{aliased_destroy_callback_name}"
       end
 
-      def plain_relation
-        "self.#{relation}"
-      end
-
-      def surrounded_relation
-        "self.#{relation} ? [self.#{relation}] : []"
-      end
-
       def direction
         "to"
       end