draftsman 0.5.1 → 0.6.0

data/lib/draftsman/config.rb

@@ -3,13 +3,16 @@ require 'singleton'
 module Draftsman
   class Config
     include Singleton
-    attr_accessor :serializer, :timestamp_field
+    attr_accessor :serializer, :timestamp_field, :whodunnit_field, :stash_drafted_changes
+    alias :stash_drafted_changes? :stash_drafted_changes
 
     def initialize
       @timestamp_field = :created_at
       @mutex = Mutex.new
       @serializer = Draftsman::Serializers::Yaml
       @enabled = true
+      @whodunnit_field = :whodunnit
+      @stash_drafted_changes = true
     end
 
     # Indicates whether Draftsman is on or off. Default: true.

data/lib/draftsman/draft.rb

@@ -1,33 +1,35 @@
 class Draftsman::Draft < ActiveRecord::Base
-  # Mass assignment (for <= ActiveRecord 3.x)
-  if Draftsman.active_record_protected_attributes?
-    attr_accessible :item_type, :item_id, :item, :event, :whodunnit, :object, :object_changes, :previous_draft
-  end
-
   # Associations
-  belongs_to :item, :polymorphic => true
+  belongs_to :item, polymorphic: true
 
   # Validations
-  validates_presence_of :event
-
-  def self.with_item_keys(item_type, item_id)
-    scoped :conditions => { :item_type => item_type, :item_id => item_id }
-  end
+  validates :event, presence: true
 
-  def self.creates
-    where :event => 'create'
-  end
+  # Scopes
+  # Returns `where` that filters to only `create` drafts.
+  scope :creates,  -> { where(event: :create) }
+  # Returns `where` that filters to only `destroy` drafts.
+  scope :destroys, -> { where(event: :destroy) }
+  # Returns `where` that filters to only `update` drafts.
+  scope :updates,  -> { where(event: :update) }
 
-  def self.destroys
-    where :event => 'destroy'
+  def self.with_item_keys(item_type, item_id)
+    scoped conditions: { item_type: item_type, item_id: item_id }
   end
 
-  # Returns whether the `object` column is using the `json` type supported by PostgreSQL.
+  # Returns whether the `object` column is using the `json` type supported by
+  # PostgreSQL.
   def self.object_col_is_json?
     @object_col_is_json ||= columns_hash['object'].type == :json
   end
 
-  # Returns whether the `object_changes` column is using the `json` type supported by PostgreSQL.
+  # Returns whether or not this class has an `object_changes` column.
+  def self.object_changes_col_present?
+    column_names.include?('object_changes')
+  end
+
+  # Returns whether the `object_changes` column is using the `json` type
+  # supported by PostgreSQL.
   def self.object_changes_col_is_json?
     @object_changes_col_is_json ||= columns_hash['object_changes'].type == :json
   end
@@ -37,15 +39,11 @@ class Draftsman::Draft < ActiveRecord::Base
     @previous_draft_col_is_json ||= columns_hash['previous_draft'].type == :json
   end
 
-  def self.updates
-    where :event => 'update'
-  end
-
   # Returns what changed in this draft. Similar to `ActiveModel::Dirty#changes`.
-  # Returns `nil` if your `drafts` table does not have an `object_changes` text column.
+  # Returns `nil` if your `drafts` table does not have an `object_changes` text
+  # column.
   def changeset
-    return nil unless self.class.column_names.include? 'object_changes'
-
+    return nil unless self.class.object_changes_col_present?
     @changeset ||= load_changeset
   end
 
@@ -59,14 +57,20 @@ class Draftsman::Draft < ActiveRecord::Base
     self.event == 'destroy'
   end
 
-  # Returns related draft dependencies that would be along for the ride for a `publish!` action.
+  # Returns related draft dependencies that would be along for the ride for a
+  # `publish!` action.
   def draft_publication_dependencies
     dependencies = []
 
-    my_item = self.item.draft? ? self.item.draft.reify : self.item
+    my_item =
+      if Draftsman.stash_drafted_changes? && self.item.draft?
+        self.item.draft.reify
+      else
+        self.item
+      end
 
-    case self.event
-    when 'create', 'update'
+    case self.event.to_sym
+    when :create, :update
       associations = my_item.class.reflect_on_all_associations(:belongs_to)
 
       associations.each do |association|
@@ -82,7 +86,7 @@ class Draftsman::Draft < ActiveRecord::Base
           dependencies << dependency.draft if dependency.present? && dependency.draft? && dependency.draft.create?
         end
       end
-    when 'destroy'
+    when :destroy
       associations = my_item.class.reflect_on_all_associations(:has_one) + my_item.class.reflect_on_all_associations(:has_many)
 
       associations.each do |association|
@@ -106,17 +110,19 @@ class Draftsman::Draft < ActiveRecord::Base
     dependencies
   end
 
-  # Returns related draft dependencies that would be along for the ride for a `revert!` action.
+  # Returns related draft dependencies that would be along for the ride for a
+  # `revert!` action.
   def draft_reversion_dependencies
     dependencies = []
 
