syncer 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in syncer.gemspec
+gemspec
+
+gem 'guard'
+gem 'rb-readline'
+gem 'growl'
+gem 'guard-rspec'
+gem 'guard-bundler'

data/Guardfile

@@ -0,0 +1,15 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :bundler do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/syncer/(.+)\.rb$})    { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')        { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Harry Hornreich
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Syncer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'syncer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install syncer
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+# adds a default spec task to run rspec
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec

data/lib/syncer/syncable_record.rb

@@ -0,0 +1,161 @@
+require 'active_record'
+
+module Kernel
+  # helper that returns object in Hash/Array structure similar to json
+  def to_rjson
+    JSON.parse(self.to_json)
+  end
+end
+
+class SyncableRecord < ActiveRecord::Base
+  # this is an abstract model that should be inherited from
+  self.abstract_class = true 
+  
+  validates_presence_of :version
+  validates_numericality_of :version, :greater_than_or_equal_to => 0
+  
+  before_validation :zero_version, :on => :create
+  after_validation :increment_version, :on => :update
+  
+  def zero_version
+    self.version = 0
+  end
+  
+  def increment_version
+    increment!(:version)
+  end  
+  
+  # helper to match record with remote record info
+  # if remote record has version use it otherwise only id matches (for delete records)
+  def matches?(remote_record)
+    if remote_record['version']
+      id == remote_record['id'] && version >= remote_record['version']
+    else
+      id == remote_record['id']
+    end
+  end
+  
+  # helper that checks if remote record has been updated
+  def updated?(remote_record)
+    id == remote_record['id'] && version > remote_record['version']
+  end  
+  
+  # finds models associated with temp ids and assigns their real id to the record
+  def self.fix_associated_ids(remote_record)
+    remote_record.keys.each do |key|
+      # if the key is of the form xxx_tmp_id
+      next unless /(?<foreign_key_prefix>.*)_tmp_id$/ =~ key
+      # then find the xxx class
+      next unless model_class = foreign_key_prefix.capitalize.to_class
+      # find the class model that matches the tmp_id
+      next unless model = model_class.find_by_tmp_id(remote_record["#{foreign_key_prefix}_tmp_id"])      
+      # save the actual model id 
+      remote_record["#{foreign_key_prefix}_id"] = model.id
+      # remove the xxx_tmp_id key & value
+      remote_record.delete(key)   
+    end
+  end
+  
+  # syncs a remote data source with server data state
+  # remote state should be provided as a Hash
+  # returns a Hash response with state changes for the remote data site
+  def self.sync(remote_state)
+    # TODO we do not currently check for id's per user
+    # TODO check both when creating and when accessing
+    # TODO we should at some point delete the tmp_ids
+
+    remote_saved = remote_state['saved'] || []
+    remote_created = remote_state['created'] || []
+    remote_deleted = remote_state['deleted'] || []
+    remote_updated = remote_state['updated'] || []
+    
+    # build list of all the server records known to remote
+    remote_existing_records = remote_saved + remote_updated + remote_deleted
+    
+    # group server records by new, updated and deleted as relates to remote state
+    all_records = self.all
+    new_records = all_records.find_all do |record|
+      !remote_existing_records.detect { |remote_record| record.matches?(remote_record) }
+    end
+    update_records = all_records.find_all do |record|
+      remote_existing_records.detect { |remote_record| record.updated?(remote_record) }
+    end
+    delete_records = remote_existing_records.find_all do |remote_record|
+      !all_records.detect { |record| record.matches?(remote_record) }
+    end    
+    
+    # created
+    created = new_records
+    
+    # handle special case where we have an updated record that was deleted remotely
+    # in that case we must recreate it
+    special_records = []
+    update_records.each do |record|
+      match = remote_deleted.detect { |remote_record| record.updated?(remote_record) }
+      if match
+        created << record
+        special_records << record
+      end
+    end
+    
+    # cleanup by removing these special case records
+    # no need to remove from remote_deleted as that we will confirm
+    special_records.each { |record| update_records.delete(record) }
+     
+    # create all new remote records and add to created list
+    if remote_created
+      remote_created.each do |remote_record|
+        fix_associated_ids(remote_record)
+        rec = self.create(remote_record)
+        if rec.persisted?
+          response = rec.to_rjson
+          created << response
+        end
+      end
+    end
+    
+    # updated
+    updated = update_records
+    
+    # update all updated remote records and add to updated list
+    if remote_updated
+      remote_updated.each do |remote_record|
+        fix_associated_ids(remote_record)
+        rec = self.find_by_id(remote_record['id'])
+        # update the record only if found and if it has not been updated on the server already        
+        if rec && !rec.updated?(remote_record) 
+          attrs = remote_record.dup
+          attrs.delete("id")      # can't update id
+          attrs.delete("version") # can't update version
+          updated << rec if rec.update_attributes(attrs)
+        end
+      end
+    end
+    
+    # deleted
+    deleted = delete_records.map{ |r| {:id => r['id']} if r['id'] }
+    deleted.delete(nil)
+    
+    # destroy all deleted remote records and add to deleted list
+    if remote_deleted
+      remote_deleted.each do |remote_record|
+        rec = self.find_by_id(remote_record['id'])
+        # destroy the record only if found and if it has not been updated on the server already
+        if rec && !rec.updated?(remote_record)         
+          rec.destroy
+          deleted << { :id => remote_record['id'] } if remote_record['id']
+        end
+      end
+    end
+
+    response = Hash.new
+    response[:create] = created unless created.empty?
+    response[:update] = updated unless updated.empty?
+    response[:delete] = deleted unless deleted.empty?
+
+    response
+    
+  rescue => error
+    { :error => "#{error}" }
+  end
+end

data/lib/syncer/syncer.rb

@@ -0,0 +1,21 @@
+require 'xstring'
+
+class Syncer
+  SYNC_ORDER_KEY = '_sync_order'  
+  
+  # request keys should be strings and not symbols
+  def self.sync(request)
+    request = request.to_rjson
+    response = {};
+    all_sync_request = request
+    sync_order = all_sync_request[SYNC_ORDER_KEY];
+    # TODO if nil raise an exception
+    sync_order.each do |model|
+      model_sync_data = all_sync_request[model]
+      next unless model_sync_data # it is ok not to have data for each model in the order
+      sync_response = model.to_class.sync(model_sync_data)
+      response[model] = sync_response
+    end
+    response.to_rjson
+  end
+end

data/lib/syncer/version.rb

@@ -0,0 +1,3 @@
+class Syncer
+  VERSION = "0.0.1"
+end

data/lib/syncer.rb

@@ -0,0 +1,4 @@
+require "syncer/version"
+require "syncer/syncer"
+require "syncer/syncable_record"
+

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+end
+
+# require the gem files
+require_relative '../lib/syncer'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}

