restforce-db 1.2.9 → 1.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa1372a2f8baf6d0af77a254f0360d6ad37aef11
-  data.tar.gz: 323beb3762fbf77ef7aa79f0465924260d22432d
+  metadata.gz: 34a3066aca21ed017edf09525c13198135e093e1
+  data.tar.gz: 1a16d555df7e28351425a1b3556361a203b3f0c6
 SHA512:
-  metadata.gz: ad8b9ed0abf1e713b416a1e352f2c65de949dde70d7ee08db7c3fb40240995a90f7ac4b912b8e34cefa625db2630fd942b40d0a9b61f15661138a69548ed1706
-  data.tar.gz: 5d065ba0b3078f5b5f67c6f7cb8f1de520eb5049bde8cd31b2f73c5ef6cf029ff16ae9a7337e128dc1fae18828b2d54cbe028613b74511f33a62522376f772ce
+  metadata.gz: ae15efd7ee63784a25e2a4946135d92ccb32a11950d377058e4f869f16130f4bc0e66b034507caf8dfba280e3c84dfa9d91c55ea0d37997449372a0169d7770a
+  data.tar.gz: 0a8268c35e4b99ae4586d51b5b69a34ae654c0a2939c07020133726fb6a0ea8ddbdc82cb623d75b3703ce27027fe009916ef109bce1d7f806fa0d49f79896062

data/lib/restforce/db/association_cache.rb

@@ -10,8 +10,11 @@ module Restforce
       attr_reader :cache
 
       # Public: Initialize a new Restforce::DB::AssociationCache.
-      def initialize
+      #
+      # record - An instance of ActiveRecord::Base (optional).
+      def initialize(record = nil)
         @cache = Hash.new { |h, k| h[k] = [] }
+        self << record if record
       end
 
       # Public: Add a record to the cache.

data/lib/restforce/db/associations/belongs_to.rb

@@ -14,10 +14,10 @@ module Restforce
         #
         # database_record   - An instance of an ActiveRecord::Base subclass.
         # salesforce_record - A Hashie::Mash representing a Salesforce object.
-        # cache             - A Restforce::DB::AssociationCache.
+        # cache             - A Restforce::DB::AssociationCache (optional).
         #
         # Returns an Array of constructed association records.
-        def build(database_record, salesforce_record, cache = AssociationCache.new)
+        def build(database_record, salesforce_record, cache = AssociationCache.new(database_record))
           @cache = cache
 
           lookups = {}
@@ -45,6 +45,30 @@ module Restforce
           @cache = nil
         end
 
+        # Public: Get a Hash of Lookup IDs for a specified database record,
+        # based on the current record for this association.
+        #
+        # database_record - An instance of an ActiveRecord::Base subclass.
+        #
+        # Returns a Hash.
+        def lookups(database_record)
+          ids = {}
+
+          for_mappings(database_record) do |mapping, lookup|
+            associated = database_record.association(name).reader
+
+            ids[lookup] =
+              if associated
+                # It's possible to define a belongs_to association in a Mapping
+                # for what is actually a one-to-many association on the
+                # ActiveRecord object.
+                Array(associated).first.send(mapping.lookup_column)
+              end
+          end
+
+          ids
+        end
+
         private
 
         # Internal: Iterate through all relevant mappings for the target
@@ -65,7 +89,7 @@ module Restforce
         # Internal: Get the Salesforce ID belonging to the associated record
         # for a supplied instance. Must be implemented per-association.
         #
-        # instance - A Restforce::DB::Instances::Base
+        # instance - A Restforce::DB::Instances::Base.
         #
         # Returns a String.
         def associated_salesforce_id(instance)

data/lib/restforce/db/associations/has_many.rb

@@ -14,17 +14,17 @@ module Restforce
         #
         # database_record   - An instance of an ActiveRecord::Base subclass.
         # salesforce_record - A Hashie::Mash representing a Salesforce object.
-        # cache             - A Restforce::DB::AssociationCache.
+        # cache             - A Restforce::DB::AssociationCache (optional).
         #
         # Returns an Array of constructed association records.
-        def build(database_record, salesforce_record, cache = AssociationCache.new)
+        def build(database_record, salesforce_record, cache = AssociationCache.new(database_record))
           @cache = cache
 
           target = target_mapping(database_record)
           lookup_id = "#{lookup_field(target, database_record)} = '#{salesforce_record.Id}'"
 
           records = []
-          target.salesforce_record_type.each(conditions: lookup_id) do |instance|
+          target.salesforce_record_type.all(conditions: lookup_id).each do |instance|
             records << construct_for(database_record, instance)
           end
 

