synced 1.0.9 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08ba04139b6a3f35c0d72930ec44b13b65dff37b
-  data.tar.gz: 30e35e40ad1dd24130a00be545e33a7c8c5bc083
+  metadata.gz: 4220ff2ed647669303e132040f72a13835a2ea11
+  data.tar.gz: 575e7b3ba5985f389655252f040b279ec80976fc
 SHA512:
-  metadata.gz: c906440ffad6ff1974f8f9cbcee2f8efb2c80da92335e7a2a424a76cf5f56410b20ab1ec69b3471a12b4900d25a12abc917877dc794bfcf063ed8611e63e552a
-  data.tar.gz: b4d93a8d7c8d60ff78f7ced2c9a2bab555fe5e26a01d0e5767debd1017f464b7bc4995adc37cfa697b62c806cdfa9cf4068fffa97a19c0529c2c6f3157686d1d
+  metadata.gz: 1168823d0315ebbeff7524139d86fe17defd940d2371ff6fa634471d7033d5d28eb38cca898871e009b0fe47b5e482eb215d799a0b7bc1721046ba2eea4147b5
+  data.tar.gz: 0f6eaf9fac8a72b73f2b001afef26521485b88fa3e3279b64dce0054b0eb33aed927379843d20de869c0daf82222b80e475a6128bd1e82199c576c7a28510202

data/lib/synced/model.rb

@@ -98,7 +98,7 @@ module Synced
     def synchronize(options = {})
       options.symbolize_keys!
       options.assert_valid_keys(:api, :fields, :include, :remote, :remove,
-        :scope)
+        :scope, :strategy)
       options[:remove]  = synced_remove unless options.has_key?(:remove)
       options[:include] = Array(synced_include) unless options.has_key?(:include)
       options[:fields]  = Array(synced_fields) unless options.has_key?(:fields)

data/lib/synced/strategies/check.rb

@@ -0,0 +1,54 @@
+module Synced
+  module Strategies
+    # This strategy doesn't do any synchronization it simply verifies if local objects are in sync
+    # with the remote ones (taken from the API).
+    class Check < Full
+      attr_reader :result
+
+      def initialize(model_class, options = {})
+        super
+        @result = Result.new
+      end
+
+      # Makes a DRY run of full synchronization. It checks and collects objects which
+      #   * are present in the local database, but not in the API. Local AR object is
+      #      returned - additional objects
+      #   * are present in the API, but not in the local database, remote object is
+      #      returned - missing objects
+      #   * are changed in the API, but not in the local database,
+      #      ActiveRecord::Model #changes hash is returned - changed objects
+      # @return [Synced::Strategies::Check::Result] Integrity check result
+      def perform
+        result.additional = remove_relation.to_a
+        remote_objects.map do |remote|
+          if local_object = local_object_by_remote_id(remote.id)
+            remote.extend(@mapper) if @mapper
+            local_object.attributes = default_attributes_mapping(remote)
+            local_object.attributes = local_attributes_mapping(remote)
+            if @globalized_attributes.present?
+              local_object.attributes = globalized_attributes_mapping(remote,
+                local_object.translations.translated_locales)
+            end
+            result.changed << local_object.changes if local_object.changed?
+          else
+            result.missing << remote
+          end
+        end
+        result
+      end
+
+      # Represents result of synchronization integrity check
+      class Result
+        attr_accessor :changed, :missing, :additional
+
+        def initialize
+          @changed, @missing, @additional = [], [], []
+        end
+
+        def passed?
+          changed.empty? && missing.empty? && additional.empty?
+        end
+      end
+    end
+  end
+end

data/lib/synced/strategies/full.rb

