draftsman 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fe742f1e72bfd060d5d737fb6de9ee7cec1119f
-  data.tar.gz: f846ec1b196415f5f33609d2a8516ca2fc087294
+  metadata.gz: 4594a89239d63ca33dfc4b008728952b04ff3d77
+  data.tar.gz: a41330672fbc6204b0a9b459db106b05cddb3675
 SHA512:
-  metadata.gz: a355e08da8ff267cc30be5b6a8bfa7dab673ca84bbda56997bd34dbc574606735b7ef312155cfd840a9ecc42e31513f352c98ef7f682888c4d316c8efaa854c8
-  data.tar.gz: 8f0d1d623df2fa66e332e1d715afa0c80a25f1d5218c6816c6a2110e283bef31587319dafec28f491217e8d4856b23bd44c8983c25f30d453475e7a1dc8d28b8
+  metadata.gz: 4a5197c59c7c471a2abeaf558274b19fa5938eba14b319ba09fe571bca17b7df2363122c87ff00dd9f4bbe34e83177056e904a535add241b7c702e2b1ce45c00
+  data.tar.gz: 31ad8696e86643c2c230fd40df6c66510360db0c8c98728fb89c27902738cde76dc5575ee7b8baf09c5c1f2b8574c923a1279c25fa8d6fac12c85408c453ad54

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 0.3.0 - July 29, 2014
+
+-  Commit [1e2a59f678](https://github.com/live-editor/draftsman/commit/1e2a59f678cc4d88222dfc1976d564b5649cd329) - Add support for PostgreSQL JSON data type for `object`, `object_changes`, and `previous_draft` columns.
+
 ## v0.2.1 - June 28, 2014
 
 -  Commit [dbc6c83abb](https://github.com/live-editor/draftsman/commit/dbc6c83abbea5211f67ad883f4a2d18a9f5ac181) - Reifying a record that was drafted for destruction uses data from a drafted update before that if that's what happened.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    draftsman (0.2.1)
+    draftsman (0.3.0)
       activerecord (>= 3.0, < 5.0)
 
 GEM

data/README.md

@@ -1,4 +1,4 @@
-# Draftsman v0.2.1 (alpha)
+# Draftsman v0.3.0 (alpha)
 
 Draftsman is a Ruby gem that lets you create draft versions of your database records. If you're developing a system in
 need of simple drafts or a publishing approval queue, then Draftsman just might be what you need.
@@ -50,7 +50,7 @@ Works well with Rails, Sinatra, or any other application that depends on ActiveR
 Add Draftsman to your `Gemfile`.
 
 ```ruby
-gem 'draftsman', '0.2.1'
+gem 'draftsman', '0.3.0'
 ```
 
 Or if you want to grab the latest from `master`:
@@ -61,14 +61,16 @@ gem 'draftsman', :github => 'live-editor/draftsman'
 
 Generate a migration which will add a `drafts` table to your database.
 
-    rails g draftsman:install
+    $ rails g draftsman:install
 
-You can pass zero, one, or both of these options to the generator:
+You can pass zero or any combination of these options to the generator:
 
     $ rails g draftsman:install --skip-initializer  # Skip generation of the boilerplate initializer at
                                                     # `config/initializers/draftsman.rb`.
 
-    $ rails g draftsman:install --with-changes      # Store changeset (diff) with each draft
+    $ rails g draftsman:install --with-changes      # Store changeset (diff) with each draft.
+
+    $ rails g draftsman:install --with-pg-json      # Use PostgreSQL JSON data type for serialized data.
 
 Run the migration(s).
 

data/lib/draftsman/draft.rb

@@ -22,6 +22,16 @@ class Draftsman::Draft < ActiveRecord::Base
     where :event => 'destroy'
   end
 
+  # 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.
+  def self.object_changes_col_is_json?
+    @object_changes_col_is_json ||= columns_hash['object_changes'].type == :json
+  end
+
   def self.updates
     where :event => 'update'
   end
@@ -31,7 +41,9 @@ class Draftsman::Draft < ActiveRecord::Base
   def changeset
     return nil unless self.class.column_names.include? 'object_changes'
 
-    HashWithIndifferentAccess.new(Draftsman.serializer.load(object_changes)).tap do |changes|
+    _changes = self.class.object_changes_col_is_json? ? self.object_changes : Draftsman.serializer.load(self.object_changes)
+
+    @changeset ||= HashWithIndifferentAccess.new(_changes).tap do |changes|
       item_type.constantize.unserialize_draft_attribute_changes(changes)
     end
   rescue
@@ -179,7 +191,7 @@ class Draftsman::Draft < ActiveRecord::Base
     end
   end
 
-  # Returns instance of item restored to its pre-draft state.
+  # Returns instance of item converted to its drafted state.
   #
   # Example usage:
   #
@@ -194,7 +206,10 @@ class Draftsman::Draft < ActiveRecord::Base
 
         model = item.reload
 
-        Draftsman.serializer.load(self.object).each do |key, value|
+        attrs = self.class.object_col_is_json? ? self.object : Draftsman.serializer.load(object)
+        model.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
@@ -211,9 +226,9 @@ class Draftsman::Draft < ActiveRecord::Base
 
   # Reverts this draft.
   # -  For create drafts, destroys the draft and the item.
-  # -  For update drafts, destyors the draft only.
-  # -  For destroy drafts, destroys the draft and undoes the `trashed_at` timestamp on the item. If a draft was drafted
-  #    for destroy, restores the draft.
+  # -  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.
   def revert!
     ActiveRecord::Base.transaction do
       case self.event
@@ -256,7 +271,9 @@ private
     draft = self.class.new
 
     without_identity_map do
-      Draftsman.serializer.load(self.previous_draft).each do |key, value|
+      attrs = self.class.object_col_is_json? ? self.previous_draft : Draftsman.serializer.load(self.previous_draft)
+
+      attrs.each do |key, value|
         if key.to_sym != :id && draft.respond_to?("#{key}=")
           draft.send "#{key}=", value
         elsif key.to_sym != :id
@@ -268,22 +285,6 @@ private
     draft
   end
 
-  # Saves associated draft dependencies by reflecting `belongs_to` associations and identifying which ones are
-  # draftable.
-  #def save_draft_dependencies
-  #  self.item.class.reflect_on_all_associations(:belongs_to).each do |association|
-  #    associated_object = self.item.send(association.name)
-  #
-  #    if associated_object.present? && associated_object.respond_to?(:draft?)
-  #      if associated_object.reload.draft?
-  #        Draftsman::DraftDependency.create(:draft_id => self.id, :dependency_id => associated_object.id)
-  #      else
-  #        Draftsman::DraftDependency.where(:draft_id => self.id, :dependency_id => associated_object.id).delete_all
-  #      end
-  #    end
-  #  end
-  #end
-
   def without_identity_map(&block)
     if defined?(ActiveRecord::IdentityMap) && ActiveRecord::IdentityMap.respond_to?(:without)
       ActiveRecord::IdentityMap.without &block

data/lib/draftsman/model.rb

@@ -110,6 +110,11 @@ module Draftsman
         end)
       end
 
+      # Returns draft class.
+      def draft_class
+        @draft_class ||= draft_class_name.constantize
+      end
+
       # Returns whether or not `has_drafts` has been called on this model.
       def draftable?
         method_defined?(:draftsman_options)
@@ -122,6 +127,9 @@ module Draftsman
 
       # Serializes attribute changes for `Draft#object_changes` attribute.
       def serialize_draft_attribute_changes(changes)
+        # Don't serialize values before inserting into columns of type `JSON` on PostgreSQL databases.
+        return changes if self.draft_class.object_changes_col_is_json?
+
         serialized_attributes.each do |key, coder|
           if changes.key?(key)
             coder = Draftsman::Serializers::Yaml unless coder.respond_to?(:dump) # Fall back to YAML if `coder` has no `dump` method
@@ -133,6 +141,9 @@ module Draftsman
 
       # Used for `Draft#object` attribute
       def serialize_attributes_for_draftsman(attributes)
+        # Don't serialize values before inserting into columns of type `JSON` on PostgreSQL databases.
+        return attributes if self.draft_class.object_col_is_json?
+
         serialized_attributes.each do |key, coder|
           if attributes.key?(key)
             coder = Draftsman::Serializers::Yaml unless coder.respond_to?(:dump) # Fall back to YAML if `coder` has no `dump` method
@@ -148,6 +159,9 @@ module Draftsman
 
       # Unserializes attribute changes for `Draft#object_changes` attribute.
       def unserialize_draft_attribute_changes(changes)
+        # Don't serialize values before inserting into columns of type `JSON` on PostgreSQL databases.
+        return changes if self.draft_class.object_changes_col_is_json?
+
         serialized_attributes.each do |key, coder|
           if changes.key?(key)
             coder = Draftsman::Serializers::Yaml unless coder.respond_to?(:dump)
@@ -159,6 +173,9 @@ module Draftsman
 
       # Used for `Draft#object` attribute
       def unserialize_attributes_for_draftsman(attributes)
+        # Don't serialize values before inserting into columns of type `JSON` on PostgreSQL databases.
+        return attributes if self.draft_class.object_col_is_json?
+
         serialized_attributes.each do |key, coder|
           if attributes.key?(key)
             coder = Draftsman::Serializers::Yaml unless coder.respond_to?(:dump)
@@ -190,9 +207,9 @@ module Draftsman
             :item      => self,
             :event     => 'create',
             :whodunnit => Draftsman.whodunnit,
-            :object    => object_to_string_for_draft
+            :object    => object_attrs_for_draft_record
           }