data/lib/restforce/db/associations/has_one.rb

@@ -14,10 +14,10 @@ module Restforce
         #
         # database_record   - An instance of an ActiveRecord::Base subclass.
         # salesforce_record - A Hashie::Mash representing a Salesforce object.
-        # cache             - A Restforce::DB::AssociationCache.
+        # cache             - A Restforce::DB::AssociationCache (optional).
         #
         # Returns an Array of constructed association records.
-        def build(database_record, salesforce_record, cache = AssociationCache.new)
+        def build(database_record, salesforce_record, cache = AssociationCache.new(database_record))
           @cache = cache
 
           target = target_mapping(database_record)

data/lib/restforce/db/associator.rb

@@ -0,0 +1,104 @@
+module Restforce
+
+  module DB
+
+    # Restforce::DB::Associator is responsible for determining when one or more
+    # associations have been updated to point to a new Salesforce/database
+    # record, and propagate the modification to the opposite system when this
+    # occurs.
+    class Associator
+
+      # Public: Initialize a new Restforce::DB::Associator.
+      #
+      # mapping - A Restforce::DB::Mapping instance.
+      # runner  - A Restforce::DB::Runner instance.
+      def initialize(mapping, runner = Runner.new)
+        @mapping = mapping
+        @runner = runner
+      end
+
+      # Public: Run the re-association process, pulling in records from
+      # Salesforce and the database to determine the most recently attached
+      # association, then propagating the change between systems.
+      #
+      # Returns nothing.
+      def run
+        return if belongs_to_associations.empty?
+
+        @runner.run(@mapping) do |run|
+          run.salesforce_instances.each { |instance| verify_associations(instance) }
+          run.database_instances.each { |instance| verify_associations(instance) }
+        end
+      end
+
+      private
+
+      # Internal: Ensure integrity between the lookup columns in Salesforce and
+      # the synchronized records in the database.
+      #
+      # instance - A Restforce::DB::Instances::Base.
+      #
+      # Returns nothing.
+      def verify_associations(instance)
+        database_instance, salesforce_instance =
+          case instance
+          when Restforce::DB::Instances::Salesforce
+            [@mapping.database_record_type.find(instance.id), instance]
+          when Restforce::DB::Instances::ActiveRecord
+            [instance, @mapping.salesforce_record_type.find(instance.id)]
+          end
+
+        return unless database_instance && salesforce_instance
+        sync_associations(database_instance, salesforce_instance)
+      end
+
+      # Internal: Given a database record and corresponding Salesforce data,
+      # synchronize the record associations in whichever system has the least
+      # recent data.
+      #
+      # database_instance   - A Restforce::DB::Instances::ActiveRecord.
+      # salesforce_instance - A Restforce::DB::Instances::Salesforce.
+      #
+      # Returns nothing.
+      def sync_associations(database_instance, salesforce_instance)
+        ids = belongs_to_association_ids(database_instance)
+        return if ids.all? { |field, id| salesforce_instance.record[field] == id }
+
+        if database_instance.last_update > salesforce_instance.last_update
+          salesforce_instance.update!(ids)
+        else
+          database_record = database_instance.record
+          belongs_to_associations.each do |association|
+            association.build(database_record, salesforce_instance.record)
+          end
+          database_record.save!
+        end
+      end
+
+      # Internal: Get a Hash of associated lookup IDs for the passed database
+      # record.
+      #
+      # database_instance - A Restforce::DB::Instances::ActiveRecord.
+      #
+      # Returns a Hash.
+      def belongs_to_association_ids(database_instance)
+        belongs_to_associations.inject({}) do |ids, association|
+          ids.merge(association.lookups(database_instance.record))
+        end
+      end
+
+      # Internal: Get a list of the BelongsTo associations defined for the
+      # target mapping.
+      #
+      # Returns an Array of Restforce::DB::Association::BelongsTo objects.
+      def belongs_to_associations
+        @belongs_to_associations ||= @mapping.associations.select do |association|
+          association.is_a?(Restforce::DB::Associations::BelongsTo)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/restforce/db/cleaner.rb

@@ -20,7 +20,7 @@ module Restforce
       #
       # Returns nothing.
       def run
-        return if @strategy.passive?
+        return if @mapping.conditions.empty? || @strategy.passive?
         @mapping.database_record_type.destroy_all(invalid_salesforce_ids)
       end
 
@@ -40,15 +40,7 @@ module Restforce
       #
       # Returns an Array of IDs.
       def all_salesforce_ids
