mongoid_alize 0.1.0

data/lib/mongoid/alize/callback.rb

@@ -0,0 +1,34 @@
+module Mongoid
+  module Alize
+    class Callback
+
+      attr_accessor :fields
+
+      attr_accessor :klass
+      attr_accessor :relation
+
+      attr_accessor :inverse_klass
+      attr_accessor :inverse_relation
+
+      def initialize(_klass, _relation, _fields)
+        self.klass = _klass
+        self.relation = _relation
+        self.fields = _fields
+
+        reflect = _klass.relations[_relation.to_s]
+        self.inverse_klass = reflect.klass
+        self.inverse_relation = reflect.inverse
+      end
+
+      def attach
+        # implement in subclasses
+      end
+
+      protected
+
+      def joined_fields
+        (fields + [:_id]).map {|f| "'#{f}'" }.join(", ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module From
+        class Many < FromCallback
+
+          protected
+
+          def define_callback
+            klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+              def #{callback_name}
+                self.#{prefixed_name} = self.#{relation}.map do |model|
+                  model.attributes.slice(#{joined_fields})
+                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
+          end
+
+          def prefixed_name
+            "#{relation}_fields"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module From
+        class One < FromCallback
+
+          protected
+
+          def define_callback
+            field_sets = ""
+            fields.each do |name|
+              field_sets << "self.set(:#{prefixed_field_name(name)}, relation && relation.read_attribute(:#{name}))\n"
+            end
+
+            klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+              def #{callback_name}
+                relation = self.#{relation}
+                #{field_sets}
+                true
+              end
+
+              protected :#{callback_name}
+            CALLBACK
+          end
+
+          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
+            end
+          end
+
+          def prefixed_field_name(name)
+            "#{relation}_#{name}"
+          end
+
+          def inverse_field_type(name)
+            field = inverse_klass.fields[name.to_s]
+            field.options[:type] ? field.type : String
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module To
+        class ManyFromMany < ToManyCallback
+          protected
+
+          def iterable_relation
+            "self.#{relation}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module To
+        class ManyFromOne < ToManyCallback
+          protected
+
+          def iterable_relation
+            "self.#{relation} ? [self.#{relation}] : []"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module To
+        class OneFromMany < ToOneCallback
+          protected
+
+          def iterable_relation
+            "self.#{relation}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Mongoid
+  module Alize
+    module Callbacks
+      module To
+        class OneFromOne < ToOneCallback
+          protected
+
+          def iterable_relation
+            "self.#{relation} ? [self.#{relation}] : []"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/alize/from_callback.rb

@@ -0,0 +1,23 @@
+module Mongoid
+  module Alize
+    class FromCallback < Callback
+
+      def attach
+        define_fields
+
+        define_callback
+        set_callback
+      end
+
+      protected
+
+      def set_callback
+        klass.set_callback(:create, :before, callback_name)
+      end
+
+      def callback_name
+        "denormalize_from_#{relation}"
+      end
+    end
+  end
+end

data/lib/mongoid/alize/macros.rb

@@ -0,0 +1,68 @@
+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
+
+        def (many = many.dup).==(klass)
+          [Mongoid::Relations::Many,
+           Mongoid::Relations::Referenced::Many].map(&:name).include?(klass.name)
+        end
+
+        klass = self
+        reflect = klass.relations[relation.to_s]
+
+        from_one  = Mongoid::Alize::Callbacks::From::One
+        from_many = Mongoid::Alize::Callbacks::From::Many
+
+        relation_superclass = reflect.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
+        end
+      end
+
+      def default_alize_fields(relation)
+        self.relations[relation.to_s].klass.
+          fields.reject { |name, field|
+          name =~ /^_/
+        }.keys
+      end
+    end
+  end
+end

data/lib/mongoid/alize/to_callback.rb

@@ -0,0 +1,32 @@
+module Mongoid
+  module Alize
+    class ToCallback < Callback
+
+      def attach
+        define_callback
+        set_callback
+
+        define_destroy_callback
+        set_destroy_callback
+      end
+
+      protected
+
+      def set_callback
+        klass.set_callback(:save, :after, callback_name)
+      end
+
+      def set_destroy_callback
+        klass.set_callback(:destroy, :after, destroy_callback_name)
+      end
+
+      def callback_name
+        "denormalize_to_#{relation}"
+      end
+
+      def destroy_callback_name
+        "denormalize_destroy_to_#{relation}"
+      end
+    end
+  end
+end

data/lib/mongoid/alize/to_many_callback.rb

@@ -0,0 +1,45 @@
+module Mongoid
+  module Alize
+    class ToManyCallback < ToCallback
+      protected
+
+      def define_callback
+        _callback(callback_name,
+                  "inverse.push(:#{prefixed_name}, self.attributes.slice(#{joined_fields}))")
+      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}
+
+            (#{iterable_relation}).each do |inverse|
+
+              # 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
+
+              #{push_content}
+            end
+          end
+
+          protected :#{_callback_name}
+        CALLBACK
+      end
+
+      def prefixed_name
+        "#{inverse_relation}_fields"
+      end
+    end
+  end
+end

data/lib/mongoid/alize/to_one_callback.rb

@@ -0,0 +1,44 @@
+module Mongoid
+  module Alize
+    class ToOneCallback < ToCallback
+      protected
+
+      def define_callback
+        _callback(callback_name, to_one_field_sets)
+      end
+
+      def define_destroy_callback
+        _callback(destroy_callback_name, to_one_destroy_field_sets)
+      end
+
+      def to_one_field_sets
+        fields.map { |field|
+          "relation.set(:#{prefixed_field_name(field)}, self.read_attribute(:#{field}))"
+        }.join("\n")
+      end
+
+      def to_one_destroy_field_sets
+        fields.map { |field|
+          "relation.set(:#{prefixed_field_name(field)}, nil)"
+        }.join("\n")
+      end
+
+      def _callback(_callback_name, field_sets)
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+          def #{_callback_name}
+            (#{iterable_relation}).each do |relation|
+              #{field_sets}
+            end
+            true
+          end
+
+          protected :#{_callback_name}
+        CALLBACK
+      end
+
+      def prefixed_field_name(name)
+        "#{inverse_relation}_#{name}"
+      end
+    end
+  end
+end

data/lib/mongoid_alize.rb

@@ -0,0 +1,27 @@
+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'
+
+require 'mongoid/alize/callbacks/from/one.rb'
+require 'mongoid/alize/callbacks/from/many.rb'
+
+require 'mongoid/alize/callbacks/to/one_from_one.rb'
+require 'mongoid/alize/callbacks/to/one_from_many.rb'
+require 'mongoid/alize/callbacks/to/many_from_one.rb'
+require 'mongoid/alize/callbacks/to/many_from_many.rb'
+
+require 'mongoid/alize/macros'
+
+module Mongoid
+  module Alize
+    extend ActiveSupport::Concern
+
+    included do
+      extend Mongoid::Alize::Macros
+    end
+  end
+end

data/spec/app/models/head.rb

@@ -0,0 +1,22 @@
+class Head
+  include Mongoid::Document
+  include Mongoid::Alize
+
+  field :size, type: Integer
+  field :weight
+
+  # to whom it's attached
+  belongs_to :person
+
+  # in who's possession it is
+  belongs_to :captor, :class_name => "Person", :inverse_of => :heads
+
+  # who'd otherwise like to possess it
+  has_and_belongs_to_many :wanted_by, :class_name => "Person", :inverse_of => :wants
+
+  # who it sees
+  has_many :sees, :class_name => "Person", :inverse_of => :seen_by
+
+  # a relation with no inverse
+  has_many :admirer, :class_name => "Person", :inverse_of => nil
+end