-          data[:object_changes] = Draftsman.serializer.dump(changes_for_draftsman(previous_changes: true)) if track_object_changes_for_draft?
+          data[:object_changes] = changes_for_draftsman(previous_changes: true) if track_object_changes_for_draft?
           data = merge_metadata_for_draft(data)
 
           send "build_#{self.class.draft_association_name}", data
@@ -214,7 +231,7 @@ module Draftsman
             :item      => self,
             :event     => 'destroy',
             :whodunnit => Draftsman.whodunnit,
-            :object    => object_to_string_for_draft
+            :object    => object_attrs_for_draft_record
           }
 
           # Stash previous draft in case it needs to be reverted later
@@ -266,11 +283,11 @@ module Draftsman
             data = {
               :item      => self,
               :whodunnit => Draftsman.whodunnit,
-              :object    => object_to_string_for_draft
+              :object    => object_attrs_for_draft_record
             }
 
             if track_object_changes_for_draft?
-              data[:object_changes] = Draftsman.serializer.dump(changes_for_draftsman(changed_from: self.send(self.class.draft_association_name).changeset))
+              data[:object_changes] = changes_for_draftsman(changed_from: self.send(self.class.draft_association_name).changeset)
             end
 
             data = merge_metadata_for_draft(data)
@@ -288,21 +305,18 @@ module Draftsman
             data = {
               :item      => self,
               :whodunnit => Draftsman.whodunnit,
-              :object    => object_to_string_for_draft
+              :object    => object_attrs_for_draft_record
             }
             data = merge_metadata_for_draft(data)
 
             # If there's already a draft, update it
             if send(self.class.draft_association_name).present?
