syncify 0.1.6 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbbff47f10eb17cab6c833696be95392bb9da92b
-  data.tar.gz: 82dd0f3812f8ec948b2e3c056fcf4ab68b963e76
+  metadata.gz: a23e94b5f7ffe7b8015aeb19a88a96835a4bfe06
+  data.tar.gz: 8134d393be46563dc8d601be98a66160451720b1
 SHA512:
-  metadata.gz: c520fc80891d255cb6fa2e15fbcc522a0c3d3625aca21829b45a705732f106bbd6442ae48af134b4e4a54dffa1f35e008f9c8203e57c29ba34514aba7e47ee97
-  data.tar.gz: cd2bd81aad8e1d4b8df61e1a58a9713bc7a6002777852585260d896a9214da508951da06e59ea514574ab9040e8e14cdcfc71675834caf3bde6dadadb49064cf
+  metadata.gz: 034efd30cd004dc2aa74d00aa7dbbba5906286435acc5a40d85517174bdf3a440831fe0bf5db3d32c7fb049dfc06834aaeec8eab9e3fbeb467842d35f5ffca86
+  data.tar.gz: 600c4a061920e6b95e14ea8bcbe9c59cb7435e2714825c3ed9cba22ac6420419b46f147251ce2c118979fc19dc3c2456f55c5dfd6ef3c700a5e9d378985ac771

data/Gemfile.lock

@@ -1,64 +1,63 @@
 PATH
   remote: .
   specs:
-    syncify (0.1.6)
+    syncify (0.1.9)
       active_interaction (~> 3.0)
-      activerecord (~> 4.2)
+      activerecord (~> 5.0)
       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)
+    actionpack (5.2.3)
+      actionview (= 5.2.3)
+      activesupport (= 5.2.3)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (4.2.11.1)
-      activesupport (= 4.2.11.1)
+    actionview (5.2.3)
+      activesupport (= 5.2.3)
       builder (~> 3.1)
-      erubis (~> 2.7.0)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
       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)
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
     activerecord-import (0.28.2)
       activerecord (>= 3.2)
-    activesupport (4.2.11.1)
-      i18n (~> 0.7)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    arel (6.0.4)
+    arel (9.0.0)
     builder (3.2.3)
     byebug (11.0.1)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
-    crass (1.0.4)
+    crass (1.0.5)
     diff-lcs (1.3)
-    erubis (2.7.0)
+    erubi (1.9.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)
+    i18n (1.7.0)
       concurrent-ruby (~> 1.0)
-    loofah (2.2.3)
+    loofah (2.3.1)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     method_source (0.9.2)
     mini_portile2 (2.4.0)
-    minitest (5.11.3)
+    minitest (5.12.2)
     nokogiri (1.10.4)
       mini_portile2 (~> 2.4.0)
     pry (0.12.2)
@@ -67,36 +66,34 @@ GEM
     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.2.0)
-      loofah (~> 2.2, >= 2.2.2)
-    railties (4.2.11.1)
-      actionpack (= 4.2.11.1)
-      activesupport (= 4.2.11.1)
+    rack (2.0.7)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.3.0)
+      loofah (~> 2.3)
+    railties (5.2.3)
+      actionpack (= 5.2.3)
+      activesupport (= 5.2.3)
+      method_source
       rake (>= 0.8.7)
-      thor (>= 0.18.1, < 2.0)
+      thor (>= 0.19.0, < 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)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.0)
+      rspec-support (~> 3.9.0)
+    rspec-expectations (3.9.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.0)
     sqlite3 (1.3.13)
     thor (0.20.3)
     thread_safe (0.3.6)

data/README.md

@@ -1,6 +1,6 @@
 # Syncify
 
-Syncify is a gem used to sync records and associations you specify from one remote ActiveRecord environment to your local environment.
+Syncify is a gem used to sync ActiveRecord records and their associations from one remote 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.
 
@@ -84,7 +84,7 @@ 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 Syncify _does not_ recursively follow associations. You'll note that not all of the the manufacturer's widgets were synced, only the one we specified.
+It's important to note that Syncify _does not_ recursively follow associations (though see below for how to discover associations programmatically). 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:
 
