drafter 0.2.8 → 0.3.0

data/Gemfile

@@ -9,6 +9,7 @@ gem "diffy"
 # Include everything needed to run rake, tests, features, etc.
 group :development do
   gem "sqlite3"
+  gem "database_cleaner"
   gem "debugger"
 	gem "minitest", ">= 0"
 	gem "bundler", "~> 1.0.0"

data/Gemfile.lock

@@ -35,6 +35,7 @@ GEM
       activemodel (>= 3.2.0)
       activesupport (>= 3.2.0)
     columnize (0.3.6)
+    database_cleaner (0.7.1)
     debugger (1.1.1)
       columnize (>= 0.3.1)
       debugger-linecache (~> 1.1)
@@ -119,6 +120,7 @@ DEPENDENCIES
   activerecord
   bundler (~> 1.0.0)
   carrierwave
+  database_cleaner
   debugger
   diffy
   jeweler (~> 1.6.4)

data/VERSION

@@ -1 +1 @@
-0.2.8
+0.3.0

data/drafter.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "drafter"
-  s.version = "0.2.8"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["futurechimp"]
-  s.date = "2012-08-29"
+  s.date = "2012-09-05"
   s.description = "A"
   s.email = "dave.hrycyszyn@headlondon.com"
   s.extra_rdoc_files = [
@@ -33,12 +33,16 @@ Gem::Specification.new do |s|
     "lib/drafter/draft_upload.rb",
     "lib/drafter/draft_uploader.rb",
     "lib/drafter/draftable.rb",
+    "lib/drafter/id_hash.rb",
+    "lib/drafter/subdrafts.rb",
     "test/drafter/test_apply.rb",
     "test/drafter/test_creation.rb",
     "test/drafter/test_diffing.rb",
     "test/drafter/test_draft.rb",
     "test/drafter/test_draft_upload.rb",
     "test/drafter/test_draftable.rb",
+    "test/drafter/test_id_hash.rb",
+    "test/drafter/test_subdrafts.rb",
     "test/fixtures/bar.txt",
     "test/fixtures/foo.txt",
     "test/helper.rb",
@@ -62,6 +66,7 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<activerecord>, [">= 0"])
       s.add_runtime_dependency(%q<diffy>, [">= 0"])
       s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<database_cleaner>, [">= 0"])
       s.add_development_dependency(%q<debugger>, [">= 0"])
       s.add_development_dependency(%q<minitest>, [">= 0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
@@ -74,6 +79,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<activerecord>, [">= 0"])
       s.add_dependency(%q<diffy>, [">= 0"])
       s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<database_cleaner>, [">= 0"])
       s.add_dependency(%q<debugger>, [">= 0"])
       s.add_dependency(%q<minitest>, [">= 0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
@@ -87,6 +93,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<activerecord>, [">= 0"])
     s.add_dependency(%q<diffy>, [">= 0"])
     s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<database_cleaner>, [">= 0"])
     s.add_dependency(%q<debugger>, [">= 0"])
     s.add_dependency(%q<minitest>, [">= 0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])

data/lib/drafter/apply.rb

@@ -4,11 +4,12 @@ module Drafter
   module Apply
     extend ActiveSupport::Concern
 
-    # Apply the draft data to the draftable, without saving it..
+    # Apply the draft data to the draftable, without saving it.
     def apply_draft
       if draft
         restore_attrs
         restore_files
+        restore_subdrafts
       end
       self
     end
@@ -36,6 +37,60 @@ module Drafter
       end
     end
 
+    # It's possible to easily restore subdrafts except in one case we've
+    # run into so far: the case where you try to restore a subdraft which
+    # is defined using Single Table Inheritance (STI) and which also has a
+    # polymorphic belongs_to relationship with the draftable class.
+    #
+    # In those edge cases, we need to do a dirty little hack, using the
+    # :polymorphic_as option from the class's draftable method to manually
+    # set the association.
+    #
+    # This won't be clear enough to make sense 5 minutes from now, so here are
+    # the details spelled out more concretely. Let's say you've got these
+    # classes:
+    #
+    # class Article < ActiveRecord::Base
+    #   draftable
+    #   has_many :likes, :as => :likeable
+    #   has_many :really_likes
+    # end
+    #
+    # class Like < ActiveRecord::Base
+    #   draftable
+    #   belongs_to :likeable, :polymorphic => true
+    # end
+    #
+    # class ReallyLike < Like
+    # end
+    #
+    # This setup will actually work fine for subdraft restoration, right up
+    # until you add "validates_presence_of :likeable" to Like. At that point,
+    # you'll be told that really_likes is invalid whenever you try to approve
+    # something, because the polymorphic STI "really_likable" won't be able
+    # to figure out what its likeable id is when it saves during the approval
+    # process.
+    #
+    # The hack basically involves explicitly telling draftable in the Like
+    # class what its polymorph relation is:
+    #
+    # class Like < ActiveRecord::Base
+    #   draftable :polymorphic_as => :likeable
+    #   ...
+    #
+    # See the models setup at tests/support/models.rb for the working setup.
+    #
+    def restore_subdrafts
+      draft.subdrafts.each_with_index do |subdraft, index|
+        inflated_object = subdraft.build_draftable
+        self.send(subdraft.parent_association_name.to_sym) << inflated_object
+        # THE HACK
+        if inflated_object.class.polymorphic_as
+          inflated_object.send("#{inflated_object.class.polymorphic_as}=", self)
+        end
+      end
+    end
+
   	# We don't want to copy all the draft's columns into the draftable
   	# objects attributes.
   	#

data/lib/drafter/creation.rb

@@ -11,37 +11,54 @@ module Drafter
     end
 
     # Build and save the draft when told to do so.
-    def save_draft
-      if self.valid?
-        attrs = self.attributes
-        if self.draft
-          draft.data = attrs
-        else
-          self.build_draft(:data => attrs)
-        end
-        # https://github.com/rails/rails/issues/617
-        draft.draftable_type = self.class.to_s
-        self.draft.save!
-        uploads = build_draft_uploads(attrs)
-        self.draft
+    def save_draft(parent_draft=nil, parent_association_name=nil)
+      if valid?
+        do_create_draft(parent_draft, parent_association_name)
+        create_subdrafts
       end
+      return self.draft.reload if self.draft
     end
 
     private
 
+      def do_create_draft(parent_draft=nil, parent_association_name=nil)
+        serialize_attributes_to_draft
+        attach_to_parent_draft(parent_draft, parent_association_name)
+        unfuck_sti
+        draft.save!
+        build_draft_uploads
+        draft
+      end
+
+      # https://github.com/rails/rails/issues/617
+      def unfuck_sti
+        draft.draftable_type = self.class.to_s
+      end
+
+      # Set up the draft object, setting its :data attribute to the serialized
+      # hash of this object's attributes.
+      #
+      def serialize_attributes_to_draft
+        if self.draft
+          draft.data = self.attributes
+        else
+          self.build_draft(:data => self.attributes)
+        end
+      end
+
       # Loop through and create DraftUpload objects for any Carrierwave
       # uploaders mounted on this draftable object.
       #
       # @param [Hash] attrs the attributes to loop through
       # @return [Array<DraftUpload>] an array of unsaved DraftUpload objects.
-      def build_draft_uploads(attrs)
-        draft_uploads = []
-        attrs.keys.each do |key|
-          if self.respond_to?(key) && self.send(key).is_a?(CarrierWave::Uploader::Base)
+      def build_draft_uploads
+        self.attributes.keys.each do |key|
+          if (self.respond_to?(key) &&
+              self.send(key).is_a?(CarrierWave::Uploader::Base) &&
+              self.send(key).file)
             self.draft.draft_uploads << build_draft_upload(key)
           end
         end
-        draft_uploads
       end
 
       # Get a reference to the CarrierWave uploader mounted on the
@@ -61,5 +78,18 @@ module Drafter
         draft_upload
       end
 
+      # Attach the draft object to a parent draft object, if there is one.
+      # The parent_draft may be for an Article which has_many :comments,
+      # as an example.
+      #
+      # @param [Draft] parent_draft the draft that this draft is associated with.
+      # @param [Symbol] relation the name of the has_many (or has_one) association.
+      def attach_to_parent_draft(parent_draft, relation)
+        if parent_draft && relation
+          draft.parent = parent_draft
+          draft.parent_association_name = relation
+        end
+      end
+
   end
 end

data/lib/drafter/diffing.rb

@@ -9,7 +9,7 @@ module Diffing
   #   [Diffy::Diff].
   def differences(attr, options={:format => :html})
     if self.draft
-      Diffy::Diff.new(self.send(attr), self.draft(attr)).to_s(options[:format])
+      Diffy::Diff.new(self.send(attr), self.draft.send(attr)).to_s(options[:format])
     end
   end
 

data/lib/drafter/draft.rb

@@ -17,6 +17,15 @@ class Draft < ActiveRecord::Base
   has_many :draft_uploads
 	belongs_to :draftable, :polymorphic => true
 
+  # Drafts are nestable, e.g. an Article's draft can have multiple
+  # Comment drafts attached, and the whole thing can be approved at once.
+  #
+  belongs_to :parent, :class_name => "Draft"
+
+  # Looked at from the other end, the parent draft should be able to address
+  # its subdrafts.
+  #
+  has_many :subdrafts, :class_name => "Draft", :foreign_key => "parent_id", :dependent => :destroy # << test that
 
 	# Store serialized data for the associated draftable as a Hash of
   # attributes.
@@ -63,4 +72,10 @@ class Draft < ActiveRecord::Base
     draftabl
 	end
 
+  def approve_subdrafts
+    subdrafts.each do |subdraft|
+      subdraft.approve!
+    end
+  end
+
 end

data/lib/drafter/draftable.rb

@@ -6,6 +6,10 @@ module Drafter
     # Overrides the +draftable+ method to define the +draftable?+ class method.
     module ClassMethods
       def draftable(options={})
+        super(options)
+
+        cattr_accessor :polymorphic_as
+        self.polymorphic_as = options[:polymorphic_as]
 
         class << self
           def draftable?

data/lib/drafter/id_hash.rb

@@ -0,0 +1,46 @@
+module IdHash
+
+
+  # Checks the state of the object to see whether it's an unapproved draft
+  # (in which case it has no :id), or whether it's an approved object which
+  # is being edited or updated (in which case we can address it by :id).
+  #
+  # This is primarily useful in your controllers. Sometimes, you might want to
+  # identify the object by its :id; other times, you're dealing with an object
+  # that only has a Draft but no actual object identity, in which case you'll
+  # want to retrieve the Draft object by its :draft_id, and call
+  # @draft.build_draftable on that.
+  #
+  # @return [Hash] a hash with either :draft_id => this object's draft's id,
+  #   or :id => this object's id.
+  def id_hash
+    if !new_record?
+      { :id => self.to_param }
+    elsif new_record? && draft
+      { :draft_id => draft.to_param }
+    else
+      raise "It's not clear what kind of id you're looking for."
+    end
+  end
+
+  # When you're attaching sub-objects to a parent object, you'll sometimes need
+  # to send the :id and :draft_id in another context, e.g. as :article_id and/or
+  # :draft_article_id.
+  #
+  #
+  # @param [Symbol] sym the symbol you want to inject into your id to provide
+  #   context.
+  # @return [Hash] a hash with e.g. :article_id or :draft_article_id, with the
+  #   appropriate values set (as per id_hash above).
+  def id_hash_as(sym)
+    if !new_record?
+      { "#{sym}_id".to_sym => self.to_param }
+    elsif new_record? && draft
+      { "draft_#{sym}_id".to_sym => draft.to_param }
+    else
+      raise "It's not clear what kind of id you're looking for."
+    end
+  end
+
+end
+

data/lib/drafter/subdrafts.rb

@@ -0,0 +1,23 @@
+module Subdrafts
+
+  private
+
+    def create_subdrafts
+      relations = self.class.approves_drafts_for
+      unless relations.empty?
+        relations.each do |relation|
+          create_subdrafts_for(relation)
+        end
+      end
+    end
+
+    def create_subdrafts_for(relation)
+      objects = self.send(relation)
+      unless objects.empty?
+        objects.each do |object|
+          object.save_draft(self.draft, relation)
+        end
+      end
+    end
+
+end

data/lib/drafter.rb

@@ -16,6 +16,8 @@ module Drafter
   autoload :Draft
   autoload :Draftable
   autoload :DraftUpload
+  autoload :IdHash
+  autoload :Subdrafts
 
   class << self
     delegate :config, :configure, :to => Draft
@@ -23,12 +25,26 @@ module Drafter
   end
 
   included do
-    include Apply
-  	include Creation
-    include Diffing
     include Draftable
   end
 
+  module ClassMethods
+
+    def draftable(options={})
+      include Apply
+      include Creation
+      include Diffing
+      include Draftable
+      include IdHash
+      include Subdrafts
+    end
+
+    def approves_drafts_for(*associations)
+      cattr_accessor :approves_drafts_for
+      self.approves_drafts_for = associations
+    end
+  end
+
 end
 
 ActiveRecord::Base.class_eval{ include Drafter }

data/test/drafter/test_apply.rb

@@ -9,6 +9,42 @@ class TestCreation < Minitest::Unit::TestCase
 			  :upload => file_upload)
     end
 
+    describe "for an unsaved article" do
+      before do
+        @draft = @article.save_draft
+      end
+
+      describe "with no comments" do
+        before do
+          @article = @draft.build_draftable
+          @article.apply_draft
+        end
+
+        it "should restore the article, unsaved" do
+          assert @article.new_record?
+          assert_equal(Article, @article.class)
+        end
+      end
+
+      describe "with comments" do
+        before do
+          @article = @draft.build_draftable
+          @article.comments.build(:text => "I'm a comment on a draft article")
+          @draft = @article.save_draft
+          @article = @draft.build_draftable
+        end
+
+        it "should restore the article, unsaved" do
+          assert @article.new_record?
+          assert_equal(Article, @article.class)
+        end
+
+        it "should restore the comments" do
+          assert_equal(1, @article.comments.length)
+        end
+      end
+    end
+
     describe "to an existing article" do
       before do
         @article.save!
@@ -38,11 +74,67 @@ class TestCreation < Minitest::Unit::TestCase
           assert_equal("changed", @article.text)
         end
 
-       it "should restore the draft upload" do
+        it "should restore the draft upload" do
           assert_equal("bar.txt", @article.upload.filename)
         end
+
+        describe "which has a subdraft attached" do
+          before do
+            @article.comments.build(:text => "I'm a comment", :upload => file_upload)
+            @draft_count = Draft.count
+            @article.save_draft
+            @reloaded = Article.find(@article.to_param)
+          end
+
+          it "should not yet have any comments attached" do
+            assert_equal(0, @reloaded.comments.length)
+          end
+
+          describe "applying the draft" do
+            before do
+              @reloaded.apply_draft
+            end
+
+            it "should be able to restore the comment" do
+              assert_equal(1, @reloaded.comments.length)
+            end
+          end
+        end
+
+        describe "which has two subdrafts attached" do
+          before do
+            @article.comments.build(:text => "I'm a comment", :upload => file_upload)
+            @article.comments.build(:text => "I'm another comment", :upload => file_upload("bar.txt"))
+            @draft_count = Draft.count
+            @article.save_draft
+            @reloaded = Article.find(@article.to_param)
+          end
+
+          it "should not yet have any comments attached" do
+            assert_equal(0, @reloaded.comments.length)
+          end
+
+          describe "applying the draft" do
+            before do
+              @reloaded.apply_draft
+            end
+
+            it "should be able to restore the comment" do
+              assert_equal(2, @reloaded.comments.length)
+            end
+
+            it "should properly restore the first file, foo.txt" do
+              contents = File.new(@reloaded.comments.first.upload.path).read
+              assert_equal(file_upload.read, contents)
+            end
+
+            it "should properly restore the second file, bar.txt" do
+              contents = File.new(@reloaded.comments.last.upload.path).read
+              assert_equal(file_upload("bar.txt").read, contents)
+            end
+          end
+        end
       end
     end
   end
-
 end

data/test/drafter/test_creation.rb

@@ -61,7 +61,6 @@ class TestCreation < Minitest::Unit::TestCase
 				it "should update the DraftUpload in place" do
 					assert_equal(@draft_upload_count, DraftUpload.count)
 				end
-
 			end
 		end
 
@@ -159,6 +158,47 @@ class TestCreation < Minitest::Unit::TestCase
 				assert_equal(1, @article.errors.count)
 			end
 		end
+
+		# We may need to save this for later.
+		#
+		# If we could get these tests working, we could call save_draft on any
+		# object in an association chain and have it save properly both up and
+		# down the chain.
+		#
+		# For the moment, it should work if you save from the top of the chain.
+		# Given the time constraints right now, let's use that for the moment.
+		#
+		# describe "a class which may belongs_to something else, e.g. a Comment" do
+			# describe "when no associated class is set, e.g. there's no Article" do
+			# 	before do
+			# 		@comment = Comment.new(:text => "foo")
+			# 		@draft_count = Draft.count
+			# 		@comment.save_draft
+			# 	end
+
+			# 	it "should save a draft" do
+			# 		assert_equal(@draft_count + 1, Draft.count)
+			# 	end
+			# end
+
+			# describe "when there's an article" do
+			# 	before do
+			# 		@article = Article.create(:text => "I'm an article")
+			# 		@comment = Comment.new(:text => "I belong to the article")
+			# 		@comment.article = @article
+			# 		@draft_count = Draft.count
+			# 		@comment.save_draft
+			# 	end
+
+				# it "should save a draft" do
+				# 	assert_equal(@draft_count + 1, Draft.count)
+				# end
+
+			# 	it "should add the @comment to the @article's subdrafts" do
+			# 		assert @article.draft.subdrafts.include? Draft.last
+			# 	end
+			# end
+		# end
 	end
 
 end

data/test/drafter/test_diffing.rb

@@ -26,9 +26,13 @@ class TestDrafter < MiniTest::Unit::TestCase
         end
 
         describe "for a string attribute" do
+          it "should not nullify the @article" do
+            assert @article
+          end
           # return an html diff string for "foo" and "superfoo"
           it "should return an HTML diff between the draft and live object" do
-            assert (@article.reload.differences(:text)).include?(%Q(<li class=\"del\"><del>f<strong>oo</strong></del></li>))
+
+            assert (@article.reload.differences(:text)).include?(%Q(<li class=\"ins\"><ins><strong>super</strong>foo</ins></li>))
           end
         end
       end