activerecord_cloneable 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7356c885224c919a9ff09103fa118b69857ddfc
+  data.tar.gz: 9be80f2671b2464ea0202688d62979d755452df9
+SHA512:
+  metadata.gz: fdbf35075828f2cc9be75cddd0c5925109e2bb50a4063e15450728afb956677168cb3e77dafd2cc5e0f2078c44f4165176ecc48eddf16b3fbe0407300f226547
+  data.tar.gz: 8d24200b3d7cdc87dba52bac2371f34ad1c7821683947ac1db68dfec8909e3761f3b7488e6e2fd7a6ba25fb22cfc52e7101e8c7438e6fc5d91ef0c626365c6ee

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [name of plugin creator]
+
+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/README

@@ -0,0 +1,70 @@
+Activerecord-cloneable
+======================
+
+This is a quick tool to help clone active records.
+
+Let's say you have a great rails app, and you want to quickly add clone
+functionality to an object.  Use this.
+
+INSTALL
+=======
+Bundler:
+
+Into your Gemfile put:
+gem 'activerecord_cloneable', :git => "git://github.com/apalmblad/activerecord_cloneable.git",
+    :require => 'active_record/cloneable'
+
+In initialize code, do:
+
+ActiveRecord::Base.send( :include, ActiveRecord::Cloneable )
+
+In each of the models that you want to clone, add in:
+class Record < ActiveRecord::Base
+  cloneable
+end
+
+
+Example
+=======
+
+Basic:
+
+cloned_record = record.clone_record
+
+By default, we'll look at belongs to relations, and clone those to.  Often,
+that's not desirable.  We might want to share some of the parents with our
+clone.
+
+Then, 
+cloned_record = record.clone_record( :shared_parents => [:belongs_to_association_name]
+
+We might want to set up some attributes on our cloned record.
+
+cloned_record = record.clone_record( :attributes => { :name => "Ima Clone" } )
+
+Sometimes there is child data that you might want to ignore.  Lets say logs of
+activity, or other things that are not desired to be attached to the clone.
+
+cloned_record = record.clone_record( :skipped_child_relations => [:logs] )
+
+Gotta go deep? Want to clone something from a parent but not it's children?
+
+cloned_record = record.clone_record( :skipped_child_relations => [{ :child_1 => :logs} ]] )
+
+Finally, everyone knows that clones you cannot tell apart are a plot device for
+a formulaic scifi movie.  Therefore, by default, if a name or title attribute is present,
+it's marked to indicate that the cloned object is a copy.  If you have another
+string field that you want to indicate as such, pass them in:
+
+cloned_record = record.clone_record( :name_fields => [ :name_title] )
+
+
+
+Disclaimer
+==========
+
+This scratches an itch for me.  I don't know if it will scratch an itch for you.
+It might ruin your day -- or worse.  I haven't tested this nearly as well as I
+should.  If you send in problem reports, I'll try and fix them.  No warranties.
+
+Copyright (c) 2011 Adam Palmblad, apalmblad@gmail.com, released under the MIT license

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the activerecord_cloneable plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the activerecord_cloneable plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Activerecord-cloneable'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/activerecord_cloneable.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = 'activerecord_cloneable'
+  s.version = '0.1.3'
+  s.summary = "A library to help clone active records - that is, generate active new record objects with the data copied from an existing record."
+  s.authors = ["Adam Palmblad"]
+  s.email = 'apalmblad@gmail.com'
+  s.date = %q{2013-08-16}
+  s.description = %q{A tool to help with cloning of active record objects.}
+  s.files= ['MIT-LICENSE', 'README', 'Rakefile', 'activerecord_cloneable.gemspec',
+      'test/activerecord_cloneable_test.rb', 'test/test_helper.rb',
+      'lib/active_record/cloneable.rb']
+end

data/lib/active_record/cloneable.rb