@@ -124,7 +124,9 @@ Syncify::Sync.run!(klass: Manufacturer,
                    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.
+You can really go wild with the associations; well beyond what you could normally run with an ActiveRecord query!
+
+> When Syncify was first released, I had an app with a hash defining a ton of associations across dozens of models that was more than 150 lines long. When I ran this sync it would identify more than 500 records and syncs them all to local dev in about 30 seconds. I've since updated to use association discovery (documented below) and sync _much_ more data. It takes longer, but it's still very fast.
 
 ### Polymorphic Associations
 
@@ -155,24 +157,36 @@ Here's our model:
 
 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.
+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: Syncify::PolymorphicAssociation.new(
-                     :product,
-                     DigitalProduct => {},
-                     PhysicalProduct => {}
-                   ),
+Syncify::Sync.run!(klass: LineItem,
+                   id: 42,
+                   association: {
+                     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 `Syncify::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).
+Let's focus in on the association:
+
+```ruby
+{
+  product: {
+    DigitalProduct => {},
+    PhysicalProduct => {}
+  }
+}
+```
+
+We know the `LineItem` has a polymorphic association named `:product` (this is documented above). This association 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:
 
@@ -181,17 +195,165 @@ Syncify::Sync.run!(klass: Customer,
                    id: 999,
                    association: {
                      invoices: {
-                       line_items: Syncify::PolymorphicAssociation.new(
-                         :product,
-                         DigitalProduct => :category,
-                         PhysicalProduct => :distributor
-                       )
+                       line_items: {
+                         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.
+This will sync a customer, all of their invoices, and 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.
+
+### Discovering Associations Programmatically
+
+The process of specifying associations, as outlined above, might be fairly tedious, especially if you have a hierarchy of dozens of interrelated models. For this reason, Syncify also includes a class that can discover associations, `Syncify::IdentifyAssociations`. Like `Syncify::Sync`, this class has one method, `run!`. You can use it like this:
+
+```ruby
+associations = Syncify::IdentifyAssociations.run!(klass: Customer)
+```
+
+This will inspect the local `Customer` class, discover its associations, and then drill down through those associations to discover nested associations. It proactively cuts out associations that are inverses of other associations, and endeavors to eradicate association loops. So, looking at the customer/invoices/products example above, it will recognize the association from `Customer` to `Invoice`, but not from `Invoice` to `Customer`, since it's the inverse of the first association. It also skips over `has_many through:` associations, since those _must_ be covered by another association.
+
+Using the example above, the associations identified would look like this:
+
+```ruby
+{
+  invoices: {
+    line_items: {
+      product: {
+        DigitalProduct => :category,
+        PhysicalProduct => :distributor
+      }
+    }
+  }
+}
+```
+
+> Important Note: Polymorphic associations are discovered by querying the database for associated types. So, in the example above, the `IdentifyAssociations` class sees the `LineItem#products` association and queries the `line_items` table for the set of distinct values in the `product_type` column. It uses that to continue discovery. So, if you're trying to discover associations, but your database is empty, you won't be able to traverse these polymorphic associations.
+
+The example above can be see in the specs at spec/lib/syncify/identify_associations_spec.rb.
+
+So, you can combine the `Sync` class and the `IdentifyAssociations` class to make your live even easier:
+
+```ruby
+Syncify::Sync.run!(
+  klass: Customer,
+  id: 999,
+  association: Syncify::IdentifyAssociations.run!(klass: Customer),
+  remote_database: :production
+)
+```
+
+#### Using `IdentifyAssociations` Remotely
+
+Under some circumstances you may want to discover the associations from the remote database. For example, maybe you don't have data in your local database to be able to discover polymorphic associations. For situations like this, `IdentifyAssociations` accepts a `remote_database` argument, just like `Sync`.
+
+```ruby
+Syncify::IdentifyAssociations.run!(klass: Customer, remote_database: :production)
+```
+
+And here it is with `Sync` in all its glory:
+
+```ruby
+Syncify::Sync.run!(
+  klass: Customer,
+  id: 999,
+  association: Syncify::IdentifyAssociations.run!(klass: Customer, remote_database: :production),
+  remote_database: :production
+)
+```
+
+#### Association Hints
+
+Sometimes, you might not want to automatically discover associations, but not _all_ of them. In these situations you can use hints. A hint is a class that can be used to filter out associations conditionally.
+
+The `Hint` class defines the interface for hints. It's a no-op hint that doesn't filter anything. If you need to create your own hints you can extend `Hint`.
+
+All hints have two methods:
+
+| Method                               | Description                                                                                                                                                                                                                                                                                                   |
+| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `applicable?(candidate_association)` | This method take a Rails association (not a Syncify association, which isn't documented here) and returns a boolean value indicating whether or not the hint is applicable for the specified association. Basically, this is what Syncify uses to determine whether or to check if an association is allowed. |
+| allowed?`                            | This method returns true or false, indicating if a particular association is allowed to be traversed or not.                                                                                                                                                                                                  |
+
+You are most likely to use the `BasicHint` class. This class has a constructor that accepts the following arguments:
+
+| Argument      | Type                       | Default | Description                                                                                                                                                                                |
+| ------------- | -------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `from_class`  | Class or array of classes  | nil     | If provided, the `from_class` argument declares that the hint applies to associations from the specified class or classes.                                                                 |
+| `association` | Symbol or array of symbols | nil     | If provided, the `association` argument declares that the hint applies to associations with the specified name or names.                                                                   |
+| `to_class`    | Class or array of classes  | nil     | If provided, the `to_class` argument declares that the hint applies to associations to the specified class or classes.                                                                     |
+| `allowed`     | Boolean (required)         |         | This argument indicates that if the hint is applicable to a particular association that it is or is not allowed, meaning that the `IdentifyAssociations` class will or will not ignore it. |
+
+Hints can be specified for use by `IdentifyAssociations` like so:
+
+```ruby
+Syncify::IdentifyAssociations.run!(
+  klass: Customer,
+  hints: [
+    Syncify::Hint::BasicHint.new(....),
+    Syncify::Hint::BasicHint.new(....)
+  ]
+```
+
+Hints are applied in the order specified and the first one that matches "wins". So, if you have an association that is explicitly disallowed by a hint before another hint allows it, the first hint wins and the association is ignored.
+
+With that out of the way, let's assume you have an an association where there are lots of associated records. For example, maybe you're Amazon and you have a `Store` class which has many `Product`s. Obviously, amazon has a bazillion products. We might not want to sync all of these products when syncing a `Store`. You could filter that out with hints in a couple ways.
+
+Don't sync by association name:
+
+```ruby
+Syncify::Hint::BasicHint.new(association: :products, allowed: false)
+```
+
+Don't sync by the target class name:
+
+```ruby
+Syncify::Hint::BasicHint.new(to_class: Product, allowed: false)
+```
+
+Perhaps some models always exist locally and remotely. In that case, you could create a hint to never sync them:
+
+```ruby
+Syncify::Hint::BasicHint.new(
+  to_class: [
+    Config,
+    Account,
+    Country,
+    SiteDomain,
+    Offer
+  ]
+)
+```
+
+Perhaps you have some classes where none of their associations ever need to be synced. For example, maybe you collect stats on some objects, but the stats aren't needed locally, or there's so many records that it's not practical to sync them all:
+
+```ruby
+Syncify::Hint::BasicHint.new(
+  from_class: [
+    Account,
+    DailyStat,
+    LifetimeDailyStat,
+    DomainDailyStat,
+    PaymentAccount,
+    User,
+  ],
+  allowed: false
+)
+```
+
+Note that in the above example we're disallowing _all_ associations from `Account`. But, let's imagine that `Account` has 50 associations and we _do_ want to sync two of them. Since hints are applied in the order specified, and the first hint that matches is the hint that is applied, you could specifically allow two of the associations from `Account`, but disallow all others like this:
+
+```ruby
+Syncify::Hint::BasicHint.new(from_class: Account, association: [:example1, :example2], allowed: true)
+Syncify::Hint::BasicHint.new(from_class: Account, allowed: false)
+```
+
+If the `BasicHint` class isn't sufficient for your needs, you can always create your own hints by extending `Hint` and implementing the `applicable?` and `allowed?` methods.
 
 ### Callbacks
 

data/bin/console

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
+require 'active_interaction'
+require 'pry-byebug'
 require "syncify"
 
 # You can add fixtures and/or initialization code here to make experimenting

data/lib/syncify.rb

@@ -2,8 +2,15 @@ require "syncify/version"
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
-Dir[File.expand_path('syncify/*.rb', __dir__)].each { |f| require f }
+require 'syncify/identify_associations'
+require 'syncify/normalize_associations'
+require 'syncify/sync'
+require 'syncify/association/polymorphic_association'
+require 'syncify/association/standard_association'
+require 'syncify/hint/hint'
+require 'syncify/hint/basic_hint'
 
 module Syncify
-  class Error < StandardError; end
+  class Error < StandardError;
+  end
 end

data/lib/syncify/association/polymorphic_association.rb

@@ -0,0 +1,62 @@
+module Syncify
+  module Association
+    class PolymorphicAssociation
+      attr_accessor :from_class, :to_classes, :name, :destination, :traversed
+
+      def self.identify_to_classes(from_class, association_name)
+        association = from_class.reflect_on_association(association_name)
+        @cache ||= {}
+        @cache[from_class] ||= {}
+        @cache[from_class][association_name] ||= from_class.
+          where("#{association.foreign_type} != ''").
+          distinct.
+          pluck(association.foreign_type).
+          uniq.
+          compact.
+          map(&:constantize)
+      end
+
+      def initialize(from_class:, association:, destination:)
+        @from_class = from_class
+        @to_classes = Syncify::Association::PolymorphicAssociation.identify_to_classes(from_class, association.name)
+        @name = association.name
+        @destination = destination
+        @traversed = false
+      end
+
+      def polymorphic?
+        true
+      end
+
+      def traversed?
+        traversed
+      end
+
+      def inverse_of?(association)
+        if association.polymorphic?
+          association.to_classes.include?(from_class) &&
+            to_classes.include?(association.from_class)
+        else
+          from_class == association.to_class &&
+            to_classes.include?(association.from_class)
+        end
+      end
+
+      def create_destination(association_name)
+        destination[name] ||= {}
+        destination[name][association_name] = {}
+      end
+
+      def hash
+        "#{self.from_class.to_s}#{self.to_classes.map(&:to_s)}#{self.name}".hash
+      end
+
+      def eql?(other_association)
+        return false unless other_association.is_a? PolymorphicAssociation
+        self.from_class == other_association.from_class &&
+          self.to_classes == other_association.to_classes &&
+          self.name == other_association.name
+      end
+    end
+  end
+end

data/lib/syncify/association/standard_association.rb

@@ -0,0 +1,45 @@
+module Syncify
+  module Association
+    class StandardAssociation
+      attr_accessor :from_class, :to_class, :name, :destination, :traversed
+
+      def initialize(from_class:, association:, destination:)
+        @from_class = from_class
+        @to_class = association.klass
+        @name = association.name
+        @destination = destination
+        @traversed = false
+      end
+
+      def polymorphic?
+        false
+      end
+
+      def traversed?
+        traversed
+      end
+
+      def inverse_of?(association)
+        if association.polymorphic?
+          association.to_classes.include?(from_class) && association.from_class == to_class
+        else
+          association.to_class == from_class && association.from_class == to_class
+        end
+      end
+
+      def create_destination(name)
+        destination[name] = {}
+      end
+
+      def hash
+        "#{self.from_class.to_s}#{self.to_class.to_s}#{self.name}".hash
+      end
+
+      def eql?(other_association)
+        self.from_class == other_association.from_class &&
+          self.to_class == other_association.to_class &&
+          self.name == other_association.name
+      end
+    end
+  end
+end

data/lib/syncify/hint/basic_hint.rb

@@ -0,0 +1,57 @@
+module Syncify
+  module Hint
+    class BasicHint < Syncify::Hint::Hint
+      attr_accessor :from_class, :association, :to_class, :allowed
+      alias :allowed? :allowed
+
+      def initialize(from_class: nil, association: nil, to_class: nil, allowed:)
+        @from_class = from_class
+        @association = association
+        @to_class = to_class
+        @allowed = allowed
+      end
+
+      def applicable?(candidate_association)
+        evaluate_from(candidate_association) &&
+          evaluate_association(candidate_association) &&
+          evaluate_to_class(candidate_association)
+      end
+
+      def allowed?
+        allowed
+      end
+
+      private
+
+      def evaluate_from(candidate_association)
+        from_class.nil? ||
+          Array.wrap(from_class).include?(candidate_association.active_record)
+      end
+
+      def evaluate_association(candidate_association)
+        return true if association.nil?
+
+        if association.is_a? Regexp
+          candidate_association.name =~ association ? true : false
+        else
+          Array.wrap(association).include? candidate_association.name
+        end
+      end
+
+      def evaluate_to_class(candidate_association)
+        return true if to_class.nil?
+
+        if candidate_association.polymorphic?
+          associated_classes = Syncify::Association::PolymorphicAssociation.identify_to_classes(
+            candidate_association.active_record,
+            candidate_association.name
+          )
+
+          (Array.wrap(to_class) & associated_classes).any?
+        else
+          Array.wrap(to_class).include?(candidate_association.klass)
+        end
+      end
+    end
+  end
+end

data/lib/syncify/hint/hint.rb

@@ -0,0 +1,13 @@
+module Syncify
+  module Hint
+    class Hint
+      def applicable?(candidate_association)
+        false
+      end
+
+      def allowed?
+        true
+      end
+    end
+  end
+end

data/lib/syncify/identify_associations.rb

@@ -0,0 +1,134 @@
+module Syncify
+  class IdentifyAssociations < ActiveInteraction::Base
+    object :klass, class: Class
+    symbol :remote_database, default: nil
+    array :hints, default: []
+
+    attr_accessor :association_registry, :identified_associations
+
+    def execute
+      @association_registry = Set[]
+      @identified_associations = {}
+
+      remote do
+        identify_associations(klass, identified_associations)
+
+        simplify_associations(traverse_associations)
+      end
+    end
+
+    private
+
+    def simplify_associations(associations)
+      simplified_associations = associations.each.reduce([]) do |memo, (association, nested_association)|
+        simplified_association = if association.is_a? Class
+                                   { association => simplify_associations(nested_association) }
+                                 elsif nested_association.empty?
+                                   association
+                                 else
+                                   { association => simplify_associations(nested_association) }
+                                 end
+
+        memo << simplified_association
+        memo
+      end
+
+      if simplified_associations.map(&:class).uniq == [Hash]
+        return simplified_associations.inject({}) { |memo, association| memo.merge(association) }
+      end
+      return simplified_associations.first if simplified_associations.size == 1
+      return nil if simplified_associations.empty?
+
+      simplified_associations
+    end
+
+    def identify_associations(from_class, destination)
+      applicable_associations(from_class).each do |association|
+        puts "Inspecting #{from_class.name}##{association.name}"
+        pending_association = if association.polymorphic?
+                                Syncify::Association::PolymorphicAssociation.new(
+                                  from_class: from_class,
+                                  association: association,
+                                  destination: destination
+                                )
+                              else
+                                Syncify::Association::StandardAssociation.new(
+                                  from_class: from_class,
+                                  association: association,
+                                  destination: destination
+                                )
+                              end
+
+        association_registry << pending_association
+      end
+    end
+
+    def traverse_associations
+      while (association = next_untraversed_association)
+        association.traversed = true
+
+        next if should_ignore_association?(association)
+
+        if association.polymorphic?
+          association.to_classes.each do |to_class|
+            identify_associations(
+              to_class,
+              association.create_destination(to_class)
+            )
+          end
+        else
+          identify_associations(
+            association.to_class,
+            association.create_destination(association.name)
+          )
+        end
+      end
+
+      identified_associations
+    end
+
+    def should_ignore_association?(association)
+      # ignore if association is the inverse of an association that has already been traversed
+      traversed_associations.find do |traversed_association|
+        traversed_association.inverse_of?(association)
+      end
+    end
+
+    def traversed_associations
+      association_registry.select { |association| association.traversed }
+    end
+
+    def next_untraversed_association
+      association_registry.find { |association| !association.traversed }
+    end
+
+    def applicable_associations(klass)
+      klass.
+        reflect_on_all_associations.
+        reject(&method(:inapplicable_associations))
+    end
+
+    def inapplicable_associations(association)
+      return true if association.class == ActiveRecord::Reflection::ThroughReflection
+
+      hints.each do |hint|
+        return !hint.allowed? if hint.applicable?(association)
+      end
+
+      false
+    end
+
+    # TODO: this is duplicated from Sync. Consider refactoring
+    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/normalize_associations.rb

@@ -19,13 +19,18 @@ module Syncify
           association.map { |node| normalize_associations(node) }
         when Hash
           association.reduce([]) do |memo, (key, value)|
-            values = normalize_associations(value)
-
-            if values.empty?
-              memo << Hash[key, {}]
+            if polymorphic_values?(value)
+              value = value.reduce({}, :merge) if value.is_a? Array
+              memo << Hash[key, value]
             else
-              values.each do |value|
-                memo << Hash[key, value]
+              values = normalize_associations(value)
+
+              if values.empty?
+                memo << Hash[key, {}]
+              else
+                values.each do |value|
+                  memo << Hash[key, value]
+                end
               end
             end
 
@@ -36,5 +41,18 @@ module Syncify
         end
       ).flatten
     end
+
+    private
+
+    def polymorphic_values?(values)
+      if values.is_a? Hash
+        values.keys.all? { |key| key.is_a? Class }
+      elsif values.is_a? Array
+        return false unless values.all? { |value| value.is_a? Hash }
+        return polymorphic_values?(values.reduce({}, :merge))
+      else
+        false
+      end
+    end
   end
 end

data/lib/syncify/sync.rb

@@ -21,12 +21,13 @@ module Syncify
       @has_and_belongs_to_many_associations = {}
 
       remote do
+        associations = normalized_associations(association)
         initial_query.each do |root_record|
-          identify_associated_records(root_record, normalized_associations(association))
+          identify_associated_records(root_record, associations)
         end
       end
 
-      puts "Identified #{identified_records.size} records to sync."
+      puts "\nIdentified #{identified_records.size} records to sync."
 
       callback.call(identified_records) if callback.present?
 
@@ -51,7 +52,11 @@ module Syncify
     end
 
     def print_status
-      print "\rIdentified #{identified_records.size} records..."
+      @identified_records_count ||= identified_records.size
+      if @identified_records_count != identified_records.size
+        puts "Identified #{identified_records.size} records..."
+        @identified_records_count = identified_records.size
+      end
     end
 
     def identify_associated_records(root, associations)
@@ -62,7 +67,12 @@ module Syncify
       polymorphic_associations = associations.select(&method(:includes_polymorphic_association))
 
       standard_associations.each do |association|
-        traverse_associations(root.class.eager_load(association).find(root.id), association)
+        begin
+          traverse_associations(root.class.eager_load(association).find(root.id), association)
+        rescue StandardError => e
+          binding.pry
+          x = 1231231231
+        end
       end
 
       identify_polymorphic_associated_records(root, polymorphic_associations)
@@ -70,20 +80,26 @@ module Syncify
 
     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)
-          next if target.nil?
-          type = polymorphic_association.associations.keys.detect do |association_type|
-            target.is_a?(association_type)
+        property = polymorphic_association.keys.first
+        nested_associations = polymorphic_association[property]
+
+        referenced_objects = Array.wrap(root.__send__(property))
+        next if referenced_objects.empty?
+
+        referenced_objects.each do |referenced_object|
+          # TODO: there's got to be a better way to express this
+          if polymorphic_association.values.first.keys.all? { |key| key.is_a? Class }
+            # TODO: please, Doug. Fix the names!!!
+            associated_types = nested_associations.keys
+            referenced_type = associated_types.find { |type| referenced_object.is_a?(type) }
+
+            identify_associated_records(
+              referenced_object,
+              normalized_associations(nested_associations[referenced_type])
+            )
+          else
+            identify_associated_records(referenced_object, normalized_associations(nested_associations))
           end
-          associations = polymorphic_association.associations[type]
-          identify_associated_records(target, normalized_associations(associations))
         end
       end
     end
@@ -96,7 +112,8 @@ module Syncify
 
       records.each do |record|
         associations.each do |association, nested_associations|
-          if is_through_association?(record, association)
+          puts "Traversing #{record.class.name}##{association}"
+          if through_association?(record, association)
             traverse_associations(
               record.__send__(
                 record.class.reflect_on_association(association).through_reflection.name
@@ -106,7 +123,7 @@ module Syncify
           else
             associated_records = record.__send__(association)
 
-            if is_has_and_belongs_to_many_association?(record, association)
+            if has_and_belongs_to_many_association?(record, association)
               cache_has_and_belongs_to_many_association(record, association, associated_records)
             end
 
@@ -121,12 +138,12 @@ module Syncify
       has_and_belongs_to_many_associations[record][association] = Array(associated_records)
     end
 
-    def is_has_and_belongs_to_many_association?(record, association)
+    def has_and_belongs_to_many_association?(record, association)
       record.class.reflect_on_association(association).class ==
         ActiveRecord::Reflection::HasAndBelongsToManyReflection
     end
 
-    def is_through_association?(record, association)
+    def through_association?(record, association)
       record.class.reflect_on_association(association).class ==
         ActiveRecord::Reflection::ThroughReflection
     end
@@ -142,12 +159,17 @@ module Syncify
 
         has_and_belongs_to_many_associations.each do |record, associations|
           associations.each do |association, associated_records|
-            local_record = record.class.find(record.id)
-            local_associated_records = associated_records.map do |associated_record|
-              associated_record.class.find(associated_record.id)
+            begin
+              local_record = record.class.find(record.id)
+              local_associated_records = associated_records.map do |associated_record|
+                associated_record.class.find(associated_record.id)
+              end
+              local_record.__send__(association) << local_associated_records
+              local_record.save
+            rescue StandardError => e
+              binding.pry
+              x = 123
             end
-            local_record.__send__(association) << local_associated_records
-            local_record.save
           end
         end
       end
@@ -176,7 +198,11 @@ module Syncify
     end
 
     def includes_polymorphic_association(association)
-      association.to_s.include?('Syncify::PolymorphicAssociation')
+      return false if association.nil?
+      return false if association == {}
+      return true if association.keys.all? { |key| key.is_a? Class }
+
+      includes_polymorphic_association(association.values.first)
     end
 
     def normalized_associations(association)

data/lib/syncify/version.rb

@@ -1,3 +1,3 @@
 module Syncify
-  VERSION = "0.1.6"
+  VERSION = "0.1.10"
 end

data/syncify.gemspec

@@ -34,6 +34,6 @@ Gem::Specification.new do |spec|
   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", "~> 5.0"
   spec.add_runtime_dependency "activerecord-import", "~> 0.17"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: syncify
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.10
 platform: ruby
 authors:
 - Doug Hughes
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-23 00:00:00.000000000 Z
+date: 2019-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: activerecord-import
   requirement: !ruby/object:Gem::Requirement
@@ -161,8 +161,12 @@ files:
 - bin/console
 - bin/setup
 - lib/syncify.rb
+- lib/syncify/association/polymorphic_association.rb
+- lib/syncify/association/standard_association.rb
+- lib/syncify/hint/basic_hint.rb
+- lib/syncify/hint/hint.rb
+- lib/syncify/identify_associations.rb
 - lib/syncify/normalize_associations.rb
-- lib/syncify/polymorphic_association.rb
 - lib/syncify/sync.rb
 - lib/syncify/version.rb
 - syncify.gemspec

data/lib/syncify/polymorphic_association.rb

@@ -1,13 +0,0 @@
-# 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