activerecord-duplicate 0.4.0

data/.travis.yml

@@ -0,0 +1,21 @@
+language: ruby
+
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+
+gemfile:
+  - Gemfile
+  - gemfiles/Rails_3_1.gemfile
+  - gemfiles/Rails_3_2.gemfile
+  - gemfiles/Rails_master.gemfile
+
+branches:
+  only:
+    - master
+
+matrix:
+  exclude:
+    - rvm: 1.9.2
+      gemfile: gemfiles/Rails_master.gemfile

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,83 @@
+## active_record-duplicate [![Build Status](https://secure.travis-ci.org/haihappen/active_record-duplicate.png)](http://travis-ci.org/haihappen/active_record-duplicate)
+
+Duplicating ActiveRecords is easy again. All you have to do:
+
+```ruby
+class Post < ActiveRecord::Base
+  attr_duplicatable :title, :content
+end
+
+post.duplicate
+```
+
+You want more controll? Check out this example:
+
+```ruby
+class Post < ActiveRecord::Base
+  # Don't duplicate if callback (on original object) returns false!
+  before_duplication(on: :original) { self.is_copyrighted? }
+  after_duplication(on: :original) { self.inform_author_about_duplicate! }
+  
+  after_duplication(on: :duplicate) { self.credit_author_in_content! }
+  
+  has_many :comments
+  has_many :tags
+  
+  # These attributes will be duplicated.
+  attr_duplicatable :title, :content
+end
+
+class Tag < ActiveRecord::Base
+  attr_duplicatable :tag
+end
+
+class Comment < ActiveRecord::Base
+  self.duplicatable = false
+end
+
+# Duplicates non-copyrighted posts and tags as well, but ignores comments.
+post.duplicate
+```
+
+## Installation
+
+Tested against Ruby versions `1.9.2`, `1.9.3`, `ruby-head` and Rails versions `3.1.x`, `3.2.x`, `master` (upcoming Rails `4.0.0`).
+
+In your `Gemfile`:
+
+```ruby
+gem 'active_record-duplicate'
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Copyright (c) 2012 Mario Uher
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = Dir.glob('spec/**/*_spec.rb')
+end
+
+task(default: :test)

data/activerecord-duplicate.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name          = 'activerecord-duplicate'
+  gem.version       = '0.4.0'
+  gem.authors       = 'Mario Uher'
+  gem.email         = 'uher.mario@gmail.com'
+  gem.description   = gem.summary = 'Duplicating ActiveRecords is easy again.'
+  gem.homepage      = 'https://github.com/haihappen/activerecord-duplicate'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.require_path  = 'lib'
+
+  gem.add_dependency 'activerecord', '>= 3.1'
+
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'purdytest'
+  gem.add_development_dependency 'rails', '>= 3.1'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'sqlite3'
+end

data/gemfiles/Rails_3_1.gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gemspec path: '../'
+
+gem 'rails', '~> 3.1.0'

data/gemfiles/Rails_3_2.gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gemspec path: '../'
+
+gem 'rails', '~> 3.2.0'

data/gemfiles/Rails_master.gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'activerecord', git: 'git://github.com/rails/rails.git'
+
+group :development do
+  gem 'minitest'
+  gem 'purdytest'
+  gem 'rails', git: 'git://github.com/rails/rails.git'
+  gem 'sqlite3'
+end

data/lib/active_record-duplicate.rb

@@ -0,0 +1,5 @@
+require 'active_record-duplicate/active_record/duplicate'
+require 'active_record-duplicate/railtie' if defined?(Rails)
+
+module ActiveRecord::Duplicate
+end

data/lib/active_record-duplicate/active_record/duplicate.rb

@@ -0,0 +1,81 @@
+require 'active_record-duplicate/active_record/duplicate/callbacks'
+
+module ActiveRecord
+  module Duplicate
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_duplicatable_attributes
+      class_attribute :_duplicatable
+      
+      attr_accessor :duplication_parent
+      
+      include ActiveRecord::Duplicate::Callbacks
+    end
+
+    def duplicate
+      return unless self.class.duplicatable
+      
+      dup.tap do |duplicate|
+        attributes.each do |key, value|
+          value = case true
+          
+          # Duplicate attribute if whitelisted
+          when self.class.attr_duplicatable.include?(key.to_sym)
+            value
+          
+          # If not whitelisted, set to default value
+          when (column = self.class.columns.detect { |c| c.name == key }).present?
+            column.default
+          
+          else
+            nil
+          end
+          
+          duplicate.send(:"#{key}=", value)
+        end
+        
+        # Duplicate all belongs_to associations.
+         self.class.reflect_on_all_associations(:belongs_to).each do |association|
+           association = self.association(association.name)
+           
+           if duplication_parent.is_a?(association.klass)
+             duplicate.send(:"#{association.reflection.name}=", duplication_parent)
+             duplicate.send(:"#{association.reflection.name}_id=", nil)
+           else
+             duplicate.send(:"#{association.reflection.name}=", send(association.reflection.name))
+           end
+         end
+        
+        # Duplicate all has_many associations.
+        self.class.reflect_on_all_associations(:has_many).each do |association|
+          association = self.association(association.name)
+          
+          duplicate.send(:"#{association.reflection.name}=", send(association.reflection.name).map do |object|
+            object.duplication_parent = duplicate
+            object = object.duplicate
+            next unless object.present?
+            
+            object
+          end.compact)
+        end
+      end
+    end
+
+    module ClassMethods
+      def attr_duplicatable(*attributes)
+        self._duplicatable_attributes = attributes.map(&:to_sym) if attributes.present?
+        self._duplicatable_attributes || []
+      end
+
+      def duplicatable=(duplicatable)
+        self._duplicatable = duplicatable unless duplicatable.nil?
+        self.duplicatable
+      end
+
+      def duplicatable
+        self._duplicatable.nil? ? true : !!self._duplicatable
+      end
+    end
+  end
+end

data/lib/active_record-duplicate/active_record/duplicate/callbacks.rb

@@ -0,0 +1,49 @@
+module ActiveRecord
+  module Duplicate
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        define_callbacks :duplication, terminator: "result == false", scope: [:kind, :name]
+        attr_accessor :duplication_context
+      end
+
+      def dup
+        super.tap do |duplicate|
+          duplicate.duplication_context = :duplicate
+          duplicate.run_callbacks(:duplication)
+        end
+      end
+
+      def duplicate
+        self.duplication_context = :original
+        self.run_callbacks(:duplication) { super }
+      end
+
+      module ClassMethods
+        # Duplicated from activemodel/lib/active_model/validations/callbacks.rb
+        def before_duplication(*args, &block)
+          options = args.last
+          
+          if options.is_a?(Hash) && options[:on]
+            options[:if] = Array.wrap(options[:if])
+            options[:if].unshift("self.duplication_context == :#{options[:on]}")
+          end
+          
+          set_callback(:duplication, :before, *args, &block)
+        end
+
+        def after_duplication(*args, &block)
+          options = args.extract_options!
+          
+          options[:prepend] = true
+          options[:if] = Array.wrap(options[:if])
+          options[:if] << "!halted"
+          options[:if].unshift("self.duplication_context == :#{options[:on]}") if options[:on]
+          
+          set_callback(:duplication, :after, *(args << options), &block)
+        end
+      end
+    end
+  end
+end

data/lib/active_record-duplicate/railtie.rb

@@ -0,0 +1,21 @@
+module ActiveRecord::Duplicate
+  if defined?(Rails::Railtie)
+    require 'rails'
+
+    class Railtie < Rails::Railtie
+      initializer 'active_record-duplicate.insert_into_active_record' do
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::Duplicate::Railtie.insert
+        end
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send(:include, ActiveRecord::Duplicate)
+      end
+    end
+  end
+end

data/spec/acts_as_duplicator_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ActiveRecord::Duplicate do
+  let(:klass) { Class.new(ActiveRecord::Base) { self.table_name = 'records' } }
+
+
+  describe :attr_duplicatable do
+    it 'allows you to whitelist attributes' do
+      klass.attr_duplicatable(:created_at, :updated_at)
+    end
+
+
+    it 'returns whitelisted attributes if called without arguments' do
+      klass.attr_duplicatable(:created_at, :updated_at)
+      
+      klass.attr_duplicatable.must_equal([:created_at, :updated_at])
+    end
+  end
+
+
+  describe :duplicatable do
+    it 'marks associations as non-duplicatable' do
+      klass.duplicatable = false
+      
+      klass.duplicatable.must_equal(false)
+    end
+  end
+
+
+  describe :duplicate do
+    it 'duplicates records' do
+      record = klass.create
+      duplicate = record.duplicate
+      
+      duplicate.must_be_instance_of(klass)
+      duplicate.wont_equal(record)
+    end
+  end
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ActiveRecord::Duplicate::Callbacks do
+  let(:klass) { Class.new(ActiveRecord::Base) { self.table_name = 'records' } }
+
+
+  it 'runs callbacks' do
+    mock = MiniTest::Mock.new
+    
+    klass.instance_eval do
+      before_duplication { mock.before_duplication(duplication_context) }
+      after_duplication { mock.after_duplication(duplication_context) }
+    end
+    
+    mock.expect(:before_duplication, nil, [:original])
+    mock.expect(:after_duplication, nil, [:original])
+    mock.expect(:before_duplication, nil, [:duplicate])
+    mock.expect(:after_duplication, nil, [:duplicate])
+        
+    klass.create.duplicate
+    mock.verify
+  end
+
+
+  it 'runs callbacks on the original object' do
+    mock = MiniTest::Mock.new
+    
+    klass.instance_eval do
+      before_duplication(on: :original) { mock.before_duplication(duplication_context) }
+      after_duplication(on: :original) { mock.after_duplication(duplication_context) }
+    end
+    
+    mock.expect(:before_duplication, nil, [:original])
+    mock.expect(:after_duplication, nil, [:original])
+    
+    klass.create.duplicate
+    mock.verify
+  end
+
+
+  it 'runs callbacks on the duplicated object' do
+    mock = MiniTest::Mock.new
+    
+    klass.instance_eval do
+      before_duplication(on: :duplicate) { mock.before_duplication(duplication_context) }
+      after_duplication(on: :duplicate) { mock.after_duplication(duplication_context) }
+    end
+    
+    mock.expect(:before_duplication, nil, [:duplicate])
+    mock.expect(:after_duplication, nil, [:duplicate])
+    
+    klass.create.duplicate
+    mock.verify
+  end
+
+
+  it 'wont duplicate records if callbacks return false' do
+    klass.instance_eval do
+      before_duplication(on: :original) { false }
+    end
+    
+    klass.create.duplicate.must_equal(false)
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe 'Integration' do
+  before do
+    ActiveRecord::Schema.define do
+      create_table :blogs
+      
+      create_table :posts do |t|
+        t.belongs_to :blog
+        t.string     :title
+        t.text       :content
+        t.boolean    :is_copyrighted
+        t.timestamp  :published_at
+      end
+      
+      create_table :comments do |t|
+        t.belongs_to :post
+        t.text       :content
+      end
+      
+      create_table :ratings do |t|
+        t.belongs_to :parent
+        t.string     :parent_type
+        t.integer    :value
+      end
+    end
+    
+    class Blog < ActiveRecord::Base
+      has_many :posts, inverse_of: :blog
+    end
+    
+    class Post < ActiveRecord::Base
+      # Don't duplicate copyrighted posts
+      before_duplication { !self.is_copyrighted? }
+      after_duplication(:increase_counter, on: :duplicate)
+      
+      belongs_to :blog
+      has_many :comments
+      has_many :ratings, as: :parent
+      
+      attr_duplicatable :content
+      class_attribute :counter
+      
+      validates :title, presence: true, uniqueness: true
+      
+    private
+      def increase_counter
+        self.class.counter ||= 0
+        self.class.counter += 1
+        self.title = "Lorem #{self.class.counter}" 
+      end
+    end
+    
+    class Comment < ActiveRecord::Base
+      self.duplicatable = false
+      
+      belongs_to :post
+      has_many :ratings, as: :parent
+    end
+    
+    class Rating < ActiveRecord::Base
+      belongs_to :parent, polymorphic: true
+    end
+  end
+
+
+  let(:blog) { Blog.create }
+
+
+  describe 'duplicating blog' do
+    subject { blog.duplicate }
+
+
+    it 'returns duplicate' do
+      subject.must_be_instance_of(Blog)
+      subject.new_record?.must_equal(true)
+    end
+
+
+    it 'duplicates posts too' do
+      3.times do |i|
+        post = blog.posts.create(title: "Post #{i}")
+        rating = post.ratings.create(value: 5)
+      end
+      
+      subject.posts.all?(&:new_record?).must_equal(true)
+      subject.posts.size.must_equal(3)
+      
+      subject.save
+      
+      Blog.count.must_equal(2)
+      Post.count.must_equal(6)
+      Rating.count.must_equal(6)
+    end
+
+
+    it 'sets blog association' do
+      3.times do |i|
+        post = blog.posts.create(title: "Post #{i}")
+        rating = post.ratings.create(value: 5)
+      end
+      
+      subject.posts.each do |post|
+        post.blog.must_equal(subject)
+        post.blog_id.must_be_nil
+      end
+    end
+
+
+    it 'ignores copyrighted posts' do
+      3.times do |i|
+        post = blog.posts.create(title: "Post #{i}", is_copyrighted: i == 0)
+        rating = post.ratings.create(value: 5)
+      end
+      
+      subject.posts.all?(&:new_record?).must_equal(true)
+      subject.posts.size.must_equal(2)
+      
+      subject.save
+      
+      Blog.count.must_equal(2)
+      Post.count.must_equal(5)
+      Rating.count.must_equal(5)
+    end
+
+
+    it 'ignores posts copyright flag' do
+      post = blog.posts.create(title: 'Post', content: 'Lorem', published_at: Time.now)
+      rating = post.ratings.create(value: 5)
+      
+      post = subject.posts.first
+      post.wont_be_nil
+      post.content.must_equal('Lorem')
+      post.published_at.must_be_nil
+    end
+
+
+    it 'wont duplicate comments' do
+      post = blog.posts.create(title: 'Post')
+      rating = post.ratings.create(value: 5)
+      3.times { post.comments.create }
+      
+      post = subject.posts.first
+      post.wont_be_nil
+      post.comments.size.must_equal(0)
+      
+      subject.save
+      
+      Blog.count.must_equal(2)
+      Post.count.must_equal(2)
+      Rating.count.must_equal(2)
+      Comment.count.must_equal(3)
+    end
+  end
+
+
+  describe 'duplicating post' do
+    it 'sets blog association' do
+      post = blog.posts.create
+      
+      post = post.duplicate
+      
+      post.blog.must_equal(blog)
+    end
+  end
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ActiveRecord::Duplicate do
+  it 'extends ActiveRecord::Base' do
+    ActiveRecord::Base.must_include(ActiveRecord::Duplicate)
+    ActiveRecord::Base.must_respond_to(:attr_duplicatable)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'purdytest'
+require 'active_record'
+require 'active_record-duplicate'
+require 'active_record-duplicate/railtie'
+
+ActiveRecord::Duplicate::Railtie.insert
+
+class MiniTest::Spec
+  before do
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+    ActiveRecord::Schema.verbose = false
+    
+    # Anonymous record class
+    ActiveRecord::Schema.define do
+      create_table :records
+    end
+  end
+
+  after do
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-duplicate
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Mario Uher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70346238966700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70346238966700
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70346238966300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346238966300
+- !ruby/object:Gem::Dependency
+  name: purdytest
+  requirement: &70346238965840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346238965840
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70346238965340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: *70346238965340
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70346238964920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346238964920
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70346238964460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70346238964460
+description: Duplicating ActiveRecords is easy again.
+email: uher.mario@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- activerecord-duplicate.gemspec
+- gemfiles/Rails_3_1.gemfile
+- gemfiles/Rails_3_2.gemfile
+- gemfiles/Rails_master.gemfile
+- lib/active_record-duplicate.rb
+- lib/active_record-duplicate/active_record/duplicate.rb
+- lib/active_record-duplicate/active_record/duplicate/callbacks.rb
+- lib/active_record-duplicate/railtie.rb
+- spec/acts_as_duplicator_spec.rb
+- spec/callbacks_spec.rb
+- spec/integration_spec.rb
+- spec/railtie_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/haihappen/activerecord-duplicate
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Duplicating ActiveRecords is easy again.
+test_files: []