-              if track_object_changes_for_draft?
-                data[:object_changes] = Draftsman.serializer.dump(changes_for_draftsman)
-              end
-
+              data[:object_changes] = changes_for_draftsman if track_object_changes_for_draft?
               send(self.class.draft_association_name).update_attributes data
             # If there's not draft, create an update draft
             else
               data[:event]          = 'update'
-              data[:object_changes] = Draftsman.serializer.dump(changes_for_draftsman) if track_object_changes_for_draft?
+              data[:object_changes] = changes_for_draftsman if track_object_changes_for_draft?
               send "build_#{self.class.draft_association_name}", data
               
               if send(self.class.draft_association_name).save
@@ -317,9 +331,9 @@ module Draftsman
             data = {
               :item      => self,
               :whodunnit => Draftsman.whodunnit,
-              :object    => object_to_string_for_draft
+              :object    => object_attrs_for_draft_record
             }
-            data[:object_changes] = Draftsman.serializer.dump(changes_for_draftsman(changed_from: @object.draft.changeset)) if track_object_changes_for_draft?
+            data[:object_changes] = changes_for_draftsman(changed_from: @object.draft.changeset) if track_object_changes_for_draft?
             data = merge_metadata_for_draft(data)
 
             send(self.class.draft_association_name).update_attributes data
@@ -333,14 +347,14 @@ module Draftsman
       end
 
       # Returns serialized object representing this drafted item.
-      def object_to_string_for_draft(object = nil)
+      def object_attrs_for_draft_record(object = nil)
         object ||= self
 
         _attrs = object.attributes.except(*self.class.draftsman_options[:skip]).tap do |attributes|
           self.class.serialize_attributes_for_draftsman attributes
         end
 
-        Draftsman.serializer.dump(_attrs)
+        self.class.draft_class.object_col_is_json? ? _attrs : Draftsman.serializer.dump(_attrs)
       end
 
       # Returns whether or not this item has been published at any point in its lifecycle.
@@ -395,12 +409,9 @@ module Draftsman
 
         # We need to merge any previous changes so they are not lost on further updates before committing or
         # reverting
-        options[:changed_from].merge new_changes
-      end
+        my_changes = options[:changed_from].merge new_changes
 
-      # Returns draft class.
-      def draft_class
-        self.draft_class_name.constantize
+        self.class.draft_class.object_changes_col_is_json? ? my_changes : Draftsman.serializer.dump(my_changes)
       end
 
       # Merges model-level metadata from `meta` and `controller_info` into draft object.
@@ -450,7 +461,7 @@ module Draftsman
 
       # Returns whether or not the draft class includes an `object_changes` attribute.
       def track_object_changes_for_draft?
-        draft_class.column_names.include? 'object_changes'
+        self.class.draft_class.column_names.include? 'object_changes'
       end
 
       # Sets `trashed_at` attribute to now and saves to the database immediately.

data/lib/draftsman/version.rb

@@ -1,3 +1,3 @@
 module Draftsman
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/lib/generators/draftsman/install_generator.rb