data/spec/support/account.rb

@@ -0,0 +1,5 @@
+class Account < SyncableRecord
+  has_many :stocks
+  
+  validates_presence_of :name
+end

data/spec/support/active_record.rb

@@ -0,0 +1,53 @@
+# setup activerecord
+
+# took idea from here -> http://iain.nl/testing-activerecord-in-isolation
+
+# establish connection to memory db
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+# config activerecord to not include type in JSON
+ActiveRecord::Base.include_root_in_json = false
+
+# create tables needed for specing
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Migration.create_table "accounts", :force => true do |t|
+  t.string   "tmp_id"
+  t.integer  "version"
+  t.string   "name"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end
+
+ActiveRecord::Migration.create_table "stocks", :force => true do |t|
+  t.string   "tmp_id"
+  t.integer  "version"
+  t.string   "market"
+  t.string   "ticker"
+  t.string   "name"
+  t.integer  "index"
+  t.integer  "account_id"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end
+
+ActiveRecord::Migration.create_table "trades", :force => true do |t|
+  t.string   "tmp_id"
+  t.integer  "version"
+  t.boolean  "buy"
+  t.integer  "amount"
+  t.datetime "date"
+  t.integer  "stock_id"
+  t.datetime "created_at"
+  t.datetime "updated_at"
+end
+
+#setup transactions
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/spec/support/factories.rb

