has_moderated 0.0.21 → 0.0.24

data/lib/has_moderated/moderated_associations.rb

@@ -0,0 +1,59 @@
+module HasModerated
+  module ModeratedAssociations
+    module ClassMethods
+      def has_moderated_association *args
+        assocs = []
+
+        unless args.blank?
+          if args == [:all]
+            assocs = self.reflections.keys.reject do |r|
+              r == :moderations
+            end
+          else
+            assocs = args
+            assocs = [assocs] unless assocs.respond_to?("[]")
+          end
+        end
+
+        #TODO: should add to some class var and clean duplicates
+
+        after_initialize do
+          assocs.each do |assoc_name|
+            assoc = self.association(assoc_name)
+            if assoc.reflection.collection?
+              def assoc.add_to_target_with_moderation record
+                if !owner.new_record? && !owner.has_moderated_updating
+                  #TODO: add moderation
+                  owner.add_associations_moderated(self.reflection.name => [record])
+                  record
+                else
+                  add_to_target_without_moderation record
+                end
+              end
+              assoc.class_eval do
+                alias_method_chain :add_to_target, :moderation
+              end
+            else
+              def assoc.replace_with_moderation(record, save = true)
+                if !owner.new_record? && !owner.has_moderated_updating
+                  #TODO: add moderation
+                  owner.add_associations_moderated(self.reflection.name => [record])
+                  record
+                else
+                  replace_without_moderation record
+                end
+              end
+              assoc.class_eval do
+                alias_method_chain :replace, :moderation
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+    end
+  end
+end

data/lib/has_moderated/moderated_attributes.rb

@@ -0,0 +1,74 @@
+module HasModerated
+  module ModeratedAttributes
+    module ClassMethods
+      def has_moderated *args, &block
+        # 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
+
+        self.moderated_attributes ||= []
+        self.moderated_options ||= {}
+
+        args.each do |arg|
+          if arg.respond_to?("[]")
+            self.moderated_options = self.moderated_options.merge(arg)
+          else
+            self.moderated_attributes.push(arg.to_s)
+          end
+        end
+
+        # use an attribute to temporarily disable moderation before_save filter
+        attr_accessor :has_moderated_updating
+
+        # send moderated attributes to moderation before saving the model
+        before_save do
+          if self.valid? && @has_moderated_updating != 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
+            if self.id.blank?
+              @pending_moderations ||= []
+              @pending_moderations.concat(moderations)
+            end
+          end
+        end
+
+        # when creating a new record, we must update moderations' id after it is known (after create)
+        after_create do
+          if !self.id.blank? && !@pending_moderations.blank?
+            @pending_moderations.each do |m|
+              m.update_attributes(:moderatable_id => self.id)
+            end
+            @pending_moderations.clear
+          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
+            }))
+            self.send(att_name+"=", values[0])
+          end
+        end
+      
+        moderations
+      end
+    end
+  end
+end

data/lib/has_moderated/moderated_create.rb

