has_moderated 0.0.9 → 0.0.10

data/README.rdoc

@@ -50,6 +50,18 @@ To moderate destruction of records, use
 
   has_moderated_destroy
 
+== 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
+
+  post.comments << new_comment
+  post.scores << new_score
+
+You will *instead* have to call add_associations_moderated 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.
+
 == Manage moderations
 To see pending moderations, simply call
 

data/lib/generators/has_moderated/install/templates/moderation.rb

@@ -1,76 +1,5 @@
 class Moderation < ActiveRecord::Base
   belongs_to :moderatable, :polymorphic => true
-
-  def accept
-    # case: moderated destruction
-    if attr_name == '-' && attr_value.class == String && attr_value == "destroy"
-      moderatable.has_moderated_updating = true
-      moderatable.destroy
-      moderatable.has_moderated_updating = false
-      self.destroy
-    elsif attr_name == '-'
-      loaded_val = YAML::load(attr_value)
-      # case: moderated existance (new record)
-      if moderatable_id.blank?
-        # create the main record
-        rec = moderatable_type.constantize.new
-        attrs = loaded_val[:main_model]
-        # bypass attr_accessible protection
-        attrs.each_pair do |key, val|
-          rec.send(key.to_s+"=", val) unless key.to_s == 'id'
-        end
-        # temporarily disable moderation check on save, and save updated record
-        rec.has_moderated_updating = true
-        rec.save(:validate => false) # don't run validations
-        rec.has_moderated_updating = false
-      # case: moderated associations (existing record)
-      else
-        rec = moderatable
-      end
-
-      # check for saved associated records
-      loaded_val[:associations].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
-
-        # all records for this associated model
-        assoc_records.each do |attrs|
-          if attrs.class == Fixnum # associate to existing record
-            arec = m.find_by_id(attrs)
-            rec.send(assoc_name.to_s) << arec if arec # add the association, if the record still exists
-          else # create a new record
-            arec = m.new # new associated model
-            attrs.each_pair do |key, val|
-              arec.send(key.to_s+"=", val) unless key.to_s == 'id'
-            end
-            fk = if assoc_details.respond_to?(:foreign_key)
-              assoc_details.foreign_key
-            else # version < 3.1
-              assoc_details.primary_key_name
-            end
-            arec.send(fk.to_s+"=", rec.id) # set association to the newly created record
-            # disable moderation for associated model (if enabled)
-            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
-      self.destroy # destroy this moderation since it has been applied
-      rec
-    # case: moderated attribute (existing record)
-    else
-      moderatable.has_moderated_updating = true
-      # bypass attr_accessible protection
-      moderatable.send(attr_name.to_s+"=", YAML::load(attr_value))
-      moderatable.save(:validate => false) # don't run validations
-      moderatable.has_moderated_updating = false
-      self.destroy # destroy this moderation since it has been applied
-    end
-  end
-
-  def discard
-    self.destroy
-  end
+  
+  include HasModerated::ModerationModel
 end

data/lib/has_moderated/carrier_wave.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+module HasModerated
+  module CarrierWave
+    
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+      
+      base.alias_method_chain :store_photo!, :moderation
+      base.alias_method_chain :write_photo_identifier, :moderation
+    end  
+    
+    def self.photo_tmp_delete(value)
+      FileUtils.rm(value) # remove temp file
+      FileUtils.rmdir(File.expand_path("..", value)) # will only remove folder if empty
+    end
+
+    module ClassMethods
+      # use class method because we only operate on hash parameters, not with a real record
+      # here we can delete the photo from tmp
+      def moderatable_discard(moderation)
+        value = moderation.interpreted_value
+        if value && value.respond_to?("[]") &&
+          value[:main_model] && value[:main_model][:photo_tmp_file]
+          HasModerated::CarrierWave::photo_tmp_delete(value[:main_model][:photo_tmp_file])
+        end
+      end
+    end
+    
+    module InstanceMethods
+      attr_accessor :has_moderated_updating # in case this model itself is not moderated
+      # maybe autodetect fields that use carrierwave, or specify them
+      def moderatable_hashize
+        attrs = self.attributes
+        attrs = attrs.merge({
+          :photo_tmp_file => self.photo.file.file
+        }) if self.photo && self.photo.file
+      end
+    
+      def photo_tmp_file=(value)
+        self.photo.store!(File.open(value))
+        HasModerated::CarrierWave::photo_tmp_delete(value)
+      end
+      
+      def store_photo_with_moderation!
+        is_moderated = self.class.respond_to?(:moderated_attributes) &&
+          self.class.moderated_attributes.include?("photo")
+        if self.has_moderated_updating || !is_moderated
+          store_photo_without_moderation!
+        else
+          self.moderations.create!({
+            :attr_name => "photo_tmp_file",
+            :attr_value => self.photo.file.file
+          })
+        end
+      end
+
+      def write_photo_identifier_with_moderation
+        is_moderated = self.class.respond_to?(:moderated_attributes) &&
+          self.class.moderated_attributes.include?("photo")
+        if self.has_moderated_updating || !is_moderated
+          write_photo_identifier_without_moderation
+        end
+      end
+    end
+  end
+end

