syncable_models 0.0.11 → 0.0.12

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWEzMmMwODJhOWE0MDNmM2QwMWU3MjA5ZTg5YTU4YTQ5NTkzMjg2NA==
+    NmFjMzY5ODRkYmFmOGMwNzdiNWQ4YWFlOTNmZjQ0ZmJmYjg1YTk3MA==
   data.tar.gz: !binary |-
-    MDg3OWFmZTVhYTVmNzM1MDI4NmJkYjY5NGI3NjJlZWNkNzA2YjRlYw==
+    Mzk4OTVkM2EwNTFiYzI1M2ExYTgwMzMwMjgwOTcwZDFhMmE3MjZmMA==
 SHA512:
   metadata.gz: !binary |-
-    MjJjOTIxNTVlNzllMDdmYjllNzNiZTA5YzA3ZjE0ZDBlZTkzY2IzOGFkMzM4
-    MWUwNjdhY2MxYzA1ZTdhMGJjNzY2NmQzM2JlYzZlYmE0OTUwODNhNmQzNjY0
-    NWE2MGVlOTEyNzVmYzkyOWRhNGE5NWViMjU2YjExZDMwYTIxODM=
+    MWQ4ODJiN2UyYjZkY2IzYTEzOWIwZjJkNmEwZTcwYzMxODk1NjQ4NzMzNGEx
+    NmYzM2M1MzMwM2IxNmEwMDJjMGE1ZjNhOGMwZDVhMDRlYzkyNDEyOWQ2MWIx
+    ZjQwOTgzNTJhMjU1MDU5YjI4MjNkZGY3YjQwNTBkNDY5MGFjZmQ=
   data.tar.gz: !binary |-
-    MzE5MDRhNjIzOTI4NDU5YjZlMTBkZDliNWZjZWYxNzM0ZmU3NThhOTQ5YjJl
-    Yjc3Zjk2ZjAwZjM3ZDZmYzE2YmZkMzMxMDJjNGE0ZTQ4YWYxM2I5ZTUzYmIz
-    YjYwYWNjNWZlYjJkNjMwM2MxNzUxMjE0OTA5M2JkNzZjZTlhOTU=
+    Y2I2OGNkNzNlMDExMTEyNGRkYWRlNzVmNjVkOTVmMGIwMDkxYjZiNzdiM2Mx
+    YzI5ZWU1MzQ1ZDUzMzQ3OThjMmE1NDkyY2Y1MjgwYzY5NzdiZjAyMTg5Y2Q1
+    MjRmYWJlYWRmN2FmOGM5Mjg2YzllODRhZjliNDU0Yjg0ZTk3MmY=

data/README.md

@@ -1,4 +1,4 @@
-# SyncableModels [![Build Status](https://travis-ci.org/flant/syncable_models.svg?branch=master)](https://travis-ci.org/flant/syncable_model)
+# SyncableModels [![Build Status](https://travis-ci.org/flant/syncable_models.svg?branch=master)](https://travis-ci.org/flant/syncable_models) [![Gem Version](https://badge.fury.io/rb/syncable_models.svg)](https://badge.fury.io/rb/syncable_models)
 
 This gem helps you to:
 

data/Rakefile

@@ -4,23 +4,13 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
-
-
 load 'rails/tasks/statistics.rake'
 
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
+RSpec::Core::RakeTask.new(:spec)
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
+task :default => :spec
 
-task default: :test
+Bundler::GemHelper.install_tasks

data/app/models/syncable_models/sync.rb

@@ -7,5 +7,27 @@ module SyncableModels
     validates :subject, :subject_type, :destination, presence: true
 
     scope :by_destination, ->(*d) { where(destination: d) }
+    scope :for_destroying, ->{ where(subject_destroyed: true) }
+
+    before_save do
+      self.subject_external_id = subject.syncable_models_external_id
+    end
+
+    def subject
+      super || begin
+        subject_klass = subject_type.constantize
+        subject_klass.where(subject_klass.syncable_models_id_key => subject_external_id).first
+      end
+    end
+
+    def sync_destruction!
+      if subject
+        self.subject = subject
+        self.subject_destroyed = false
+        save!
+      else
+        destroy
+      end
+    end
   end
 end