@@ -0,0 +1,20 @@
+require 'factory_girl'
+
+FactoryGirl.define do
+  factory :account do
+    name 'Leumi'
+  end
+
+  factory :stock do
+    market 'il'
+    ticker '629014'
+    name 'Teva'
+  end
+
+  factory :trade do
+    amount 100
+    buy true
+    date DateTime.now
+    association :stock  
+  end
+end

data/spec/support/stock.rb

@@ -0,0 +1,9 @@
+class Stock < SyncableRecord
+  belongs_to :account
+  has_many :trades, :dependent => :delete_all
+  
+  MARKET_LIST = %w(il us)
+  
+  validates_presence_of :ticker, :name
+  validates_inclusion_of :market, :in => MARKET_LIST
+end

data/spec/support/trade.rb

@@ -0,0 +1,6 @@
+class Trade < SyncableRecord
+  belongs_to :stock
+  
+  validates_numericality_of :amount, :greater_than => 0
+  validates_presence_of :date, :stock
+end

data/spec/syncable_record_spec.rb

@@ -0,0 +1,447 @@
+require 'spec_helper.rb'
+
+describe "SyncableRecord" do
+
+  describe "with no server records" do
+    
+    describe "and no remote records" do
+      
+      it "it should return empty response" do
+        response = Stock.sync({})
+        response.should be_empty
+      end 
+    end
+
+    describe "and created remote records" do
+      before(:each) do
+        @stock1 = { :market => 'il', :ticker => 'Teva', :name => 'Teva Pharma', :tmp_id => '12' }
+        @stock2 = { :market => 'us', :ticker => 'AAPL', :name => 'Apple', :tmp_id => '13' }
+      end
+      
+      it "it should create the records and return create response for them" do
+        remote_state = { 'created' => [@stock1, @stock2] }
+        
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check they were created on server
+        stocks = Stock.all
+        stocks.length.should == 2
+        Stock.find_by_name('Teva Pharma').should_not be_nil
+        Stock.find_by_name('Apple').should_not be_nil
+        
+        response[:create].length.should == 2
+        response[:create][0]['name'].should == @stock1[:name]
+        response[:create][0]['version'].should == 0
+        response[:create][0]['id'].should_not be_nil
+        response[:create][0]['tmp_id'].should == @stock1[:tmp_id]      
+        response[:create][1]['name'].should == @stock2[:name]
+        response[:create][1]['version'].should == 0
+        response[:create][1]['id'].should_not be_nil
+        response[:create][1]['tmp_id'].should == @stock2[:tmp_id]
+        response[:delete].should be_nil
+        response[:update].should be_nil
+      end 
+    end
+  end    
+
+  describe "with server records" do
+    before(:each) do
+      @stock1 = FactoryGirl.create(:stock)
+      @stock2 = FactoryGirl.create(:stock, :market => 'us')
+    end
+
+    describe "and no remote records" do
+      
+      it "it should return create for server records" do
+        response = Stock.sync({})
+        response[:create].length.should == 2
+        response[:create][0].should == @stock1
+        response[:create][1].should == @stock2
+        response[:delete].should be_nil
+        response[:update].should be_nil
+      end
+    end
+    
+    describe "already saved on remote" do
+      
+      it "it should return empty response" do
+        remote_state = { 'saved' => [@stock1, @stock2] }
+        response = Stock.sync(remote_state)
+        response.should be_empty
+      end
+    end      
+
+    describe "one of the remote records is deleted" do
+      
+      it "it should delete the deleted record and keep the saved record" do
+        remote_state = { 'saved' => [@stock1], 'deleted' => [@stock2] }
+        response = Stock.sync(remote_state)
+        response[:delete].length.should == 1
+        response[:delete][0][:id].should == @stock2.id   
+        response[:create].should be_nil
+        response[:update].should be_nil
+      end
+    end
+  end
+  
+  describe "with new records on server" do
+    before(:each) do
+      @stock1 = FactoryGirl.create(:stock)
+      @new_stock = FactoryGirl.create(:stock, :market => 'us', :ticker => 'AMZN', :name => 'Amazon')
+    end
+    
+    describe "and some saved records on remote" do
+      
+      it "it should return create for new records" do
+        remote_state = { 'saved' => [@stock1] }
+  
+        response = Stock.sync(remote_state)
+        response[:create].length.should == 1
+        response[:create][0].should == @new_stock
+        response[:delete].should be_nil
+        response[:update].should be_nil
+      end
+    end      
+
+    describe "and saved & created remote records" do
+      before(:each) do
+        @stock3 = { :market => 'il', :ticker => 'Teva', :name => 'Teva Pharma', :tmp_id => '12' }
+        @stock4 = { :market => 'us', :ticker => 'AAPL', :name => 'Apple', :tmp_id => '13' }
+      end
+      
+      it "it should create the new and created records and return create response for them" do
+        remote_state = { 'saved' => [@stock1], 'created' => [@stock3, @stock4] }
+        
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check they were created on server
+        stocks = Stock.all
+        stocks.length.should == 4
+        Stock.find_by_name('Teva Pharma').should_not be_nil
+        Stock.find_by_name('Apple').should_not be_nil
+        Stock.find_by_name('Amazon').should_not be_nil
+        
+        # check response
+        response[:create].length.should == 3
+        response[:create][0]['name'].should == @new_stock[:name]
+        response[:create][0]['version'].should == @new_stock[:version]
+        response[:create][1]['name'].should == @stock3[:name]
+        response[:create][1]['version'].should == 0
+        response[:create][1]['id'].should_not be_nil
+        response[:create][1]['tmp_id'].should == @stock3[:tmp_id]      
+        response[:create][2]['name'].should == @stock4[:name]
+        response[:create][2]['version'].should == 0
+        response[:create][2]['id'].should_not be_nil
+        response[:create][2]['tmp_id'].should == @stock4[:tmp_id]
+        response[:delete].should be_nil
+        response[:update].should be_nil
+      end 
+    end
+  end
+
+  describe "with server saved, new, deleted and updated records" do
+    before(:each) do
+      @stock1 = FactoryGirl.create(:stock)
+      @stock2 = FactoryGirl.create(:stock, :market => 'us', :ticker => 'IBM', :name => 'International Business Machines')
+      @new_stock = FactoryGirl.create(:stock, :market => 'us', :ticker => 'AMZN', :name => 'Amazon')
+      @updated_stock = FactoryGirl.create(:stock, :market => 'us', :ticker => 'APPL', :name => 'Apple')
+      @deleted_stock = FactoryGirl.create(:stock, :market => 'il', :ticker => 'Chil', :name => 'Israel Chemicals')
+    end
+    
+    describe "and only saved remote records" do   
+      
+      it "it should create the new, update the updated and delete the deleted" do
+        remote_state = { 'saved' => [@stock1, @stock2, @updated_stock.to_rjson, @deleted_stock] }
+        
+        # do server changes: update a stock, delete a stock
+        @updated_stock.update_attributes({:name => "Apple Computers"})
+        @deleted_stock.destroy
+                  
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check nothing was created on server
+        stocks = Stock.all
+        stocks.length.should == 4
+        
+        # check response
+        response[:create].length.should == 1                  
+        response[:create][0].should == @new_stock
+        response[:update].length.should == 1                  
+        response[:update][0].should == @updated_stock
+        @updated_stock[:version].should == 1
+        @updated_stock[:name].should == "Apple Computers"
+        response[:delete].length.should == 1                  
+        response[:delete][0][:id].should == @deleted_stock.id        
+      end
+    end
+    
+    describe "and saved & deleted remote records" do
+         
+      it "it should create the new, delete the deleted and update the updated" do
+        remote_state = { 'saved' => [@stock2, @updated_stock.to_rjson, @deleted_stock], 'deleted' => [@stock1] }
+        
+        # do server changes: update a stock, delete a stock
+        @updated_stock.update_attributes({:name => "Apple Computers"})
+        @deleted_stock.destroy
+        
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check record was deleted on server
+        stocks = Stock.all
+        stocks.length.should == 3
+        Stock.find_by_id(@stock1.id).should be_false
+        
+        # check response
+        response[:create].length.should == 1                  
+        response[:create][0].should == @new_stock
+        response[:update].length.should == 1                  
+        response[:update][0].should == @updated_stock
+        response[:delete].length.should == 2               
+        response[:delete][0][:id].should == @deleted_stock.id
+        response[:delete][1][:id].should == @stock1.id
+      end
+    end   
+
+    describe "and saved & updated remote records" do
+      
+      it "it should create the new, delete the deleted and update the updated" do
+        remote_update = @stock1
+        remote_update['name'] = 'This is an updated name'
+        remote_state = { 'saved' => [@stock1, @stock2, @updated_stock, @deleted_stock], 'updated' => [remote_update] }
+        remote_state = remote_state.to_rjson
+                
+        # do server changes: update a stock, delete a stock
+        @updated_stock.update_attributes({:name => "Apple Computers"})
+        @deleted_stock.destroy
+        
+        # update what we expect in the response
+        remote_update['version'] += 1
+        
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check nothing was created on server and what needed to be updated was
+        stocks = Stock.all
+        stocks.length.should == 4
+        Stock.find_by_id(@stock1.id).name == remote_update['name']     
+        
+        # check response
+        response[:create].length.should == 1                  
+        response[:create][0].should == @new_stock
+        response[:update].length.should == 2                 
+        response[:update][0].should == @updated_stock
+        response[:update][1]['id'].should == remote_update['id']
+        response[:update][1]['name'].should == remote_update['name']
+        response[:update][1]['version'].should == remote_update['version']
+        response[:delete].length.should == 1             
+        response[:delete][0][:id].should == @deleted_stock[:id]               
+      end
+    end
+
+    describe "and saved, created, updated, and deleted remote records" do
+      
+      it "it should create the new, delete the deleted and update the updated" do
+        remote_update = @stock1
+        remote_update['name'] = 'This is an updated name'
+        remote_create = { :market => 'il', :ticker => 'Razio', :name => 'Razio Oil', :tmp_id => '19' }
+        remote_state = { 'saved' => [@stock1.to_rjson, @updated_stock, @deleted_stock], 'created' => [remote_create], 'updated' => [remote_update], 'deleted' => [@stock2] }             
+        remote_state = remote_state.to_rjson
+        
+        # do server changes: update a stock, delete a stock
+        @updated_stock.update_attributes({:name => "Apple Computers"})
+        @deleted_stock.destroy
+        
+        # update what we expect in the response
+        remote_update['version'] += 1
+        
+        response = Stock.sync(HashWithIndifferentAccess.new(remote_state))
+        
+        # check nothing was created on server and what needed to be updated was
+        stocks = Stock.all
+        stocks.length.should == 4
+        Stock.find_by_name(remote_create[:name]).name == remote_create['name']
+        Stock.find_by_id(@stock1.id).name == remote_update['name']
+        Stock.find_by_id(@stock2.id).should be_false             
+        
+        # check response
+        response[:create].length.should == 2              
+        response[:create][0].should == @new_stock
+        response[:create][1]['name'].should == remote_create[:name]
+        response[:create][1]['version'].should == 0
+        response[:create][1]['id'].should_not be_nil
+        response[:create][1]['tmp_id'].should == remote_create[:tmp_id]          
+        response[:update].length.should == 2                 
+        response[:update][0].should == @updated_stock
+        response[:update][1]['id'].should == remote_update['id']
+        response[:update][1]['name'].should == remote_update['name']
+        response[:update][1]['version'].should == remote_update['version']
+        response[:delete].length.should == 2            
+        response[:delete][0][:id].should == @deleted_stock.id
+        response[:delete][1][:id].should == @stock2.id                  
+      end
+    end
+  end
+  
+  describe "with conflicts" do
+    before(:each) do
+      @stock = FactoryGirl.create(:stock, :market => 'us', :ticker => 'IBM', :name => 'International Business Machines')
+    end 
+    
+    describe "between server deleted record and remote deleted record" do
+      
+      it "it should delete the record" do    
+        remote_state = { 'deleted' => [@stock.to_rjson] }               
+        
+        # do server changes: delete the stock
+        @stock.destroy
+        
+        response = Stock.sync(remote_state)
+        
+        # check nothing was created on server
+        stocks = Stock.all
+        stocks.length.should == 0        
+        
+        # check response
+        response[:create].should be_nil
+        response[:update].should be_nil          
+        response[:delete].length.should == 1            
+        response[:delete][0][:id].should == @stock.id
+      end
+    end      
+    
+    describe "between server deleted record and remote updated record" do
+      
+      it "it should delete the record" do
+        remote_update = @stock.to_rjson
+        remote_update['name'] = 'Tabulation company'          
+        
+        remote_state = { 'updated' => [@stock.to_rjson] } 
+        
+        # do server changes: delete the stock
+        @stock.destroy
+        
+        response = Stock.sync(remote_state)
+        
+        # check nothing was created on server
+        stocks = Stock.all
+        stocks.length.should == 0        
+        
+        # check response
+        response[:create].should be_nil
+        response[:update].should be_nil          
+        response[:delete].length.should == 1            
+        response[:delete][0][:id].should == @stock.id
+      end
+    end
+    
+    describe "between server updated record and remote deleted record" do
+      
+      it "it should create the record as if new" do
+        remote_state = { 'deleted' => [@stock.to_rjson] }           
+        
+        # do server changes: update the stock
+        @stock.update_attributes({:name => 'Tabulation company'})
+        @stock = Stock.find(@stock.id)
+
+        response = Stock.sync(remote_state)
+        
+        # check nothing has changed on server
+        stocks = Stock.all
+        stocks.length.should == 1
+        
+        # check response  
+        response[:create].length.should == 1            
+        response[:create][0]['id'].should == @stock[:id]
+        response[:create][0]['name'].should == @stock[:name]
+        response[:update].should be_nil   
+        response[:delete].should be_nil             
+      end        
+    end  
+    
+    describe "between server updated record and remote updated record" do
+      
+      it "it should update the record with the server version" do
+        remote_update = @stock.to_rjson
+        remote_update['name'] = 'Tabulation company'          
+        
+        remote_state = { 'updated' => [remote_update] } 
+        
+        # do server changes: update the stock
+        @stock.update_attributes({:name => 'ICR'})
+        @stock = Stock.find(@stock.id)
+
+        response = Stock.sync(remote_state)
+        
+        # check nothing has changed on server
+        stocks = Stock.all
+        stocks.length.should == 1
+        @stock.name.should == 'ICR'
+        
+        # check response
+        # response = JSON.parse(json_response) 
+        response[:create].should be_nil  
+        response[:update].length.should == 1
+        response[:update][0]['id'].should == @stock[:id]
+        response[:update][0]['name'].should == @stock[:name]
+        response[:delete].should be_nil             
+      end
+    end          
+  end
+
+  describe "with bad information" do
+    
+    describe "send ilegal data" do
+      
+      it "it should return error with 'Ilegal JSON'" do
+        response = Stock.sync(123)
+        
+        response.should == { :error => "can't convert String into Integer" }
+      end
+    end
+
+    describe "send nonsense data" do
+      
+      it "it should return empty" do
+        response = Stock.sync({ "foo" => 123 })
+        
+        response.should == {}
+      end
+    end
+
+    describe "send remote update id that does not exist" do
+      
+      it "it should ignore it" do
+        @stock = { :market => 'il', :ticker => 'Teva', :name => 'Teva Pharma' }
+        
+        remote_state = { 'updated' => [@stock] }                 
+        
+        response = Stock.sync(remote_state)
+        response.should be_empty
+      end
+    end
+    
+    describe "send remote update with ilegal attributes" do
+      
+      it "it should ignore it" do
+        @stock = { :marketing => 'yyy', :ticker => 'Teva', :name => 'Teva Pharma' }
+        
+        remote_state = { 'updated' => [@stock] }                 
+        
+        response = Stock.sync(remote_state)
+        response.should be_empty
+      end
+    end      
+    
+    describe "send remote create with ilegal attributes" do
+      
+      it "it should return error" do
+        @stock = { :marketing => 'yyy', :ticker => 'Teva', :name => 'Teva Pharma' }
+        
+        remote_state = { 'created' => [@stock] }
+
+        response = Stock.sync(remote_state)
+        response[:error].should_not be_empty
+      end
+    end      
+  end
+  
+end