data/lib/has_moderated/moderation_model.rb

@@ -0,0 +1,106 @@
+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 update_associations_from_value rec
+      # loop association types, e.g. :comments
+      interpreted_value[:associations].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
+
+        # all instances for this association type
+        assoc_records.each do |attrs|
+        # 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
+            attrs.each_pair do |key, val|
+              arec.send(key.to_s+"=", val) unless key.to_s == 'id'
+            end
+            fk = if assoc_details.respond_to?(:foreign_key)
+              assoc_details.foreign_key
+            else # Rails < v3.1
+              assoc_details.primary_key_name
+            end
+            arec.send(fk.to_s+"=", rec.id) # set association to the newly created record
+            # 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
+    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
+        
+        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
+    end
+
+    def discard
+      if moderatable_type
+        klass = moderatable_type.constantize
+        klass.moderatable_discard(self) if klass.respond_to?(:moderatable_discard)
+      end
+      self.destroy
+    end
+  end
+end

data/lib/has_moderated/version.rb

@@ -1,3 +1,3 @@
 module HasModerated
-  VERSION = "0.0.9"
+  VERSION = "0.0.10"
 end

data/lib/has_moderated.rb

@@ -1,3 +1,6 @@
+require 'has_moderated/moderation_model'
+require 'has_moderated/carrier_wave'
+
 module HasModerated
 
   def self.included(base)
@@ -110,7 +113,7 @@ module HasModerated
 
     def get_assocs_for_moderation options
       assocs = []
-              
+      
       unless options.blank?
         unless options[:with_associations].blank?
           if options[:with_associations] == :all
@@ -129,7 +132,7 @@ module HasModerated
         one_assoc = []
         self.send(assoc).each do |m|
           if m.new_record?
-            one_assoc.push(m.attributes)
+            one_assoc.push(get_moderation_attributes(m))
           else
             one_assoc.push(m.id)
           end
@@ -140,11 +143,19 @@ module HasModerated
       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 => self.attributes,
+        :main_model => get_moderation_attributes(self),
         :associations => assoc_attrs
       }
       
@@ -182,7 +193,7 @@ module HasModerated
           if m.class == Fixnum
             one_assoc.push(m)
           elsif m.new_record?
-            one_assoc.push(m.attributes)
+            one_assoc.push(get_moderation_attributes(m))
           else
             one_assoc.push(m.id)
           end
@@ -202,6 +213,12 @@ module HasModerated
       
       moderations
     end
+    
+    def moderatable_updating
+      self.has_moderated_updating = true
+      yield(self)
+      self.has_moderated_updating = false
+    end
   end
 end
 

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

@@ -1,76 +1,5 @@
 class Moderation < ActiveRecord::Base
   belongs_to :moderatable, :polymorphic => true