@@ -0,0 +1,48 @@
+module HasModerated
+  module ModeratedCreate
+    module ClassMethods
+      def has_moderated_create *options
+        # 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] : {} 
+
+        alias_method_chain :create_or_update, :moderation
+      end
+    end
+    
+    module InstanceMethods
+      def create_or_update_with_moderation *args
+        if valid? && new_record? && @has_moderated_updating != true
+          to_moderation_created
+          true
+        else
+          create_or_update_without_moderation *args
+        end
+      end
+
+      def to_moderation_created
+        options = self.class.moderated_create_options
+        assoc_attrs = HasModerated::Common::get_assocs_for_moderation(options[:with_associations], self)
+
+        attr_value = {
+          :main_model => get_moderation_attributes(self),
+          :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
+  end
+end

data/lib/has_moderated/moderated_destroy.rb

@@ -0,0 +1,36 @@
+module HasModerated
+  module ModeratedDestroy
+    module ClassMethods
+      def has_moderated_destroy *options
+        # 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 InstanceMethods
+      def destroy_with_moderation *args
+        if @has_moderated_updating == true
+          destroy_without_moderation *args
+        else
+          to_moderation_destroyed
+          true
+        end
+      end
+
+      def to_moderation_destroyed
+        create_moderation_with_hooks!({
+          :moderatable_type => self.class.to_s,
+          :moderatable_id => self.id,
+          :attr_name => "-",
+          :attr_value => "destroy"
+        })
+      end
+    end
+  end
+end

data/lib/has_moderated/moderation_model.rb

@@ -24,40 +24,81 @@ module HasModerated
       end
     end
     
-    def update_associations_from_value rec
+    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? 
+        arec.send(rec.class.to_s.underscore.pluralize) << rec
+      elsif assoc.macro == :has_many || assoc.macro == :has_one
+        arec.send(rec.class.to_s.underscore + "=", rec)
+        #fk = if assoc.respond_to?(:foreign_key)
+        #  assoc.foreign_key
+        #else # Rails < v3.1
+        #  assoc.primary_key_name
+        #end
+        #arec.send(fk.to_s+"=", rec.id)
+      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_value[:associations] ||= {}
+      interpreted_assocs ||= {}
       # loop association types, e.g. :comments
-      interpreted_value[:associations].each_pair do |assoc_name, assoc_records|
+      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?
-        # PARAM = ID
-          if attrs.class == Fixnum
-            arec = m.find_by_id(attrs)
-            # add the association, if the record still existss
-            rec.send(assoc_name.to_s) << arec if arec
-        # PARAM = Hash (create)
-          else
-            arec = m.new
-            # set foreign key first, may be required sometimes
-            fk = if assoc_details.respond_to?(:foreign_key)
-              assoc_details.foreign_key
-            else # Rails < v3.1
-              assoc_details.primary_key_name
+          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
-            arec.send(fk.to_s+"=", rec.id) # set association to the newly created record
-            attrs && attrs.each_pair do |key, val|
-              arec.send(key.to_s+"=", val) unless key.to_s == 'id' || key.to_s == fk.to_s
+            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
-            # disable moderation for associated model (if moderated)
-            arec.has_moderated_updating = true if arec.respond_to?("has_moderated_updating=")
-            arec.save(:validate => false) # don't run validations
-            arec.has_moderated_updating = false if arec.respond_to?("has_moderated_updating=")
           end
         end
       end

data/lib/has_moderated/user_hooks.rb

@@ -0,0 +1,10 @@
+module HasModerated
+  module UserHooks
+    module ClassMethods
+      def moderation_creating &block
+        cattr_accessor :moderation_creating_hook
+        self.moderation_creating_hook = block
+      end
+    end
+  end
+end

data/lib/has_moderated/version.rb

@@ -1,3 +1,3 @@
 module HasModerated
-  VERSION = "0.0.21"
+  VERSION = "0.0.24"
 end

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

@@ -0,0 +1,3 @@
+class HjoinTest < ActiveRecord::Base
+  has_and_belongs_to_many :tasks
+end

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

@@ -0,0 +1,4 @@
+class HmanythroughJoin < ActiveRecord::Base
+  belongs_to :task
+  belongs_to :hmanythrough_test
+end

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

@@ -0,0 +1,4 @@
+class HmanythroughTest < ActiveRecord::Base
+  has_many :hmanythrough_join
+  has_many :tasks, :through => :hmanythrough_join
+end

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

@@ -0,0 +1,3 @@
+class HoneTest < ActiveRecord::Base
+  belongs_to :task
+end

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

@@ -2,6 +2,6 @@ class Photo < ActiveRecord::Base
   belongs_to :photo_holder
   mount_uploader :photo, GenericUploader
   has_moderated_create
-  has_moderated :photo
+  has_moderated :carrierwave_photo
   include HasModerated::CarrierWave
 end

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

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

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

@@ -2,7 +2,12 @@ class Task < ActiveRecord::Base
   attr_accessible :title
   has_many :subtasks
   has_many :task_photos
-  has_moderated :title, :desc, { :with_associations => [:subtasks] }
-  has_moderated_create :with_associations => [:subtasks, :task_photos]
+  has_and_belongs_to_many :hjoin_tests
+  has_one :hone_test
+  has_many :hmanythrough_join
+  has_many :hmanythrough_test, :through => :hmanythrough_join
+  has_moderated :title, :desc
+  has_moderated_create :with_associations => [:subtasks, :task_photos, :hjoin_tests, :hone_test, :hmanythrough_test, :hmanythrough_join]
+  has_moderated_association :all
   has_moderated_destroy
 end

data/test/dummy/db/migrate/20111008195728_create_hone_tests.rb

@@ -0,0 +1,9 @@
+class CreateHoneTests < ActiveRecord::Migration
+  def change
+    create_table :hone_tests do |t|
+      t.integer :task_id
+
+      t.timestamps
+    end
+  end
+end

data/test/dummy/db/migrate/20111008195809_create_hjoin_tests.rb

@@ -0,0 +1,13 @@
+class CreateHjoinTests < ActiveRecord::Migration
+  def change
+    create_table :hjoin_tests do |t|
+      t.string :title
+
+      t.timestamps
+    end
+    create_table :hjoin_tests_tasks do |t|
+      t.integer :task_id
+      t.integer :hjoin_test_id
+    end
+  end
+end

data/test/dummy/db/migrate/20111009193145_fix_join_table.rb

@@ -0,0 +1,8 @@
+class FixJoinTable < ActiveRecord::Migration
+  def up
+    remove_column :hjoin_tests_tasks, :id
+  end
+
+  def down
+  end
+end

data/test/dummy/db/migrate/20111009201729_add_title_to_hone_tests.rb

@@ -0,0 +1,5 @@
+class AddTitleToHoneTests < ActiveRecord::Migration
+  def change
+    add_column :hone_tests, :title, :string
+  end
+end