has_moderated 0.0.34 → 1.0.alpha

data/README.rdoc

@@ -164,9 +164,26 @@ You can run the tests by running
 
 in the root directory of this gem (so you have to clone it first).
 
+== NOTES
+- to moderate has_many :through assoc, must add both associations to moderation
 == TODO
 
 This is just for my personal todo list...
+
+hm maybe has_moderated_association could be just a has_moderated_create on the assoc? just check stuff like if task_id is not nil or something. could be much easier to implement then
+
+also maybe use dirty https://github.com/rails/rails/blob/master/activemodel/lib/active_model/dirty.rb
+
+and provide the same interface to show changes before accepting a moderation (just overwrite the dirty methods on the instance, also overwrite save at a low level to throw exception since its only a preview)
+
+to make it possible to support other than activerecord, use activemodel when its possible AND try to make it so its possible to call the last step before activerecord (e.g. a func that reads all the values of current attributes and figures out which ones changed) - and use this in activerecord.
+
+use YARD for docs
+check again railscasts episodes for gems (e.g. railties)
+-
+
+make hasone, hasmany etc. each a separate "extension" (like carrierwave). for tests just use 2 models (task, subtask) and dont define has_many in model but in test
+
 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.
 

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

@@ -1,14 +1,15 @@
 class CreateModerations < ActiveRecord::Migration
   def self.up
     if table_exists? :moderations # for upgrading
-      Moderation.all.each { |m| m.accept }
+      if Moderation.count > 0
+        raise "Moderations table must be empty before upgrading has_moderated!"
+      end
       drop_table :moderations
     end
     create_table "moderations" do |t|
       t.integer "moderatable_id",  :null => true
       t.string  "moderatable_type",  :null => true
-      t.string  "attr_name",    :limit => 60,  :null => false
-      t.text    "attr_value",  :null => false
+      t.text    "data",  :null => false
       t.timestamps
     end
   end

data/lib/has_moderated/adapters/active_record.rb

@@ -0,0 +1,109 @@
+# everything that does with activerecord should be here.
+# use a wrapper that calls stuff from here, so that impl. can be switched eg with mongomapper
+# also write test that if one attr is moderated and one is not, the unmoderated one must still save immediately!
+
+module HasModerated
+  module Adapters
+    module ActiveRecord
+      # AR specific
+      def self.foreign_key(reflection)
+        if reflection.respond_to?(:foreign_key)
+          reflection.foreign_key
+        else # Rails < v3.1
+          reflection.primary_key_name
+        end
+      end
+      
+      # General
+      def self.add_moderations_association(klass)
+        klass.class_eval do
+          has_many :moderations, :as => :moderatable, :dependent => :destroy
+        end
+      end
+      
+      def self.get_default_moderation_attributes(record)
+        record.attributes
+      end
+      
+      def self.hashize_association(from_record, assoc_name, m)
+        # todo
+        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 = nil
+        if m.class == Fixnum
+          assoc = m
+        elsif m.kind_of? Hash  # already a hash (for has_many :through association)
+          assoc = m
+        elsif m.respond_to?(:get_moderation_attributes) && m.new_record?
+          assoc = m.get_moderation_attributes
+        elsif m.respond_to?(:get_moderation_attributes)
+          assoc = m.id
+        else
+          raise "don't know how to convert #{m.class} to hash"
+        end
+        
+        if through_assocs[assoc_name.to_sym] # TODO !
+          assoc[:associations] = get_assocs_for_moderation(:all, m)
+        end
+        assoc
+      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(m.get_moderation_attributes)
+            else
+              one_assoc.push(m.id)
+            end
+            if through_assocs[assoc.to_sym]
+              one_assoc.last[:associations] = get_assocs_for_moderation(:all, m)
+            end
+          end
+          assoc_attrs[assoc] = one_assoc unless one_assoc.empty?
+        end
+
+        assoc_attrs
+      end
+    end
+  end
+end

data/lib/has_moderated/adapters/proxy.rb

@@ -0,0 +1,23 @@
+module HasModerated
+  module Adapters
+    module Proxy
+      def self.add_moderations_association(klass)
+        if klass.superclass.to_s == "ActiveRecord::Base"
+          Adapters::ActiveRecord::add_moderations_association(klass)
+        end
+      end
+      
+      def self.get_default_moderation_attributes(record)
+        if record.class.superclass.to_s == "ActiveRecord::Base"
+          Adapters::ActiveRecord::get_default_moderation_attributes(record)
+        end
+      end
+      
+      def self.hashize_association(record, assoc_name, m)
+        if record.class.superclass.to_s == "ActiveRecord::Base"
+          Adapters::ActiveRecord::hashize_association(record, assoc_name, m)
+        end
+      end
+    end
+  end
+end