-        all_ids = []
-
-        @mapping.unscoped do |map|
-          @runner.run(map) do |run|
-            run.salesforce_records { |record| all_ids << record.id }
-          end
-        end
-
-        all_ids
+        @mapping.unscoped { valid_salesforce_ids }
       end
 
       # Internal: Get the IDs of the recently-modified Salesforce records which
@@ -56,13 +48,9 @@ module Restforce
       #
       # Returns an Array of IDs.
       def valid_salesforce_ids
-        valid_ids = []
-
         @runner.run(@mapping) do |run|
-          run.salesforce_records { |record| valid_ids << record.id }
+          run.salesforce_instances.map(&:id)
         end
-
-        valid_ids
       end
 
     end

data/lib/restforce/db/collector.rb

@@ -8,8 +8,6 @@ module Restforce
     # locate recently-updated records and fetch their attributes.
     class Collector
 
-      attr_reader :last_run
-
       # Public: Initialize a new Restforce::DB::Collector.
       #
       # mapping - A Restforce::DB::Mapping instance.
@@ -30,8 +28,8 @@ module Restforce
         @accumulated_changes = accumulator || accumulated_changes
 
         @runner.run(@mapping) do |run|
-          run.salesforce_records { |record| accumulate(record) }
-          run.database_records { |record| accumulate(record) }
+          run.salesforce_instances.each { |instance| accumulate(instance) }
+          run.database_instances.each { |instance| accumulate(instance) }
         end
 
         accumulated_changes

data/lib/restforce/db/initializer.rb

@@ -25,8 +25,8 @@ module Restforce
         return if @strategy.passive?
 
         @runner.run(@mapping) do |run|
-          run.salesforce_records { |record| create_in_database(record) }
-          run.database_records { |record| create_in_salesforce(record) }
+          run.salesforce_instances.each { |instance| create_in_database(instance) }
+          run.database_instances.each { |instance| create_in_salesforce(instance) }
         end
       end
 
@@ -36,24 +36,24 @@ module Restforce
       # passed Salesforce record. Does nothing if the Salesforce record has
       # already been synchronized into the system at least once.
       #
-      # record - A Restforce::DB::Instances::Salesforce.
+      # instance - A Restforce::DB::Instances::Salesforce.
       #
       # Returns nothing.
-      def create_in_database(record)
-        return unless @strategy.build?(record)
-        @mapping.database_record_type.create!(record)
+      def create_in_database(instance)
+        return unless @strategy.build?(instance)
+        @mapping.database_record_type.create!(instance)
       end
 
       # Internal: Attempt to create a partner record in Salesforce for the
       # passed database record. Does nothing if the database record already has
       # an associated Salesforce record.
       #
-      # record - A Restforce::DB::Instances::ActiveRecord.
+      # instance - A Restforce::DB::Instances::ActiveRecord.
       #
       # Returns nothing.
-      def create_in_salesforce(record)
-        return if record.synced?
-        @mapping.salesforce_record_type.create!(record)
+      def create_in_salesforce(instance)
+        return if instance.synced?
+        @mapping.salesforce_record_type.create!(instance)
       end
 
     end

data/lib/restforce/db/record_types/active_record.rb

@@ -44,8 +44,8 @@ module Restforce
           Instances::ActiveRecord.new(@record_type, record, @mapping)
         end
 
-        # Public: Iterate through all recently-updated ActiveRecord records of
-        # this type.
+        # Public: Get a collection of all modified ActiveRecord records of this
+        # type which match the passed criteria.
         #
         # options - A Hash of options which should be applied to the set of
         #           fetched records. Allowed options are:
@@ -54,15 +54,14 @@ module Restforce
         #           :after  - A Time object defining the least recent update
         #                     timestamp for which records should be returned.
         #
-        # Yields a series of Restforce::DB::Instances::ActiveRecord instances.
-        # Returns nothing.
-        def each(options = {})
+        # Returns an Array of Restforce::DB::Instances::ActiveRecord instances.
+        def all(options = {})
           scope = @record_type.where("updated_at > synchronized_at OR synchronized_at IS NULL")
           scope = scope.where("updated_at < ?", options[:before]) if options[:before]
           scope = scope.where("updated_at >= ?", options[:after]) if options[:after]
 
-          scope.find_each do |record|
-            yield Instances::ActiveRecord.new(@record_type, record, @mapping)
+          scope.map do |record|
+            Instances::ActiveRecord.new(@record_type, record, @mapping)
           end
         end
 

data/lib/restforce/db/record_types/base.rb

@@ -8,8 +8,6 @@ module Restforce
       # models defined in the Restforce::DB::RecordTypes namespace.
       class Base
 