@@ -6,14 +6,28 @@ module Draftsman
   class InstallGenerator < ::Rails::Generators::Base
     include ::Rails::Generators::Migration
 
-    desc 'Generates (but does not run) a migration to add a drafts table.'
+    desc 'Creates config initializer and generates (but does not run) a migration to add a drafts table.'
     source_root File.expand_path('../templates', __FILE__)
     class_option :skip_initializer, :type => :boolean, :default => false, :desc => 'Skip generation of the boilerplate initializer at `config/initializers/draftsman.rb`.'
-    class_option :with_changes, :type => :boolean, :default => false, :desc => 'Store changeset (diff) with each draft'
+    class_option :with_changes, :type => :boolean, :default => false, :desc => 'Store changeset (diff) with each draft.'
+    class_option :with_pg_json, :type => :boolean, :default => false, :desc => 'Use PostgreSQL JSON data type for serialized data.'
 
     def create_migration_file
-      migration_template 'create_drafts.rb', 'db/migrate/create_drafts.rb'
-      migration_template 'add_object_changes_column_to_drafts.rb', 'db/migrate/add_object_changes_column_to_drafts.rb' if options.with_changes?
+      if options.with_pg_json?
+        migration_template 'create_drafts_json.rb', 'db/migrate/create_drafts.rb'
+
+        if options.with_changes?
+          migration_template 'add_object_changes_column_to_drafts_json.rb',
+                             'db/migrate/add_object_changes_column_to_drafts.rb'
+        end
+      else
+        migration_template 'create_drafts.rb', 'db/migrate/create_drafts.rb'
+
+        if options.with_changes?
+          migration_template 'add_object_changes_column_to_drafts.rb',
+                             'db/migrate/add_object_changes_column_to_drafts.rb'
+        end
+      end
     end
 
     def self.next_migration_number(dirname)

data/lib/generators/draftsman/templates/add_object_changes_column_to_drafts_json.rb

@@ -0,0 +1,9 @@
+class AddObjectChangesColumnToDrafts < ActiveRecord::Migration
+  def self.up
+    add_column :drafts, :object_changes, :json
+  end
+
+  def self.down
+    remove_column :drafts, :object_changes
+  end
+end

data/lib/generators/draftsman/templates/config/initializers/draftsman.rb

@@ -1,10 +1,14 @@
 # Override global `draft` class. For example, perhaps you want your own class at `app/models/draft.rb` that adds
-# extra attributes, validations, associations, etc. Be sure that this new model class extends `Draftsman::Draft`.
+# extra attributes, validations, associations, methods, etc. Be sure that this new model class extends
+# `Draftsman::Draft`.
 # Draftsman.draft_class_name = 'Draftsman::Draft'
 
 # Serializer for `object`, `object_changes`, and `previous_draft` columns. To use the JSON serializer, change to
 # `Draftsman::Serializers::Json`. You could implement your own serializer if you really wanted to. See files in
 # `lib/draftsman/serializers`.
+#
+# Note: this option is not needed if you're using the PostgreSQL JSON data type for the `object`,
+# `object_changes`, and `previous_draft` columns.
 # Draftsman.serializer = Draftsman::Serializers::Json
 
 # Field which records when a draft was created.

data/lib/generators/draftsman/templates/create_drafts_json.rb

@@ -0,0 +1,22 @@
+class CreateDrafts < ActiveRecord::Migration
+  def change
+    create_table :drafts do |t|
+      t.string  :item_type, :null => false
+      t.integer :item_id,   :null => false
+      t.string  :event,     :null => false
+      t.string  :whodunnit#  :null => false
+      t.json    :object
+      t.json    :previous_draft
+      t.timestamps
+    end
+
+    change_table :drafts do |t|
+      t.index :item_type
+      t.index :item_id
+      t.index :event
+      t.index :whodunnit
+      t.index :created_at
+      t.index :updated_at
+    end
+  end
+end

data/spec/models/draft_spec.rb

@@ -1,34 +1,23 @@
 require 'spec_helper'
 
 describe Draftsman::Draft do
-  let(:trashable) { Trashable.new :name => 'Bob' }
-  subject { trashable.draft }
-
-  describe :event, :create?, :update?, :destroy?, :object, :changeset do
-    context 'with `create` draft' do
-      before { trashable.draft_creation }
-      its(:event) { should eql 'create' }
-      its(:create?) { should be_true }
-      its(:update?) { should be_false }
-      its(:destroy?) { should be_false }
-      its(:object) { should be_present }
-      its(:changeset) { should include :id }
-      its(:changeset) { should include :name }
-      its(:changeset) { should_not include :title }
-      its(:changeset) { should include :created_at }
-      its(:changeset) { should include :updated_at }
-      its(:previous_draft) { should be_nil }
-
-      context 'updated create' do
-        before do
-          trashable.name = 'Sam'
-          trashable.draft_update
-        end
+  describe 'class methods' do
+    subject { Draftsman::Draft }
+    its(:object_col_is_json?) { should be_false }
+    its(:object_changes_col_is_json?) { should be_false }
+  end
 