data/spec/syncer_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper.rb'
+
+describe "Sync.sync" do
+  
+  let(:stock) { FactoryGirl.create(:stock) }
+  let(:syncOrder) { [:Account, :Stock, :Trade] }
+  let(:syncOrderKey) { Syncer::SYNC_ORDER_KEY }
+
+  it "should sync a single Model" do
+    updated_stock = { :name => 'Teva Pharma', :id => stock.id, :version => stock.version }
+    stocks_sync_data = { :updated => [ updated_stock ] }
+    all_sync_data = { syncOrderKey => syncOrder, :Stock => stocks_sync_data }
+    
+    result = Syncer.sync(all_sync_data)  
+    
+    stock_results = result['Stock']
+    stock_results.should_not be_nil
+    update_stock = stock_results['update'][0]   
+    update_stock['id'].should == stock.id
+    update_stock['version'].should == stock.version + 1
+    update_stock['market'].should == stock.market
+    update_stock['ticker'].should == stock.ticker
+    update_stock['name'].should == updated_stock[:name]
+  end  
+
+  it "should sync multiple independent Models" do
+    updated_stock = { :name => 'Teva Pharma', :id => stock.id, :version => stock.version }
+    stocks_sync_data = { :updated => [ updated_stock ] }
+    created_account = FactoryGirl.attributes_for(:account)
+    created_account['tmp_id'] = "12345abcde"
+    accounts_sync_data = { :created => [ created_account ] }      
+    all_sync_data = { syncOrderKey => syncOrder, :Stock => stocks_sync_data, :Account => accounts_sync_data }
+
+    result = Syncer.sync(all_sync_data) 
+      
+    stock_results = result['Stock']
+    stock_results.should_not be_nil
+    update_stock = stock_results['update'][0]
+    update_stock['id'].should == stock.id
+    update_stock['version'].should == stock.version + 1
+    update_stock['market'].should == stock.market
+    update_stock['ticker'].should == stock.ticker
+    update_stock['name'].should == updated_stock[:name]
+    
+    account_results = result['Account']
+    account_results.should_not be_nil
+    create_account = account_results['create'][0]
+    create_account['id'].should_not be_nil
+    create_account['tmp_id'].should == "12345abcde"
+    create_account['version'].should == 0
+    create_account['name'].should == created_account[:name]      
+  end
+  
+  it "should sync dependent Models with new model where dependency exists" do
+    updated_stock = { :name => 'Teva Pharma', :id => stock.id, :version => stock.version }
+    stocks_sync_data = { :updated => [ updated_stock ] }
+    created_trade = FactoryGirl.attributes_for(:trade, :stock_id => stock.id)
+    created_trade['tmp_id'] = "12345abcde"
+    trades_sync_data = { :created => [ created_trade ] }      
+    all_sync_data = { syncOrderKey => syncOrder, :Trade => trades_sync_data, :Stock => stocks_sync_data }
+
+    result = Syncer.sync(all_sync_data)
+     
+    stock_results = result['Stock']
+    update_stock = stock_results['update'][0]
+    update_stock['id'].should == stock.id
+    update_stock['version'].should == stock.version + 1
+    update_stock['market'].should == stock.market
+    update_stock['ticker'].should == stock.ticker
+    update_stock['name'].should == updated_stock[:name]
+    
+    trade_results = result['Trade']
+    create_trade = trade_results['create'][0]
+    create_trade['id'].should_not be_nil
+    create_trade['tmp_id'].should == "12345abcde"
+    create_trade['version'].should == 0
+    create_trade['stock_id'].should == stock.id
+    create_trade['amount'].should == created_trade[:amount]      
+    create_trade['buy'].should == created_trade[:buy]      
+    # TODO maybe also test date that seems to return different ...      
+  end
+  
+  it "should sync dependent Models when both models are new" do
+    created_stock = FactoryGirl.attributes_for(:stock, :name => 'Teva Pharma')
+    created_stock['tmp_id'] = "abcde12345"
+    stocks_sync_data = { :saved => [ stock ], :created => [ created_stock ] }
+    created_trade = FactoryGirl.attributes_for(:trade)
+    created_trade['tmp_id'] = "12345abcde"
+    created_trade['stock_tmp_id'] = "abcde12345"
+    trades_sync_data = { :created => [ created_trade ] }
+    all_sync_data = { syncOrderKey => syncOrder, :Trade => trades_sync_data, :Stock => stocks_sync_data }
+
+    result = Syncer.sync(all_sync_data)     
+    
+    stock_results = result['Stock']
+    create_stock = stock_results['create'][0]
+    create_stock['id'].should_not be_nil
+    create_stock['tmp_id'].should == "abcde12345"
+    create_stock['version'].should == 0
+    create_stock['market'].should == created_stock[:market]
+    create_stock['ticker'].should == created_stock[:ticker]
+    create_stock['name'].should == created_stock[:name]
+    
+    trade_results = result['Trade']
+    create_trade = trade_results['create'][0]
+    create_trade['id'].should_not be_nil
+    create_trade['tmp_id'].should == "12345abcde"
+    create_trade['stock_id'].should == create_stock['id']
+    create_trade['version'].should == 0
+    create_trade['amount'].should == created_trade[:amount]      
+    create_trade['buy'].should == created_trade[:buy]  
+    # TODO maybe also test date that seems to return different ...      
+  end    
+
+  it "should sync dependent Models with new model where dependent exists and is updated to point to new Model" do
+    updated_stock = { :name => 'Teva Pharma', :id => stock.id, :version => stock.version, :account_tmp_id => "12345abcde" }
+    stocks_sync_data = { :updated => [ updated_stock ] }
+    created_account = FactoryGirl.attributes_for(:account)
+    created_account['tmp_id'] = "12345abcde"
+    accounts_sync_data = { :created => [ created_account ] }      
+    all_sync_data = { syncOrderKey => syncOrder, :Account => accounts_sync_data, :Stock => stocks_sync_data }
+
+    result = Syncer.sync(all_sync_data)    
+
+    account_results = result['Account']
+    account_results.should_not be_nil
+    create_account = account_results['create'][0]
+    create_account['id'].should_not be_nil
+    create_account['tmp_id'].should == "12345abcde"
+    create_account['version'].should == 0
+    create_account['name'].should == created_account[:name]       
+     
+    stock_results = result['Stock']
+    update_stock = stock_results['update'][0]
+    update_stock['id'].should == stock.id
+    update_stock['version'].should == stock.version + 1
+    update_stock['market'].should == stock.market
+    update_stock['ticker'].should == stock.ticker
+    update_stock['name'].should == updated_stock[:name]
+    update_stock['account_id'].should == create_account['id']          
+  end
+end