-        include Enumerable
-
         # Public: Initialize a new Restforce::DB::RecordTypes::Base.
         #
         # record_type - The name or class of the system record type.

data/lib/restforce/db/record_types/salesforce.rb

@@ -47,7 +47,8 @@ module Restforce
           first("Id = '#{id}'")
         end
 
-        # Public: Iterate through all Salesforce records of this type.
+        # Public: Get a collection of all Salesforce records of this type which
+        # match the passed criteria.
         #
         # options - A Hash of options which should be applied to the set of
         #           fetched records. Allowed options are:
@@ -60,17 +61,16 @@ module Restforce
         #           :conditions - An Array of conditions to append to the lookup
         #                         query.
         #
-        # Yields a series of Restforce::DB::Instances::Salesforce instances.
-        # Returns nothing.
-        def each(options = {})
+        # Returns an Array of Restforce::DB::Instances::Salesforce instances.
+        def all(options = {})
           constraints = [
             ("SystemModstamp < #{options[:before].utc.iso8601}" if options[:before]),
             ("SystemModstamp >= #{options[:after].utc.iso8601}" if options[:after]),
             *options[:conditions],
           ]
 
-          DB.client.query(query(*constraints)).each do |record|
-            yield Instances::Salesforce.new(@record_type, record, @mapping)
+          DB.client.query(query(*constraints)).map do |record|
+            Instances::Salesforce.new(@record_type, record, @mapping)
           end
         end
 

data/lib/restforce/db/runner.rb

@@ -19,6 +19,7 @@ module Restforce
       def initialize(delay = 0, last_run_time = DB.last_run)
         @delay = delay
         @last_run = last_run_time
+        @cache = RunnerCache.new
       end
 
       # Public: Indicate that a new phase of the run is beginning. Updates the
@@ -26,6 +27,7 @@ module Restforce
       #
       # Returns the new run Time.
       def tick!
+        @cache.reset
         run_time = Time.now
 
         @before = run_time - @delay
@@ -50,19 +52,17 @@ module Restforce
       # Public: Iterate through recently-updated records for the Salesforce
       # record type defined by the current mapping.
       #
-      # Yields a series of Restforce::DB::Instances::Salesforce objects.
-      # Returns nothing.
-      def salesforce_records
-        @mapping.salesforce_record_type.each(options) { |record| yield record }
+      # Returns an Enumerator yielding Restforce::DB::Instances::Salesforces.
+      def salesforce_instances
+        @cache.collection(@mapping, :salesforce_record_type, options)
       end
 
       # Public: Iterate through recently-updated records for the database model
       # record type defined by the current mapping.
       #
-      # Yields a series of Restforce::DB::Instances::ActiveRecord objects.
-      # Returns nothing.
-      def database_records
-        @mapping.database_record_type.each(options) { |record| yield record }
+      # Returns an Enumerator yielding Restforce::DB::Instances::ActiveRecords.
+      def database_instances
+        @cache.collection(@mapping, :database_record_type, options)
       end
 
       private

data/lib/restforce/db/runner_cache.rb