@@ -0,0 +1,229 @@
+module Synced
+  module Strategies
+    # This strategy performs full synchronization.
+    # It takes all the objects from the API and
+    #   - creates missing in the local database
+    #   - removes local objects which are missing the API
+    #   - updates local objects which are changed in the API
+    # This is the base synchronization strategy.
+    class Full
+      include AttributesAsHash
+
+      # Initializes new Full sync strategy
+      #
+      # @param remote_objects [Array|NilClass] Array of objects to be synchronized
+      #   with local database. Objects need to respond to at least :id message.
+      #   If it's nil, then synchronizer will fetch the remote objects on it's own from the API.
+      # @param model_class [Class] ActiveRecord model class from which local objects
+      #   will be created.
+      # @param options [Hash]
+      # @option options [Symbol] scope: Within this object scope local objects
+      #   will be synchronized. By default it's model_class.
+      # @option options [Symbol] id_key: attribute name under which
+      #   remote object's ID is stored, default is :synced_id.
+      # @option options [Symbol] synced_all_at_key: attribute name under which
+      #   remote object's sync time is stored, default is :synced_all_at
+      # @option options [Symbol] data_key: attribute name under which remote
+      #   object's data is stored.
+      # @option options [Array] local_attributes: Array of attributes in the remote
+      #   object which will be mapped to local object attributes.
+      # @option options [Boolean] remove: If it's true all local objects within
+      #   current scope which are not present in the remote array will be destroyed.
+      #   If only_updated is enabled, ids of objects to be deleted will be taken
+      #   from the meta part. By default if cancel_at column is present, all
+      #   missing local objects will be canceled with cancel_all,
+      #   if it's missing, all will be destroyed with destroy_all.
+      #   You can also force method to remove local objects by passing it
+      #   to remove: :mark_as_missing.
+      # @param api [BookingSync::API::Client] - API client to be used for fetching
+      #   remote objects
+      # @option options [Boolean] only_updated: If true requests to API will take
+      #   advantage of updated_since param and fetch only created/changed/deleted
+      #   remote objects
+      # @option options [Module] mapper: Module class which will be used for
+      #   mapping remote objects attributes into local object attributes
+      # @option options [Array|Hash] globalized_attributes: A list of attributes
+      #   which will be mapped with their translations.
+      def initialize(model_class, options = {})
+        @model_class           = model_class
+        @scope                 = options[:scope]
+        @id_key                = options[:id_key]
+        @synced_all_at_key     = options[:synced_all_at_key]
+        @data_key              = options[:data_key]
+        @remove                = options[:remove]
+        @only_updated          = options[:only_updated]
+        @include               = options[:include]
+        @local_attributes      = synced_attributes_as_hash(options[:local_attributes])
+        @api                   = options[:api]
+        @mapper                = options[:mapper].respond_to?(:call) ?
+                                   options[:mapper].call : options[:mapper]
+        @fields                = options[:fields]
+        @remove                = options[:remove]
+        @associations          = Array(options[:associations])
+        @perform_request       = options[:remote].nil?
+        @remote_objects        = Array(options[:remote]) unless @perform_request
+        @globalized_attributes = synced_attributes_as_hash(options[:globalized_attributes])
+      end
+
+      def perform
+        instrument("perform.synced", model: @model_class) do
+          relation_scope.transaction do
+            instrument("remove_perform.synced", model: @model_class) do
+              remove_relation.send(remove_strategy) if @remove
+            end
+            instrument("sync_perform.synced", model: @model_class) do
+              remote_objects.map do |remote|
+                remote.extend(@mapper) if @mapper
+                local_object = local_object_by_remote_id(remote.id) || relation_scope.new
+                local_object.attributes = default_attributes_mapping(remote)
+                local_object.attributes = local_attributes_mapping(remote)
+                if @globalized_attributes.present?
+                  local_object.attributes = globalized_attributes_mapping(remote,
+                    local_object.translations.translated_locales)
+                end
+                local_object.save! if local_object.changed?
+                local_object.tap do |local_object|
+                  synchronize_associations(remote, local_object)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def synchronize_associations(remote, local_object)
+        @associations.each do |association|
+          klass = association.to_s.classify.constantize
+          klass.synchronize(remote: remote[association], scope: local_object, remove: @remove)
+        end
+      end
+
+      def local_attributes_mapping(remote)
+        Hash[@local_attributes.map do |k, v|
+          [k, v.respond_to?(:call) ? v.call(remote) : remote.send(v)]
+        end]
+      end
+
+      def default_attributes_mapping(remote)
+        {}.tap do |attributes|
+          attributes[@id_key] = remote.id
+          attributes[@data_key] = remote if @data_key
+        end
+      end
+
+      def globalized_attributes_mapping(remote, used_locales)
+        empty = Hash[used_locales.map { |locale| [locale.to_s, nil] }]
+        {}.tap do |attributes|
+          @globalized_attributes.each do |local_attr, remote_attr|
+            translations = empty.merge(remote.send(remote_attr) || {})
+            attributes["#{local_attr}_translations"] = translations
+          end
+        end
+      end
+
+      # Returns relation within which local objects are created/edited and removed
+      # If no scope is provided, the relation_scope will be class on which
+      # .synchronize method is called.
+      # If scope is provided, like: account, then relation_scope will be a relation
+      # account.rentals (given we run .synchronize on Rental class)
+      #
+      # @return [ActiveRecord::Relation|Class]
+      def relation_scope
+        if @scope
+          @model_class.unscoped { @scope.send(resource_name).scope }
+        else
+          @model_class.unscoped
+        end
+      end
+
+      # Returns api client from the closest possible source.
+      #
+      # @raise [BookingSync::API::Unauthorized] - On unauthorized user
+      # @return [BookingSync::API::Client] BookingSync API client
+      def api
+        return @api if @api
+        closest = [@scope, @scope.class, @model_class].find do |object|
+                    object.respond_to?(:api)
+                  end
+        closest.try(:api) || raise(MissingAPIClient.new(@scope, @model_class))
+      end
+
+      def local_object_by_remote_id(remote_id)
+        local_objects.find { |l| l.public_send(@id_key) == remote_id }
+      end
+
+      def local_objects
+        @local_objects ||= relation_scope.where(@id_key => remote_objects_ids).to_a
+      end
+
+      def remote_objects_ids
+        @remote_objects_ids ||= remote_objects.map(&:id)
+      end
+
+      def remote_objects
+        @remote_objects ||= @perform_request ? fetch_remote_objects : nil
+      end
+
+      def fetch_remote_objects
+        instrument("fetch_remote_objects.synced", model: @model_class) do
+          api.paginate(resource_name, api_request_options)
+        end
+      end
+
+      def api_request_options
+        {}.tap do |options|
+          options[:include] = @associations if @associations.present?
+          if @include.present?
+            options[:include] ||= []
+            options[:include] += @include
+          end
+          options[:fields] = @fields if @fields.present?
+          options[:auto_paginate] = true
+        end
+      end
+
+      def resource_name
+        @model_class.to_s.tableize
+      end
+
+      def remove_strategy
+        @remove == true ? default_remove_strategy : @remove
+      end
+
+      def default_remove_strategy
+        if @model_class.column_names.include?("canceled_at")
+          :cancel_all
+        else
+          :destroy_all
+        end
+      end
+
+      # Remove all local objects which are not present in the remote objects
+      def remove_relation
+        relation_scope.where.not(@id_key => remote_objects_ids)
+      end
+
+      def instrument(*args, &block)
+        Synced.instrumenter.instrument(*args, &block)
+      end
+
+      class MissingAPIClient < StandardError
+        def initialize(scope, model_class)
+          @scope = scope
+          @model_class = model_class
+        end
+
+        def message
+          if @scope
+            %Q{Missing BookingSync API client in #{@scope} object or \
+#{@scope.class} class when synchronizing #{@model_class} model}
+          else
+            %Q{Missing BookingSync API client in #{@model_class} class}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/synced/strategies/updated_since.rb

@@ -0,0 +1,75 @@
+module Synced
+  module Strategies
+    # This strategy performs partial synchronization.
+    # It fetches only changes (additions, modifications and deletions) from the API.
+    class UpdatedSince < Full
+      # @option options [Time|Proc] initial_sync_since: A point in time from which
+      #   objects will be synchronized on first synchronization.
+      def initialize(model_class, options = {})
+        super
+        @initial_sync_since = options[:initial_sync_since]
+      end
+
+      def perform
+        super.tap do |local_objects|
+          instrument("update_synced_all_at_perform.synced", model: @model_class) do
+            # TODO: it can't be Time.now. this value has to be fetched from the API as well
+            # https://github.com/BookingSync/synced/issues/29
+            relation_scope.update_all(@synced_all_at_key => Time.now)
+          end
+        end
+      end
+
+      private
+
+      def api_request_options
+        super.merge(updated_since: updated_since)
+      end
+
+      def initial_sync_since
+        if @initial_sync_since.respond_to?(:call)
+          @initial_sync_since.arity == 0 ? @initial_sync_since.call :
+            @initial_sync_since.call(@scope)
+        else
+          @initial_sync_since
+        end
+      end
+
+      def updated_since
+        instrument("updated_since.synced") do
+          [relation_scope.minimum(@synced_all_at_key), initial_sync_since].compact.max
+        end
+      end
+
+      def deleted_remote_objects_ids
+        meta && meta[:deleted_ids] or raise CannotDeleteDueToNoDeletedIdsError.new(@model_class)
+      end
+
+      def meta
+        remote_objects
+        @meta ||= api.last_response.meta
+      end
+
+      # Remove all objects with ids from deleted_ids field in the meta key
+      def remove_relation
+        relation_scope.where(@id_key => deleted_remote_objects_ids)
+      end
+
+      class CannotDeleteDueToNoDeletedIdsError < StandardError
+        def initialize(model_class)
+          @model_class = model_class
+        end
+
+        def message
+          "Cannot delete #{pluralized_model_class}. No deleted_ids were returned in API response."
+        end
+
+        private
+
+        def pluralized_model_class
+          @model_class.to_s.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/synced/synchronizer.rb

@@ -1,17 +1,20 @@
 require 'synced/delegate_attributes'
 require 'synced/attributes_as_hash'
+require 'synced/strategies/full'
+require 'synced/strategies/check'
+require 'synced/strategies/updated_since'
+
 # Synchronizer class which performs actual synchronization between
 # local database and given array of remote objects
 module Synced
   class Synchronizer
-    include AttributesAsHash
-    attr_reader :id_key
+    attr_reader :strategy
 
     # Initializes a new Synchronizer
     #
     # @param remote_objects [Array|NilClass] Array of objects to be synchronized
     #   with local database. Objects need to respond to at least :id message.
-    #   If it's nil, then synchronizer will fetch the remote objects on it's own.
+    #   If it's nil, then synchronizer will fetch the remote objects on it's own from the API.
     # @param model_class [Class] ActiveRecord model class from which local objects
     #   will be created.
     # @param options [Hash]
@@ -42,221 +45,30 @@ module Synced
     #   mapping remote objects attributes into local object attributes
     # @option options [Array|Hash] globalized_attributes: A list of attributes
     #   which will be mapped with their translations.
-    # @option options [Time|Proc] initial_sync_since: A point in time from which
-    #   objects will be synchronized on first synchronization.
-    #   Works only for partial (updated_since param) synchronizations.
+    # @option options [Symbol] strategy: Strategy to be used for synchronization
+    #   process, possible values are :full, :updated_since, :check and nil. Default
+    #   is nil, so strategy will be chosen automatically.
     def initialize(model_class, options = {})
-      @model_class           = model_class
-      @scope                 = options[:scope]
-      @id_key                = options[:id_key]
-      @synced_all_at_key     = options[:synced_all_at_key]
-      @data_key              = options[:data_key]
-      @remove                = options[:remove]
-      @only_updated          = options[:only_updated]
-      @include               = options[:include]
-      @local_attributes      = synced_attributes_as_hash(options[:local_attributes])
-      @api                   = options[:api]
-      @mapper                = options[:mapper].respond_to?(:call) ?
-                               options[:mapper].call : options[:mapper]
-      @fields                = options[:fields]
-      @remove                = options[:remove]
-      @associations          = Array(options[:associations])
-      @perform_request       = options[:remote].nil?
-      @remote_objects        = Array(options[:remote]) unless @perform_request
-      @globalized_attributes = synced_attributes_as_hash(options[:globalized_attributes])
-      @initial_sync_since    = options[:initial_sync_since]
+      @model_class       = model_class
+      @synced_all_at_key = options[:synced_all_at_key]
+      @only_updated      = options[:only_updated]
+      @perform_request   = options[:remote].nil?
+      @strategy          = strategy_class(options[:strategy]).new(model_class, options)
     end
 
     def perform
-      instrument("perform.synced", model: @model_class) do
-        relation_scope.transaction do
-          instrument("remove_perform.synced", model: @model_class) do
-            remove_relation.send(remove_strategy) if @remove
-          end
-          instrument("sync_perform.synced", model: @model_class) do
-            remote_objects.map do |remote|
-              remote.extend(@mapper) if @mapper
-              local_object = local_object_by_remote_id(remote.id) || relation_scope.new
-              local_object.attributes = default_attributes_mapping(remote)
-              local_object.attributes = local_attributes_mapping(remote)
-              if @globalized_attributes.present?
-                local_object.attributes = globalized_attributes_mapping(remote,
-                  local_object.translations.translated_locales)
-              end
-              local_object.save! if local_object.changed?
-              local_object.tap do |local_object|
-                @associations.each do |association|
-                  klass = association.to_s.classify.constantize
-                  klass.synchronize(remote: remote[association], scope: local_object,
-                    remove: @remove)
-                end
-              end
-            end
-          end.tap do |local_objects|
-            if updated_since_enabled?
-              instrument("update_synced_all_at_perform.synced", model: @model_class) do
-                relation_scope.update_all(@synced_all_at_key => Time.now)
-              end
-            end
-          end
-        end
-      end
+      @strategy.perform
     end
 
     private
 
-    def local_attributes_mapping(remote)
-      Hash[@local_attributes.map do |k, v|
-        [k, v.respond_to?(:call) ? v.call(remote) : remote.send(v)]
-      end]
-    end
-
-    def default_attributes_mapping(remote)
-      {}.tap do |attributes|
-        attributes[@id_key] = remote.id
-        attributes[@data_key] = remote if @data_key
-      end
-    end
-
-    def globalized_attributes_mapping(remote, used_locales)
-      empty = Hash[used_locales.map { |locale| [locale.to_s, nil] }]
-      {}.tap do |attributes|
-        @globalized_attributes.each do |local_attr, remote_attr|
-          translations = empty.merge(remote.send(remote_attr) || {})
-          attributes["#{local_attr}_translations"] = translations
-        end
-      end
-    end
-
-    # Returns relation within which local objects are created/edited and removed
-    # If no scope is provided, the relation_scope will be class on which
-    # .synchronize method is called.
-    # If scope is provided, like: account, then relation_scope will be a relation
-    # account.rentals (given we run .synchronize on Rental class)
-    #
-    # @return [ActiveRecord::Relation|Class]
-    def relation_scope
-      if @scope
-        @model_class.unscoped { @scope.send(resource_name).scope }
-      else
-        @model_class.unscoped
-      end
-    end
-
-    # Returns api client from the closest possible source.
-    #
-    # @raise [BookingSync::API::Unauthorized] - On unauthorized user
-    # @return [BookingSync::API::Client] BookingSync API client
-    def api
-      return @api if @api
-      closest = [@scope, @scope.class, @model_class].detect do |o|
-                  o.respond_to?(:api)
-                end
-      closest && closest.api || raise(MissingAPIClient.new(@scope, @model_class))
-    end
-
-    def local_object_by_remote_id(remote_id)
-      local_objects.find { |l| l.public_send(id_key) == remote_id }
-    end
-
-    def local_objects
-      @local_objects ||= relation_scope.where(id_key => remote_objects_ids).to_a
-    end
-
-    def remote_objects_ids
-      @remote_objects_ids ||= remote_objects.map(&:id)
-    end
-
-    def remote_objects
-      @remote_objects ||= @perform_request ? fetch_remote_objects : nil
-    end
-
-    def deleted_remote_objects_ids
-      remote_objects
-      api.last_response.meta[:deleted_ids]
+    def strategy_class(name)
+      name ||= updated_since? ? :updated_since : :full
+      "Synced::Strategies::#{name.to_s.classify}".constantize
     end
 
-    def fetch_remote_objects
-      instrument("fetch_remote_objects.synced", model: @model_class) do
-        api.paginate(resource_name, api_request_options)
-      end
-    end
-
-    def api_request_options
-      {}.tap do |options|
-        options[:include] = @associations if @associations.present?
-        if @include.present?
-          options[:include] ||= []
-          options[:include] += @include
-        end
-        options[:fields] = @fields if @fields.present?
-        options[:updated_since] = updated_since if updated_since_enabled?
-        options[:auto_paginate] = true
-      end
-    end
-
-    def updated_since
-      instrument("updated_since.synced") do
-        [relation_scope.minimum(@synced_all_at_key),
-          initial_sync_since].compact.max
-      end
-    end
-
-    def initial_sync_since
-      if @initial_sync_since.respond_to?(:call)
-        @initial_sync_since.arity == 0 ? @initial_sync_since.call :
-          @initial_sync_since.call(@scope)
-      else
-        @initial_sync_since
-      end
-    end
-
-    def updated_since_enabled?
+    def updated_since?
       @only_updated && @synced_all_at_key && @perform_request
     end
-
-    def resource_name
-      @model_class.to_s.tableize
-    end
-
-    def remove_strategy
-      @remove == true ? default_remove_strategy : @remove
-    end
-
-    def default_remove_strategy
-      if @model_class.column_names.include?("canceled_at")
-        :cancel_all
-      else
-        :destroy_all
-      end
-    end
-
-    def remove_relation
-      if updated_since_enabled?
-        relation_scope.where(id_key => deleted_remote_objects_ids)
-      else
-        relation_scope.where.not(id_key => remote_objects_ids)
-      end
-    end
-
-    def instrument(*args, &block)
-      Synced.instrumenter.instrument(*args, &block)
-    end
-
-    class MissingAPIClient < StandardError
-      def initialize(scope, model_class)
-        @scope = scope
-        @model_class = model_class
-      end
-
-      def message
-        if @scope
-          %Q{Missing BookingSync API client in #{@scope} object or \
-#{@scope.class} class when synchronizing #{@model_class} model}
-        else
-          %Q{Missing BookingSync API client in #{@model_class} class}
-        end
-      end
-    end
   end
 end

data/lib/synced/version.rb

@@ -1,3 +1,3 @@
 module Synced
-  VERSION = "1.0.9"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synced
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.1.0
 platform: ruby
 authors:
 - Sebastien Grosjean
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -167,6 +167,9 @@ files:
 - lib/synced/has_synced_data.rb
 - lib/synced/model.rb
 - lib/synced/rails.rb
+- lib/synced/strategies/check.rb
+- lib/synced/strategies/full.rb
+- lib/synced/strategies/updated_since.rb
 - lib/synced/synchronizer.rb
 - lib/synced/version.rb
 homepage: https://github.com/BookingSync/synced
@@ -189,8 +192,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Keep your BookingSync Application synced with BookingSync.
 test_files: []
+has_rdoc: