has_moderated 0.0.34 → 1.0.alpha

data/lib/has_moderated/common.rb

@@ -4,140 +4,89 @@ module HasModerated
       base.send :include, InstanceMethods
     end
     
+    def self.init(klass)
+      unless klass.class_variable_defined? "@@moderation_disabled"
+        klass.class_eval do
+          attr_accessor :moderation_disabled
+          @@moderation_disabled = false
+        end  
+        HasModerated::Adapters::Proxy::add_moderations_association klass
+      end
+    end
+    
+    def self.try_without_moderation rec
+      # TODO: fix this, this method should only be avail. to moderated models
+      if rec.respond_to?(:moderation_disabled)
+        rec.without_moderation(true) { |rec| yield(rec) }
+      else
+        yield(rec)
+      end
+    end
+
+    # calls user hooks for creation of a new moderation
+    def self.call_creating_hook model, moderation
+      #todo use model.class.moderation_hooks[:creating_moderation]
+      if model.class.respond_to?(:moderation_hooks)
+        model.class.moderation_hooks[:creating] ||= []
+        model.class.moderation_hooks[:creating].each do |hook|
+          model.instance_exec moderation, &hook
+        end
+      end
+    end
+    
     module InstanceMethods
-      def create_moderation_with_hooks!(*args)
-        m = Moderation.new(*args)
-        HasModerated::Common::call_creating_hook(self, m)
-        m.save!
-        m
+      def without_moderation(do_disable = true)
+        raise "moderation already disabled - illegal nesting" if self.moderation_disabled && do_disable
+        self.moderation_disabled = true if do_disable
+        yield(self)
+        self.moderation_disabled = false if do_disable
       end
       
-      def moderatable_updating(disable_moderation = true)
-        self.has_moderated_updating = true if disable_moderation
-        yield(self)
-        self.has_moderated_updating = false if disable_moderation
+      def get_moderation_attributes
+        HasModerated::Adapters::Proxy::get_default_moderation_attributes(self)
       end
       
-      def get_moderation_attributes(model)
-        if model.respond_to?(:moderatable_hashize)
-          model.moderatable_hashize
-        else
-          model.attributes
-        end
+      def create_moderation_with_hooks!(*args)
+        m = self.moderations.build(:data => args.first)
+        HasModerated::Common::call_creating_hook(self, m)
+        m.save!
+        m
       end
       
-      def add_associations_moderated assocs
-        # check for through assocs
-        from_record = self
-        through_assocs = {}
-        from_record.class.reflections.keys.each do |assoc|
-          join_model = from_record.class.reflections[assoc.to_sym].options[:through]
-          if join_model
-            join_model = join_model.to_sym
-            through_assocs[join_model] ||= []
-            through_assocs[join_model].push(assoc)
+      def add_associations_moderated assocs_data
+        # convert associations data so it can be serialized
+        assocs_processed = Hash.new
+        assocs_data.each_pair do |assoc_name, assoc_data_array|
+          assocs_processed[assoc_name] = []
+          assoc_data_array.each do |assoc_data|
+            # convert assoc data to either ID or, if it's a new record, hash of its attributes
+            pdata = HasModerated::Adapters::Proxy::hashize_association(self, assoc_name, assoc_data)
+            assocs_processed[assoc_name].push(pdata)
           end
         end
-
-        assoc_attrs = {}
-        assocs.each_pair do |assoc_name, assoc|
-          one_assoc = []
-          assoc.each do |m|
-            if m.class == Fixnum
-              one_assoc.push(m)
-            elsif m.new_record?
-              one_assoc.push(from_record.get_moderation_attributes(m))
-            else
-              one_assoc.push(m.id)
-            end
-            if through_assocs[assoc_name.to_sym]
-              one_assoc.last[:associations] = HasModerated::Common::get_assocs_for_moderation(through_assocs[assoc_name.to_sym], m)
-            end
-          end
-          assoc_attrs[assoc_name] = one_assoc unless one_assoc.empty?
-        end
-
+        
+        # create moderation for adding the associations and return it
         moderations = []
-        if !assoc_attrs.empty?
-          moderations.push(create_moderation_with_hooks!({
-              :moderatable_type => self.class.to_s,
-              :moderatable_id => self.id,
-              :attr_name => "-",
-              :attr_value => { :associations => assoc_attrs }
-            }))
+        unless assocs_processed.empty?
+          moderations.push(create_moderation_with_hooks!(
+              :associations => assocs_processed
+            ))
         end
 
         moderations
       end
       
+      # moderate removing associations
       def delete_associations_moderated(assocs)
         moderations = []
-        if !assocs.empty?
-          moderations.push(create_moderation_with_hooks!({
-              :moderatable_type => self.class.to_s,
-              :moderatable_id => self.id,
-              :attr_name => "-",
-              :attr_value => { :delete_associations => assocs }
-            }))
+        unless assocs.empty?
+          moderations.push(create_moderation_with_hooks!(
+              :delete_associations => assocs
+            ))
         end
 
         moderations
       end
     end
-    
-    def self.get_assocs_for_moderation assocs, from_record = nil
-      from_record ||= self
-      return if assocs.blank?
-
-      if assocs == :all
-        assocs = from_record.class.reflections.keys.reject do |r|
-          r == :moderations
-        end
-      end
-      
-      assocs = [assocs] unless assocs.respond_to?("[]")
-
-      # check for through assocs
-      assocs = assocs.dup
-      through_assocs = {}
-      assocs.each do |assoc|
-        join_model = from_record.class.reflections[assoc.to_sym].options[:through]
-        if join_model
-          join_model = join_model.to_sym
-          through_assocs[join_model] ||= []
-          through_assocs[join_model].push(assoc)
-          assocs.push(join_model) unless assocs.include?(join_model)
-          #assocs.delete(assoc)
-        end
-      end
-
-      assoc_attrs = {}
-      assocs.each do |assoc|
-        one_assoc = []
-        assoc_value = from_record.send(assoc)
-        # if it's has_one it won't be an array
-        assoc_value = [assoc_value] if assoc_value && assoc_value.class != Array
-        assoc_value ||= []
-        assoc_value.each do |m|
-          if m.new_record?
-            one_assoc.push(from_record.get_moderation_attributes(m))
-          else
-            one_assoc.push(m.id)
-          end
-          if through_assocs[assoc.to_sym]
-            one_assoc.last[:associations] = get_assocs_for_moderation(through_assocs[assoc.to_sym], m)
-          end
-        end
-        assoc_attrs[assoc] = one_assoc unless one_assoc.empty?
-      end
-
-      assoc_attrs
-    end
-    
-    def self.call_creating_hook model, moderation
-      if model.class.respond_to?(:moderation_creating_hook)
-        model.instance_exec moderation, &(model.class.moderation_creating_hook)
-      end
-    end
   end
 end

data/lib/has_moderated/moderated_attributes.rb

@@ -2,12 +2,11 @@ module HasModerated
   module ModeratedAttributes
     module ClassMethods
       def has_moderated *args, &block
+        HasModerated::Common::init(self)
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
         send :include, InstanceMethods
 
-        has_many :moderations, :as => :moderatable, :dependent => :destroy
-
         cattr_accessor :moderated_attributes
         cattr_accessor :moderated_options
 
@@ -23,11 +22,11 @@ module HasModerated
         end
 
         # use an attribute to temporarily disable moderation before_save filter
-        attr_accessor :has_moderated_updating
+        attr_accessor :moderation_disabled
 
         # send moderated attributes to moderation before saving the model
         before_save do
-          if self.valid? && @has_moderated_updating != true &&
+          if self.valid? && @moderation_disabled != true &&
             # don't save moderated attributes if create is moderated and it's a new record
             !(self.class.respond_to?("moderated_create_options") && new_record?)
             moderations = self.to_moderation
@@ -39,6 +38,7 @@ module HasModerated
         end
 
         # when creating a new record, we must update moderations' id after it is known (after create)
