tush 0.2.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.ruby-gemset

@@ -0,0 +1 @@
+tush

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p327

data/Gemfile

@@ -0,0 +1,24 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem "activerecord"
+gem "activesupport"
+gem "shoulda", ">= 0"
+gem "rdoc", "~> 3.12"
+gem "bundler"
+gem "ruby_deep_clone"
+gem "sneaky-save", :git => "git@github.com:partyearth/sneaky-save.git"
+
+group :development, :test do
+  gem 'simplecov'
+  gem "awesome_print"
+  gem "pry"
+  gem "pry-nav"
+  gem "rspec"
+  gem "sqlite3"
+  gem "jeweler", "~> 1.8.4"
+end

data/Gemfile.lock

@@ -0,0 +1,86 @@
+GIT
+  remote: git@github.com:partyearth/sneaky-save.git
+  revision: b000d4f941fc220ea9f4686b99753712b103c853
+  specs:
+    sneaky-save (0.0.4)
+      activerecord (>= 3.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+    activerecord (3.2.13)
+      activemodel (= 3.2.13)
+      activesupport (= 3.2.13)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    awesome_print (1.1.0)
+    builder (3.0.4)
+    coderay (1.0.9)
+    diff-lcs (1.2.4)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    method_source (0.8.1)
+    multi_json (1.7.3)
+    pry (0.9.12.1)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-nav (0.2.3)
+      pry (~> 0.9.10)
+    rake (10.0.4)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    ruby_deep_clone (0.3.0)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.1)
+    shoulda-matchers (2.1.0)
+      activesupport (>= 3.0.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.4)
+    sqlite3 (1.3.7)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  activesupport
+  awesome_print
+  bundler
+  jeweler (~> 1.8.4)
+  pry
+  pry-nav
+  rdoc (~> 3.12)
+  rspec
+  ruby_deep_clone
+  shoulda
+  simplecov
+  sneaky-save!
+  sqlite3

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 David Huie
+
+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.md

