synced 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8fd447ac4edfd7650c0cbc27b6dd390e01709b9
-  data.tar.gz: e0bc89a27dacb6abd1039c0e0c86eb233d85266e
+  metadata.gz: 9269d91cf4e1c50718fb11cc8c3a6860ede34a3a
+  data.tar.gz: 07a7b737a0d403e3e78011a2dd9b49385e65bfa9
 SHA512:
-  metadata.gz: b037b0f4e35a473b0c0d0ea4e9cc95161f362620af9ad3a5b6aabad5590080c3b6133fcfab6fc2568144e1e1b0b0d34ae7bc4fb58ed8fd79e52768a1838d6e48
-  data.tar.gz: cc2c8a5fcdb35be25a7dd4ebba407f6b7be476066bd95a6b60a37d6cbb44a4b78dff786f5396638cfd17271d616e09c84f9bf8ae5b057b47f397581335492e45
+  metadata.gz: e787d2b0ccca79dd8cd4dbe21814bbef16664e88290a82185253a88e4e4088cac2c30b8c925b8e01e2048570d552b0696151f06e1d9dde0ddcf8b5edca767613
+  data.tar.gz: 5236ccc2bebfbd74810f21d29630075322426a6c5ffc9e60fed447b912637b05875a96f74536240c9212764217c600a907633bf87355364159400b25b522cec1

data/lib/synced/has_synced_data.rb

@@ -3,39 +3,41 @@ require 'hashie'
 # Provide a serialized attribute for models. This attribute is `synced_data_key`
 # which by default is `:synced_data`. This is a friendlier alternative to
 # `serialize` with respect to dirty attributes.
-module Synced::HasSyncedData
-  extend ActiveSupport::Concern
-  class SyncedData < Hashie::Mash; end
+module Synced
+  module HasSyncedData
+    extend ActiveSupport::Concern
+    class SyncedData < Hashie::Mash; end
 
-  included do
-    if synced_data_key
-      define_method "#{synced_data_key}=" do |object|
-        write_attribute synced_data_key, dump(object)
-      end
+    included do
+      if synced_data_key
+        define_method "#{synced_data_key}=" do |object|
+          write_attribute synced_data_key, dump(object)
+        end
 
-      define_method synced_data_key do
-        instance_variable_get("@#{synced_data_key}") ||
-          instance_variable_set("@#{synced_data_key}",
-            SyncedData.new(loaded_synced_data))
+        define_method synced_data_key do
+          instance_variable_get("@#{synced_data_key}") ||
+            instance_variable_set("@#{synced_data_key}",
+              SyncedData.new(loaded_synced_data))
+        end
       end
     end
-  end
 
-  private
+    private
 
-  def loaded_synced_data
-    if data = read_attribute(synced_data_key)
-      load data
-    else
-      {}
+    def loaded_synced_data
+      if data = read_attribute(synced_data_key)
+        load data
+      else
+        {}
+      end
     end
-  end
 
-  def dump(object)
-    JSON.dump object
-  end
+    def dump(object)
+      JSON.dump object
+    end
 
-  def load(source)
-    JSON.load source
+    def load(source)
+      JSON.load source
+    end
   end
 end

data/lib/synced/model.rb

@@ -1,75 +1,77 @@
 require "synced/synchronizer"
 
-module Synced::Model
-  # Enables synced for ActiveRecord model.
-  #
-  # @param options [Hash] Configuration options for synced. They are inherited
-  #   by subclasses, but can be overwritten in the subclass.
-  # @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
-  #   last synchronization time is stored, default is :synced_all_at. It's only
-  #   used when only_updated option is enabled.
-  # @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 [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.
-  def synced(options = {})
-    class_attribute :synced_id_key, :synced_all_at_key, :synced_data_key,
-      :synced_local_attributes, :synced_associations, :synced_only_updated
-    self.synced_id_key           = options.fetch(:id_key, :synced_id)
-    self.synced_all_at_key       = options.fetch(:synced_all_at_key,
-      :synced_all_at)
-    self.synced_data_key         = options.fetch(:data_key, :synced_data)
-    self.synced_local_attributes = options.fetch(:local_attributes, [])
-    self.synced_associations     = options.fetch(:associations, [])
-    self.synced_only_updated     = options.fetch(:only_updated, false)
-    include Synced::HasSyncedData
-  end
+module Synced
+  module Model
+    # Enables synced for ActiveRecord model.
+    #
+    # @param options [Hash] Configuration options for synced. They are inherited
+    #   by subclasses, but can be overwritten in the subclass.
+    # @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
+    #   last synchronization time is stored, default is :synced_all_at. It's only
+    #   used when only_updated option is enabled.
+    # @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 [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.
+    def synced(options = {})
+      class_attribute :synced_id_key, :synced_all_at_key, :synced_data_key,
+        :synced_local_attributes, :synced_associations, :synced_only_updated
+      self.synced_id_key           = options.fetch(:id_key, :synced_id)
+      self.synced_all_at_key       = options.fetch(:synced_all_at_key,
+        :synced_all_at)
+      self.synced_data_key         = options.fetch(:data_key, :synced_data)
+      self.synced_local_attributes = options.fetch(:local_attributes, [])
+      self.synced_associations     = options.fetch(:associations, [])
+      self.synced_only_updated     = options.fetch(:only_updated, false)
+      include Synced::HasSyncedData
+    end
 
