has_draft 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 43802ee528c537f22d4b0996caa82708366eca1a
-  data.tar.gz: 237e44c17d24fe2aa960a34123fb1f2b8e6637d9
+SHA256:
+  metadata.gz: 29d15db9d31975799a93a854e620a005c6358befe684fdb7e1d5766324463d33
+  data.tar.gz: 85e9962ebe1ad2d7f76afe2a5b2be0f94cc2fb26d188ea746d0eed6330e66cd2
 SHA512:
-  metadata.gz: ab07707560bffdecf87a35b439f783a7a53ded60a733b22423e55eabd7a221ec947f787785e71c5d3731a7fdadbdcf1401b084b3e1a52061b043d026e95cdf1a
-  data.tar.gz: f6ebd0abcf1390d97c26109f397ee209a24bd1b3d78cd12a03264bd3e6a31c74d41b66b27d9ffbfd4ce3a4f8b8919336cb841a754400d76a37910d3bd71f4b95
+  metadata.gz: c20a9d20993e59c7161b1225c99b27c03341c7efb11762f34ef33a0cbdab616ce8a138f45eb97a415ca3b46e72aa624266e6af679abf25ff2be166dcded0f4c2
+  data.tar.gz: 9e4739990706a7fc0bb6500ec0a2caab469cca88550be61ab050f70effc6d611e20e67e41fc2e678fcd3e3601f4a93f413123f20b8178a36806c314148bbaca2

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+## 2.0.0
+
+Supports Rails (ActiveRecord) 6.1 through 8.1 on Ruby 3.0 and later.
+
+### Breaking changes
+
+- Requires ActiveRecord 6.1+ and Ruby 3.0+.
+- `instantiate_draft` builds the draft without saving it, as originally intended.
+  `instantiate_draft!` still saves it.
+- On a new record, `instantiate_draft!` no longer saves the record. The draft is saved along with the
+  record instead. `save_to_draft` raises `ActiveRecord::RecordNotSaved`.
+- The foreign key defaults to `"#{belongs_to}_id"`, so with `belongs_to: :element` it's
+  `element_id` rather than one named after the including class. This is unchanged when `:belongs_to`
+  isn't given.
+- The Railtie and the `init.rb` files are gone. The gem hooks into ActiveRecord when it's required.
+
+### Fixes
+
+- `save_to_draft`, `destroy_draft!` and the `with_draft`/`without_draft` scopes work on modern Rails.
+- `save_to_draft` returns false when the draft fails to save.
+- Defining a model no longer needs a database connection. Drafted columns are worked out on first use.
+- Columns that only exist on the draft table are no longer copied, which used to raise `NoMethodError`.
+- A symbol `:foreign_key` is no longer copied as if it were a drafted column.
+
+## 1.4.0 and earlier
+
+See the [commit history](https://github.com/eigenben/has_draft/commits/master).

data/README.md

@@ -0,0 +1,213 @@
+# has_draft
+
+[![CI](https://github.com/eigenben/has_draft/actions/workflows/ci.yml/badge.svg)](https://github.com/eigenben/has_draft/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/has_draft.svg)](https://rubygems.org/gems/has_draft)
+
+Gives your ActiveRecord models a draft copy that lives alongside the live record. Typical uses:
+
+- A draft and a live version of a page, where edits are previewed before they're published
+- An approval workflow, where the live copy stays active while a draft waits for review
+
+Drafts are stored in a separate, nearly identical table, joined to the live record by a `has_one`.
+Your existing table and queries don't change: `Page.all` still returns only live pages, with no extra
+conditions needed. The draft table is backed by a model that `has_draft` creates for you as a constant
+on the original class, so if `Page` has a draft, `Page::Draft` is the model for the `page_drafts` table.
+
+Because a draft is a real model with real columns, it can have its own validations, associations and
+indexes, and you can query drafts with SQL like any other table. The trade-off is that the draft table
+has to be kept in step with the live table: when you add a column to one, add it to the other.
+
+## Installation
+
+Requires Rails (ActiveRecord) 6.1 or later and Ruby 3.0 or later.
+
+```ruby
+gem "has_draft"
+```
+
+## Basic example
+
+```ruby
+class CreateArticles < ActiveRecord::Migration[7.1]
+  def change
+    [:articles, :article_drafts].each do |table_name|
+      create_table table_name do |t|
+        t.references :article if table_name == :article_drafts
+
+        t.string :title
+        t.text :summary
+        t.text :body
+        t.date :post_date
+        t.timestamps
+      end
+    end
+  end
+end
+
+class Article < ApplicationRecord
+  has_draft
+end
+```
+
+Class methods and scopes:
+
+```ruby
+Article.draft_class   # => Article::Draft
+Article.with_draft    # articles that have a draft
+Article.without_draft # articles that don't
+```
+
+Working with drafts:
+
+```ruby
+article = Article.create!(title: "My Title", body: "Full body", post_date: Date.today)
+
+article.has_draft?          # => false
+article.instantiate_draft!  # copies the article into a new, saved draft
+article.has_draft?          # => true
+article.draft               # => #<Article::Draft ...>
+
+article.draft.update!(title: "New Title")
+article.replace_with_draft! # copies the draft onto the article and saves it
+article.title               # => "New Title"
+
+article.destroy_draft!
+article.has_draft?          # => false
+```
+
+`save_to_draft` saves a record's unsaved changes into its draft (creating the draft if needed) instead
+of the live table, then reloads the live record:
+
+```ruby
+article.title = "Work in progress"
+article.save_to_draft        # validates the article first; returns false if invalid
+article.title                # => "New Title"
+article.draft.title          # => "Work in progress"
+
+article.save_to_draft(false) # skip validation
+```
+
+Drafts belong to a saved record. On a new record, `instantiate_draft!` builds the draft and it's saved
+along with the record, while `save_to_draft` raises `ActiveRecord::RecordNotSaved`.
+`instantiate_draft` (without the bang) builds the draft without saving it.
+
+Every column the two tables share is copied, except the primary key, the foreign key, `created_at`,
+`updated_at` and the STI type column. Columns that only exist on the draft table (say, an `approved_at`
+for a review workflow) are left alone. `Article.draft_columns` lists the columns that are copied.
+
+## Custom options
+
+```ruby
+class Article < ApplicationRecord
+  has_draft class_name: "Copy", foreign_key: :news_article_id, table_name: "article_copies"
+end
+```
+
+| Option         | Default                                  |
+| -------------- | ---------------------------------------- |
+| `:class_name`  | `"Draft"` (defined as `Article::Draft`)   |
+| `:table_name`  | `"article_drafts"`                       |
+| `:belongs_to`  | `:article`, the draft's parent association |
+| `:foreign_key` | `"#{belongs_to}_id"`, so `"article_id"`  |
+| `:extends`     | `ActiveRecord::Base`, the draft class's superclass |
+
+## Single table inheritance
+
+Subclasses draft into the base class's draft table. Use `:belongs_to` so every draft class shares the
+same parent association, and `:extends` to share behavior between draft classes:
+
+```ruby
+class CreateElements < ActiveRecord::Migration[7.1]
+  def change
+    [:elements, :element_drafts].each do |table_name|
+      create_table table_name do |t|
+        t.references :element if table_name == :element_drafts
+
+        t.string :title
+        t.text :content
+        t.string :type
+      end
+    end
+  end
+end
+
+class Element < ApplicationRecord
+  # Uses the element_drafts table, with each subclass's draft class stored via STI
+  class Draft < ApplicationRecord
+    def icon_path
+      "images/default.png"
+    end
+  end
+end
+
+class BlueElement < Element
+  has_draft belongs_to: :element, extends: Element::Draft do
+    def icon_path
+      "images/blue.png"
+    end
+  end
+end
+
+class UnknownElement < Element
+  has_draft belongs_to: :element, extends: Element::Draft
+end
+```
+
+Now `draft.element` works on any element's draft, without needing to know to call
+`draft.blue_element` or `draft.unknown_element`. Calling `has_draft` in a class whose parent already
+called it does nothing.
+
+## Callbacks
+
+Define any of these methods to hook into the draft lifecycle:
+
+```ruby
+class Article < ApplicationRecord
+  has_draft
+
+  def before_instantiate_draft
+  end
+
+  def before_replace_with_draft
+  end
+
+  def before_destroy_draft
+  end
+end
+```
+
+## Extending the draft class
+
+Since you don't define the draft class yourself, pass a block to `has_draft` to run code in its context:
+
+```ruby
+class Article < ApplicationRecord
+  belongs_to :user
+
+  has_draft do
+    belongs_to :last_updated_user, class_name: "User", optional: true
+
+    def approve!
+      update!(approved_at: Time.current)
+    end
+  end
+end
+```
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+```
+
+To test against a specific Rails version, use one of the gemfiles in `gemfiles/`:
+
+```sh
+BUNDLE_GEMFILE=gemfiles/rails_6.1.gemfile bundle install
+BUNDLE_GEMFILE=gemfiles/rails_6.1.gemfile bundle exec rake
+```
+
+## License
+
+MIT

data/lib/has_draft/version.rb

@@ -1,3 +1,3 @@
 module HasDraft
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 end

data/lib/has_draft.rb

@@ -1,31 +1,35 @@
+require "active_support"
+require "active_record"
+require "has_draft/version"
+
 module HasDraft
   def self.included(base)
     base.extend ClassMethods
   end
-  
+
   module ClassMethods
     def has_draft(options = {}, &block)
       return if self.included_modules.include?(HasDraft::InstanceMethods)
       include HasDraft::InstanceMethods
-      
-      cattr_accessor :draft_class_name, :draft_foreign_key, :draft_table_name, :draft_columns
-      
-      self.draft_class_name = options[:class_name]  || 'Draft'
-      self.draft_foreign_key = options[:foreign_key] || self.to_s.foreign_key
-      self.draft_table_name = options[:table_name]  || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_drafts#{table_name_suffix}"
+
+      class_attribute :draft_class_name, :draft_foreign_key, :draft_table_name, :instance_writer => false
 
       # Default parent association
-      options[:belongs_to] = self.to_s.demodulize.underscore.to_sym if options[:belongs_to].nil?
+      options[:belongs_to] = self.name.demodulize.underscore.to_sym if options[:belongs_to].nil?
+
+      self.draft_class_name = options[:class_name]  || 'Draft'
+      self.draft_foreign_key = (options[:foreign_key] || "#{options[:belongs_to]}_id").to_s
+      self.draft_table_name = options[:table_name]  || "#{table_name_prefix}#{base_class.name.demodulize.underscore}_drafts#{table_name_suffix}"
 
       # Create Relationship to Draft Copy
       class_eval do
-        has_one :draft, :class_name => "#{self.to_s}::#{draft_class_name}",
+        has_one :draft, :class_name => "#{self.name}::#{draft_class_name}",
                         :foreign_key => draft_foreign_key,
                         :dependent => :destroy,
                         :inverse_of => options[:belongs_to]
 
-        scope :with_draft, lambda { includes(:draft).where("#{draft_table_name}.id IS NOT NULL") }
-        scope :without_draft, lambda { includes(:draft).where("#{draft_table_name}.id IS NULL") }
+        scope :with_draft, lambda { includes(:draft).where.not(draft_table_name => { draft_class.primary_key => nil }) }
+        scope :without_draft, lambda { includes(:draft).where(draft_table_name => { draft_class.primary_key => nil }) }
       end
 
       # Default parent class to ActiveRecord::Base
@@ -33,95 +37,102 @@ module HasDraft
 
       # Dynamically Create Model::Draft Class
       const_set(draft_class_name, Class.new(options[:extends]))
-      
-      draft_class.cattr_accessor :original_class
+
+      draft_class.class_attribute :original_class, :instance_writer => false
       draft_class.original_class = self
       draft_class.table_name = draft_table_name
 
       # Draft Parent Association
-      draft_class.belongs_to options[:belongs_to], :class_name  => "::#{self.to_s}", :foreign_key => draft_foreign_key, :inverse_of => :draft
+      draft_class.belongs_to options[:belongs_to], :class_name  => "::#{self.name}", :foreign_key => draft_foreign_key, :inverse_of => :draft
 
       # Block extension
       draft_class.class_eval(&block) if block_given?
-      
-      # Finally setup which columns to draft
-      self.draft_columns = draft_class.new.attributes.keys - [draft_class.primary_key, draft_foreign_key, 'created_at', 'updated_at', inheritance_column]
     end
-    
+
+    # Columns copied between the live record and its draft: those the two share, minus keys and
+    # timestamps. Computed on first use so defining the model doesn't need a database connection.
+    def draft_columns
+      @draft_columns ||= (draft_class.attribute_types.keys & attribute_types.keys) - [draft_class.primary_key, draft_foreign_key, 'created_at', 'updated_at', inheritance_column]
+    end
+
     def draft_class
       const_get(draft_class_name)
     end
   end
-  
+
   module InstanceMethods
     def has_draft?
       !self.draft.nil?
     end
-    
+
     def save_to_draft(perform_validation = true)
+      raise ActiveRecord::RecordNotSaved.new("Can't save a draft of a new record; save the record first", self) if self.new_record?
       return false if perform_validation and !self.valid?
-      
-      instantiate_draft! unless has_draft?
-      copy_attributes_to_draft
-      
-      self.draft.save(perform_validation)
+
+      has_draft? ? copy_attributes_to_draft : instantiate_draft
+
+      return false unless self.draft.save(:validate => perform_validation)
       self.reload
     end
-    
+
+    # Builds a draft copy of the record without saving it.
     def instantiate_draft
       self.build_draft
-      
+
       copy_attributes_to_draft
       before_instantiate_draft
-      
-      self.draft.tap(&:save)
+
+      self.draft
     end
-    
+
+    # Builds and saves a draft copy of the record. On a new record, the draft is saved along with it.
     def instantiate_draft!
-      instantiate_draft do |draft|
+      instantiate_draft.tap do |draft|
         draft.save unless self.new_record?
       end
     end
-    
+
     def copy_attributes_to_draft
       self.class.draft_columns.each do |attribute|
         self.draft.send("#{attribute}=", send(attribute))
       end
       self
     end
-    
+
     def copy_attributes_from_draft
       self.class.draft_columns.each do |attribute|
         self.send("#{attribute}=", self.draft.send(attribute))
       end
       self
     end
-    
+
     def before_instantiate_draft
     end
-    
+
     def replace_with_draft!
       copy_attributes_from_draft
-      
+
       before_replace_with_draft
-      
+
       self.save unless self.new_record?
       self
     end
-    
+
     def before_replace_with_draft
     end
-    
+
     def destroy_draft!
       before_destroy_draft
-      
+
       self.draft.destroy if self.draft
-      self.draft(true)
+      self.reload_draft
     end
-    
+
     def before_destroy_draft
     end
   end
 end
 
-require "has_draft/railtie"
+ActiveSupport.on_load(:active_record) do
+  include HasDraft
+end

metadata

@@ -1,127 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: has_draft
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ben Hughes
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: factory_girl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.1
-- !ruby/object:Gem::Dependency
-  name: faker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.1
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.3.4
-- !ruby/object:Gem::Dependency
-  name: appraisal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.0
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 10.1.0
+        version: '6.1'
 description: Allows for your ActiveRecord models to have drafts which are stored in
   a separate duplicate table.
 email: ben@railsgarden.com
@@ -129,27 +30,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Appraisals
-- Gemfile
-- Gemfile.lock
+- CHANGELOG.md
 - LICENSE
-- README.rdoc
-- Rakefile
-- init.rb
+- README.md
 - lib/has_draft.rb
-- lib/has_draft/railtie.rb
 - lib/has_draft/version.rb
-- spec/db/database.yml
-- spec/db/schema.rb
-- spec/db/test.sqlite3
-- spec/factories/article.rb
-- spec/has_draft_spec.rb
-- spec/spec_helper.rb
-homepage: http://github.com/rubiety/has_draft
+homepage: https://github.com/eigenben/has_draft
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  source_code_uri: https://github.com/eigenben/has_draft
+  changelog_uri: https://github.com/eigenben/has_draft/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/eigenben/has_draft/issues
 rdoc_options: []
 require_paths:
 - lib
@@ -157,17 +49,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.4
+      version: '0'
 requirements: []
-rubyforge_project: has_draft
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
-summary: Attached draft model to your ActiveRecord models.
+summary: Attach drafts to your ActiveRecord models.
 test_files: []
-has_rdoc: 

data/Appraisals

@@ -1,23 +0,0 @@
-appraise "3.0" do
-  gem "rails", "~> 3.0.12"
-end
-
-appraise "3.1" do
-  gem "rails", "~> 3.1.4"
-  gem "i18n", "~> 0.6.0"
-  gem "rack-cache", "~> 1.2.0"
-end
-
-appraise "3.2" do
-  gem "rails", "~> 3.2.2"
-  gem "i18n", "~> 0.6.0"
-  gem "rack-cache", "~> 1.2.0"
-end
-
-appraise "4.0" do
-  gem "rails", "~> 4.0.0"
-end
-
-appraise "5.0" do
-  gem "rails", "~> 5.0.0"
-end

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/Gemfile.lock

@@ -1,64 +0,0 @@
-PATH
-  remote: .
-  specs:
-    has_draft (1.4.0)
-      activerecord (>= 3.0.0)
-      activesupport (>= 3.0.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activemodel (4.0.3)
-      activesupport (= 4.0.3)
-      builder (~> 3.1.0)
-    activerecord (4.0.3)
-      activemodel (= 4.0.3)
-      activerecord-deprecated_finders (~> 1.0.2)
-      activesupport (= 4.0.3)
-      arel (~> 4.0.0)
-    activerecord-deprecated_finders (1.0.4)
-    activesupport (4.0.3)
-      i18n (~> 0.6, >= 0.6.4)
-      minitest (~> 4.2)
-      multi_json (~> 1.3)
-      thread_safe (~> 0.1)
-      tzinfo (~> 0.3.37)
-    appraisal (0.4.1)
-      bundler
-      rake
-    arel (4.0.2)
-    builder (3.1.4)
-    diff-lcs (1.2.4)
-    factory_girl (1.3.3)
-    faker (0.9.5)
-      i18n (~> 0.4)
-    i18n (0.6.5)
-    minitest (4.7.5)
-    multi_json (1.13.1)
-    rake (10.1.0)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.5)
-    rspec-expectations (2.14.3)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.3)
-    sqlite3 (1.3.13)
-    thread_safe (0.3.6)
-    tzinfo (0.3.54)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  appraisal (~> 0.4.0)
-  factory_girl (~> 1.3.1)
-  faker (~> 0.9.1)
-  has_draft!
-  rake (~> 10.1.0)
-  rspec (~> 2.0)
-  sqlite3 (~> 1.3.4)
-
-BUNDLED WITH
-   1.17.1

data/README.rdoc

@@ -1,227 +0,0 @@
-{<img src="https://secure.travis-ci.org/rubiety/has_draft.svg?branch=master" alt="Build Status" />}[http://travis-ci.org/rubiety/has_draft]
-{<img src="https://gemnasium.com/rubiety/has_draft.svg" alt="Dependency Status" />}[https://gemnasium.com/rubiety/has_draft]
-{<img src="https://codeclimate.com/github/rubiety/has_draft.svg" />}[https://codeclimate.com/github/rubiety/has_draft]
-
-== Has Draft
-
-Allows for multiple "drafts" of a model which can be useful when developing:
-* Draft/Live Version of Pages, for examples
-* A workflow system whereby a live copy may need to be active while a draft copy is 
-  awaiting approval.
-
-This was built to be able to be tacked on to existing models, so the data schema doesn't need to change 
-at all for the model this is applied to.  Drafts are actually stored in a nearly-identical table 
-and there is a has_one relationship to this.  This separation allows the base model to really be treated 
-just as before without having to apply conditions in queries to make sure you are really getting the 
-"live" (non-draft) copy: Page.all will still only return the non-draft pages.  This separate table is backed by 
-a model created on the fly as a constant on the original model class.  For example if a Page has_draft, 
-a Page::Draft class will exist as the model for the page_drafts table.
-
-== Installation
-
-This gem supports ActiveRecord 3, 4, and 5.
-
-In your Gemfile:
-  
-  gem "has_draft"
-
-== Basic Example
-  
-  ## First Migration (If Creating base model and drafts at the same time):
-  class InitialSchema < ActiveRecord::Migration
-  
-    [:articles, :article_drafts].each do |table_name|
-      create_table table_name, :force => true do |t|
-        t.references :article if table_name == :article_drafts
-      
-        t.string :title
-        t.text :summary
-        t.text :body
-        t.date :post_date
-      end
-    end
-    
-  end
-  
-  
-  ## Model Class
-  class Article < ActiveRecord::Base
-    has_draft
-  end
-  
-  ## Exposed Class Methods & Scopes:
-  Article.draft_class
-  => Article::Draft
-  Article.with_draft.all
-  => (Articles that have an associated draft)
-  Article.without_draft.all
-  => (Articles with no associated draft)
-  
-  
-  
-  ## Usage Examples:
-  
-  article = Article.create(
-    :title => "My Title", 
-    :summary => "Information here.",
-    :body => "Full body",
-    :post_date => Date.today
-  )
-  
-  article.has_draft?
-  => false
-  
-  article.instantiate_draft!
-  
-  article.has_draft?
-  => true
-  
-  article.draft
-  => Article::Draft Instance
-  
-  article.draft.update_attributes(
-    :title => "New Title"
-  )
-  
-  article.replace_with_draft!
-  
-  article.title
-  => "New Title"
-  
-  article.destroy_draft!
-  
-  article.has_draft?
-  => false
-  
-== Custom Options
-  
-  ## First Migration (If Creating base model and drafts at the same time):
-  class InitialSchema < ActiveRecord::Migration
-  
-    [:articles, :article_copies].each do |table_name|
-      create_table table_name, :force => true do |t|
-        t.integer :news_article_id if table_name == :article_copies
-      
-        t.string :title
-        t.text :summary
-        t.text :body
-        t.date :post_date
-      end
-    end
-    
-  end
-  
-  ## Model Class
-  class Article < ActiveRecord::Base
-    has_draft :class_name => 'Copy', :foreign_key => :news_article_id, :table_name => 'article_copies'
-  end
-  
-  ## Single Table Inheritance Example
-  class InitialSchema < ActiveRecord::Migration
-  
-    [:elements, :element_drafts].each do |table_name|
-      create_table table_name, :force => true do |t|
-        t.integer :element_id if table_name == :element_drafts
-      
-        t.string :title
-        t.text :content
-        t.string :type
-      end
-    end
-    
-  end
-  
-  class Element < ActiveRecord::Base
-    class Draft < ActiveRecord::Base
-      def element_icon_path
-        'assets/images/default.png'
-      end
-    end
-    
-    module HasDraftCallbacks
-      def before_instantiate_draft
-        # Need to append ::Draft so that it knows to use the Draft class
-        self.draft.type = self.type + '::Draft'
-      end
-  		
-      def before_replace_with_draft
-        # We are storing drafts with the ::Draft on the end so we have to strip it
-        self.type = self.draft.type.split(':')[0]
-      end
-    end
-  end
-  
-  class BlueElement < Element
-    has_draft :belongs_to => :element, :extends => Element::Draft do
-      def element_icon_path
-        'assets/images/blue.png'
-      end
-    end
-    
-    include Element::HasDraftCallbacks
-  end
-  
-  class UnknownElement < Element
-    has_draft :belongs_to => :element, :extends => Element::Draft
-    
-    include Element::HasDraftCallbacks
-  end
-  
-  This allows us to call element_draft.element on any subclass of Element::Draft
-  instead of needing to know to call element_draft.blue_element or element_draft.unknown_element.
-  
-  Note: calling has_draft will have no effect if the parent class has already executed has_draft. 
-    
-  
-
-== Method Callbacks
-
-There are three callbacks you can specify directly as methods:
-
-  class Article < ActiveRecord::Base
-    has_draft
-    
-    def before_instantiate_draft
-      # Do Something
-    end
-    
-    def before_replace_with_draft
-      # Do Something
-    end
-    
-    def before_destroy_draft
-      # Do Something
-    end
-  end
-
-
-
-== Extending the Draft Class
-
-Because you don't directly define the draft class, you can specify a block of code to be run in its
-context by passing a block to has_draft:
-  
-  class Article < ActiveRecord::Base
-    belongs_to :user
-    
-    has_draft do
-      belongs_to :last_updated_user
-      
-      def approve!
-        self.approved_at = Time.now
-        self.save
-      end
-    end
-    
-  end
-
-== Running Tests
-
-This gem uses appraisal to test with different versions of the dependencies. See Appraisal first for which versions are tested.
-
-  # Just the gems locked in Gemfile.lock
-  $ bundle exec rake test
-
-  # All of the Appraisals:
-  $ bundle exec rake all
-

data/Rakefile

@@ -1,30 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'rake'
-require 'rspec/core/rake_task'
-require 'appraisal'
-
-Bundler::GemHelper.install_tasks
-
-desc 'Default: run unit tests.'
-task :default => [:clean, :all]
-
-desc "Run Specs against all Appraisals"
-task :all => :spec do
-  Rake::Task["appraisal:install"].execute
-  system("bundle exec rake -s appraisal spec")
-end
-
-desc "Run Specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-end
-
-task :test => :spec
-
-desc "Clean up files."
-task :clean do |t|
-  FileUtils.rm_rf "tmp"
-  Dir.glob("spec/db/*.sqlite3").each {|f| FileUtils.rm f }
-  Dir.glob("has_draft-*.gem").each {|f| FileUtils.rm f }
-end

data/init.rb

@@ -1,3 +0,0 @@
-require "has_draft"
-
-HasDraft::Railtie.insert

data/lib/has_draft/railtie.rb

@@ -1,19 +0,0 @@
-module HasDraft
-  if defined?(Rails::Railtie)
-    require "rails"
-    
-    class Railtie < Rails::Railtie
-      initializer "has_draft.extend_active_record" do
-        ActiveSupport.on_load(:active_record) do
-          HasDraft::Railtie.insert
-        end
-      end
-    end
-  end
-  
-  class Railtie
-    def self.insert
-      ActiveRecord::Base.send(:include, HasDraft)
-    end
-  end
-end

data/spec/db/database.yml

@@ -1,21 +0,0 @@
-sqlite:
-  adapter: sqlite
-  database: spec/db/test.sqlite
-
-sqlite3:
-  adapter: sqlite3
-  database: spec/db/test.sqlite3
-
-postgresql:
-  adapter: postgresql
-  username: postgres
-  password: postgres
-  database: has_draft_plugin_test
-  min_messages: ERROR
-
-mysql:
-  adapter: mysql
-  host: localhost
-  username: root
-  password:
-  database: has_draft_plugin_test

data/spec/db/schema.rb

@@ -1,32 +0,0 @@
-ActiveRecord::Schema.define(:version => 0) do
-  
-  [:articles, :article_drafts].each do |table_name|
-    create_table table_name, :force => true do |t|
-      t.references :article if table_name == :article_drafts
-      
-      t.string :title
-      t.text :summary
-      t.text :body
-      t.date :post_date
-    end
-  end
-
-  [:posts, :post_drafts].each do |table_name|
-    create_table table_name, :force => true do |t|
-      t.references :post if table_name == :post_drafts
-
-      t.string :title
-      t.text :body
-    end
-  end
-
-  [:pages, :page_drafts].each do |table_name|
-    create_table table_name, :force => true do |t|
-      t.references :page if table_name == :page_drafts
-
-      t.string :title
-      t.text :body
-    end
-  end
-  
-end

data/spec/factories/article.rb

@@ -1,20 +0,0 @@
-require "factory_girl"
-
-Factory.define(:article) do |f|
-  f.title { Faker::Lorem.sentence }
-  f.summary { Faker::Lorem.paragraphs.first }
-  f.body { Faker::Lorem.paragraphs.join("\n\n") }
-  f.post_date { 1.day.ago.to_date }
-end
-
-Factory.define(:article_draft, :class => Article::Draft) do |f|
-  f.association(:article)
-  f.title { Faker::Lorem.sentence }
-  f.summary { Faker::Lorem.paragraphs.first }
-  f.body { Faker::Lorem.paragraphs.join("\n\n") }
-  f.post_date { 1.day.ago.to_date }
-end
-
-Factory.define(:article_with_draft, :parent => :article) do |f|
-  f.association(:draft, :factory => :article_draft)
-end

data/spec/has_draft_spec.rb

@@ -1,111 +0,0 @@
-require "spec_helper"
-
-describe HasDraft do
-  before(:all) do
-    ActiveSupport::Deprecation.silenced = true
-  end
-
-  context "Model with has_draft" do
-    it "should expose #draft_class_name as Draft" do
-      Article.draft_class_name.should == "Draft"
-    end
-    
-    it "should expose #draft_class as Article::Draft" do
-      Article.draft_class.should == Article::Draft
-    end
-    
-    it "should default #draft_foreign_key as article_id" do
-      Article.draft_foreign_key.should == "article_id"
-    end
-    
-    it "should default #draft_table_name as article_drafts" do
-      Article.draft_table_name.should == "article_drafts"
-    end
-    
-    describe "Draft Model" do
-      it "should be defined under the Article namespace" do
-        Article.constants.map(&:to_s).should include('Draft')
-      end
-      
-      it "should expose #original_class as Article" do
-        Article::Draft.original_class.should == Article
-      end
-    end
-  end
-  
-  context "an article" do
-    before { @article = Factory.create(:article) }
-    
-    context "when instantiating a new draft" do
-      before { @article.instantiate_draft! }
-      
-      it "should create draft" do
-        @article.draft.should_not be_nil
-        @article.draft.should_not be_new_record
-      end
-      
-      it "should copy draft fields" do
-        Article.draft_columns.each do |column|
-          @article.send(column).should == @article.draft.send(column)
-        end
-      end
-
-      it "should set the associations as inverses of each other" do
-        @article.draft.article.should be @article
-        article_draft = Article::Draft.find(@article.draft.id)
-        article_draft.article.draft.should be article_draft
-      end
-    end
-    
-    context "when destroying an existing draft" do
-      before do
-        @article = Factory.create(:article_with_draft)
-        @article.destroy_draft!
-      end
-      
-      it "should associated draft" do
-        @article.draft.should be_nil
-      end
-    end
-    
-    context "when replacing with draft" do
-      before do
-        @article = Factory.create(:article_with_draft)
-        @article.replace_with_draft!
-      end
-      
-      it "should still have draft" do
-        @article.draft.should_not be_nil
-      end
-      
-      it "should now have the same field values as draft" do
-        Article.draft_columns.each do |column|
-          @article.send(column).should == @article.draft.send(column)
-        end
-      end
-    end
-  end
-
-  context "Draft class extends" do
-
-    it "ActiveRecord::Base when no options are passed" do
-      Article::Draft.superclass.should == ActiveRecord::Base
-    end
-
-    it "the class passed in with the :extends option" do
-      BlogPost::Draft.superclass.should == Post
-    end
-  end
-
-  context "Draft class belongs to" do
-
-    it "self when :belongs_to is not specified" do
-      Article::Draft.reflect_on_association(:article).macro.should == :belongs_to
-    end
-
-    it "the model passed in with the :belongs_to option" do
-      BlogPost::Draft.reflect_on_association(:post).macro.should == :belongs_to
-    end
-  end
-  
-end

data/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-require "rubygems"
-require "rspec"
-require "factory_girl"
-require "faker"
-require "active_record"
-require "active_support"
-
-# Establish DB Connection
-config = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'db', 'database.yml')))
-ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] || 'sqlite3']}
-ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-
-# Load Test Schema into the Database
-load(File.dirname(__FILE__) + "/db/schema.rb")
-
-require File.dirname(__FILE__) + '/../init'
-
-# Example has_draft Model:
-class Article < ActiveRecord::Base
-  has_draft
-end
-
-# Empty class to test ability of Draft class to extend other classes
-class Post < ActiveRecord::Base
-
-end
-
-# Model for testing ability to have the draft extend a different class
-class BlogPost < Post
-  has_draft :extends => Post, :belongs_to => :post
-end
-
-# Load Factories:
-Dir[File.join(File.dirname(__FILE__), "factories/**/*.rb")].each {|f| require f}