@@ -0,0 +1,60 @@
+# Tush
+
+Tush is a gem for migrating database rows between applications with ActiveRecord,
+while preserving *all associations.*
+
+## Installing Tush
+
+If you're using Rails, just add the following to your Gemfile:
+```
+gem 'tush'
+```
+
+## Tush Exports
+
+Data is fed to the importer by first creating a JSON export of your
+rows. This is done by feeding your ActiveRecord model instances to the
+exporter:
+```ruby
+model_instance1 = ActiveRecordModel.create
+json_export = Tush::Exporter.new([model_instance1]).export_json
+```
+This will immediately scan each input model instance and recursively
+add any associated models to the export. If `model_instance1` has an
+association with `model_instance2` and `model_instance2` has an
+association with `model_instance3`, *all 3* model instances will be
+included in the export.
+
+## Tush Imports
+
+Using a JSON export created with `Tush::Exporter`, we can initialize
+an import, usually in a different application that shares the same
+ActiveRecord models,like this:
+```ruby
+importer = Tush::Importer.new_from_json(json_export)
+```
+When we want to create the new models, and therefore importing all
+exported rows from our other application, we run
+```ruby
+importer.create_models!
+```
+And to update all foreign keys to be accurate in the new application,
+run
+```ruby
+importer.update_foreign_keys!
+```
+
+## Contributing to Tush
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Tush has *100% test coverage*; keep it that way.
+
+## Copyright
+
+Copyright (c) 2013 NationBuilder. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "tush"
+  gem.homepage = "http://github.com/3dna/tush"
+  gem.license = "MIT"
+  gem.summary = "Simplified ActiveRecord data migrations between app instances"
+  gem.description = "Simplified ActiveRecord data migrations between app instances"
+  gem.email = "david@nationbuilder.com"
+  gem.authors = ["David Huie", "Lauren Mermel"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tush #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/tush.rb

@@ -0,0 +1,12 @@
+require 'tush/model_store'
+require 'tush/model_wrapper'
+require 'tush/exporter'
+require 'tush/importer'
+
+module Tush
+
+  SUPPORTED_ASSOCIATIONS = [:belongs_to,
+                            :has_one,
+                            :has_many]
+
+end

data/lib/tush/exporter.rb

@@ -0,0 +1,27 @@
+require 'json'
+
+module Tush
+
+  # This class exports a collection of ModelStores as JSON.
+  class Exporter
+
+    attr_accessor :data
+
+    def initialize(model_instances, opts={})
+      blacklisted_models = opts[:blacklisted_models] || []
+      copy_only_models = opts[:copy_only_models] || []
+
+      model_store = ModelStore.new(:blacklisted_models => blacklisted_models,
+                                   :copy_only_models => copy_only_models)
+      model_store.push_array(model_instances)
+
+      self.data = model_store.export
+    end
+
+    def export_json
+      self.data.to_json
+    end
+
+  end
+
+end

data/lib/tush/helpers/association_helpers.rb

@@ -0,0 +1,92 @@
+module Tush
+
+  class AssociationHelpers
+
+    def self.relation_infos(relation_type, klass)
+      if klass.is_a?(String)
+        klass = klass.constantize
+      end
+
+      klass.reflect_on_all_associations(relation_type)
+    end
+
+    def self.model_relation_info(model)
+      relation_infos = {}
+
+      SUPPORTED_ASSOCIATIONS.each do |association_type|
+        relation_infos[association_type] = self.relation_infos(association_type, model)
+      end
+
+      relation_infos
+    end
+
+    def self.model_to_relation_infos(models)
+      models = models.uniq
+      model_to_relation_infos_hash = {}
+
+      models.each do |model|
+        model_to_relation_infos_hash[model] = self.model_relation_info(model)
+      end
+
+      model_to_relation_infos_hash
+    end
+
+    # Determine the class the foreign key points to
+    def self.class_for_foreign_key(association_info)
+      if association_info.macro == :belongs_to
+        association_info.class_name.constantize
+      else
+        association_info.active_record
+      end
+    end
+
+    # Determine the class that actually has the foreign key.
+    def self.class_with_foreign_key(association_info)
+      if association_info.macro == :belongs_to
+        association_info.active_record
+      else
+        # has_one and has_many keys are stored in a model that's
+        # different than the one they're declared in.
+        association_info.class_name.constantize
+      end
+    end
+
+    # This method locates all foreign key columns for a a list of model classes
+    # for foreign keys declared within the list of models classes.
+    def self.create_foreign_key_mapping(model_classes)
+      model_to_foreign_keys = {}
+      model_classes.each do |model_class|
+        model_to_foreign_keys[model_class] = []
+      end
+
+      model_to_relation_infos(model_classes).each do |model, relation_infos|
+        SUPPORTED_ASSOCIATIONS.each do |association_type|
+
+          associations = relation_infos[association_type]
+
+          associations.each do |association|
+            klass = self.class_with_foreign_key(association)
+
+            # An association with a class that wasn't
+            # included in our list of model_classes might be found.
+            unless model_to_foreign_keys.keys.include?(klass)
+              model_to_foreign_keys[klass] = []
+            end
+
+            association_hash = { :foreign_key => association.foreign_key,
+                                 :class => self.class_for_foreign_key(association) }
+
+            unless model_to_foreign_keys[klass].include?(association_hash)
+              model_to_foreign_keys[klass] << association_hash
+            end
+          end
+        end
+
+      end
+
+      model_to_foreign_keys
+    end
+
+  end
+
+end

data/lib/tush/importer.rb

@@ -0,0 +1,91 @@
+require 'tush/model_store'
+require 'json'
+
+module Tush
+
+  # This class takes in a tush export and imports it into ActiveRecord.
+  class Importer
+
+    class NonUniqueWrapperError < RuntimeError; end
+    class InvalidWrapperError < RuntimeError; end
+
+    attr_accessor(:data,
+                  :imported_model_wrappers,
+                  :model_to_attribute_blacklist)
+
+    def initialize(exported_data)
+      self.data = exported_data
+      self.imported_model_wrappers = []
+      self.model_to_attribute_blacklist = {}
+    end
+
+    def self.new_from_json_file(json_path)
+      unparsed_json = File.read(json_path)
+      self.new(JSON.parse(unparsed_json))
+    end
+
+    def self.new_from_json(unparsed_json)
+      self.new(JSON.parse(unparsed_json))
+    end
+
+    def create_models!
+      model_wrappers = self.data["model_wrappers"]
+
+      model_wrappers.each do |model_wrapper|
+        model_class = model_wrapper["model_class"].constantize
+        imported_model_wrapper =
+          ModelWrapper.new(:model_class => model_class.to_s,
+                           :model_attributes => model_wrapper["model_attributes"],
+                           :blacklisted_attributes => self.model_to_attribute_blacklist[model_class])
+
+        imported_model_wrapper.create_copy
+
+        self.imported_model_wrappers << imported_model_wrapper
+      end
+    end
+
+    def find_wrapper_by_class_and_old_id(klass, old_id)
+      wrappers = self.imported_model_wrappers.select do |wrapper|
+        (wrapper.model_class == klass) and (wrapper.original_db_id == old_id)
+      end
+
+      wrappers[0]
+    end
+
+    # This method updates stale foreign keys after the new models have been created.
+    def update_foreign_keys!
+      models = self.imported_model_wrappers.map { |wrapper| wrapper.model_class }
+      model_to_foreign_keys = AssociationHelpers.create_foreign_key_mapping(models)
+
+      imported_model_wrappers.each do |wrapper|
+        foreign_keys = model_to_foreign_keys[wrapper.model_class]
+
+        foreign_keys.each do |foreign_key_info|
+          match = self.find_wrapper_by_class_and_old_id(foreign_key_info[:class],
+                                                        wrapper.model_attributes[foreign_key_info[:foreign_key]])
+
+          if match
+            new_id = match.new_model.send(match.original_db_key)
+          else
+            # If we don't have a model wrapper (like in the case of a copy only model),
+            # remove the id
+            new_id = nil
+          end
+
+          ActiveRecord::Base.transaction(:requires_new => true) do
+            begin
+              wrapper.new_model.update_column(foreign_key_info[:foreign_key],
+                                              new_id)
+            # If the column has a not null restraint, keep the original value
+            rescue ActiveRecord::StatementInvalid
+              raise ActiveRecord::Rollback
+            end
+
+            wrapper.new_model_attributes[foreign_key_info[:foreign_key]] = new_id
+          end
+        end
+      end
+    end
+  end
+
+end