-    case self.event
-    when 'create'
+    case self.event.to_sym
+    when :create
       associations = self.item.class.reflect_on_all_associations(:has_one) + self.item.class.reflect_on_all_associations(:has_many)
 
       associations.each do |association|
         if association.klass.draftable?
-          # Reconcile different association types into an array, even if `has_one` produces a single-item
+          # Reconcile different association types into an array, even if
+          # `has_one` produces a single-item
           associated_dependencies =
             case association.macro
             when :has_one
@@ -130,7 +136,7 @@ class Draftsman::Draft < ActiveRecord::Base
           end
         end
       end
-    when 'destroy'
+    when :destroy
       associations = self.item.class.reflect_on_all_associations(:belongs_to)
 
       associations.each do |association|
@@ -151,25 +157,28 @@ class Draftsman::Draft < ActiveRecord::Base
     dependencies
   end
 
-  # Publishes this draft's associated `item`, publishes its `item`'s dependencies, and destroys itself.
-  # -  For `create` drafts, adds a value for the `published_at` timestamp on the item and destroys the draft.
-  # -  For `update` drafts, applies the drafted changes to the item and destroys the draft.
+  # Publishes this draft's associated `item`, publishes its `item`'s
+  # dependencies, and destroys itself.
+  # -  For `create` drafts, adds a value for the `published_at` timestamp on the
+  #    item and destroys the draft.
+  # -  For `update` drafts, applies the drafted changes to the item and destroys
+  #    the draft.
   # -  For `destroy` drafts, destroys the item and the draft.
   def publish!
     ActiveRecord::Base.transaction do
-      case self.event
-      when 'create', 'update'
+      case self.event.to_sym
+      when :create, :update
         # Parents must be published too
         self.draft_publication_dependencies.each { |dependency| dependency.publish! }
 
         # Update drafts need to copy over data to main record
-        self.item.attributes = self.reify.attributes if self.update?
+        self.item.attributes = self.reify.attributes if Draftsman.stash_drafted_changes? && self.update?
 
         # Write `published_at` attribute
-        self.item.send "#{self.item.class.published_at_attribute_name}=", Time.now
+        self.item.send("#{self.item.class.published_at_attribute_name}=", Time.now)
 
         # Clear out draft
-        self.item.send "#{self.item.class.draft_association_name}_id=", nil
+        self.item.send("#{self.item.class.draft_association_name}_id=", nil)
 
         # Determine which columns should be updated
         only   = self.item.class.draftsman_options[:only]
@@ -182,13 +191,13 @@ class Draftsman::Draft < ActiveRecord::Base
         self.item.attributes.slice(*attributes_to_change).each do |key, value|
           self.item.send("#{key}=", value)
         end
-        self.item.save(:validate => false)
-        
+
+        self.item.save(validate: false)
         self.item.reload
 
         # Destroy draft
         self.destroy
-      when 'destroy'
+      when :destroy
         self.item.destroy
       end
     end
@@ -198,33 +207,50 @@ class Draftsman::Draft < ActiveRecord::Base
   #
   # Example usage:
   #
-  #     `@category = @category.reify if @category.draft?`
+  #     `@category = @category.draft.reify if @category.draft?`
   def reify
+    # This appears to be necessary if for some reason the draft's model
+    # hasn't been loaded (such as when done in the console).
+    unless defined? self.item_type
+      require self.item_type.underscore
+    end
+
     without_identity_map do
-      if !self.previous_draft.nil?
+      # Create draft doesn't require reification.
+      if self.create?
+        self.item
+      # If a previous draft is stashed, restore that.
+      elsif self.previous_draft.present?
         reify_previous_draft.reify
-      elsif !self.object.nil?
-        # This appears to be necessary if for some reason the draft's model hasn't been loaded (such as when done in the console).
-        unless defined? self.item_type
-          require self.item_type.underscore
+      # Prefer changeset for refication if it's present.
+      elsif !self.changeset.empty?
+        self.changeset.each do |key, value|
+          # Skip counter_cache columns
+          if self.item.respond_to?("#{key}=") && !key.end_with?('_count')
+            self.item.send("#{key}=", value.last)
+          elsif !key.end_with?('_count')
+            logger.warn("Attribute #{key} does not exist on #{self.item_type} (Draft ID: #{self.id}).")
+          end
         end
 
-        model = item.reload
-
-        attrs = self.class.object_col_is_json? ? self.object : Draftsman.serializer.load(object)
-        model.class.unserialize_attributes_for_draftsman attrs
+        self.item.send("#{self.item.class.draft_association_name}=", self)
+        self.item
+      # Reify based on object if it's all that's available.
+      elsif self.object.present?
+        attrs = self.class.object_col_is_json? ? self.object : Draftsman.serializer.load(self.object)
+        self.item.class.unserialize_attributes_for_draftsman(attrs)
 
         attrs.each do |key, value|
           # Skip counter_cache columns