data/syncer.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/syncer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Harry Hornreich"]
+  gem.email         = ["harryhorn@gmail.com"]
+  gem.description   = %q{ActiveRecord syncer}
+  gem.summary       = %q{ActiveRecord syncer}
+  gem.homepage      = ""
+
+  gem.add_runtime_dependency 'activerecord', '>= 2.0'
+  gem.add_runtime_dependency 'xstring', '>= 0.0.7'
+  gem.add_development_dependency 'rspec', '>= 2.0'
+  gem.add_development_dependency 'sqlite3', '>= 1.3'
+  gem.add_development_dependency 'factory_girl', "~> 3.1.0"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "syncer"
+  gem.require_paths = ["lib"]
+  gem.version       = Syncer::VERSION
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: syncer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Harry Hornreich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: xstring
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: ActiveRecord syncer
+email:
+- harryhorn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/syncer.rb
+- lib/syncer/syncable_record.rb
+- lib/syncer/syncer.rb
+- lib/syncer/version.rb
+- spec/spec_helper.rb
+- spec/support/account.rb
+- spec/support/active_record.rb
+- spec/support/factories.rb
+- spec/support/stock.rb
+- spec/support/trade.rb
+- spec/syncable_record_spec.rb
+- spec/syncer_spec.rb
+- syncer.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: ActiveRecord syncer
+test_files:
+- spec/spec_helper.rb
+- spec/support/account.rb
+- spec/support/active_record.rb
+- spec/support/factories.rb
+- spec/support/stock.rb
+- spec/support/trade.rb
+- spec/syncable_record_spec.rb
+- spec/syncer_spec.rb
+has_rdoc: