has_moderated 0.0.21 → 0.0.24

data/README.rdoc

@@ -2,12 +2,14 @@
 
 == Installing
 
-  gem install has_moderated
-
-And add it to your project's Gemfile
+Add it to your project's Gemfile
 
   gem "has_moderated"
 
+and run
+
+  bundle install
+  
 To set up has_moderated in your project, use
 
   rails generate has_moderated:install
@@ -50,17 +52,19 @@ To moderate destruction of records, use
 
   has_moderated_destroy
 
+Warning! Always put has_many etc. BEFORE has_moderated calls in your model!
 == Moderating associations on existing records
-Sometimes you will want to moderate association changes for existing records, not only on create. Right now, there is only one way to do this and it's not as automagic as most of the other things. Instead of doing something like
+There is an automatic way to moderate associations on already-created records. Use:
 
-  post.comments << new_comment
-  post.scores << new_score
+  has_moderated_association :links, :comments
+  
+to moderate the links and comments associations. You can use :all to moderate all associations, but I recommend you explicitly specify them.
 
-You will *instead* have to call add_associations_moderated like so
+You can also manually add associations to moderation like so
 
   post.add_associations_moderated(:comments => [new_comment], :scores => [new_score])
 
-The values can be either new records (not in the database), existing records, or Fixnum (numerical) IDs. Please note you should not use .build to create new records, because if you call save on the parent model it will automatically create the record, bypassing moderation.
+The values can be either new records (not in the database), existing records, or Fixnum (numerical) IDs. Please note in this case you should not use .build to create new records, because if you call save on the parent model it will automatically create the record (this only applies if you use the manual way).
 
 == Manage moderations
 To see pending moderations, simply call
@@ -88,7 +92,7 @@ to discard (destroy) it, call
 
 If you need any special data attached to the Moderation model, you can use the moderation_creating hook.
 
-=== Example for moderation_creating hook
+=== Attaching user ID to moderations
 
 For example you have a Comment model, and it is moderated. But your visitors are logged in when they post comments, so you want to add the user ID to the moderation.
 
@@ -119,6 +123,9 @@ There is support for CarrierWave uploads to be moderated. You must put this line
 Right now *you must use the field name "photo" for the upload filename* because it is currently hardcoded into this module. If you do this, then moderation for the photo should work correctly.
 
 It does not matter if this model has any moderation itself or if you just have an association to it from some other model that is moderated. You must include this module in either case, because it ensures proper serialization of the photo information.
+If you want to moderate changes to the photo on this model itself (e.g. not only when its associated to something else), add also
+
+  has_moderated :carrierwave_photo
 
 If you need some more customization look at this module in lib/has_moderated/carrier_wave.rb and just copy the methods into your model and customize them (with some care when you do this, some methods should be class methods).
 
@@ -136,7 +143,39 @@ in the root directory.
 
 == TODO
 
+DONT save association when calling .build... only when calling save!
+
+This is just for my personal todo list...
 Amend moderations... Eg if you create a new record and save it, then change something additionally and save again.
+Preview method which gives changed object but doesnt save it.
+
+For automagic associations, look at https://github.com/rails/rails/blob/master/activerecord/lib/active_record/associations/collection_association.rb method concat, concat_records, add_to_target
+u get the instance of this class from with .association("name")
+assoc = t.association(:subtasks)
+def assoc.concat *args ; whatever ; end
+or if we need block (capture outer scope)
+metaclass = class << assoc; self; end
+metaclass.send(:define_method, :concat) do
+   puts "concat 2"
+end
+
+in model use 
+after_initialize do...end
+to overwrite these methods
+ruby-1.8.7-p334 :013 > def assoc.concat_with_mo *args
+ruby-1.8.7-p334 :014?>   puts "in concat mo"
+ruby-1.8.7-p334 :015?>   concat_without_mo *args
+ruby-1.8.7-p334 :016?>   end
+ => nil 
+ruby-1.8.7-p334 :017 > assoc.class_eval do
+ruby-1.8.7-p334 :018 >     alias_method_chain :concat, :mo
+ruby-1.8.7-p334 :019?>   end
+use add_to_target!!! lowest lvl
+add something like has_moderated_association
+don't do anything on create (parent.new_record?) since we already handle that
+test also for one-to-one and join table and has_many through assoc
+
+fix tests for offline working
 == Problems
 
 You may encounter problems with models that have some sort of non-serializable attributes. This might be something like file attachments, you'll have to try it to see.

data/lib/has_moderated.rb

@@ -1,242 +1,21 @@
 require 'has_moderated/moderation_model'
 require 'has_moderated/carrier_wave'