-  # Performs synchronization of given remote objects to local database.
-  #
-  # @param remote [Array] - Remote objects to be synchronized with local db. If
-  #   it's nil then synchronizer will make request on it's own.
-  # @param model_class [Class] - ActiveRecord model class to which remote objects
-  #   will be synchronized.
-  # @param scope [ActiveRecord::Base] - Within this object scope local objects
-  #   will be synchronized. By default it's model_class.
-  # @param remove [Boolean] - 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.
-  # @example Synchronizing amenities
-  #
-  #   Amenity.synchronize(remote: [remote_amenity1, remote_amenity2])
-  #
-  # @example Synchronizing rentals within given website. This will
-  #   create/remove/update rentals only within website.
-  #   It requires relation website.rentals to exist.
-  #
-  #  Rental.synchronize(remote: remote_rentals, scope: website)
-  #
-  def synchronize(remote: nil, model_class: self, scope: nil, remove: false,
-    include: nil)
-    options = {
-      scope: scope,
-      id_key: synced_id_key,
-      synced_all_at_key: synced_all_at_key,
-      data_key: synced_data_key,
-      remove: remove,
-      local_attributes: synced_local_attributes,
-      associations: synced_associations,
-      only_updated: synced_only_updated,
-      include: include
-    }
-    synchronizer = Synced::Synchronizer.new(remote, model_class, options)
-    synchronizer.perform
+    # Performs synchronization of given remote objects to local database.
+    #
+    # @param remote [Array] - Remote objects to be synchronized with local db. If
+    #   it's nil then synchronizer will make request on it's own.
+    # @param model_class [Class] - ActiveRecord model class to which remote objects
+    #   will be synchronized.
+    # @param scope [ActiveRecord::Base] - Within this object scope local objects
+    #   will be synchronized. By default it's model_class.
+    # @param remove [Boolean] - 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.
+    # @example Synchronizing amenities
+    #
+    #   Amenity.synchronize(remote: [remote_amenity1, remote_amenity2])
+    #
+    # @example Synchronizing rentals within given website. This will
+    #   create/remove/update rentals only within website.
+    #   It requires relation website.rentals to exist.
+    #
+    #  Rental.synchronize(remote: remote_rentals, scope: website)
+    #
+    def synchronize(remote: nil, model_class: self, scope: nil, remove: false,
+      include: nil)
+      options = {
+        scope: scope,
+        id_key: synced_id_key,
+        synced_all_at_key: synced_all_at_key,
+        data_key: synced_data_key,
+        remove: remove,
+        local_attributes: synced_local_attributes,
+        associations: synced_associations,
+        only_updated: synced_only_updated,
+        include: include
+      }
+      synchronizer = Synced::Synchronizer.new(remote, model_class, options)
+      synchronizer.perform
+    end
   end
 end

data/lib/synced/rails.rb

@@ -1,4 +1,3 @@
-require "synced/has_synced_data"
 require "synced/model"
 
 module Synced
@@ -9,6 +8,10 @@ module Synced
       g.test_framework :rspec
     end
 
+    config.to_prepare do
+      require "synced/has_synced_data"
+    end
+
     ActiveSupport.on_load :active_record do
       extend Synced::Model
     end

data/lib/synced/synchronizer.rb

@@ -1,194 +1,196 @@
 # Synchronizer class which performs actual synchronization between
 # local database and given array of remote objects
-class Synced::Synchronizer
-  attr_reader :id_key
-
-  # 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.
-  # @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.
-  # @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
-  def initialize(remote_objects, 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  = Array(options[:local_attributes])
-    @associations      = Array(options[:associations])
-    @remote_objects    = Array(remote_objects) if remote_objects
-    @request_performed = false
-  end
+module Synced
+  class Synchronizer
+    attr_reader :id_key
+
+    # 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.
+    # @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.
+    # @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
+    def initialize(remote_objects, 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  = Array(options[:local_attributes])
+      @associations      = Array(options[:associations])
+      @remote_objects    = Array(remote_objects) if remote_objects
+      @request_performed = false
+    end
 
-  def perform
-    relation_scope.transaction do
-      remove_relation.send(remove_strategy) if @remove
-
-      remote_objects.map do |remote|
-        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)
-        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)
+    def perform
+      relation_scope.transaction do
+        remove_relation.send(remove_strategy) if @remove
+
+        remote_objects.map do |remote|
+          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)
+          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.tap do |local_objects|
+          if updated_since_enabled? && @request_performed
+            relation_scope.update_all(@synced_all_at_key => Time.now)
           end
-        end
-      end.tap do |local_objects|
-        if updated_since_enabled? && @request_performed
-          relation_scope.update_all(@synced_all_at_key => Time.now)
         end
       end
     end
-  end
-
-  private
 