+        # TODO is this even necessary when using assoc.create ?
         after_create do
           if !self.id.blank? && !@pending_moderations.blank?
             @pending_moderations.each do |m|
@@ -50,19 +50,32 @@ module HasModerated
       end
     end
     
-    module InstanceMethods
+    module ApplyModeration
+      def self.apply(moderation, value)
+        if value[:attributes].present?
+          rec = moderation.moderatable
+          rec.without_moderation do
+            value[:attributes].each_pair do |attr_name, attr_value|
+              # bypass attr_accessible protection
+              rec.send(attr_name.to_s+"=", attr_value)
+            end
+            rec.save(:validate => false) # don't run validations
+          end
+        end
+      end
+    end
     
+    module InstanceMethods
       def to_moderation
         moderations = []
         self.changes.each_pair do |att_name, values|
           att_name = att_name.to_s
           if self.class.moderated_attributes.include?(att_name) && !(values[0].blank? && values[1].blank?)
-            moderations.push(create_moderation_with_hooks!({
-              :moderatable_type => self.class.to_s,
-              :moderatable_id => self.id,
-              :attr_name => att_name,
-              :attr_value => self.attributes[att_name].to_yaml
-            }))
+            moderations.push(create_moderation_with_hooks!(
+              :attributes => {
+                att_name => self.attributes[att_name]
+              }
+            ))
             self.send(att_name+"=", values[0])
           end
         end

data/lib/has_moderated/moderated_create.rb

@@ -2,13 +2,11 @@ module HasModerated
   module ModeratedCreate
     module ClassMethods
       def has_moderated_create *options
+        HasModerated::Common::init(self)
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
         send :include, InstanceMethods
 
-        # use an attribute to temporarily disable moderation before_save filter
-        attr_accessor :has_moderated_updating
-
         # save options for use later
         cattr_accessor :moderated_create_options
         self.moderated_create_options = (options.count > 0) ? options[0] : {} 
@@ -17,9 +15,26 @@ module HasModerated
       end
     end
     
+    module ApplyModeration
+      def self.apply(moderation, value)
+        if value[:create].present?
+          # create the main record
+          rec = moderation.moderatable_type.constantize.new
+          attrs = value[:create][:attributes]
+          # bypass attr_accessible protection
+          attrs && attrs.each_pair do |key, val|
+            rec.send(key.to_s+"=", val) unless key.to_s == 'id'
+          end
+          rec.without_moderation { rec.save(:validate => false) }
+          moderation.moderatable = rec
+          HasModerated::Associations::Base::ApplyModeration::apply(moderation, value[:create])
+        end
+      end
+    end
+    
     module InstanceMethods
       def create_or_update_with_moderation *args
-        if valid? && new_record? && @has_moderated_updating != true
+        if valid? && new_record? && @moderation_disabled != true
           to_moderation_created
           true
         else
@@ -29,18 +44,11 @@ module HasModerated
 
       def to_moderation_created
         options = self.class.moderated_create_options
-        assoc_attrs = HasModerated::Common::get_assocs_for_moderation(options[:with_associations], self)
+        assoc_attrs = HasModerated::Adapters::ActiveRecord::get_assocs_for_moderation(options[:with_associations], self)
 