data/lib/has_moderated/associations/base.rb

@@ -0,0 +1,157 @@
+module HasModerated
+  module Associations
+    module Base
+      
+      # Class methods included into ActiveRecord::Base so that you can call them in
+      # your ActiveRecord models.
+      module ClassMethods
+        
+        # Will moderate the passed in associations if they are supported.
+        # Example: has_moderated_association(:posts, :comments).
+        # Also supports passing :all to moderate all associations, but I personally
+        # do not recommend using this option.
+        # @param [Hash] associations the associations to moderate
+        def has_moderated_association(*args)
+          # some common initialization (lazy loading)
+          HasModerated::Common::init(self)
+          
+          args = [args] unless args.kind_of? Array
+
+          # handle :all option
+          assoc_names = if args.include?(:all)
+            self.reflections.keys.reject do |r|
+              r == :moderations
+            end
+          else
+            args
+          end
+          
+          # process associations + lazy loading
+          assoc_names.map{ |name| self.reflections[name] }.each do |assoc|
+            case assoc.macro
+              when :has_many then
+                self.send :extend, HasModerated::Associations::HasMany::ClassMethods
+                has_moderated_has_many_association(assoc)
+              when :has_one then
+                self.send :extend, HasModerated::Associations::HasOne::ClassMethods
+                has_moderated_has_one_association(assoc)
+              else raise "don't know how to moderate association macro #{assoc.macro}"
+            end
+          end
+        end
+      end # module
+      
+      module ApplyModeration
+        # just a helper
+        def self.try_without_moderation(*args, &block)
+          HasModerated::Common::try_without_moderation(*args, &block)
+        end
+      
+        def self.add_assoc_to_record(to, assoc_id, reflection)
+          return unless to && assoc_id
+          
+          # TODO has_one weirness?
+          if reflection.macro == :has_many
+            HasModerated::Associations::Collection::AssociationHelpers::add_assoc_to_record(to, assoc_id, reflection)
+          end
+        end
+        
+        def self.delete_assoc_from_record(from, assoc_id, reflection)
+          return unless from && assoc_id
+
+          if reflection.macro == :has_one
+            HasModerated::Associations::HasOne::AssociationHelpers::delete_assoc_from_record(from, assoc_id, reflection)
+          else
+            HasModerated::Associations::Collection::AssociationHelpers::delete_assoc_from_record(from, assoc_id, reflection)
+          end
+        end
+      
+        def self.apply_add_association(to, reflection, attrs)
+          klass = reflection.class_name.constantize
+          fk = HasModerated::Adapters::ActiveRecord::foreign_key(reflection)
+        
+          attrs = HashWithIndifferentAccess.new(attrs) if attrs.kind_of? Hash
+          
+          # TODO: perhaps allow to change existing associated object
+          if attrs.class != Fixnum && !attrs[:id].blank?
+            attrs = attrs[:id].to_i
+          end
+        
+          # parse new associations
+          try_without_moderation(to) do |rec|
+            arec = nil
+            # PARAM = ID
+            if attrs.class == Fixnum
+              arec = klass.find_by_id(attrs)
+              add_assoc_to_record(rec, arec, reflection)
+            # PARAM = Hash (create)
+            elsif attrs.kind_of? Hash
+              arec = klass.new
+              # set foreign key first, may be required sometimes
+              add_assoc_to_record(rec, arec, reflection)
+              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
+              # recursive, used for has_many :through
+              apply(arec, attrs) if attrs[:associations].present?
+            else
+              raise "don't know how to parse #{attrs.class}"
+            end
+            if arec
+              try_without_moderation(arec) do
+                arec.save(:validate => false) # don't run validations
+                # TODO: validations? sup?
+              end
+              if reflection.collection?
+                rec.send(reflection.name.to_s) << arec
+              else
+                rec.send(reflection.name.to_s + "=", arec)
+              end
+            end
+          end
+        end
+        
+        def self.apply_delete_association(to, reflection, attrs)
+          m = reflection.class_name.constantize
+
+          fk = HasModerated::Adapters::ActiveRecord::foreign_key(reflection)
+
+          return if attrs.blank?
+          return if attrs.class != Fixnum
+          
+          try_without_moderation(to) do
+            delete_assoc_from_record(to, attrs, reflection)
+          end
+        end
+      
+        # add/delete associations to a record
+        def self.apply(moderation, data)
+          record = if moderation.kind_of? Moderation
+            moderation.moderatable
+          else
+            moderation
+          end
+          associations = data[:associations]
+          delete_associations = data[:delete_associations]
+          
+          associations && associations.each_pair do |assoc_name, assoc_records|
+            reflection = record.class.reflections[assoc_name.to_sym]
+          
+            assoc_records.each do |attrs|
+              apply_add_association(record, reflection, attrs) if attrs.present?
+            end
+          end
+          
+          delete_associations && delete_associations.each_pair do |assoc_name, assoc_records|
+            reflection = record.class.reflections[assoc_name.to_sym]
+            
+            assoc_records.each do |attrs|
+              apply_delete_association(record, reflection, attrs) if attrs.present?
+            end
+          end
+        end
+      end # module
+    end
+  end
+end