-        it { should be_create }
-        it { should_not be_update }
-        it { should_not be_destroy }
+  describe 'instance methods' do
+    let(:trashable) { Trashable.new :name => 'Bob' }
+    subject { trashable.draft }
+
+    describe :event, :create?, :update?, :destroy?, :object, :changeset do
+      context 'with `create` draft' do
+        before { trashable.draft_creation }
         its(:event) { should eql 'create' }
+        its(:create?) { should be_true }
+        its(:update?) { should be_false }
+        its(:destroy?) { should be_false }
         its(:object) { should be_present }
         its(:changeset) { should include :id }
         its(:changeset) { should include :name }
@@ -36,32 +25,32 @@ describe Draftsman::Draft do
         its(:changeset) { should include :created_at }
         its(:changeset) { should include :updated_at }
         its(:previous_draft) { should be_nil }
-      end
-    end
 
-    context 'with `update` draft' do
-      before do
-        trashable.save!
-        trashable.name = 'Sam'
-        trashable.title = 'My Title'
-        trashable.draft_update
+        context 'updated create' do
+          before do
+            trashable.name = 'Sam'
+            trashable.draft_update
+          end
+
+          it { should be_create }
+          it { should_not be_update }
+          it { should_not be_destroy }
+          its(:event) { should eql 'create' }
+          its(:object) { should be_present }
+          its(:changeset) { should include :id }
+          its(:changeset) { should include :name }
+          its(:changeset) { should_not include :title }
+          its(:changeset) { should include :created_at }
+          its(:changeset) { should include :updated_at }
+          its(:previous_draft) { should be_nil }
+        end
       end
 
-      it { should_not be_create }
-      it { should be_update }
-      it { should_not be_destroy }
-      its(:event) { should eql 'update' }
-      its(:object) { should be_present }
-      its(:changeset) { should_not include :id }
-      its(:changeset) { should include :name }
-      its(:changeset) { should include :title }
-      its(:changeset) { should_not include :created_at }
-      its(:changeset) { should_not include :updated_at }
-      its(:previous_draft) { should be_nil }
-
-      context 'updating the update' do
+      context 'with `update` draft' do
         before do
-          trashable.title = nil
+          trashable.save!
+          trashable.name = 'Sam'
+          trashable.title = 'My Title'
           trashable.draft_update
         end
 
@@ -72,186 +61,180 @@ describe Draftsman::Draft do
         its(:object) { should be_present }
         its(:changeset) { should_not include :id }
         its(:changeset) { should include :name }
-        its(:changeset) { should_not include :title }
+        its(:changeset) { should include :title }
         its(:changeset) { should_not include :created_at }
         its(:changeset) { should_not include :updated_at }
         its(:previous_draft) { should be_nil }
-      end
-    end
 
-    context 'with `destroy` draft' do
-      context 'without previous draft' do
-        before do
-          trashable.save!
-          trashable.draft_destroy
+        context 'updating the update' do
+          before do
+            trashable.title = nil
+            trashable.draft_update
+          end
+
+          it { should_not be_create }
+          it { should be_update }
+          it { should_not be_destroy }
+          its(:event) { should eql 'update' }
+          its(:object) { should be_present }
+          its(:changeset) { should_not include :id }
+          its(:changeset) { should include :name }
+          its(:changeset) { should_not include :title }
+          its(:changeset) { should_not include :created_at }
+          its(:changeset) { should_not include :updated_at }
+          its(:previous_draft) { should be_nil }
         end
-
-        it { should_not be_create }
-        it { should_not be_update }
-        it { should be_destroy }
-        it { should_not be_destroyed }
-        its(:event) { should eql 'destroy' }
-        its(:object) { should be_present }
-        its(:changeset) { should eql Hash.new }
-        its(:previous_draft) { should be_nil }
       end
 
-      context 'with previous `create` draft' do
-        before do
-          trashable.draft_creation
-          trashable.draft_destroy
+      context 'with `destroy` draft' do
+        context 'without previous draft' do
+          before do
+            trashable.save!
+            trashable.draft_destroy
+          end
+
+          it { should_not be_create }
+          it { should_not be_update }
+          it { should be_destroy }
+          it { should_not be_destroyed }
+          its(:event) { should eql 'destroy' }
+          its(:object) { should be_present }
+          its(:changeset) { should eql Hash.new }
+          its(:previous_draft) { should be_nil }
         end
 