-        attr_value = {
-          :main_model => get_moderation_attributes(self),
+        create_moderation_with_hooks!(:create => {
+          :attributes => get_moderation_attributes,
           :associations => assoc_attrs
-        }
-
-        create_moderation_with_hooks!({
-          :moderatable_type => self.class.to_s,
-          :moderatable_id => self.id,
-          :attr_name => "-",
-          :attr_value => attr_value.to_yaml
         })
       end
     end

data/lib/has_moderated/moderated_destroy.rb

@@ -2,20 +2,26 @@ module HasModerated
   module ModeratedDestroy
     module ClassMethods
       def has_moderated_destroy *options
+        HasModerated::Common::init(self)
         # Lazily include the instance methods so we don't clutter up
         # any more ActiveRecord models than we have to.
         send :include, InstanceMethods
       
-        # use an attribute to temporarily disable moderation before_save filter
-        attr_accessor :has_moderated_updating
-      
         alias_method_chain :destroy, :moderation
       end
     end
     
+    module ApplyModeration
+      def self.apply(moderation, value)
+        if value.to_s == "destroy"
+          moderation.moderatable.without_moderation { |m| m.destroy }
+        end
+      end
+    end
+    
     module InstanceMethods
       def destroy_with_moderation *args
-        if @has_moderated_updating == true
+        if @moderation_disabled == true
           destroy_without_moderation *args
         else
           to_moderation_destroyed
@@ -24,12 +30,7 @@ module HasModerated
       end
 
       def to_moderation_destroyed
-        create_moderation_with_hooks!({
-          :moderatable_type => self.class.to_s,
-          :moderatable_id => self.id,
-          :attr_name => "-",
-          :attr_value => "destroy"
-        })
+        create_moderation_with_hooks!(:destroy)
       end
     end
   end

data/lib/has_moderated/moderation_model.rb

@@ -1,206 +1,12 @@
 module HasModerated
   module ModerationModel
-    
-    def interpreted_value
-      @interpreted_value ||= if attr_name == '-'
-        YAML::load(attr_value)
-      else
-        attr_value
-      end
-    end
-    
-    def create_from_value
-      if moderatable_id.blank?
-        # create the main record
-        rec = moderatable_type.constantize.new
-        attrs = interpreted_value[:main_model]
-        # bypass attr_accessible protection
-        attrs && attrs.each_pair do |key, val|
-          rec.send(key.to_s+"=", val) unless key.to_s == 'id'
-        end
-        rec
-      else
-        nil
-      end
-    end
-    
-    def delete_assoc_from_record arec, rec, assoc_name
-      return unless rec && arec
-      
-      assoc = rec.class.reflections[assoc_name.to_sym]
-      
-      if assoc.macro == :has_and_belongs_to_many || !assoc.options[:through].blank? || assoc.macro == :has_many
-        rec.send(assoc_name).delete(arec)
-      else
-        raise "Cannot delete association for this type of associations!"
-      end
-    end
-    
-    def delete_associations_from_value rec, interpreted_assocs = nil
-      interpreted_assocs ||= interpreted_value[:delete_associations]
-      # in case it's empty
-      interpreted_assocs ||= {}
-      
-      interpreted_assocs.each_pair do |assoc_name, assoc_records|
-        # read reflections attribute to determine proper class name and primary key
-        assoc_details = rec.class.reflections[assoc_name.to_sym]
-        m = assoc_details.class_name.constantize
-        
-        fk = if assoc_details.respond_to?(:foreign_key)
-          assoc_details.foreign_key
-        else # Rails < v3.1
-          assoc_details.primary_key_name
-        end
-
-        # all instances for this association type
-        assoc_records.each do |attrs|
-          next if attrs.blank?
-          next if attrs.class != Fixnum
-          try_moderatable_updating(rec) do
-            arec = nil
-          # PARAM = ID
-            arec = m.find_by_id(attrs)
-            delete_assoc_from_record(arec, rec, assoc_name)
-          end
-        end
-      end
-    end
-    
-    def add_assoc_to_record arec, rec, assoc_name
-      return unless rec && arec
-      
-      assoc = rec.class.reflections[assoc_name.to_sym]
-      
-      if assoc.macro == :has_and_belongs_to_many || !assoc.options[:through].blank?
-        field = if !assoc.options[:join_table].blank?
-          jointable = assoc.options[:join_table].to_s
-          results = arec.class.reflections.reject do |assoc_name, assoc|
-            !(assoc.options[:join_table] && assoc.options[:join_table].to_s == jointable)
-          end
-          if results.blank?
-            raise "has_moderated: Cannot determine join table for a Habtm association!"
-          end
-          results.first[1].name.to_s
-        else
-          rec.class.to_s.underscore.pluralize
-        end
-        arec.send(field) << rec
-      elsif assoc.macro == :has_many || assoc.macro == :has_one
-        field = if !assoc.options[:as].blank?
-          assoc.options[:as].to_s
-        elsif !assoc.options[:foreign_key].blank?
-          fk = assoc.options[:foreign_key].to_s
-          results = arec.class.reflections.reject do |assoc_name, assoc|
-            !(assoc.options[:foreign_key] && assoc.options[:foreign_key].to_s == fk)
-          end
-          if results.blank?
-            raise "Please set foreign_key for both belongs_to and has_one/has_many!"
-          end
-          results.first[1].name.to_s
-        else
-          rec.class.to_s.underscore
-        end
-        arec.send(field + "=", rec)
-      end
-    end
-    
-    def try_moderatable_updating rec
-      rec.has_moderated_updating = true if rec.respond_to?("has_moderated_updating=")
-      yield(rec)
-      rec.has_moderated_updating = false if rec.respond_to?("has_moderated_updating=")
-    end
-    
-    def update_associations_from_value rec, interpreted_assocs = nil
-      interpreted_assocs ||= interpreted_value[:associations]
-      # in case it's empty
-      interpreted_assocs ||= {}
-      # loop association types, e.g. :comments
-      interpreted_assocs.each_pair do |assoc_name, assoc_records|
-        # read reflections attribute to determine proper class name and primary key
-        assoc_details = rec.class.reflections[assoc_name.to_sym]
-        m = assoc_details.class_name.constantize
-        
-        fk = if assoc_details.respond_to?(:foreign_key)
-          assoc_details.foreign_key
-        else # Rails < v3.1
-          assoc_details.primary_key_name
-        end
-
-        # all instances for this association type
-        assoc_records.each do |attrs|
-          next if attrs.blank?
-          if attrs.class != Fixnum && !attrs[:id].blank?
-            attrs = attrs[:id].to_i
-          end
-          try_moderatable_updating(rec) do
-            arec = nil
-          # PARAM = ID
-            if attrs.class == Fixnum
-              arec = m.find_by_id(attrs)
-              add_assoc_to_record(arec, rec, assoc_name)
-          # PARAM = Hash (create)
-            else
-              arec = m.new
-              # set foreign key first, may be required sometimes
-              add_assoc_to_record(arec, rec, assoc_name)
-              attrs && attrs.each_pair do |key, val|
-                next if key.to_s == "associations" || key.to_s == 'id' || key.to_s == fk
-                arec.send(key.to_s+"=", val)
-              end
-              if attrs[:associations]
-                update_associations_from_value arec, attrs[:associations]
-              end
-            end
-            if arec
-              try_moderatable_updating(arec) do
-                arec.save(:validate => false) # don't run validations
-              end
-              if assoc_details.collection?
-                rec.send(assoc_name.to_s) << arec if arec
-              else
-                rec.send(assoc_name.to_s + "=", arec) if arec
-              end
-            end
-          end
-        end
-      end
-    end
-    
     def accept
-      # DESTROY
-      if attr_name == '-' && attr_value.class == String && attr_value == "destroy"
-        moderatable.moderatable_updating { moderatable.destroy }
-        self.destroy
-      
-      # CREATE or ASSOCIATIONS
-      elsif attr_name == '-'
-        loaded_val = YAML::load(attr_value)
-        # case: moderated existance (new record)
-        if moderatable_id.blank?
-          rec = create_from_value
-          # save, don't run validations
-          rec.moderatable_updating { rec.save(:validate => false) }
-        # case: moderated associations (existing record)
-        else
-          rec = moderatable
-        end
-
-        # check for saved associated records
-        update_associations_from_value rec
-        delete_associations_from_value rec
-        
-        self.destroy # destroy this moderation since it has been applied
-        rec
-        
-      # CHANGE ATTRIBUTE
-      else
-        moderatable.moderatable_updating do
-          # bypass attr_accessible protection
-          moderatable.send(attr_name.to_s+"=", YAML::load(attr_value))
-          moderatable.save(:validate => false) # don't run validations
-        end
-        self.destroy # destroy this moderation since it has been applied
-      end
+      loaded_val = YAML::load(data)
+      HasModerated::Associations::Base::ApplyModeration::apply(self, loaded_val)
+      HasModerated::ModeratedAttributes::ApplyModeration::apply(self, loaded_val)
+      HasModerated::ModeratedCreate::ApplyModeration::apply(self, loaded_val)
+      HasModerated::ModeratedDestroy::ApplyModeration::apply(self, loaded_val)
+      self.destroy
     end
 
     def discard

data/lib/has_moderated/user_hooks.rb

@@ -2,8 +2,9 @@ module HasModerated
   module UserHooks
     module ClassMethods
       def moderation_creating &block
-        cattr_accessor :moderation_creating_hook
-        self.moderation_creating_hook = block
+        cattr_accessor :moderation_hooks
+        self.moderation_hooks ||= { :creating => [] }
+        self.moderation_hooks[:creating].push(block)
       end
     end
   end

data/lib/has_moderated/version.rb

@@ -1,3 +1,3 @@
 module HasModerated
-  VERSION = "0.0.34"
+  VERSION = "1.0.alpha"
 end

data/lib/has_moderated.rb

@@ -1,21 +1,29 @@
-require 'has_moderated/moderation_model'
-require 'has_moderated/carrier_wave'
 require 'has_moderated/common'
 require 'has_moderated/user_hooks'
+require 'has_moderated/moderation_model'
+
+require 'has_moderated/adapters/proxy'
+require 'has_moderated/adapters/active_record'
+require 'has_moderated/associations/base'
+require 'has_moderated/associations/has_one'
+require 'has_moderated/associations/collection'
+require 'has_moderated/associations/has_many'
+
+
+require 'has_moderated/moderated_attributes'
 require 'has_moderated/moderated_create'
 require 'has_moderated/moderated_destroy'
-require 'has_moderated/moderated_attributes'
-require 'has_moderated/moderated_associations'
 
 module HasModerated
   def self.included(base)
-    #base.send :extend, HasModerated::Common
     HasModerated::Common::included(base)
     base.send :extend, HasModerated::UserHooks::ClassMethods
+    
+    # TODO: only include class methods that can be called, lazy load everything else
+    base.send :extend, HasModerated::Associations::Base::ClassMethods
+    base.send :extend, HasModerated::ModeratedAttributes::ClassMethods
     base.send :extend, HasModerated::ModeratedCreate::ClassMethods
     base.send :extend, HasModerated::ModeratedDestroy::ClassMethods
-    base.send :extend, HasModerated::ModeratedAssociations::ClassMethods
-    base.send :extend, HasModerated::ModeratedAttributes::ClassMethods
   end
 end
 

data/test/dummy/app/models/subtask.rb

@@ -1,4 +1,3 @@
 class Subtask < ActiveRecord::Base
   belongs_to :task
-  belongs_to :task_all
 end

data/test/dummy/app/models/task.rb

@@ -1,16 +1,3 @@
 class Task < ActiveRecord::Base
   attr_accessible :title
-  has_many :subtasks
-  has_many :task_photos
-  has_and_belongs_to_many :hjoin_tests
-  has_and_belongs_to_many :habtms, :class_name => "HabtmNameTest"
-  has_one :hone_test
-  has_one :hone_as_test, :as => :testable
-  has_many :hmanythrough_join
-  has_many :hmanythrough_test, :through => :hmanythrough_join
-  has_many :lalas, :class_name => "HmanyFkTest", :foreign_key => "something_id"
-  has_moderated :title, :desc
-  has_moderated_create :with_associations => [:subtasks, :task_photos, :hjoin_tests, :hone_test, :hmanythrough_test, :hmanythrough_join, :hone_as_test, :lalas]
-  has_moderated_association :all
-  has_moderated_destroy
 end