tush 0.2.1

data/lib/tush/model_store.rb

@@ -0,0 +1,58 @@
+require 'tush/helpers/association_helpers'
+
+module Tush
+
+  # This holds the collection of models that will be exported.
+  class ModelStore
+
+    attr_accessor :model_wrappers, :blacklisted_models, :copy_only_models
+
+    def initialize(opts={})
+      self.blacklisted_models = opts[:blacklisted_models] || []
+      self.copy_only_models = opts[:copy_only_models] || []
+      self.model_wrappers = []
+    end
+
+    def push_array(model_array)
+      model_array.each { |model_instance| self.push(model_instance) }
+    end
+
+    def push(model_instance, parent_wrapper=nil)
+      return if self.object_in_stack?(model_instance)
+      return if self.blacklisted_models.include?(model_instance.class)
+
+      model_wrapper = ModelWrapper.new(:model => model_instance)
+
+      if parent_wrapper and parent_wrapper.model_trace.any?
+        model_wrapper.add_model_trace_list(parent_wrapper.model_trace)
+        model_wrapper.add_model_trace(parent_wrapper)
+      elsif parent_wrapper
+        model_wrapper.add_model_trace(parent_wrapper)
+      end
+
+      model_wrappers.push(model_wrapper)
+
+      return if self.copy_only_models.include?(model_instance.class)
+
+      model_wrapper.association_objects.each do |object|
+        self.push(object, model_wrapper)
+      end
+    end
+
+    def object_in_stack?(model_instance)
+      self.model_wrappers.each do |model_wrapper|
+        next if model_instance.class != model_wrapper.model_class
+        next if model_instance.attributes != model_wrapper.model_attributes
+        return true
+      end
+
+      return false
+    end
+
+    def export
+      { :model_wrappers => self.model_wrappers.map { |model_wrapper| model_wrapper.export } }
+    end
+
+  end
+
+end

data/lib/tush/model_wrapper.rb

@@ -0,0 +1,107 @@
+require 'active_record'
+require 'active_support'
+require 'deep_clone'
+require 'sneaky-save'
+
+module Tush
+
+  # This is a class the wraps each model instance that we
+  # plan on exporting.
+  class ModelWrapper
+
+    attr_accessor(:model_attributes,
+                  :new_model,
+                  :new_model_attributes,
+                  :model,
+                  :model_class,
+                  :model_trace,
+                  :original_db_id)
+
+    def initialize(opts={})
+      model = opts[:model]
+
+      if model.is_a?(ActiveRecord::Base)
+        self.model = model
+        self.model_class = model.class
+        self.model_attributes = model.attributes || {}
+      else
+        self.model_class = opts[:model_class].constantize
+        self.model_attributes = opts[:model_attributes] || {}
+      end
+
+      self.model_trace = []
+    end
+
+    def original_db_key
+      "id"
+    end
+
+    def create_copy
+      # Define the custom_create method on a model to save
+      # new models in a custom manner.
+      if model_class.respond_to?(:custom_create)
+        self.new_model = self.model_class.custom_create(model_attributes)
+        self.new_model_attributes = self.new_model.attributes
+      else
+        create_without_validation_and_callbacks
+      end
+    end
+
+    def create_without_validation_and_callbacks
+      attributes = model_attributes.clone
+      attributes.delete(original_db_key)
+
+      copy = model_class.new(attributes)
+      copy.sneaky_save
+      copy.reload
+
+      self.new_model = copy
+      self.new_model_attributes = copy.attributes
+    end
+
+    def original_db_id
+      model_attributes[self.original_db_key]
+    end
+
+    def add_model_trace_list(list)
+      model_trace.concat(list)
+    end
+
+    def add_model_trace(model_wrapper)
+      model_trace << [model_wrapper.model_class.to_s,
+                      model_wrapper.original_db_id]
+    end
+
+    def association_objects
+      objects = []
+      SUPPORTED_ASSOCIATIONS.each do |association_type|
+        relation_infos =
+          AssociationHelpers.relation_infos(association_type,
+                                            model_class)
+        next if relation_infos.empty?
+
+        relation_infos.each do |info|
+          next unless model.respond_to?(info.name)
+
+          object = model.send(info.name)
+
+          if object.is_a?(Array)
+            objects.concat(object)
+          elsif object
+            objects << object
+          end
+        end
+      end
+
+      objects
+    end
+
+    def export
+      { :model_class => model_class.to_s,
+      	:model_attributes => model_attributes,
+        :model_trace => model_trace }
+    end
+
+  end
+
+end

data/spec/association_helpers_spec.rb

