has_moderated 1.1.4 → 1.1.5

data/lib/has_moderated/associations/base.rb

@@ -70,6 +70,7 @@ module HasModerated
         end
 
         def self.apply_add_association(to, reflection, attrs)
+          preview_mode = to.instance_variable_get(:@has_moderated_preview)
           klass = reflection.class_name.constantize
           fk = HasModerated::ActiveRecordHelpers::foreign_key(reflection)
 
@@ -86,10 +87,12 @@ module HasModerated
             # PARAM = ID
             if attrs.class == Fixnum
               arec = klass.find_by_id(attrs)
+              arec.instance_variable_set(:@has_moderated_preview, preview_mode)
               add_assoc_to_record(rec, arec, reflection)
             # PARAM = Hash (create)
             elsif attrs.kind_of? Hash
               arec = klass.new
+              arec.instance_variable_set(:@has_moderated_preview, preview_mode)
               # set foreign key first, may be required sometimes
               add_assoc_to_record(rec, arec, reflection)
               attrs.each_pair do |key, val|
@@ -97,7 +100,7 @@ module HasModerated
                 arec.send(key.to_s+"=", val)
               end
               # recursive, used for has_many :through
-              apply(arec, attrs) if attrs[:associations].present?
+              apply(arec, attrs, preview_mode) if attrs[:associations].present?
             else
               raise "don't know how to parse #{attrs.class}"
             end
@@ -108,6 +111,7 @@ module HasModerated
               end
               if reflection.collection?
                 rec = rec.reload
+                rec.instance_variable_set(:@has_moderated_preview, true) if preview_mode
                 #rec.send(reflection.name.to_s) << arec unless rec.send(reflection.name.to_s).include?(arec)
               else
                 rec.send(reflection.name.to_s + "=", arec)
@@ -130,7 +134,8 @@ module HasModerated
         end
 
         # add/delete associations to a record
-        def self.apply(record, data)
+        def self.apply(record, data, preview_mode = false)
+          record.instance_variable_set(:@has_moderated_preview, true) if preview_mode
           associations = data[:associations]
           delete_associations = data[:delete_associations]
 

data/lib/has_moderated/carrier_wave.rb

@@ -1,11 +1,11 @@
 require 'fileutils'
 module HasModerated
   module CarrierWave
-    
+
     def self.included(base)
       base.send :extend, ClassMethods
-    end  
-    
+    end
+
     def self.photo_tmp_delete(value)
       begin
         dirname = File.expand_path("..", value)
@@ -28,21 +28,44 @@ module HasModerated
       def has_moderated_carrierwave_field field_names
         base = self
         base.send :include, InstanceMethods
-        
+
         cattr_accessor :moderated_carrierwave_fields
-        
+
         field_names = [field_names] unless field_names.kind_of? Array
-        
+
         field_names.each do |field_name|
           field_name = field_name.to_s
           self.moderated_carrierwave_fields ||= []
           self.moderated_carrierwave_fields.push(field_name)
-        
-          base.send :define_method, "#{field_name}_tmp_file=" do |value|
-            self.send("#{field_name}=", File.open(value))
-            HasModerated::CarrierWave::photo_tmp_delete(value)
+
+          base.send :define_method, "#{field_name}_tmp_file=" do |tmp_filename|
+            if @has_moderated_preview != true
+              self.send("#{field_name}=", File.open(tmp_filename))
+              HasModerated::CarrierWave::photo_tmp_delete(tmp_filename)
+            elsif tmp_filename.present?
+              # preview
+              self.singleton_class.class_eval do
+                define_method :"#{field_name}_with_preview" do |*args, &block|
+                  uploader = send(:"#{field_name}_without_preview", *args, &block)
+                  unless uploader.frozen?
+                    uploader.instance_variable_set(:@file,
+                      ::CarrierWave::SanitizedFile.new(
+                        File.open(tmp_filename, "rb")))
+                    uploader.freeze
+                  end
+                  uploader
+                end
+                define_method :"#{field_name}?" do
+                  true
+                end
+                define_method :"#{field_name}_url" do
+                  send("#{field_name}").url
+                end
+                alias_method_chain :"#{field_name}", :preview
+              end
+            end
           end
-        
+
           base.send :define_method, "store_#{field_name}_with_moderation!" do
             is_moderated = self.class.respond_to?(:moderated_attributes) &&
               self.class.moderated_attributes.include?(field_name)
@@ -56,26 +79,28 @@ module HasModerated
               })
             end
           end
-        
+
           base.send :define_method, "write_#{field_name}_identifier_with_moderation" do
             is_moderated = self.class.respond_to?(:moderated_attributes) &&
               self.class.moderated_attributes.include?(field_name)
-            if !is_moderated || self.moderation_disabled || !self.send("#{field_name}_changed?")
+            if !@has_moderated_preview &&
+              (!is_moderated || self.moderation_disabled || !self.send("#{field_name}_changed?"))
               self.send("write_#{field_name}_identifier_without_moderation")
             end
           end