-        it { should_not be_create }
-        it { should_not be_update }
-        it { should be_destroy }
-        it { should_not be_destroyed }
-        its(:event) { should eql 'destroy' }
-        its(:object) { should be_present }
-        its(:changeset) { should include :id }
-        its(:changeset) { should include :name }
-        its(:changeset) { should_not include :title }
-        its(:changeset) { should include :created_at }
-        its(:changeset) { should include :updated_at }
-        its(:previous_draft) { should be_present }
-      end
-    end
-  end
-
-  describe :publish! do
-    context 'with `create` draft' do
-      before { trashable.draft_creation }
-      subject { trashable.draft.publish!; return trashable.reload }
-      it { expect { subject }.to_not raise_exception }
-      it { should be_published }
-      it { should_not be_trashed }
-      it { should_not be_draft }
-      its(:published_at) { should be_present }
-      its(:draft_id) { should be_nil }
-      its(:draft) { should be_nil }
-      its(:trashed_at) { should be_nil }
-
-      it 'deletes the draft' do
-        expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+        context 'with previous `create` draft' do
+          before do
+            trashable.draft_creation
+            trashable.draft_destroy
+          end
+
+          it { should_not be_create }
+          it { should_not be_update }
+          it { should be_destroy }
+          it { should_not be_destroyed }
+          its(:event) { should eql 'destroy' }
+          its(:object) { should be_present }
+          its(:changeset) { should include :id }
+          its(:changeset) { should include :name }
+          its(:changeset) { should_not include :title }
+          its(:changeset) { should include :created_at }
+          its(:changeset) { should include :updated_at }
+          its(:previous_draft) { should be_present }
+        end
       end
     end
 
-    context 'with `update` draft' do
-      before do
-        trashable.save!
-        trashable.name = 'Sam'
-        trashable.draft_update
-      end
-
-      subject { trashable.draft.publish!; return trashable.reload }
-      it { expect { subject }.to_not raise_exception }
-      it { should be_published }
-      it { should_not be_draft }
-      it { should_not be_trashed }
-      its(:name) { should eql 'Sam' }
-      its(:published_at) { should be_present }
-      its(:draft_id) { should be_nil }
-      its(:draft) { should be_nil }
-      its(:trashed_at) { should be_nil }
-
-      it 'deletes the draft' do
-        expect { subject }.to change(Draftsman::Draft, :count).by(-1)
-      end
+    describe :publish! do
+      context 'with `create` draft' do
+        before { trashable.draft_creation }
+        subject { trashable.draft.publish!; return trashable.reload }
+        it { expect { subject }.to_not raise_exception }
+        it { should be_published }
+        it { should_not be_trashed }
+        it { should_not be_draft }
+        its(:published_at) { should be_present }
+        its(:draft_id) { should be_nil }
+        its(:draft) { should be_nil }
+        its(:trashed_at) { should be_nil }
 
-      it 'does not delete the associated item' do
-        expect { subject }.to_not change(Trashable, :count)
+        it 'deletes the draft' do
+          expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+        end
       end
-    end
 
-    context 'with `destroy` draft' do
-      context 'without previous draft' do
+      context 'with `update` draft' do
         before do
           trashable.save!
-          trashable.draft_destroy
+          trashable.name = 'Sam'
+          trashable.draft_update
         end
 
-        subject { trashable.draft.publish! }
+        subject { trashable.draft.publish!; return trashable.reload }
+        it { expect { subject }.to_not raise_exception }
+        it { should be_published }
+        it { should_not be_draft }
+        it { should_not be_trashed }
+        its(:name) { should eql 'Sam' }
+        its(:published_at) { should be_present }
+        its(:draft_id) { should be_nil }
+        its(:draft) { should be_nil }
+        its(:trashed_at) { should be_nil }
 
-        it 'destroys the draft' do
+        it 'deletes the draft' do
           expect { subject }.to change(Draftsman::Draft, :count).by(-1)
         end
 
-        it 'deletes the associated item' do
-          expect { subject }.to change(Trashable, :count).by(-1)
+        it 'does not delete the associated item' do
+          expect { subject }.to_not change(Trashable, :count)
         end
       end
 
-      context 'with previous `create` draft' do
-        before do
-          trashable.draft_creation
-          trashable.draft_destroy
-        end
+      context 'with `destroy` draft' do
+        context 'without previous draft' do
+          before do
+            trashable.save!
+            trashable.draft_destroy
+          end
 
-        subject { trashable.draft.publish! }
+          subject { trashable.draft.publish! }
 
-        it 'destroys the draft' do
-          expect { subject }.to change(Draftsman::Draft, :count).by(-1)
-        end
+          it 'destroys the draft' do
+            expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+          end
 
-        it 'deletes the associated item' do
-          expect { subject }.to change(Trashable, :count).by(-1)
+          it 'deletes the associated item' do
+            expect { subject }.to change(Trashable, :count).by(-1)
+          end
         end