@@ -0,0 +1,81 @@
+require 'active_record'
+require 'helper'
+require 'tush'
+
+describe Tush::AssociationHelpers do
+
+  before :all do
+
+    class Jacob < ActiveRecord::Base
+      belongs_to :jesse
+    end
+
+    class Jesse < ActiveRecord::Base
+      has_one :jim
+    end
+
+    class Jim < ActiveRecord::Base
+      belongs_to :jesse
+      has_many :leah
+    end
+
+    class Leah < ActiveRecord::Base
+      belongs_to :jim
+    end
+
+  end
+
+  describe ".relation_infos" do
+
+    it "returns an info for an association" do
+      infos = Tush::AssociationHelpers.relation_infos(:has_one, Jesse)
+
+      infos.count.should == 1
+      infos.first.name.should == :jim
+    end
+
+    it "works with string classes" do
+      infos = Tush::AssociationHelpers.relation_infos(:belongs_to, "Jacob")
+
+      infos.count.should == 1
+      infos.first.name.should == :jesse
+    end
+
+  end
+
+  describe ".model_relation_info" do
+
+    it "returns a mapping of association to relation info" do
+      info = Tush::AssociationHelpers.model_relation_info(Jim)
+
+      info.keys.should == Tush::SUPPORTED_ASSOCIATIONS
+      info[:has_many].count.should == 1
+      info[:has_many].first.name.should == :leah
+    end
+
+  end
+
+  describe ".create_foreign_key_mapping" do
+
+    it "it finds the appropriate foreign keys for the passed in classes" do
+      mapping = Tush::AssociationHelpers.create_foreign_key_mapping([Jacob, Jesse, Jim, Leah])
+
+      mapping.should == { Jacob => [{ :foreign_key=>"jesse_id", :class=> Jesse }],
+                          Jesse => [],
+                          Jim => [{ :foreign_key=>"jesse_id", :class=> Jesse }],
+                          Leah => [{ :foreign_key=>"jim_id", :class=> Jim }] }
+    end
+
+    it "it returns newly discovered classes in the mapping if an input class has \
+        a has_many or a has_one" do
+      mapping = Tush::AssociationHelpers.create_foreign_key_mapping([Jacob, Jesse])
+
+      mapping.should == { Jacob => [{ :foreign_key=>"jesse_id", :class=> Jesse }],
+                          Jesse => [],
+                          Jim => [{ :foreign_key=>"jesse_id", :class=> Jesse }] }
+    end
+
+
+  end
+
+end

data/spec/exporter_spec.rb

@@ -0,0 +1,39 @@
+require 'helper'
+require 'tempfile'
+
+describe Tush::Exporter do
+
+  before :all do
+    class Jason < ActiveRecord::Base
+      has_one :kumie
+    end
+
+    class Kumie < ActiveRecord::Base; end
+  end
+
+  let!(:jason1) { Jason.create }
+  let!(:jason2) { Jason.create }
+  let!(:kumie1) { Kumie.create :jason_id => jason1.id }
+  let!(:kumie2) { Kumie.create :jason_id => jason2.id }
+
+  let!(:exporter) { Tush::Exporter.new([jason1, jason2]) }
+
+  describe "#data" do
+
+    it "should store data correctly" do
+      exporter.data.should ==
+        {:model_wrappers=>[{:model_class=>"Jason", :model_attributes=>{"id"=>1}, :model_trace=>[]}, {:model_class=>"Kumie", :model_attributes=>{"id"=>1, "jason_id"=>1}, :model_trace=>[["Jason", 1]]}, {:model_class=>"Jason", :model_attributes=>{"id"=>2}, :model_trace=>[]}, {:model_class=>"Kumie", :model_attributes=>{"id"=>2, "jason_id"=>2}, :model_trace=>[["Jason", 2]]}]}
+    end
+
+  end
+
+  describe "#export_json" do
+
+    it "should export its data in json" do
+      exporter.export_json.should ==
+        "{\"model_wrappers\":[{\"model_class\":\"Jason\",\"model_attributes\":{\"id\":1},\"model_trace\":[]},{\"model_class\":\"Kumie\",\"model_attributes\":{\"id\":1,\"jason_id\":1},\"model_trace\":[[\"Jason\",1]]},{\"model_class\":\"Jason\",\"model_attributes\":{\"id\":2},\"model_trace\":[]},{\"model_class\":\"Kumie\",\"model_attributes\":{\"id\":2,\"jason_id\":2},\"model_trace\":[[\"Jason\",2]]}]}"
+    end
+
+  end
+
+end

data/spec/helper.rb

@@ -0,0 +1,40 @@
+require 'simplecov'
+SimpleCov.start
+
+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 'rspec'
+require 'shoulda'
+require 'pry'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'tush'
+
+require 'active_record'
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+require 'support/schema'
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+
+def test_root
+  File.expand_path '../..', __FILE__
+end

data/spec/importer_spec.rb