data/lib/has_moderated/associations/collection.rb

@@ -0,0 +1,123 @@
+module HasModerated
+  module Associations
+    module Collection
+      module AssociationPatches
+        # moderate adding associations
+        def add_to_target_with_moderation record
+          if owner.moderation_disabled
+            add_to_target_without_moderation record
+          else
+            owner.add_associations_moderated(self.reflection.name => [record])
+            record
+          end
+        end
+
+        # moderate removing associations
+        def delete_records_with_moderation(records, method) # method comes from :dependent => :destroy
+          if owner.new_record? || owner.moderation_disabled
+            delete_records_without_moderation(records, method)
+          else
+            # TODO only care for records which are already in database
+            record_ids = records.map(&:id)
+            owner.delete_associations_moderated(self.reflection.name => record_ids)
+          end
+        end
+      end
+      
+      module ClassMethods
+        protected
+          def has_moderated_collection_association(reflection)
+            after_initialize do
+              assoc = self.association(reflection.name)
+              # check association type
+              if reflection.collection?
+                # avoid multiple patch problem and still work for tests
+                if assoc.respond_to?(:add_to_target_without_moderation)
+                  assoc.class_eval do
+                    alias_method :add_to_target, :add_to_target_without_moderation
+                  end
+                end
+                # patch methods to moderate changes
+                assoc.class.send(:include, AssociationPatches)
+                assoc.class_eval do
+                  alias_method_chain :add_to_target, :moderation
+                  alias_method_chain :delete_records, :moderation
+                end
+              else
+                raise "called on an invalid association"
+              end
+            end
+          end
+      end
+      
+      module AssociationHelpers
+        def self.add_assoc_to_record_habtm_hmt(target, assoc_record, reflection)
+          field = if reflection.options[:join_table].present?
+            join_table = reflection.options[:join_table].to_s
+            results = assoc_record.class.reflections.reject do |assoc_name, assoc|
+              !(assoc.options[:join_table] && assoc.options[:join_table].to_s == join_table)
+            end
+            if results.count != 1
+              raise "has_moderated: Cannot determine join table for a Habtm association!"
+            end
+            results.first[1].name.to_s
+          elsif reflection.options[:through].present?
+            through_model = reflection.options[:through].to_s
+            results = assoc_record.class.reflections.reject do |assoc_name, assoc|
+              !(assoc.options[:through] && assoc.options[:through].to_s == through_model)
+            end
+            if results.count != 1
+              raise "has_moderated: Cannot determine correct association for a has_many :through association!"
+            end
+            results.first[1].name.to_s
+          else
+            raise "has_moderated: Cannot determine association details!"
+          end
+          assoc_record.send(field) << target
+        end
+
+        def self.add_assoc_to_record_hm(to, record, reflection)
+          fk = HasModerated::Adapters::ActiveRecord::foreign_key(reflection).try(:to_s)
+          field = if !reflection.options[:as].blank?
+            # todo: extract
+            reflection.options[:as].to_s
+          elsif !fk.blank?
+            all_keys = []
+            results = record.class.reflections.reject do |assoc_name, assoc|
+              all_keys.push(HasModerated::Adapters::ActiveRecord::foreign_key(assoc).try(:to_s))
+              !(HasModerated::Adapters::ActiveRecord::foreign_key(assoc).try(:to_s) == fk)
+            end
+            if results.blank?
+              raise "Please set foreign_key for both belongs_to and has_one/has_many! fk: #{fk}, keys: #{all_keys.to_yaml}"
+            end
+            results.first[1].name.to_s
+          else
+            to.class.to_s.underscore # TODO hardcoded, fix
+          end
+          HasModerated::Common::try_without_moderation(record) do
+            record.send(field + "=", to)
+          end
+        end
+
+        def self.add_assoc_to_record(to, record, reflection)
+          if reflection.macro == :has_and_belongs_to_many || !reflection.options[:through].blank?
+            add_assoc_to_record_habtm_hmt(to, record, reflection)
+          else
+            add_assoc_to_record_hm(to, record, reflection)
+          end
+        end
+
+        def self.delete_assoc_from_record(from, assoc_id, reflection)
+          return unless from && assoc_id
+          klass = reflection.class_name.constantize
+
+          if reflection.macro == :has_and_belongs_to_many || !reflection.options[:through].blank? || reflection.macro == :has_many
+            from.send(reflection.name).delete(klass.find_by_id(assoc_id))
+          else
+            raise "Cannot delete association for this type of associations!"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/has_moderated/associations/has_many.rb