-      end
-    end
-  end
 
-  describe :revert! do
-    context 'with `create` draft' do
-      before { trashable.draft_creation }
-      subject { trashable.draft.revert! }
-      it { expect { subject }.to_not raise_exception }
+        context 'with previous `create` draft' do
+          before do
+            trashable.draft_creation
+            trashable.draft_destroy
+          end
 
-      it 'deletes the draft' do
-        expect { subject }.to change(Draftsman::Draft, :count).by(-1)
-      end
+          subject { trashable.draft.publish! }
 
-      it 'deletes associated item' do
-        expect { subject }.to change(Trashable, :count).by(-1)
-      end
-    end
+          it 'destroys the draft' do
+            expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+          end
 
-    context 'with `update` draft' do
-      before do
-        trashable.save!
-        trashable.name = 'Sam'
-        trashable.draft_update
+          it 'deletes the associated item' do
+            expect { subject }.to change(Trashable, :count).by(-1)
+          end
+        end
       end
+    end
 
-      subject { trashable.draft.revert!; return trashable.reload }
-      it { expect { subject }.to_not raise_exception }
-      it { should_not be_draft }
-      its(:name) { should eql 'Bob' }
-      its(:draft_id) { should be_nil }
-      its(:draft) { should be_nil }
+    describe :revert! do
+      context 'with `create` draft' do
+        before { trashable.draft_creation }
+        subject { trashable.draft.revert! }
+        it { expect { subject }.to_not raise_exception }
 
-      it 'deletes the draft' do
-        expect { subject }.to change(Draftsman::Draft, :count).by(-1)
-      end
+        it 'deletes the draft' do
+          expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+        end
 
-      it 'does not delete the associated item' do
-        expect { subject }.to_not change(Trashable, :count)
+        it 'deletes associated item' do
+          expect { subject }.to change(Trashable, :count).by(-1)
+        end
       end
-    end
 
-    context 'with `destroy` draft' do
-      context 'without previous draft' do
+      context 'with `update` draft' do
         before do
           trashable.save!
-          trashable.draft_destroy
+          trashable.name = 'Sam'
+          trashable.draft_update
         end
 
         subject { trashable.draft.revert!; return trashable.reload }
         it { expect { subject }.to_not raise_exception }
-        it { should_not be_trashed }
         it { should_not be_draft }
+        its(:name) { should eql 'Bob' }
         its(:draft_id) { should be_nil }
         its(:draft) { should be_nil }
-        its(:trashed_at) { should be_nil }
 
         it 'deletes the draft' do
           expect { subject }.to change(Draftsman::Draft, :count).by(-1)
@@ -262,112 +245,137 @@ describe Draftsman::Draft do
         end
       end
 
-      context 'with previous `create` draft' do
-        before do
-          trashable.draft_creation
-          trashable.draft_destroy
+      context 'with `destroy` draft' do
+        context 'without previous draft' do
+          before do
+            trashable.save!
+            trashable.draft_destroy
+          end
+
+          subject { trashable.draft.revert!; return trashable.reload }
+          it { expect { subject }.to_not raise_exception }
+          it { should_not be_trashed }
+          it { should_not be_draft }
+          its(:draft_id) { should be_nil }
+          its(:draft) { should be_nil }
+          its(:trashed_at) { should be_nil }
+
+          it 'deletes the draft' do
+            expect { subject }.to change(Draftsman::Draft, :count).by(-1)
+          end
+
+          it 'does not delete the associated item' do
+            expect { subject }.to_not change(Trashable, :count)
+          end
         end
 
-        subject { trashable.draft.revert!; return trashable.reload }
-        it { expect { subject }.to_not raise_exception }
-        it { should_not be_trashed }
-        it { should be_draft }
-        its(:draft_id) { should be_present }
-        its(:draft) { should be_present }
-        its(:trashed_at) { should be_nil }
-
-        it 'deletes the `destroy` draft' do
-          expect { subject }.to change(Draftsman::Draft.where(:event => 'destroy'), :count).by(-1)
+        context 'with previous `create` draft' do
+          before do
+            trashable.draft_creation
+            trashable.draft_destroy
+          end
+
+          subject { trashable.draft.revert!; return trashable.reload }
+          it { expect { subject }.to_not raise_exception }
+          it { should_not be_trashed }
+          it { should be_draft }
+          its(:draft_id) { should be_present }
+          its(:draft) { should be_present }
+          its(:trashed_at) { should be_nil }
+
+          it 'deletes the `destroy` draft' do
+            expect { subject }.to change(Draftsman::Draft.where(:event => 'destroy'), :count).by(-1)
+          end
+
+          it 'reifies the previous `create` draft' do
+            expect { subject }.to change(Draftsman::Draft.where(:event => 'create'), :count).by(1)
+          end
+
+          it 'does not delete the associated item' do
+            expect { subject }.to_not change(Trashable, :count)
+          end
+
+          its "draft's previous draft should be nil" do
+            subject.draft.previous_draft.should be_nil
+          end
         end
+      end
+    end
 
-        it 'reifies the previous `create` draft' do
-          expect { subject }.to change(Draftsman::Draft.where(:event => 'create'), :count).by(1)
-        end
+    describe :reify do
+      subject { trashable.draft.reify }
 
-        it 'does not delete the associated item' do
-          expect { subject }.to_not change(Trashable, :count)
-        end
+      context 'with `create` draft' do
+        before { trashable.draft_creation }
+        its(:title) { should eql trashable.title }
+
+        context 'updated create' do
+          before do
+            trashable.name = 'Sam'
+            trashable.draft_update
+          end
 
-        its "draft's previous draft should be nil" do
-          subject.draft.previous_draft.should be_nil
+          its(:name) { should eql 'Sam' }
+          its(:title) { should be_nil }
         end
       end
-    end
-  end
-
-  describe :reify do
-    subject { trashable.draft.reify }
 
-    context 'with `create` draft' do
-      before { trashable.draft_creation }
-      its(:title) { should eql trashable.title }
-
-      context 'updated create' do
+      context 'with `update` draft' do
         before do
+          trashable.save!
           trashable.name = 'Sam'
+          trashable.title = 'My Title'
           trashable.draft_update
         end
 
         its(:name) { should eql 'Sam' }
-        its(:title) { should be_nil }
-      end
-    end
-
-    context 'with `update` draft' do
-      before do
-        trashable.save!
-        trashable.name = 'Sam'
-        trashable.title = 'My Title'
-        trashable.draft_update
-      end
+        its(:title) { should eql 'My Title' }
 
-      its(:name) { should eql 'Sam' }
-      its(:title) { should eql 'My Title' }
+        context 'updating the update' do
+          before do
+            trashable.title = nil
+            trashable.draft_update
+          end
 
-      context 'updating the update' do
-        before do
-          trashable.title = nil
-          trashable.draft_update
+          its(:name) { should eql 'Sam' }
+          its(:title) { should be_nil }
         end
-
-        its(:name) { should eql 'Sam' }
-        its(:title) { should be_nil }
       end
-    end
 
-    context 'with `destroy` draft' do
-      context 'without previous draft' do
-        before do
-          trashable.save!
-          trashable.draft_destroy
-        end
-
-        its(:name) { should eql 'Bob' }
-        its(:title) { should be_nil }
-      end
+      context 'with `destroy` draft' do
+        context 'without previous draft' do
+          before do
+            trashable.save!
+            trashable.draft_destroy
+          end
 
-      context 'with previous `create` draft' do
-        before do
-          trashable.draft_creation
-          trashable.draft_destroy
+          its(:name) { should eql 'Bob' }
+          its(:title) { should be_nil }
         end
 
-        its(:name) { should eql 'Bob' }
-        its(:title) { should be_nil }
-      end
+        context 'with previous `create` draft' do
+          before do
+            trashable.draft_creation
+            trashable.draft_destroy
+          end
 
-      context 'with previous `update` draft' do
-        before do
-          trashable.save!
-          trashable.name = 'Sam'
-          trashable.title = 'My Title'
-          trashable.draft_update
-          # Typically, 2 draft operations won't happen in the same request, so reload before draft-destroying.
-          trashable.reload.draft_destroy
+          its(:name) { should eql 'Bob' }
+          its(:title) { should be_nil }
         end
 
-        its(:name) { should eql 'Sam' }
-        its(:title) { should eql 'My Title' }
+        context 'with previous `update` draft' do
+          before do
+            trashable.save!
+            trashable.name = 'Sam'
+            trashable.title = 'My Title'
+            trashable.draft_update
+            # Typically, 2 draft operations won't happen in the same request, so reload before draft-destroying.
+            trashable.reload.draft_destroy
+          end
+
+          its(:name) { should eql 'Sam' }
+          its(:title) { should eql 'My Title' }
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: draftsman
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Peters
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-28 00:00:00.000000000 Z
+date: 2014-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -165,8 +165,10 @@ files:
 - lib/draftsman/version.rb
 - lib/generators/draftsman/install_generator.rb
 - lib/generators/draftsman/templates/add_object_changes_column_to_drafts.rb
+- lib/generators/draftsman/templates/add_object_changes_column_to_drafts_json.rb
 - lib/generators/draftsman/templates/config/initializers/draftsman.rb
 - lib/generators/draftsman/templates/create_drafts.rb
+- lib/generators/draftsman/templates/create_drafts_json.rb
 - spec/controllers/informants_controller_spec.rb
 - spec/controllers/users_controller_spec.rb
 - spec/controllers/whodunnits_controller_spec.rb