@@ -0,0 +1,177 @@
+require 'helper'
+require 'tempfile'
+require 'json'
+require 'sneaky-save'
+
+describe Tush::Importer do
+
+  before :all do
+    class Kai < ActiveRecord::Base
+      has_one :brett
+    end
+
+    class Brett < ActiveRecord::Base; end
+
+    class Byron < ActiveRecord::Base
+      belongs_to :kai
+    end
+
+  end
+
+  let!(:exported_data_path) { "#{test_root}/spec/support/exported_data.json" }
+  let(:file) { File.read(exported_data_path) }
+  let(:importer) { Tush::Importer.new_from_json_file(exported_data_path) }
+
+  describe "#create_models!" do
+
+    it "imports data" do
+      importer.create_models!
+      importer.data.should ==
+        {"model_wrappers"=>
+        [{"model_class"=>"Kai",
+           "model_attributes"=>{"id"=>10, "sample_data"=>"data string"},
+           "original_db_key"=>"id",
+           "new_db_key"=>nil,
+           "original_db_id"=>1},
+         {"model_class"=>"Brett",
+           "model_attributes"=>{"id"=>1, "kai_id"=>10, "sample_data"=>"data string"},
+           "original_db_key"=>"id",
+           "new_db_key"=>nil,
+           "original_db_id"=>1},
+         {"model_class"=>"Kai",
+           "model_attributes"=>{"id"=>2, "sample_data"=>"data string"},
+           "original_db_key"=>"id",
+           "new_db_key"=>nil,
+           "original_db_id"=>2},
+         {"model_class"=>"Brett",
+           "model_attributes"=>{"id"=>2, "kai_id"=>2, "sample_data"=>"data string"},
+           "original_db_key"=>"id",
+           "new_db_key"=>nil,
+           "original_db_id"=>2}]}
+    end
+
+  end
+
+  describe "#find_wrapper_by_class_and_old_id" do
+
+    it "returns a matching wrapper" do
+      importer.create_models!
+      match = importer.find_wrapper_by_class_and_old_id(Kai, 10)
+
+      match.model_class.should == Kai
+      match.original_db_id.should == 10
+      match.original_db_key.should == "id"
+      match.new_model.should == Kai.first
+    end
+
+  end
+
+  describe "#update_foreign_keys!" do
+
+    PREFILLED_ROWS = 11
+
+    before :all do
+      class Lauren < ActiveRecord::Base
+        has_one :david
+        def self.custom_create(attributes)
+          Lauren.find_or_create_by_sample_data(attributes["sample_data"])
+        end
+      end
+
+      class David < ActiveRecord::Base
+        belongs_to :charlie
+      end
+
+      class Charlie < ActiveRecord::Base
+        belongs_to :lauren
+      end
+
+      class Miguel < ActiveRecord::Base
+        belongs_to :lauren
+      end
+
+      class Dan < ActiveRecord::Base
+        has_many :lauren
+      end
+
+      PREFILLED_ROWS.times do
+        Lauren.create
+        Charlie.create
+        David.create
+        Dan.create
+      end
+
+    end
+
+    let!(:dan) { Dan.create }
+    let!(:lauren1) { Lauren.create :dan_id => dan.id, :sample_data => "sample data" }
+    let!(:lauren2) { Lauren.create :dan_id => dan.id, :sample_data => "a;sdlfad" }
+    let!(:charlie) { Charlie.create :lauren_id => lauren2.id }
+    let!(:david) { David.create :lauren_id => lauren1.id, :charlie_id => charlie.id }
+
+    let!(:exported) { Tush::Exporter.new([lauren1, lauren2, david, charlie, dan]).export_json }
+    let!(:importer) { Tush::Importer.new(JSON.parse(exported)) }
+
+    it "imports a few database rows into the same database correctly" do
+      importer.create_models!
+      importer.update_foreign_keys!
+
+      existing_rows = PREFILLED_ROWS + 1
+
+      Dan.count.should == existing_rows + 1
+      Lauren.count.should == existing_rows + 1
+      Charlie.count.should == existing_rows + 1
+      David.count.should == existing_rows + 1
+
+      Dan.last.lauren.map { |lauren| lauren.id }.should == [12, 13]
+      David.last.charlie.id.should == 13
+      David.last.lauren_id.should == 12
+      Charlie.last.lauren.id.should == 13
+    end
+
+    describe "when a model wrapper doesn't exist" do
+
+      it "removes foreign keys if a model wrapper doesn't exist for an association" do
+        lauren = Lauren.create
+        charlie = Charlie.create :lauren => lauren
+
+        exported = Tush::Exporter.new([charlie], :blacklisted_models => [Lauren]).export_json
+        importer = Tush::Importer.new(JSON.parse(exported))
+
+        importer.create_models!
+        importer.update_foreign_keys!
+
+        importer.imported_model_wrappers.count.should == 1
+        importer.imported_model_wrappers[0].new_model.lauren_id.should == nil
+      end
+
+      it "Doesn't remove foreign keys if the column has a not null restraint" do
+        lauren = Lauren.create
+        miguel = Miguel.create :lauren => lauren
+
+        exported = Tush::Exporter.new([miguel], :blacklisted_models => [Lauren]).export_json
+        importer = Tush::Importer.new(JSON.parse(exported))
+
+        importer.create_models!
+        importer.update_foreign_keys!
+
+        importer.imported_model_wrappers.count.should == 1
+        importer.imported_model_wrappers[0].new_model.lauren_id.should == lauren.id
+      end
+
+    end
+
+  end
+
+  describe ".new_from_json" do
+
+    it "parses json and stores it in the data attribute" do
+      test_hash = { 'data' => 'data' }
+      importer = Tush::Importer.new_from_json(test_hash.to_json)
+
+      importer.data.should == test_hash
+    end
+
+  end
+
+end