-        
+
           base.alias_method_chain :get_moderation_attributes, :carrierwave unless base.instance_methods.include?("get_moderation_attributes_without_carrierwave")
           base.alias_method_chain "store_#{field_name}!", :moderation
           base.alias_method_chain "write_#{field_name}_identifier", :moderation
         end
       end
-      
+
       # 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)
+      def moderatable_discard(moderation, options)
+        return if options[:preview_mode]
         value = moderation.parsed_data
-        
+
         moderated_carrierwave_fields.each do |field_name|
           if value.kind_of? Hash
             if value.has_key?(:create) && value[:create].has_key?(:attributes)
@@ -93,7 +118,7 @@ module HasModerated
         end
       end
     end
-    
+
     module InstanceMethods
       def get_moderation_attributes_with_carrierwave
         attrs = get_moderation_attributes_without_carrierwave
@@ -106,4 +131,4 @@ module HasModerated
       end
     end
   end
-end
+end

data/lib/has_moderated/moderated_attributes.rb

@@ -49,8 +49,9 @@ module HasModerated
     end
 
     module ApplyModeration
-      def self.apply(rec, value)
+      def self.apply(rec, value, preview_mode = false)
         if value[:attributes].present?
+          rec.instance_variable_set(:@has_moderated_preview, true) if preview_mode
           Moderation.without_moderation do
             value[:attributes].each_pair do |attr_name, attr_value|
               rec.send(attr_name.to_s+"=", attr_value)

data/lib/has_moderated/moderated_create.rb

@@ -16,17 +16,18 @@ module HasModerated
     end
 
     module ApplyModeration
-      def self.apply(klass, value)
+      def self.apply(klass, value, preview_mode = false)
         rec = nil
         if value[:create].present?
           # create the main record
           rec = klass.new
+          rec.instance_variable_set(:@has_moderated_preview, true) if preview_mode
           attrs = value[:create][:attributes]
           attrs && attrs.each_pair do |key, val|
             rec.send(key.to_s+"=", val) unless key.to_s == 'id'
           end
           Moderation.without_moderation { rec.save(:validate => false) }
-          HasModerated::Associations::Base::ApplyModeration::apply(rec, value[:create])
+          HasModerated::Associations::Base::ApplyModeration::apply(rec, value[:create], preview_mode)
         end
         rec
       end

data/lib/has_moderated/moderation_model.rb

@@ -23,14 +23,14 @@ module HasModerated
       @parsed_data ||= YAML::load(data)
     end
 
-    def apply
+    def apply(preview_mode = false)
       if create?
-        record = HasModerated::ModeratedCreate::ApplyModeration::apply(moderatable_type.constantize, parsed_data)
+        record = HasModerated::ModeratedCreate::ApplyModeration::apply(moderatable_type.constantize, parsed_data, preview_mode)
       else
         record = moderatable
         if record
-          record = HasModerated::ModeratedAttributes::ApplyModeration::apply(record, parsed_data)
-          record = HasModerated::Associations::Base::ApplyModeration::apply(record, parsed_data)
+          record = HasModerated::ModeratedAttributes::ApplyModeration::apply(record, parsed_data, preview_mode)
+          record = HasModerated::Associations::Base::ApplyModeration::apply(record, parsed_data, preview_mode)
           record = HasModerated::ModeratedDestroy::ApplyModeration::apply(record, parsed_data)
         end
       end
@@ -47,26 +47,27 @@ module HasModerated
       record
     end
 
-    def accept!(save_opts = Hash.new)
-      record = apply
+    def accept!(save_opts = Hash.new, preview_mode = false)
+      record = apply(preview_mode)
       accept_changes(record, save_opts)
-      self.destroy
+      self.destroy(:preview_mode => preview_mode)
       record
     end
 
-    def accept(save_opts = Hash.new)
+    def accept(save_opts = Hash.new, preview_mode = false)
       begin
-        accept!(save_opts)
+        accept!(save_opts, preview_mode)
         true
       rescue
         false
       end
     end
 
-    def destroy_with_moderation_callbacks
+    def destroy_with_moderation_callbacks(*args)
+      options = args.first || Hash.new
       if moderatable_type
         klass = moderatable_type.constantize
-        klass.moderatable_discard(self) if klass.respond_to?(:moderatable_discard)
+        klass.moderatable_discard(self, options) if klass.respond_to?(:moderatable_discard)
       end
       destroy_without_moderation_callbacks
     end
@@ -76,8 +77,14 @@ module HasModerated
     end
 
     def live_preview
+      # absolutely no point to preview a destroy moderation
+      if destroy? && parsed_data.keys.count == 1
+        yield(nil)
+        return nil
+      end
+
       self.transaction do
-        record = accept!(:perform_validation => false)
+        record = accept!({ :perform_validation => false }, true)
         yield(record)
         raise ActiveRecord::Rollback
       end

data/lib/has_moderated/version.rb

@@ -1,3 +1,3 @@
 module HasModerated
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end