data/db/migrate/20160225141153_create_syncs.rb

@@ -3,12 +3,16 @@ class CreateSyncs < ActiveRecord::Migration
     create_table :syncs do |t|
       t.integer :subject_id
       t.string :subject_type
-      t.string :destination
+      t.string :destination, null: false
+
+      t.string :subject_external_id, null: false
+      t.boolean :subject_destroyed, null: false, default: false
 
       t.timestamps
     end
 
     add_index :syncs, [:subject_id, :subject_type, :destination]
     add_index :syncs, :destination
+    add_index :syncs, [:subject_external_id, :subject_destroyed]
   end
 end

data/lib/syncable_models/active_record.rb

@@ -2,9 +2,14 @@ module SyncableModels::ActiveRecord
   extend ActiveSupport::Concern
 
   included do
-    has_many :syncs, as: :subject, inverse_of: :subject, class_name: ::SyncableModels::Sync
+    has_many :syncs,
+      as: :subject,
+      inverse_of: :subject,
+      class_name: ::SyncableModels::Sync,
+      dependent: :nullify
 
     after_update :clear_syncs_on_update
+    after_destroy :set_syncs_destroyed
 
     scope :synced, ->(d){ joins(:syncs).where(syncs: { destination: d }) }
     scope :not_synced, ->(d) do
@@ -19,23 +24,31 @@ module SyncableModels::ActiveRecord
   end
 
   def synced?(destination)
-    self.syncs.where(destination: destination).exists?
+    syncs.where(destination: destination).exists?
   end
 
   def sync(destination)
-    self.syncs.create(destination: destination) unless self.synced?(destination)
+    syncs.create(destination: destination) unless synced?(destination)
   end
 
   def clear_syncs(destination = nil)
-    syncs = destination ? self.syncs.by_destination(destination) : self.syncs
-    syncs.destroy_all
+    (destination ? syncs.by_destination(destination) : syncs).destroy_all
+  end
+
+  def syncable_models_external_id
+    self.send(self.class.syncable_models_id_key)
   end
 
   def clear_syncs_on_update
-    self.clear_syncs
+    clear_syncs
+  end
+
+  def set_syncs_destroyed
+    SyncableModels::Sync.where(subject_external_id: self.syncable_models_external_id)
+      .update_all(subject_destroyed: true)
   end
 
   def to_import_hash
-    self.attributes
+    attributes
   end
 end

data/lib/syncable_models/controller.rb

@@ -4,7 +4,7 @@ module SyncableModels::Controller
   BATCH_COUNT = 50
 
   module ClassMethods
-    def sync_for(subject, class_name: nil, sync_method: nil, fetch_method: nil)
+    def sync_for(subject, id_key: :uuid, class_name: nil, sync_method: nil, fetch_method: nil)
       klass = class_name || subject.to_s.singularize.camelize
       klass = klass.constantize unless klass.is_a?(Class)
 
@@ -13,7 +13,7 @@ module SyncableModels::Controller
 
       class_eval """
         def #{sync_method}
-          set_synced #{klass.name}
+          set_synced #{klass.name}, :#{id_key.to_s}
         end
 
         def #{fetch_method}
@@ -31,16 +31,35 @@ module SyncableModels::Controller
   def fetch(klass)
     if params[:destination]
       count = params[:count].present? ? params[:count].to_i : BATCH_COUNT
-      result = klass.not_synced(params[:destination]).limit(count).map(&:to_import_hash)
-      render json: { status: 200, objects: result }
+
+      for_sync = klass.not_synced(params[:destination]).limit(count).map(&:to_import_hash)
+      count = count - for_sync.count
+      for_destroy = SyncableModels::Sync
+        .by_destination(params[:destination])
+        .for_destroying
+        .limit(count)
+        .map(&:subject_external_id)
+
+      render json: { status: 200, for_sync: for_sync, for_destroy: for_destroy }
     else
       render_argument_error
     end
   end
 
-  def set_synced(klass, id_key = :uuid)
+  def set_synced(klass, id_key)
     if params[:ids] && params[:destination]
-      klass.where(id_key => params[:ids]).sync(params[:destination])
+      ids = params[:ids]
+
+      destruction_syncs = SyncableModels::Sync
+        .by_destination(params[:destination])
+        .for_destroying
+        .where(subject_external_id: ids)
+
+      destruction_sync_ids = destruction_syncs.pluck(:subject_external_id).map(&:to_s)
+      destruction_syncs.each{ |s| s.sync_destruction! }
+      ids -= destruction_sync_ids
+
+      klass.where(id_key => ids).sync(params[:destination])
       render json: { status: 200 }
     else
       render_argument_error

data/lib/syncable_models/engine.rb

@@ -1,5 +1,10 @@
 module SyncableModels
   class Engine < ::Rails::Engine
     isolate_namespace SyncableModels
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+    end
   end
 end

data/lib/syncable_models/importer.rb

@@ -36,45 +36,76 @@ module SyncableModels
       end
 
       def import(model_names=[])
+        model_names = [model_names] unless model_names.is_a?(Array)
+        model_names.map!(&:to_s)
         selected_models = model_names.any? ?
           @models.select{ |k, v| k.in? model_names } :
           @models
 
         selected_models.each do |model_name, params|
           puts "[SyncableModels::Importer] Importing #{model_name.underscore.pluralize}..."
-          next if model_names.any? && !model_name.in?(model_names)
 
-          fetch_url = self.api_url + params[:fetch_path]
-          sync_url = self.api_url + params[:sync_path]
+          next if model_names.any? && !model_name.in?(model_names)
 
-          conn = Faraday.new(url: fetch_url)
-          response = conn.get '', params_with_api_key(destination: destination)
+          response = fetch_request(params)
 
           if response.success?
             response = JSON.parse(response.body)
-
             if response["status"].to_i == 401
               puts "[SyncableModels::Importer] Wrong api key!"
             end
 
-            if response['objects'] && response['objects'].count > 0
-              klass = model_name.constantize
-              synced_ids = []
-
-              response['objects'].each do |o|
-                id = o[params[:id_key].to_s]
-                result = klass.from_import_hash(o)
-                puts "[SyncableModels::Importer] Importing #{model_name} (id=#{id}): #{ result ? 'OK' : 'FAIL' }"
-                synced_ids << id if result
-              end
-
-              if synced_ids.any?
-                conn = Faraday.new(url: sync_url)
-                response = conn.get '', params_with_api_key(destination: self.destination, ids: synced_ids)
-              end
-            end
+            synced_ids = []
+
+            synced_ids += sync_update model_name, params, response['for_sync']
+            synced_ids += sync_destroy model_name, response['for_destroy']
+
+            sync_request(params, synced_ids) if synced_ids.any?
+          end
+        end
+      end
+
+      def fetch_request(params)
+        conn = Faraday.new(url: api_url + params[:fetch_path])
+        conn.get '', params_with_api_key(destination: destination)
+      end
+
+      def sync_request(params, ids)
+        conn = Faraday.new(url: api_url + params[:sync_path])
+        conn.get '', params_with_api_key(destination: destination, ids: ids)
+      end
+
+      def sync_update(model_name, params, objects)
+        synced_ids = []
+
+        if objects
+          klass = model_name.constantize
+
+          objects.each do |o|
+            id = o[params[:id_key].to_s]
+            result = klass.from_import_hash(o)
+            puts "[SyncableModels::Importer] Importing #{model_name} (external_id=#{id}): #{ result ? 'OK' : 'FAIL' }"
+            synced_ids << id if result
+          end
+        end
+
+        synced_ids
+      end
+
+      def sync_destroy(model_name, ids)
+        synced_ids = []
+
+        if ids
+          klass = model_name.constantize
+
+          ids.each do |id|
+            result = klass.where(external_id: id).first.try(:destroy)
+            puts "[SyncableModels::Importer] Destroying #{model_name} (external_id=#{id}): #{ result ? 'OK' : 'FAIL' }"
+            synced_ids << id if result
           end
         end
+
+        synced_ids
       end
     end
 
@@ -96,7 +127,7 @@ module SyncableModels
     end
 
     def self.import_all
-      @@imports.each &:import
+      @@imports.each(&:import)
     end
   end
 end

data/lib/syncable_models/syncable.rb

@@ -0,0 +1,20 @@
+require 'active_support'
+
+module SyncableModels
+  module Syncable
+    def syncable(options = {})
+      options.assert_valid_keys(
+        :id_key
+      )
+
+      class_attribute :syncable_models_id_key
+      self.syncable_models_id_key = options[:id_key] || :uuid
+
+      include SyncableModels::ActiveRecord
+    end
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  ActiveRecord::Base.send :extend, SyncableModels::Syncable
+end

data/lib/syncable_models/version.rb

@@ -1,3 +1,3 @@
 module SyncableModels
-  VERSION = "0.0.11"
+  VERSION = "0.0.12"
 end

data/lib/syncable_models.rb

@@ -1,4 +1,5 @@
 require "syncable_models/engine"
+require "syncable_models/syncable"
 require "syncable_models/active_record"
 require "syncable_models/controller"
 require "syncable_models/importer"

data/lib/tasks/syncable_models.rake

@@ -1,8 +1,8 @@
-# desc "Explaining what the task does"
+require 'rake'
 
 def prepare_models(models)
   return unless models
-  models.split(',').map(&:camelize)
+  models.gsub(/\s*/, '').split(',').map(&:camelize)
 end
 
 namespace :syncable_models do

data/spec/controllers/syncable_models/import_api_controller_spec.rb

@@ -0,0 +1,101 @@
+require 'rails_helper'
+
+RSpec.describe ImportApiController, type: :controller do
+  let(:json) { JSON.parse(response.body) }
+  let(:for_sync) { json['for_sync'] }
+  let(:for_destroy) { json['for_destroy'] }
+
+  describe '#fetch method' do
+    before do
+      @teams = [create(:first_team),
+        create(:second_team),
+        create(:third_team),
+        create(:fourth_team)]
+    end
+
+    it 'fetches objects if all unsynced' do
+      get :teams, destination: :test
+      expect(for_sync.count).to eq(4)
+    end
+
+    it 'fetches only unisynced objects' do
+      @teams.last.sync(:test)
+      get :teams, destination: :test
+      expect(for_sync.count).to eq(3)
+    end
+
+    describe 'fetching mixed response' do
+      before do
+        @teams.last(2).each{ |t| t.sync(:test) }
+        @teams.last(2).each(&:destroy)
+      end
+
+      it 'fetches destroyed syncs' do
+        get :teams, destination: :test
+        expect(for_destroy.count).to eq(2)
+      end
+
+      it 'response still has undestroyed syncs' do
+        get :teams, destination: :test
+        expect(for_sync.count).to eq(2)
+      end
+
+      describe 'when using limit' do
+        it 'returns correct amount of for_sync objects' do
+          get :teams, destination: :test, count: 3
+          expect(for_sync.count).to eq(2)
+        end
+
+        it 'returns correct amount of for_destroy objects' do
+          get :teams, destination: :test, count: 3
+          expect(for_destroy.count).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '#sync method' do
+    it 'syncs objects' do
+      teams = [create(:first_team), create(:second_team), create(:third_team)]
+      get :sync_teams, destination: :test, ids: teams.first(2).map(&:id)
+      expect(Team.synced(:test)).to eq(teams.first(2))
+    end
+
+    describe 'when objects destroyed' do
+      describe 'and they are non-permanent' do
+        before do
+          @teams = [create(:first_team), create(:second_team), create(:third_team)]
+          @teams.each{ |o| o.sync(:test) }
+          @teams.first(2).each(&:destroy)
+          get :sync_teams, destination: :test, ids: @teams.first(2).map(&:id)
+        end
+
+        it 'destroys their syncs' do
+          expect(SyncableModels::Sync.count).to eq(1)
+        end
+
+        it 'keeps the remaining syncs' do
+          expect(SyncableModels::Sync.first.subject).to eq(@teams.last)
+        end
+      end
+
+      describe 'and they are permanent' do
+        before do
+          @projects = [create(:first_project), create(:second_project), create(:third_project)]
+          @projects.each{ |o| o.sync(:test) }
+          @projects.first(2).each(&:destroy)
+          get :sync_projects, destination: :test, ids: @projects.first(2).map(&:uuid)
+          @projects.each(&:reload)
+        end
+
+        it 'doesn\'t destroy their syncs' do
+          expect(SyncableModels::Sync.count).to eq(3)
+        end
+
+        it 'makes syncs of destroyed object with correct subject_destroyed attribute' do
+          expect(@projects.first(2).map(&:syncs).flatten.compact.map(&:subject_destroyed)).to eq([false, false])
+        end
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/import_api_controller.rb

@@ -0,0 +1,6 @@
+class ImportApiController < ActionController::Base
+  include SyncableModels::Controller
+
+  sync_for :projects
+  sync_for :teams, id_key: :id
+end

data/spec/dummy/app/models/project.rb

@@ -0,0 +1,12 @@
+class Project < ActiveRecord::Base
+  syncable
+
+  validates :name, :uuid, presence: true
+
+  def self.from_import_hash(hash)
+    object = Project.where(external_id: hash['uuid']).first || Project.new(uuid: SecureRandom.uuid, external_id: hash['uuid'])
+    object.name = hash['name']
+    object.external_id = hash['uuid']
+    object.save
+  end
+end

data/spec/dummy/app/models/team.rb

@@ -0,0 +1,12 @@
+class Team < ActiveRecord::Base
+  syncable id_key: :id
+
+  validates :name, presence: true
+
+  def self.from_import_hash(hash)
+    object = Team.where(external_id: hash['id']).first || Team.new
+    object.name = hash['name']
+    object.external_id = hash['id']
+    object.save
+  end
+end

data/{test → spec}/dummy/config/application.rb

@@ -1,6 +1,12 @@
 require File.expand_path('../boot', __FILE__)
 
-require 'rails/all'
+# Pick the frameworks you want:
+require "active_record/railtie"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+require "sprockets/railtie"
+# require "rails/test_unit/railtie"
 
 Bundler.require(*Rails.groups)
 require "syncable_models"

data/spec/dummy/config/routes.rb

@@ -0,0 +1,11 @@
+Rails.application.routes.draw do
+
+  namespace 'import_api' do
+    get 'projects'
+    get 'sync_projects'
+    get 'teams'
+    get 'sync_teams'
+  end
+
+  mount SyncableModels::Engine => "/syncable_models"
+end

data/spec/dummy/db/migrate/20160327104327_create_projects.rb

@@ -0,0 +1,13 @@
+class CreateProjects < ActiveRecord::Migration
+  def change
+    create_table :projects do |t|
+      t.string :name, null: false
+      t.string :uuid, null: false
+      t.datetime :deleted_at, null: true
+      t.string :external_id
+      t.timestamps null: false
+    end
+
+    add_index :projects, :uuid, unique: true, length: 36
+  end
+end

data/spec/dummy/db/migrate/20160327111225_create_teams.rb

@@ -0,0 +1,9 @@
+class CreateTeams < ActiveRecord::Migration
+  def change
+    create_table :teams do |t|
+      t.string :name, null:false
+      t.string :external_id
+      t.timestamps null: false
+    end
+  end
+end