syncify 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb790579afcec3a69a0241d30029691ede3a17ef
+  data.tar.gz: 71380e359bb049e5f945337e4948c2d3a6bab75e
+SHA512:
+  metadata.gz: d019996265b60d5a5f9c3a721e27282815766a2a3a7de3b514cccd21599d2e68b8319d6a78b78f3a31ee4a14701ea65b9db7bdc95ec8431c8a7f13ecd7e6dbdd
+  data.tar.gz: d8e4eaca79bae5ba9058f1205e46b8d88db5f1211262b55c35d106814f729cf69871e9856445d04f2e7b1ee22bebca94de3132851261ad35dfdf51d2ddff1616

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+.idea
+
+# ignore temp databases for testing
+spec/default.db
+spec/faux_remote.db

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.7
+before_install: gem install bundler -v 2.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in syncify.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,119 @@
+PATH
+  remote: .
+  specs:
+    syncify (0.1.0)
+      active_interaction (~> 3.0)
+      activerecord (~> 4.2)
+      activerecord-import (~> 0.17)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.2.11.1)
+      actionview (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.11.1)
+      activesupport (= 4.2.11.1)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    active_interaction (3.7.1)
+      activemodel (>= 4, < 7)
+    activemodel (4.2.11.1)
+      activesupport (= 4.2.11.1)
+      builder (~> 3.1)
+    activerecord (4.2.11.1)
+      activemodel (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      arel (~> 6.0)
+    activerecord-import (0.28.2)
+      activerecord (>= 3.2)
+    activesupport (4.2.11.1)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.4)
+    builder (3.2.3)
+    byebug (11.0.1)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    crass (1.0.4)
+    diff-lcs (1.3)
+    erubis (2.7.0)
+    factory_bot (4.11.1)
+      activesupport (>= 3.0.0)
+    factory_bot_rails (4.11.1)
+      factory_bot (~> 4.11.1)
+      railties (>= 3.0.0)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (0.9.2)
+    mini_portile2 (2.4.0)
+    minitest (5.11.3)
+    nokogiri (1.10.3)
+      mini_portile2 (~> 2.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
+      pry (~> 0.10)
+    rack (1.6.11)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.9)
+      activesupport (>= 4.2.0, < 5.0)
+      nokogiri (~> 1.6)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.1.0)
+      loofah (~> 2.2, >= 2.2.2)
+    railties (4.2.11.1)
+      actionpack (= 4.2.11.1)
+      activesupport (= 4.2.11.1)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    sqlite3 (1.3.13)
+    thor (0.20.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  factory_bot_rails (~> 4.11)
+  pry-byebug (~> 3.7)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  sqlite3 (~> 1.3, < 1.4)
+  syncify!
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Doug Hughes
+
+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,196 @@
+# Syncify
+
+Syncify is a gem used to sync records and associations you specify from one remote ActiveRecord environment to your local environment.
+
+Consider this hypothetical problem: You have a gigantic production database with complex associations between your models, including polymorphic associations. The database includes sensitive data that shouldn't really be in your development or staging environments. But, there's something wrong in production and you need production data to be able to debug it. It's not practical, efficient, safe, or generally advisable to restore a backup of the production database locally.
+
+How do you get that data safely from production to an environment where you can make use of it? This is the problem that Syncify aims to address.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'syncify'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install syncify
+
+## Usage
+
+
+Syncify doesn't require Rails, just ActiveRecord, but it's a reasonable foundation for the following examples.
+
+Also, you can sync from any environment to whatever your current environment is. So, you could sync from your staging environment to your client test environment or from staging to development. Heck, you could go from staging to prod if you'd like.
+
+For the purposes of this documentation we'll assume that you're syncing data in a Rails app from production to your local development environment.
+
+Syncify has a pretty simple API. There's just one method, `run!`. Here's a really basic example where we're syncing a single `Widget` from production to the current environment. The current environment could be any environment, but we'll assume it's development for this documentation.
+
+```ruby
+Syncify::Sync.run!(klass: Widget, id: 123, remote_database: :production)
+```
+
+Boom! You've copied `Widget` 123 to local dev. The widget will have all the same values including its `id`, `created_at`, `updated_at`, etc values. The above example assumes that the `Widget` doesn't have any foreign keys that don't exist locally.
+
+Now, let's say a `Widget` `belongs_to` a `Manufacturer`. Furthermore, let's say a `Manufacturer` `has_many` `Widget`s. We'll pretend we have this data in the prod database:
+
+`widgets`:
+
+| id  | name                                               | manufacturer_id |
+| --- | -------------------------------------------------- | --------------- |
+| 123 | Lubricated Stainless Steel Helical Insert          | 78              |
+| 124 | Magnetic Contact Alarm Switches                    | 79              |
+| 125 | Idler Sprocket for Double-Strand ANSI Roller Chain | 78              |
+| 126 | Rod End Bolt Blank                                 | 79              |
+| 127 | Press-Fit Drill Bushing                            | 78              |
+
+`manufacturers`:
+
+| id  | name                       |
+| --- | -------------------------- |
+| 78  | South Seas Trading Company |
+| 79  | Blandco Manufacturing      |
+
+If your database uses foreign keys and the production `Widget`'s `Manufacturer` doesn't exist locally then the example above would fail. To get around this we can specify an association to also sync when syncing the `Widget`.
+
+```ruby
+Syncify::Sync.run!(klass: Widget,
+                   id: 123,
+                   association: :manufacturer,
+                   remote_database : :production)
+```
+
+Running the above example will copy two records into your local database:
+
+* The `Widget` with id 123 (Lubricated Stainless Steel Helical Insert)
+* The `Manufacturer` with id 78 (South Seas Trading Company)
+
+It's important to note that Syncer _does not_ recursively follow associations. You'll note that not all of the the manufacturer's widgets were synced, only the one we specified.
+
+The `association` attribute passed into the `run!` method can be any valid value that you might use when joining records with ActiveRecord. The above effectively becomes:
+
+```ruby
+Widget.eager_load(:manufacturer).find(123)
+```
+
+Because of this, you can pass any sort of ActiveRecord association into Syncify's `run!` method.
+
+Now let's imagine that a `Manufacturer` `has_many` `Plant`s which `belong_to` a `State`. Here are some example rows in these tables:
+
+`plants`:
+
+| id  | name            | manufacturer_id | city    | state_id |
+| --- | --------------- | --------------- | ------- | -------- |
+| 64  | Rapid Run       | 78              | Lansing | 13       |
+| 65  | Ye Olde Factory | 78              | Naples  | 15       |
+| 66  | Catco           | 79              | Balston | 43       |
+
+`states`:
+
+| id  | name     |
+| --- | -------- |
+| 13  | Michigan |
+| 15  | Florida  |
+| 43  | Virginia |
+
+We could sync a `Manufacturer` along with its widgets, factories, and the state the factory is in with this example:
+
+```ruby
+Syncify::Sync.run!(klass: Manufacturer,
+                   id: 78,
+                   association: [
+                     :widgets,
+                     { factories: :state }
+                   ],
+                   remote_database: :production)
+```
+
+You can really go wild with the associations; well beyond what you could normally run with an ActiveRecord query! In one app I have a hash defining a ton of associations across dozens of models that is more than 150 lines long. When I run this sync it identifies more than 500 records and syncs them all to local dev in about 30 seconds.
+
+### Polymorphic Associations
+
+Syncify also works with (and across) Polymorphic associations! To sync across polymorphic associations you need to specify an association using the `Syncer::PolymorphicAssociation` class. This is put in place in your otherwise-normal associations.
+
+Let's imagine that we run an online store that sells both physical and digital goods. A given invoice then might have line items that refer to either type of good.
+
+Here's our model:
+
+* `Customer`
+	* `has_many :invoices`
+* `Invoice`
+	* `belongs_to :customer`
+	* `has_many :line_items`
+* `LineItem`
+	* `belongs_to :invoice`
+	* `belongs_to :product, polymorphic: true`
+* `DigitalProduct`
+	* `has_many :line_items, as: :product`
+	* `belongs_to :category`
+* `PhysicalProduct`
+	* `has_many :line_items, as: :product`
+	* `belongs_to :distributor`
+* `Category`
+	* `has_many :digital_products`
+* `Distributor`
+	* `has_many :physical_products`
+
+There's a lot going on above, and I'll spare you the example database tables. You can use your imagination! 😉
+
+Let's say we want to sync a particular `LineItem`. With ActiveRecord queries you can't simply `eager_load` across a polymorphic association, much less to any sub-associations (EG: category or distributor). With Syncify you can.
+
+Here's an example. For simplicity's sake it assumes that the database doesn't use foreign keys. (Don't worry, we'll do a more complex example next!):
+
+```ruby
+Syncify::Sync.run!(klass: Customer,
+                   id: 999,
+                   association: Syncer::PolymorphicAssociation.new(
+                     :product,
+                     DigitalProduct => {},
+                     PhysicalProduct => {}
+                   ),
+                   remote_database: :production)
+```
+
+Assuming that line item 42's product is a `DigitalProduct`, this example would have synced the `LineItem` and its `DigitalProduct` and nothing else.
+
+The `Syncer::PolymorphicAssociation` is saying that, for the `LineItem`'s `product` polymorphic association, when the product is a `DigitalProduct`, sync it with the specified associations (in this case none). When the product is a `PhysicalProduct`, sync it with the specified associations (again, none in this case).
+
+Now let's say that we want to sync a specific `Customer` and all of their invoices and the related products. IE: the whole kit and caboodle. Here's how you can do it:
+
+```ruby
+Syncify::Sync.run!(klass: Customer,
+                   id: 999,
+                   association: {
+                     invoices: {
+                       line_items: Syncer::PolymorphicAssociation.new(
+                         :product,
+                         DigitalProduct => :category,
+                         PhysicalProduct => :distributor
+                       )
+                     }
+                   },
+                   remote_database: :production)
+```
+
+This will sync a customer, all of their invoices, all of those invoice's line items. It goes on to sync all of the line item's products, whether digital or physical, as well as the digital product's category and the physical product's distributor.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dhughes/syncify.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "syncify"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/syncify.rb

@@ -0,0 +1,9 @@
+require "syncify/version"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+Dir[File.expand_path('syncify/*.rb', __dir__)].each { |f| require f }
+
+module Syncify
+  class Error < StandardError; end
+end

data/lib/syncify/normalize_associations.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Syncify
+  class NormalizeAssociations < ActiveInteraction::Base
+    object :association, class: Object
+
+    def execute
+      normalize_associations(association)
+    end
+
+    private
+
+    def normalize_associations(association)
+      Array.wrap(
+        case association
+        when Symbol
+          Hash[association, {}]
+        when Array
+          association.map { |node| normalize_associations(node) }
+        when Hash
+          association.reduce([]) do |memo, (key, value)|
+            values = normalize_associations(value)
+
+            if values.empty?
+              memo << Hash[key, {}]
+            else
+              values.each do |value|
+                memo << Hash[key, value]
+              end
+            end
+
+            memo
+          end
+        else
+          association
+        end
+      ).flatten
+    end
+  end
+end

data/lib/syncify/polymorphic_association.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Syncify
+  class PolymorphicAssociation
+    attr_accessor :property
+    attr_accessor :associations
+
+    def initialize(property, associations)
+      @property = property
+      @associations = associations
+    end
+  end
+end

data/lib/syncify/sync.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Syncify
+  class Sync < ActiveInteraction::Base
+    object :klass, class: Class
+    integer :id
+    object :association, class: Object, default: []
+    object :callback, class: Proc, default: nil
+
+    symbol :remote_database
+
+    attr_accessor :identified_records
+
+    def execute
+      @identified_records = Set[]
+
+      remote do
+        identify_associated_records(klass.find(id), normalized_associations(association))
+      end
+
+      callback.call(identified_records) if callback.present?
+
+      sync_records
+    end
+
+    def identify_associated_records(root, associations)
+      identified_records << root
+
+      standard_associations = associations.reject(&method(:includes_polymorphic_association))
+      polymorphic_associations = associations.select(&method(:includes_polymorphic_association))
+
+      standard_associations.each do |association|
+        traverse_associations(
+          root.class.eager_load(association).find(root.id),
+          association
+        )
+      end
+
+      identify_polymorphic_associated_records(root, polymorphic_associations)
+    end
+
+    def identify_polymorphic_associated_records(root, polymorphic_associations)
+      polymorphic_associations.each do |polymorphic_association|
+        if polymorphic_association.is_a?(Hash)
+          polymorphic_association.each do |key, association|
+            Array.wrap(root.__send__(key)).each do |target|
+              identify_polymorphic_associated_records(target, Array.wrap(association))
+            end
+          end
+        else
+          target = root.__send__(polymorphic_association.property)
+          type = polymorphic_association.associations.keys.detect do |association_type|
+            target.is_a?(association_type)
+          end
+          associations = polymorphic_association.associations[type]
+          identify_associated_records(target, normalized_associations(associations))
+        end
+      end
+    end
+
+    def traverse_associations(records, associations)
+      records = Array(records)
+
+      identified_records.merge records
+
+      records.each do |record|
+        associations.each do |association, nested_associations|
+          traverse_associations(record.__send__(association), nested_associations)
+        end
+      end
+    end
+
+    def sync_records
+      ActiveRecord::Base.connection.disable_referential_integrity do
+        classify_identified_instances.each do |class_name, new_instances|
+          puts "Syncing #{new_instances.size} #{class_name} objects"
+          clazz = Object.const_get(class_name)
+          clazz.import(new_instances, validate: false, on_duplicate_key_update: [:id])
+        end
+      end
+    end
+
+    def classify_identified_instances
+      puts "Classifying #{identified_records.size} records for bulk import."
+
+      identified_records.each_with_object({}) do |instance, memo|
+        clazz = instance.class
+        class_name = clazz.name
+        memo[class_name] ||= []
+        memo[class_name] << clone_instance(instance)
+      end
+    end
+
+    def clone_instance(instance)
+      clazz = instance.class
+      new_instance = clazz.new
+
+      instance.attributes.each do |attribute, value|
+        new_instance[attribute.to_s] = value
+      end
+
+      new_instance
+    end
+
+    def includes_polymorphic_association(association)
+      association.to_s.include?('Syncify::PolymorphicAssociation')
+    end
+
+    def normalized_associations(association)
+      Syncify::NormalizeAssociations.run!(association: association)
+    end
+
+    def remote
+      run_in_environment(remote_database) { yield }
+    end
+
+    def run_in_environment(environment)
+      initial_config = ActiveRecord::Base.connection_config
+      ActiveRecord::Base.establish_connection environment
+      yield
+    ensure
+      ActiveRecord::Base.establish_connection initial_config
+    end
+
+  end
+end

data/lib/syncify/version.rb

@@ -0,0 +1,3 @@
+module Syncify
+  VERSION = "0.1.0"
+end

data/syncify.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "syncify/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "syncify"
+  spec.version       = Syncify::VERSION
+  spec.authors       = ["Doug Hughes"]
+  spec.email         = ["doug@doughughes.net"]
+
+  spec.summary       = %q{Copies data between Rails environments}
+  spec.description   = %q{You can use this gem to copy records and their specified associations from production (or other) environments to your local environment.}
+  spec.homepage      = "http://github.com/dhughes/syncify"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "http://github.com/dhughes/syncify"
+  spec.metadata["changelog_uri"] = "http://github.com/dhughes/syncify"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry-byebug", "~> 3.7"
+  spec.add_development_dependency "sqlite3", '~> 1.3', '< 1.4'
+  spec.add_development_dependency "factory_bot_rails", "~> 4.11"
+
+  spec.add_runtime_dependency "active_interaction", "~> 3.0"
+  spec.add_runtime_dependency "activerecord", "~> 4.2"
+  spec.add_runtime_dependency "activerecord-import", "~> 0.17"
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: syncify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doug Hughes
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: factory_bot_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.11'
+- !ruby/object:Gem::Dependency
+  name: active_interaction
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord-import
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+description: You can use this gem to copy records and their specified associations
+  from production (or other) environments to your local environment.
+email:
+- doug@doughughes.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/syncify.rb
+- lib/syncify/normalize_associations.rb
+- lib/syncify/polymorphic_association.rb
+- lib/syncify/sync.rb
+- lib/syncify/version.rb
+- syncify.gemspec
+homepage: http://github.com/dhughes/syncify
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/dhughes/syncify
+  source_code_uri: http://github.com/dhughes/syncify
+  changelog_uri: http://github.com/dhughes/syncify
+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.5.2.3
+signing_key: 
+specification_version: 4
+summary: Copies data between Rails environments
+test_files: []