-  def local_attributes_mapping(remote)
-    Hash[@local_attributes.map { |k| [k, remote[k]] }]
-  end
+    private
 
-  def default_attributes_mapping(remote)
-    {}.tap do |attributes|
-      attributes[@id_key] = remote.id
-      attributes[@data_key] = remote if @data_key
+    def local_attributes_mapping(remote)
+      Hash[@local_attributes.map { |k| [k, remote[k]] }]
     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
-    @scope ? @scope.send(resource_name) : @model_class
-  end
+    def default_attributes_mapping(remote)
+      {}.tap do |attributes|
+        attributes[@id_key] = remote.id
+        attributes[@data_key] = remote if @data_key
+      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
-    closest = [@scope, @scope.class, @model_class].detect do |o|
-                o.respond_to?(:api)
-              end
-    closest && closest.api || raise(MissingAPIClient.new(@scope, @model_class))
-  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
+      @scope ? @scope.send(resource_name) : @model_class
+    end
 
-  def local_object_by_remote_id(remote_id)
-    local_objects.find { |l| l.attributes[id_key.to_s] == remote_id }
-  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
+      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_objects
-    @local_objects ||= relation_scope.where(id_key => remote_objects_ids).to_a
-  end
+    def local_object_by_remote_id(remote_id)
+      local_objects.find { |l| l.attributes[id_key.to_s] == remote_id }
+    end
 
-  def remote_objects_ids
-    @remote_objects_ids ||= remote_objects.map(&:id)
-  end
+    def local_objects
+      @local_objects ||= relation_scope.where(id_key => remote_objects_ids).to_a
+    end
 
-  def remote_objects
-    @remote_objects ||= fetch_remote_objects
-  end
+    def remote_objects_ids
+      @remote_objects_ids ||= remote_objects.map(&:id)
+    end
 
-  def deleted_remote_objects_ids
-    remote_objects unless @request_performed
-    api.last_response.meta[:deleted_ids]
-  end
+    def remote_objects
+      @remote_objects ||= fetch_remote_objects
+    end
 
-  def fetch_remote_objects
-    api.paginate(resource_name, api_request_options).tap do
-      @request_performed = true
+    def deleted_remote_objects_ids
+      remote_objects unless @request_performed
+      api.last_response.meta[:deleted_ids]
     end
-  end
 
-  def api_request_options
-    {}.tap do |options|
-      options[:include] = @associations if @associations.present?
-      if @include.present?
-        options[:include] ||= []
-        options[:include] += @include
+    def fetch_remote_objects
+      api.paginate(resource_name, api_request_options).tap do
+        @request_performed = true
       end
-      options[:updated_since] = minimum_updated_at if updated_since_enabled?
-      options[:auto_paginate] = true
     end
-  end
-
-  def minimum_updated_at
-    relation_scope.minimum(@synced_all_at_key)
-  end
 
-  def updated_since_enabled?
-    @only_updated && @synced_all_at_key
-  end
+    def api_request_options
+      {}.tap do |options|
+        options[:include] = @associations if @associations.present?
+        if @include.present?
+          options[:include] ||= []
+          options[:include] += @include
+        end
+        options[:updated_since] = minimum_updated_at if updated_since_enabled?
+        options[:auto_paginate] = true
+      end
+    end
 
-  def resource_name
-    @model_class.to_s.tableize
-  end
+    def minimum_updated_at
+      relation_scope.minimum(@synced_all_at_key)
+    end
 
-  def remove_strategy
-    @remove == true ? default_remove_strategy : @remove
-  end
+    def updated_since_enabled?
+      @only_updated && @synced_all_at_key
+    end
 
-  def default_remove_strategy
-    if @model_class.column_names.include?("canceled_at")
-      :cancel_all
-    else
-      :destroy_all
+    def resource_name
+      @model_class.to_s.tableize
     end
-  end
 
-  def remove_relation
-    if @only_updated
-      relation_scope.where(id_key => deleted_remote_objects_ids)
-    else
-      relation_scope.where.not(id_key => remote_objects_ids)
+    def remove_strategy
+      @remove == true ? default_remove_strategy : @remove
     end
-  end
 
-  class MissingAPIClient < StandardError
-    def initialize(scope, model_class)
-      @scope = scope
-      @model_class = model_class
+    def default_remove_strategy
+      if @model_class.column_names.include?("canceled_at")
+        :cancel_all
+      else
+        :destroy_all
+      end
     end
 
-    def message
-      if @scope
-        %Q{Missing BookingSync API client in #{@scope} object or
-#{@scope.class} class}
+    def remove_relation
+      if @only_updated
+        relation_scope.where(id_key => deleted_remote_objects_ids)
       else
-        %Q{Missing BookingSync API client in #{@model_class} class}
+        relation_scope.where.not(id_key => remote_objects_ids)
+      end
+    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}
+        else
+          %Q{Missing BookingSync API client in #{@model_class} class}
+        end
       end
     end
   end

data/lib/synced/version.rb

@@ -1,3 +1,3 @@
 module Synced
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synced
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Sebastien Grosjean