mongoid_alize 0.1.0 → 0.2.0

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  mongoid:
+    errors:
+      messages:
+        alize:
+          invalid_field:
+            "%{name} does not exist on the %{inverse_klass} model."
+          already_defined_field:
+            "%{name} is already defined on the %{klass} model."
+

data/lib/mongoid/alize/callback.rb

@@ -6,6 +6,7 @@ module Mongoid
 
       attr_accessor :klass
       attr_accessor :relation
+      attr_accessor :reflect
 
       attr_accessor :inverse_klass
       attr_accessor :inverse_relation
@@ -15,9 +16,12 @@ module Mongoid
         self.relation = _relation
         self.fields = _fields
 
-        reflect = _klass.relations[_relation.to_s]
-        self.inverse_klass = reflect.klass
-        self.inverse_relation = reflect.inverse
+        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)
       end
 
       def attach
@@ -26,9 +30,49 @@ module Mongoid
 
       protected
 
+      def callback_attached?(callback_type, callback_name)
+        !!klass.send(:"_#{callback_type}_callbacks").
+          map(&:raw_filter).include?(callback_name)
+      end
+
+      def callback_defined?(callback_name)
+        klass.method_defined?(callback_name)
+      end
+
+      def alias_callback
+        unless callback_defined?(aliased_callback_name)
+          klass.send(:alias_method, aliased_callback_name, callback_name)
+        end
+      end
+
+      def callback_name
+        "_#{aliased_callback_name}"
+      end
+
+      def aliased_callback_name
+        "denormalize_#{direction}_#{relation}"
+      end
+
       def joined_fields
         (fields + [:_id]).map {|f| "'#{f}'" }.join(", ")
       end
+
+      def joined_field_values(source)
+        <<-RUBY
+          [#{joined_fields}].inject({}) { |hash, name|
+            hash[name] = #{source}.send(name)
+            hash
+          }
+        RUBY
+      end
+
+      def force_param
+        "(force=false)"
+      end
+
+      def force_check
+        "force || self.force_denormalization"
+      end
     end
   end
 end

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

@@ -8,22 +8,20 @@ module Mongoid
 
           def define_callback
             klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-              def #{callback_name}
+              def #{callback_name}#{force_param}
                 self.#{prefixed_name} = self.#{relation}.map do |model|