@@ -0,0 +1,147 @@
+module ActiveRecord::Cloneable
+  # ------------------------------------------------------------------- included
+  def self.included( base )
+    base.extend( ClassMethods )
+  end
+  module ClassMethods
+    # ---------------------------------------------------------------- cloneable
+    def cloneable
+      # HACK: check that this best way
+      class_eval <<-EOV
+      include ActiveRecord::Cloneable::InstanceMethods
+      EOV
+    end
+  end
+  module InstanceMethods
+    # ------------------------------------------------------ clone_basic_details
+    def clone_basic_details(cloned_record, belongs_to_keys, args )
+      # assign the attributes, minus any assigned or any from a belongs_to relation
+      self.class.content_columns.each do |column|
+        if !args[:attributes].has_key?( column.name.to_sym ) && !belongs_to_keys.include?( column.name.to_sym )
+          m = "#{column.name}=".to_sym
+          if cloned_record.respond_to?( m )
+            cloned_record.send( m, read_attribute( column.name ) )
+          else
+            cloned_record.write_attribute( column.name, read_attribute( column.name ) )
+          end
+        end
+      end
+      args[:attributes].each_pair do |k,v|
+        cloned_record.send( "#{k}=", v )
+      end
+      # Set the name or title field to be the existing value + (copy)
+      ( args[:name_fields] || [:name,:title] ).each do |name_attr|
+        if has_attribute?( name_attr ) && read_attribute( :name_attr )
+          cloned_form.write_attribute( name_attr, read_attribute( name_attr ) + ' (copy)' )
+          break if args[:name_fields].nil?
+        end
+      end
+      #cloned_record.save
+    end
+    # ----------------------------------------------- clone_bleongs_to_relations
+    def clone_belongs_to_relations( relations, cloned_record, args )
+      return if relations.nil?
+      relations.each do |parent_relation|
+        obj = send( parent_relation.name )
+        next if obj.nil?
+        if args[:shared_parent_relations].include?( parent_relation.name.to_sym )
+          cloned_record.send( "#{parent_relation.name}=", obj )
+        elsif !args[:cloned_parents].include?( obj )
+          # We don't know what the parent calls this child.
+          begin
+            rec = obj.clone_record( :skipped_children => args[:skipped_children] + [self],
+                :skipped_child_relations => find_applicable_clone_args( parent_relation.name, args[:skipped_child_relations] ),
+                :skipped_parent_relations => find_applicable_clone_args( parent_relation.name, args[:skipped_parent_relations] ),
+                :shared_parent_relations => find_applicable_clone_args( parent_relation.name, args[:shared_parent_relations] )
+              )
+          rescue NoMethodError => e
+            raise "#{obj.class.name} objects do not know how to clone themselves; they should be marked as cloneable or skipped."
+          end
+          cloned_record.send( "#{parent_relation.name}=", rec )
+        end
+      end
+    end
+    # ----------------------------------------------- find_applicable_clone_args
+    def find_applicable_clone_args( relation_name, args )
+      relation_name = relation_name.to_sym
+      return nil if args.nil?
+      r_val = args.map do |x|
+        if x.is_a?( Hash )
+          x[relation_name]
+        else
+          nil
+        end
+      end
+      r_val.flatten
+    end
+    # ---------------------------------------------------- clone_child_relation?
+    def clone_child_relation?( relation_name, skipped_child_relations )
+      relation_name = relation_name.to_sym
+      skipped_child_relations.each do |relation|
+        unless relation.is_a?( Hash )
+          return false if relation == relation_name
+        end
+      end
+      return true
+    end
+    # ---------------------------------------------------------------------- clone
+    def clone_record( args = {} )
+      args[:shared_parent_relations] ||= []
+      args[:skipped_child_relations] ||= []
+      args[:cloned_parents] ||= []
+      args[:skipped_children] ||= []
+      args[:attributes] ||={}
+      cloned_record = args[:object] || self.class.new
+      data = {}
+      self.class.reflections.each do |k,v|
+        data[v.macro] ||= []
+        data[v.macro] << v
+      end
+      belongs_to_keys = ( data[:belongs_to] || [] ).map{ |x| x.primary_key_name.to_sym }
+
+      clone_belongs_to_relations( data[:belongs_to], cloned_record, args )
+      clone_basic_details( cloned_record, belongs_to_keys, args )
+
+      ((data[:has_many] || []) + (data[:has_and_belongs_to_many]||[])  ).each do |child_relation|
+        next if child_relation.through_reflection
+        next if !clone_child_relation?( child_relation.name, args[:skipped_child_relations] )
+        kids = send( child_relation.name )
+        next if kids.nil?
+        records = kids.find( :all )
+        records.each do |child_record|
+          next if args[:skipped_children].include?( child_record )
+          cloned_child_record = kids.build
+          child_args = { :cloned_parents => args[:cloned_parents] + [self], :attributes => {}, :object => cloned_child_record,
+              :skipped_child_relations => find_applicable_clone_args( child_relation.name, args[:skipped_child_relations] ) }
+          #if child_relation.macro == :has_many ||child_relation.macro  == :has_one
+          #  child_args[:attributes][child_relation.primary_key_name.to_sym] = nil
+          #end
+          begin
+            cloned_child_record = child_record.clone_record( child_args )
+            cloned_record.send( child_relation.name ) << cloned_child_record
+          rescue NoMethodError => e
+            raise "#{child_record.class.name} objects do not know how to clone themselves; they should be marked as cloneable or skipped. (#{self.class.name} / #{child_relation.name}"
+          end
+        end
+      end
+      ( data[:has_one] || []).each do |child_relation|
+        next if child_relation.through_reflection
+        next if !clone_child_relation?( child_relation.name, args[:skipped_child_relations] )
+        kid = send( child_relation.name )
+        next if kid.nil?
+        next if args[:skipped_children].include?( kid )
+        cloned_child_record = kid.build
+        child_args = { :cloned_parents => args[:cloned_parents] + [self],
+            :attributes => {}, :object => cloned_child_record,
+            :skipped_child_relations => args[:skipped_child_relations].find_all{ |x| x.is_a?( Hash ) && x[child_relation.name.to_sym]  }.map{ |x| x.values }.flatten }
+        begin
+          cloned_child_record = kid.clone_record( child_args )
+          cloned_record.send( "#{child_relation.name}=",  cloned_child_record )
+        rescue NoMethodError => e
+          raise "#{kid.class.name} objects do not know how to clone themselves; they should be marked as cloneable or skipped. (#{self.class.name} / #{child_relation.name}"
+        end
+      end
+      return cloned_record
+    end
+  end
+end