-          if model.respond_to?("#{key}=") && !key.end_with?('_count')
-            model.send "#{key}=", value
+          if self.item.respond_to?("#{key}=") && !key.end_with?('_count')
+            self.item.send("#{key}=", value)
           elsif !key.end_with?('_count')
-            logger.warn "Attribute #{key} does not exist on #{item_type} (Draft ID: #{id})."
+            logger.warn("Attribute #{key} does not exist on #{self.item_type} (Draft ID: #{self.id}).")
           end
         end
 
-        model.send "#{model.class.draft_association_name}=", self
-        model
+        self.item.send("#{self.item.class.draft_association_name}=", self)
+        self.item
       end
     end
   end
@@ -232,18 +258,29 @@ class Draftsman::Draft < ActiveRecord::Base
   # Reverts this draft.
   # -  For create drafts, destroys the draft and the item.
   # -  For update drafts, destroys the draft only.
-  # -  For destroy drafts, destroys the draft and undoes the `trashed_at` timestamp on the item. If a previous draft was
-  #    drafted for destroy, restores the draft.
+  # -  For destroy drafts, destroys the draft and undoes the `trashed_at`
+  #    timestamp on the item. If a previous draft was drafted for destroy,
+  #    restores the draft.
   def revert!
     ActiveRecord::Base.transaction do
-      case self.event
-      when 'create'
+      case self.event.to_sym
+      when :create
         self.item.destroy
         self.destroy
-      when 'update'
-        self.item.class.where(:id => self.item).update_all("#{self.item.class.draft_association_name}_id".to_sym => nil)
+      when :update
+        # If we're not stashing changes, we need to restore original values from
+        # the changeset.
+        if self.class.object_changes_col_present? && !Draftsman.stash_drafted_changes?
+          self.changeset.each do |attr, values|
+            self.item.send("#{attr}=", values.first) if self.item.respond_to?(attr)
+          end
+        end
+        # Then clear out the draft ID.
+        self.item.send("#{self.item.class.draft_association_name}_id=", nil)
+        self.item.save!(validate: false)
+        # Then destroy draft.
         self.destroy
-      when 'destroy'
+      when :destroy
         # Parents must be restored too
         self.draft_reversion_dependencies.each { |dependency| dependency.revert! }
 
@@ -252,13 +289,13 @@ class Draftsman::Draft < ActiveRecord::Base
           prev_draft = reify_previous_draft
           prev_draft.save!
 
-          self.item.class.where(:id => self.item).update_all "#{self.item.class.draft_association_name}_id".to_sym => prev_draft.id,
-                                                             self.item.class.trashed_at_attribute_name => nil
+          self.item.class.where(id: self.item).update_all "#{self.item.class.draft_association_name}_id".to_sym => prev_draft.id,
+                                                          self.item.class.trashed_at_attribute_name => nil
         else
-          self.item.class.where(:id => self.item).update_all "#{self.item.class.draft_association_name}_id".to_sym => nil,
-                                                             self.item.class.trashed_at_attribute_name => nil
+          self.item.class.where(id: self.item).update_all "#{self.item.class.draft_association_name}_id".to_sym => nil,
+                                                          self.item.class.trashed_at_attribute_name => nil
         end
-        
+
         self.destroy
       end
     end
@@ -266,7 +303,7 @@ class Draftsman::Draft < ActiveRecord::Base
 
   # Returns whether or not this is an `update` event.
   def update?
-    self.event == 'update'
+    self.event.to_sym == :update
   end
 
 private
@@ -280,9 +317,9 @@ private
 
       attrs.each do |key, value|
         if key.to_sym != :id && draft.respond_to?("#{key}=")
-          draft.send "#{key}=", value
+          draft.send("#{key}=", value)
         elsif key.to_sym != :id
-          logger.warn "Attribute #{key} does not exist on #{item_type} (Draft ID: #{self.id})."
+          logger.warn("Attribute #{key} does not exist on #{item_type} (Draft ID: #{self.id}).")
         end
       end
     end
@@ -292,7 +329,7 @@ private
 
   def without_identity_map(&block)
     if defined?(ActiveRecord::IdentityMap) && ActiveRecord::IdentityMap.respond_to?(:without)
-      ActiveRecord::IdentityMap.without &block
+      ActiveRecord::IdentityMap.without(&block)
     else
       block.call
     end
@@ -300,7 +337,7 @@ private
 
   def load_changeset
     changes = HashWithIndifferentAccess.new(object_changes_deserialized)
-    item_type.constantize.unserialize_draft_attribute_changes(changes)
+    self.item_type.constantize.unserialize_draft_attribute_changes(changes)
     changes
   rescue
     {}
@@ -308,9 +345,9 @@ private
 
   def object_changes_deserialized
     if self.class.object_changes_col_is_json?
-      object_changes
+      self.object_changes
     else
-      Draftsman.serializer.load(object_changes)
+      Draftsman.serializer.load(self.object_changes)
     end
   end
 end

data/lib/draftsman/frameworks/rspec.rb

@@ -1,4 +1,4 @@
-if defined? RSpec
+if defined? RSpec::Core
   require 'rspec/core'
   require 'rspec/matchers'