-                  model.attributes.slice(#{joined_fields})
+                  #{joined_field_values("model")}
                 end
               end
-
               protected :#{callback_name}
             CALLBACK
           end
 
           def define_fields
-            unless !!klass.fields[prefixed_name]
-              klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-                field :#{prefixed_name}, :type => Array
-              CALLBACK
-            end
+            ensure_field_not_defined!(prefixed_name, klass)
+            klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+              field :#{prefixed_name}, :type => Array, :default => []
+            CALLBACK
           end
 
           def prefixed_name

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

@@ -9,13 +9,18 @@ module Mongoid
           def define_callback
             field_sets = ""
             fields.each do |name|
-              field_sets << "self.set(:#{prefixed_field_name(name)}, relation && relation.read_attribute(:#{name}))\n"
+              field_sets << "self.send(:#{prefixed_field_name(name)}=,
+                               relation && relation.send(:#{name}))\n"
             end
 
             klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-              def #{callback_name}
-                relation = self.#{relation}
-                #{field_sets}
+              def #{callback_name}#{force_param}
+                if #{force_check} ||
+                    #{!reflect.stores_foreign_key?} ||
+                    self.#{reflect.key}_changed?
+                  relation = self.#{relation}
+                  #{field_sets}
+                end
                 true
               end
 
@@ -26,9 +31,11 @@ module Mongoid
           def define_fields
             fields.each do |name|
               prefixed_name = prefixed_field_name(name)
-              klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-                field :#{prefixed_name}, :type => #{inverse_field_type(name)}
-              CALLBACK
+              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
 
@@ -37,8 +44,13 @@ module Mongoid
           end
 
           def inverse_field_type(name)
-            field = inverse_klass.fields[name.to_s]
-            field.options[:type] ? field.type : String
+            name = name.to_s
+
+            name = "_id" if name == "id"
+            name = "_type" if name == "type"
+
+            field = inverse_klass.fields[name]
+            (field && field.options[:type]) ? field.type : String
           end
         end
       end

data/lib/mongoid/alize/callbacks/to/many_from_many.rb

@@ -6,8 +6,9 @@ module Mongoid
           protected
 
           def iterable_relation
-            "self.#{relation}"
+            plain_relation
           end
+
         end
       end
     end

data/lib/mongoid/alize/callbacks/to/many_from_one.rb

@@ -6,7 +6,7 @@ module Mongoid
           protected
 
           def iterable_relation
-            "self.#{relation} ? [self.#{relation}] : []"
+            surrounded_relation
           end
         end
       end

data/lib/mongoid/alize/callbacks/to/one_from_many.rb

@@ -6,7 +6,7 @@ module Mongoid
           protected
 
           def iterable_relation
-            "self.#{relation}"
+            plain_relation
           end
         end
       end

data/lib/mongoid/alize/callbacks/to/one_from_one.rb

@@ -6,7 +6,7 @@ module Mongoid
           protected
 
           def iterable_relation
-            "self.#{relation} ? [self.#{relation}] : []"
+            surrounded_relation
           end
         end
       end

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

@@ -0,0 +1,13 @@
+module Mongoid
+  module Alize
+    module Errors
+
+      class AlizeError < Mongoid::Errors::MongoidError
+        def translate(key, data={})
+          super("alize.#{key}", data)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Errors
+
+      class AlreadyDefinedField < AlizeError
+        def initialize(name, klass)
+          super(
+            translate("already_defined_field", { :name => name, :klass => klass })
+          )
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Errors
+
+      class InvalidField < AlizeError
+        def initialize(name, inverse_klass)
+          super(
+            translate("invalid_field", { :name => name, :inverse_klass => inverse_klass })
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/alize/from_callback.rb

@@ -6,17 +6,30 @@ module Mongoid
         define_fields
 
         define_callback
+        alias_callback
         set_callback
       end
 
       protected
 
       def set_callback
-        klass.set_callback(:create, :before, callback_name)
+        unless callback_attached?("save", aliased_callback_name)
+          klass.set_callback(:save, :before, aliased_callback_name)
+        end
       end
 
-      def callback_name
-        "denormalize_from_#{relation}"
+      def ensure_field_not_defined!(prefixed_name, klass)
+        if field_defined?(prefixed_name, klass)
+          raise Mongoid::Alize::Errors::AlreadyDefinedField.new(prefixed_name, klass.name)
+        end
+      end
+
+      def field_defined?(prefixed_name, klass)
+        !!klass.fields[prefixed_name]
+      end
+
+      def direction
+        "from"
       end
     end
   end

data/lib/mongoid/alize/to_callback.rb

@@ -4,28 +4,52 @@ module Mongoid
 
       def attach
         define_callback
+        alias_callback
         set_callback
 
         define_destroy_callback
+        alias_destroy_callback
         set_destroy_callback
       end
 
       protected
 
       def set_callback
-        klass.set_callback(:save, :after, callback_name)
+        unless callback_attached?("save", aliased_callback_name)
+          klass.set_callback(:save, :after, aliased_callback_name)
+        end
       end
 
       def set_destroy_callback
-        klass.set_callback(:destroy, :after, destroy_callback_name)
+        unless callback_attached?("destroy", aliased_destroy_callback_name)
+          klass.set_callback(:destroy, :after, aliased_destroy_callback_name)
+        end
       end
 
-      def callback_name
-        "denormalize_to_#{relation}"
+      def alias_destroy_callback
+        unless callback_defined?(aliased_destroy_callback_name)
+          klass.send(:alias_method, aliased_destroy_callback_name, destroy_callback_name)
+        end
+      end
+
+      def aliased_destroy_callback_name
+        "denormalize_destroy_#{direction}_#{relation}"
       end
 
       def destroy_callback_name
-        "denormalize_destroy_to_#{relation}"
+        "_#{aliased_destroy_callback_name}"
+      end
+
+      def plain_relation
+        "self.#{relation}"
+      end
+
+      def surrounded_relation
+        "self.#{relation} ? [self.#{relation}] : []"
+      end
+
+      def direction
+        "to"
       end
     end
   end

data/lib/mongoid/alize/to_many_callback.rb

@@ -4,36 +4,41 @@ module Mongoid
       protected
 
       def define_callback
-        _callback(callback_name,
-                  "inverse.push(:#{prefixed_name}, self.attributes.slice(#{joined_fields}))")
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+          def #{callback_name}#{force_param}
+            data = #{joined_field_values("self")}
+            (#{iterable_relation}).each do |inverse|
+              #{pull_from_inverse}
+              inverse.push(:#{prefixed_name}, data)
+            end
+          end
+          protected :#{callback_name}
+        CALLBACK
       end
 
       def define_destroy_callback
-        _callback(destroy_callback_name)
-      end
-
-      def _callback(_callback_name, push_content="")
         klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-          def #{_callback_name}
-
+          def #{destroy_callback_name}
             (#{iterable_relation}).each do |inverse|
+              #{pull_from_inverse}
+            end
+          end
+          protected :#{destroy_callback_name}
+        CALLBACK
+      end
 
-              # this pull works in the DB, but not in memory
-              # ($pull w/ expression not currently supported by Mongoid)
-              inverse.pull(:#{prefixed_name}, { "_id" => self.id })
-
-              # manually do the pull in memory for now
-              if inverse.#{prefixed_name}
-                inverse.#{prefixed_name}.reject! do |hash|
-                  hash["_id"] == self.id
-                end
-              end
+      def pull_from_inverse
+        <<-CALLBACK
+          # this pull works in the DB, but not in memory
+          # ($pull w/ expression not currently supported by Mongoid)
+          inverse.pull(:#{prefixed_name}, { "_id" => self.id })
 
-              #{push_content}
+          # manually do the pull in memory for now
+          if inverse.#{prefixed_name}
+            inverse.#{prefixed_name}.reject! do |hash|
+              hash["_id"] == self.id
             end
           end
-
-          protected :#{_callback_name}
         CALLBACK
       end
 

data/lib/mongoid/alize/to_one_callback.rb

@@ -13,7 +13,7 @@ module Mongoid
 
       def to_one_field_sets
         fields.map { |field|
-          "relation.set(:#{prefixed_field_name(field)}, self.read_attribute(:#{field}))"
+          "relation.set(:#{prefixed_field_name(field)}, self.send(:#{field}))"
         }.join("\n")
       end
 
@@ -25,13 +25,12 @@ module Mongoid
 
       def _callback(_callback_name, field_sets)
         klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-          def #{_callback_name}
+          def #{_callback_name}#{force_param}
             (#{iterable_relation}).each do |relation|
               #{field_sets}
             end
             true
           end
-
           protected :#{_callback_name}
         CALLBACK
       end

data/lib/mongoid_alize.rb

@@ -1,7 +1,10 @@
+require 'mongoid/alize/errors/alize_error'
+require 'mongoid/alize/errors/invalid_field'
+require 'mongoid/alize/errors/already_defined_field'
+
 require 'mongoid/alize/callback'
 
 require 'mongoid/alize/from_callback.rb'
-
 require 'mongoid/alize/to_callback.rb'
 require 'mongoid/alize/to_one_callback.rb'
 require 'mongoid/alize/to_many_callback.rb'
@@ -16,6 +19,8 @@ require 'mongoid/alize/callbacks/to/many_from_many.rb'
 
 require 'mongoid/alize/macros'
 
+I18n.load_path << File.join(File.dirname(__FILE__), "..", "config", "locales", "en.yml")
+
 module Mongoid
   module Alize
     extend ActiveSupport::Concern