data/test/activerecord_cloneable_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class ActiveRecordCloneableTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  class Apple < ActiveRecord::Base
+    cloneable
+    belongs_to :banana
+    validates_presence_of :banana
+    validates_associated :banana
+  end
+  class Banana < ActiveRecord::Base
+    cloneable
+    has_many :apples
+    has_one :bread
+  end
+  class NonCloneableThing < ActiveRecord::Base
+    belongs_to :apple
+  end
+  class Bread < ActiveRecord::Base
+    cloneable
+    belongs_to :banana
+  end
+  test "Basic test" do
+    original = Banana.new
+    original.save
+    a = original.apples.build
+    apple =original.apples.new
+    original.save!
+    original.reload
+    assert( original.apples.any? )
+    clone = original.clone_record
+    clone.save!
+    assert( clone.apples.any? )
+  end
+  def test_with_non_cloneable_things
+    Apple.has_many( :non_cloneable_things )
+    original = Banana.new
+    original.save
+    a = original.apples.create
+    a.non_cloneable_things.create
+    original.save
+    clone = original.clone_record( :skipped_child_relations => [{ :apples => :non_cloneable_things}] )
+    assert( clone.apples.any? )
+  end
+  def test_with_have_one
+    b = Bread.new
+    b.banana = Banana.new
+    b.save!
+    new_bread = b.clone_record( :skipped_parent_relations => [ { :bread => :banana }] )
+    new_bread.save!
+    assert( new_bread.banana )
+    assert_equal( new_bread, new_bread.banana.bread )
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+require 'active_record/cloneable'
+ActiveRecord::Base.send( :include, ActiveRecord::Cloneable )
+ActiveRecord::Base.establish_connection(:adapter  => 'mysql',
+        :database => 'cloneable_test',
+        :username => 'root' )
+class DoSetup < ActiveRecord::Migration
+  def self.up
+    create_table :breads do |t|
+      t.column :banana_id, :integer
+    end
+    drop_table :non_cloneable_things
+    create_table :non_cloneable_things do |t|
+      t.column :apple_id,:integer
+    end
+    create_table :apples do |t|
+      t.column :banana_id, :integer
+    end
+    create_table :bananas do |t|
+    end
+  end
+
+ def self.down
+   drop_table :bananas
+   drop_table :apples
+ end
+end
+begin
+  DoSetup.up
+rescue ActiveRecord::StatementInvalid => e
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: activerecord_cloneable
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Adam Palmblad
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-16 00:00:00.000000000 Z
+dependencies: []
+description: A tool to help with cloning of active record objects.
+email: apalmblad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README
+- Rakefile
+- activerecord_cloneable.gemspec
+- lib/active_record/cloneable.rb
+- test/activerecord_cloneable_test.rb
+- test/test_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A library to help clone active records - that is, generate active new record
+  objects with the data copied from an existing record.
+test_files: []