-
-  def accept
-    # case: moderated destruction
-    if attr_name == '-' && attr_value.class == String && attr_value == "destroy"
-      moderatable.has_moderated_updating = true
-      moderatable.destroy
-      moderatable.has_moderated_updating = false
-      self.destroy
-    elsif attr_name == '-'
-      loaded_val = YAML::load(attr_value)
-      # case: moderated existance (new record)
-      if moderatable_id.blank?
-        # create the main record
-        rec = moderatable_type.constantize.new
-        attrs = loaded_val[:main_model]
-        # bypass attr_accessible protection
-        attrs.each_pair do |key, val|
-          rec.send(key.to_s+"=", val) unless key.to_s == 'id'
-        end
-        # temporarily disable moderation check on save, and save updated record
-        rec.has_moderated_updating = true
-        rec.save(:validate => false) # don't run validations
-        rec.has_moderated_updating = false
-      # case: moderated associations (existing record)
-      else
-        rec = moderatable
-      end
-
-      # check for saved associated records
-      loaded_val[:associations].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
-
-        # all records for this associated model
-        assoc_records.each do |attrs|
-          if attrs.class == Fixnum # associate to existing record
-            arec = m.find_by_id(attrs)
-            rec.send(assoc_name.to_s) << arec if arec # add the association, if the record still exists
-          else # create a new record
-            arec = m.new # new associated model
-            attrs.each_pair do |key, val|
-              arec.send(key.to_s+"=", val) unless key.to_s == 'id'
-            end
-            fk = if assoc_details.respond_to?(:foreign_key)
-              assoc_details.foreign_key
-            else # version < 3.1
-              assoc_details.primary_key_name
-            end
-            arec.send(fk.to_s+"=", rec.id) # set association to the newly created record
-            # disable moderation for associated model (if enabled)
-            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
-      self.destroy # destroy this moderation since it has been applied
-      rec
-    # case: moderated attribute (existing record)
-    else
-      moderatable.has_moderated_updating = true
-      # bypass attr_accessible protection
-      moderatable.send(attr_name.to_s+"=", YAML::load(attr_value))
-      moderatable.save(:validate => false) # don't run validations
-      moderatable.has_moderated_updating = false
-      self.destroy # destroy this moderation since it has been applied
-    end
-  end
-
-  def discard
-    self.destroy
-  end
+  
+  include HasModerated::ModerationModel
 end

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

@@ -0,0 +1,6 @@
+class Photo < ActiveRecord::Base
+  mount_uploader :photo, GenericUploader
+  has_moderated_create
+  has_moderated :photo
+  include HasModerated::CarrierWave
+end

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

@@ -1,7 +1,8 @@
 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]
+  has_moderated_create :with_associations => [:subtasks, :task_photos]
   has_moderated_destroy
 end

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

@@ -0,0 +1,5 @@
+class TaskPhoto < ActiveRecord::Base
+  belongs_to :task
+  mount_uploader :photo, GenericUploader
+  include HasModerated::CarrierWave
+end

data/test/dummy/app/uploaders/generic_uploader.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+class GenericUploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or ImageScience support:
+  # include CarrierWave::RMagick
+  # include CarrierWave::MiniMagick
+  # include CarrierWave::ImageScience
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  # storage :fog
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process :scale => [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  # Create different versions of your uploaded files:
+  # version :thumb do
+  #   process :scale => [50, 50]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/test/dummy/db/migrate/20111003205633_create_photos.rb

@@ -0,0 +1,9 @@
+class CreatePhotos < ActiveRecord::Migration
+  def change
+    create_table :photos do |t|
+      t.string :photo
+
+      t.timestamps
+    end
+  end
+end

data/test/dummy/db/migrate/20111003234101_create_task_photos.rb

@@ -0,0 +1,10 @@
+class CreateTaskPhotos < ActiveRecord::Migration
+  def change
+    create_table :task_photos do |t|
+      t.string :photo
+      t.integer :task_id
+
+      t.timestamps
+    end
+  end
+end

data/test/dummy/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20110908025606) do
+ActiveRecord::Schema.define(:version => 20111003234101) do
 
   create_table "moderations", :force => true do |t|
     t.integer  "moderatable_id"
@@ -21,6 +21,12 @@ ActiveRecord::Schema.define(:version => 20110908025606) do
     t.datetime "updated_at"
   end
 
+  create_table "photos", :force => true do |t|
+    t.string   "photo"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
   create_table "subtasks", :force => true do |t|
     t.integer  "task_id"
     t.string   "title"
@@ -37,6 +43,13 @@ ActiveRecord::Schema.define(:version => 20110908025606) do
     t.datetime "updated_at"
   end
 
+  create_table "task_photos", :force => true do |t|
+    t.string   "photo"
+    t.integer  "task_id"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
   create_table "tasks", :force => true do |t|
     t.string   "title"
     t.string   "desc"