+require 'has_moderated/common'
+require 'has_moderated/user_hooks'
+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, ClassMethods
-  end
-
-  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
-    
-    def moderation_creating &block
-      cattr_accessor :moderation_creating_hook
-      self.moderation_creating_hook = block
-    end
-    
-    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] : nil 
-      
-      alias_method_chain :create_or_update, :moderated_check
-    end
-    
-    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, :moderated_check
-    end
-  end
-  
-  module InstanceMethods
-    def create_or_update_with_moderated_check *args
-      if valid? && new_record? && @has_moderated_updating != true
-        self.to_moderation_created(self.class.moderated_create_options)
-        true
-      else
-        create_or_update_without_moderated_check *args
-      end
-    end
-
-    def destroy_with_moderated_check *args
-      if @has_moderated_updating == true
-        destroy_without_moderated_check *args
-      else
-        to_moderation_destroyed
-        true
-      end
-    end
-    
-    def call_creating_hook moderation
-      if self.class.respond_to?(:moderation_creating_hook)
-        self.instance_exec moderation, &self.class.moderation_creating_hook
-      end
-    end
-    
-    def create_moderation_with_hooks!(*args)
-      m = Moderation.new(*args)
-      call_creating_hook(m)
-      m.save!
-      m
-    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
-
-    def get_assocs_for_moderation options
-      assocs = []
-      
-      unless options.blank?
-        unless options[:with_associations].blank?
-          if options[:with_associations] == :all
-            assocs = self.class.reflections.keys.reject do |r|
-              r == :moderations
-            end
-          else
-            assocs = options[:with_associations]
-            assocs = [assocs] unless assocs.respond_to?("[]")
-          end
-        end
-      end
-
-      assoc_attrs = {}
-      assocs.each do |assoc|
-        one_assoc = []
-        self.send(assoc).each do |m|
-          if m.new_record?
-            one_assoc.push(get_moderation_attributes(m))
-          else
-            one_assoc.push(m.id)
-          end
-        end
-        assoc_attrs[assoc] = one_assoc unless one_assoc.empty?
-      end
-
-      assoc_attrs
-    end
-    
-    def get_moderation_attributes(model)
-      if model.respond_to?(:moderatable_hashize)
-        model.moderatable_hashize
-      else
-        model.attributes
-      end
-    end
-    
-    def to_moderation_created options
-      assoc_attrs = get_assocs_for_moderation(options)
-
-      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
-    
-    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
-
-    def add_associations_moderated assocs
-      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(get_moderation_attributes(m))
-          else
-            one_assoc.push(m.id)
-          end
-        end
-        assoc_attrs[assoc_name] = one_assoc unless one_assoc.empty?
-      end
-
-      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 }
-          }))
-      end
-      
-      moderations
-    end
-    
-    def moderatable_updating
-      self.has_moderated_updating = true
-      yield(self)
-      self.has_moderated_updating = false
-    end
+    #base.send :extend, HasModerated::Common
+    HasModerated::Common::included(base)
+    base.send :extend, HasModerated::UserHooks::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/lib/has_moderated/carrier_wave.rb

@@ -47,7 +47,7 @@ module HasModerated
       
       def store_photo_with_moderation!
         is_moderated = self.class.respond_to?(:moderated_attributes) &&
-          self.class.moderated_attributes.include?("photo")
+          self.class.moderated_attributes.include?("carrierwave_photo")
         if self.has_moderated_updating || !is_moderated
           store_photo_without_moderation!
         else
@@ -60,7 +60,7 @@ module HasModerated
 
       def write_photo_identifier_with_moderation
         is_moderated = self.class.respond_to?(:moderated_attributes) &&
-          self.class.moderated_attributes.include?("photo")
+          self.class.moderated_attributes.include?("carrierwave_photo")
         if self.has_moderated_updating || !is_moderated
           write_photo_identifier_without_moderation
         end

data/lib/has_moderated/common.rb

@@ -0,0 +1,129 @@
+module HasModerated
+  module Common
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+    
+    module InstanceMethods
+      def create_moderation_with_hooks!(*args)
+        m = Moderation.new(*args)
+        HasModerated::Common::call_creating_hook(self, m)
+        m.save!
+        m
+      end
+      
+      def moderatable_updating
+        self.has_moderated_updating = true
+        yield(self)
+        self.has_moderated_updating = false
+      end
+      
+      def get_moderation_attributes(model)
+        if model.respond_to?(:moderatable_hashize)
+          model.moderatable_hashize
+        else
+          model.attributes
+        end
+      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)
+          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
+
+        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 }
+            }))
+        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