@@ -0,0 +1,93 @@
+module Restforce
+
+  module DB
+
+    # Restforce::DB::RunnerCache serves as a means of caching the collections of
+    # recently-updated database and Salesforce instances for passed mappings.
+    # The general goal is to avoid making repetitive Salesforce API calls or
+    # database queries, and ensure a consistent list of objects during a
+    # synchronization run.
+    class RunnerCache
+
+      # Public: Initialize a new Restforce::DB::RunnerCache.
+      def initialize
+        reset
+      end
+
+      # Public: Iterate through the recently-updated instances of the specified
+      # type for the passed mapping. Memoizes the records if the collection has
+      # not previously been cached.
+      #
+      # mapping     - A Restforce::DB::Mapping.
+      # record_type - A Symbol naming a mapping record type. Valid values are
+      #               :salesforce_record_type or :database_record_type.
+      # options     - A Hash of options to pass to `all` (optional).
+      #
+      # Returns an Array of Restforce::DB::Instances::Base.
+      def collection(mapping, record_type, options = {})
+        return cached_value(mapping, record_type) if cached?(mapping, record_type)
+        cache(mapping, record_type, mapping.send(record_type).all(options))
+      end
+
+      # Public: Reset the cache. Should be invoked between runs to ensure that
+      # new options are respected.
+      #
+      # Returns nothing.
+      def reset
+        @cache = Hash.new { |h, k| h[k] = {} }
+      end
+
+      private
+
+      # Internal: Store the supplied value in the cache for the passed mapping
+      # and record type.
+      #
+      # mapping     - A Restforce::DB::Mapping.
+      # record_type - A Symbol naming a mapping record type. Valid values are
+      #               :salesforce_record_type or :database_record_type.
+      #
+      # Returns the cached value.
+      def cache(mapping, record_type, value)
+        @cache[record_type][key_for(mapping)] = value
+      end
+
+      # Internal: Get the cached collection for the passed mapping and record
+      # type.
+      #
+      # mapping     - A Restforce::DB::Mapping.
+      # record_type - A Symbol naming a mapping record type. Valid values are
+      #               :salesforce_record_type or :database_record_type.
+      #
+      # Returns nil or an Array.
+      def cached_value(mapping, record_type)
+        @cache[record_type][key_for(mapping)]
+      end
+
+      # Internal: Have we cached a collection for the passed mapping and record
+      # type?
+      #
+      # mapping     - A Restforce::DB::Mapping.
+      # record_type - A Symbol naming a mapping record type. Valid values are
+      #               :salesforce_record_type or :database_record_type.
+      #
+      # Returns a Boolean.
+      def cached?(mapping, record_type)
+        !cached_value(mapping, record_type).nil?
+      end
+
+      # Internal: Get a unique key with enough information to look up the passed
+      # mapping in the cache. Scopes the mapping by its current list of
+      # conditions.
+      #
+      # mapping - A Restforce::DB::Mapping.
+      #
+      # Returns an Object.
+      def key_for(mapping)
+        [mapping, mapping.conditions]
+      end
+
+    end
+
+  end
+
+end

data/lib/restforce/db/version.rb

@@ -3,7 +3,7 @@ module Restforce
   # :nodoc:
   module DB
 
-    VERSION = "1.2.9"
+    VERSION = "1.2.10"
 
   end
 

data/lib/restforce/db/worker.rb

@@ -37,15 +37,7 @@ module Restforce
       #
       # Returns nothing.
       def start
-        trap("TERM") do
-          Thread.new { log "Exiting..." }
-          stop
-        end
-
-        trap("INT") do
-          Thread.new { log "Exiting..." }
-          stop
-        end
+        trap_signals
 
         loop do
           runtime = Benchmark.realtime { perform }
@@ -60,11 +52,22 @@ module Restforce
       #
       # Returns nothing.
       def stop
+        Thread.new { log "Exiting..." }
         @exit = true
       end
 
       private
 
+      # Internal: Configure the main loop to trap specific signals, triggering
+      # an exit once the loop completes.
+      #
+      # Return nothing.
+      def trap_signals
+        %w(TERM INT).each do |signal|
+          trap(signal) { stop }
+        end
+      end
+
       # Internal: Perform the synchronization loop, recording the time that the
       # run is performed so that future runs can pick up where the last run
       # left off.
@@ -79,6 +82,7 @@ module Restforce
             task("PROPAGATING RECORDS", mapping) { propagate mapping }
             task("CLEANING RECORDS", mapping) { clean mapping }
             task("COLLECTING CHANGES", mapping) { collect mapping }
+            task("UPDATING ASSOCIATIONS", mapping) { associate mapping }
           end
 
           # NOTE: We can only perform the synchronization after all record
@@ -151,6 +155,16 @@ module Restforce
         Collector.new(mapping, runner).run(@changes)
       end
 
+      # Internal: Update the associated records and Salesforce lookups for
+      # records belonging to the passed mapping.
+      #
+      # mapping - A Restforce::DB::Mapping.
+      #
+      # Returns nothing.
+      def associate(mapping)
+        Associator.new(mapping, runner).run
+      end
+
       # Internal: Apply the aggregated changes to the objects in both systems,
       # according to the defined mappings.
       #

data/lib/restforce/db.rb

@@ -28,9 +28,11 @@ require "restforce/db/strategies/always"
 require "restforce/db/strategies/associated"
 require "restforce/db/strategies/passive"
 
+require "restforce/db/runner_cache"
 require "restforce/db/runner"
 
 require "restforce/db/accumulator"
+require "restforce/db/associator"
 require "restforce/db/attribute_map"
 require "restforce/db/cleaner"
 require "restforce/db/collector"

data/restforce-db.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files`.split($RS)
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(/^exe\//) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activerecord"
@@ -30,11 +30,11 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.8"
   spec.add_development_dependency "database_cleaner"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest", "5.5.1"
   spec.add_development_dependency "minitest-spec-expect"
   spec.add_development_dependency "minitest-vcr"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop", ">= 0.30.0"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "webmock"
 end