@@ -0,0 +1,15 @@
+module HasModerated
+  module Associations
+    module HasMany
+      module ClassMethods
+        protected
+          def has_moderated_has_many_association(reflection)
+            # lazy load
+            self.send :extend, HasModerated::Associations::Collection::ClassMethods
+            has_moderated_collection_association(reflection)
+          end
+      end
+      
+    end
+  end
+end

data/lib/has_moderated/associations/has_one.rb

@@ -0,0 +1,58 @@
+module HasModerated
+  module Associations
+    module HasOne
+      module AssociationPatches
+        def replace_with_moderation(record, save = true)
+          # TODO: code duplication
+          if owner.new_record? || owner.moderation_disabled
+            replace_without_moderation record
+          else
+            if record.blank? # use dummy value so it's not nil
+              owner.delete_associations_moderated(self.reflection.name => [1])
+            else
+              owner.add_associations_moderated(self.reflection.name => [record])
+            end
+            record
+          end
+        end
+      end
+      
+      module ClassMethods
+        protected
+          def has_moderated_has_one_association(reflection)
+            after_initialize do
+              assoc = self.association(reflection.name)
+              # check association type
+              if !reflection.collection?
+                # avoid multiple patch problem and still work for tests
+                if assoc.respond_to?(:replace_without_moderation)
+                  assoc.class_eval do
+                    alias_method :replace, :replace_without_moderation
+                  end
+                end
+                # patch methods to moderate changes
+                assoc.class_eval do
+                  include AssociationPatches
+                  alias_method_chain :replace, :moderation
+                end
+              else
+                raise "called on an invalid association"
+              end
+            end
+          end
+      end
+      
+      module AssociationHelpers
+        def self.add_assoc_to_record(*args)
+          # same as HasMany
+          HasModerated::Associations::Collection::AssociationHelpers::add_assoc_to_record(*args)
+        end
+      
+        def self.delete_assoc_from_record(from, assoc_id, reflection)
+          from.send("#{reflection.name}=", nil)
+          from.save # TODO necessary?
+        end
+      end
+    end
+  end
+end

data/lib/has_moderated/carrier_wave.rb

@@ -47,7 +47,7 @@ module HasModerated
     end
     
     module InstanceMethods
-      attr_accessor :has_moderated_updating # in case this model itself is not moderated
+      attr_accessor :moderation_disabled # in case this model itself is not moderated
       # maybe autodetect fields that use carrierwave, or specify them
       def moderatable_hashize
         attrs = self.attributes
@@ -64,7 +64,7 @@ module HasModerated
       def store_photo_with_moderation!
         is_moderated = self.class.respond_to?(:moderated_attributes) &&
           self.class.moderated_attributes.include?("carrierwave_photo")
-        if self.has_moderated_updating || !is_moderated || !self.photo_changed?
+        if self.moderation_disabled || !is_moderated || !self.photo_changed?
           store_photo_without_moderation!
         else
           self.moderations.create!({
@@ -77,7 +77,7 @@ module HasModerated
       def write_photo_identifier_with_moderation
         is_moderated = self.class.respond_to?(:moderated_attributes) &&
           self.class.moderated_attributes.include?("carrierwave_photo")
-        if self.has_moderated_updating || !is_moderated || !self.photo_changed?
+        if self.moderation_disabled || !is_moderated || !self.photo_changed?
           write_photo_identifier_without_moderation
         end
       end