synchronisable 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1816035987d8bab6ea54e58aab1a9ee8a8477766
-  data.tar.gz: 1c2e17f3e3ed31c29e87283a0065ac25861a210e
+  metadata.gz: 373108e0dab22db4d8c9ff814efc6df6c875a012
+  data.tar.gz: 01d16982d0a8085ed46b69a117b4189ef8d39be1
 SHA512:
-  metadata.gz: 1903884dcb5008df7cc0703bfa294397faaa2b2cf806e3597f0f670529df88a62613464aeb230c40564a46cb6968b5bd03e4a1222a4cfa46d23948db15172ba5
-  data.tar.gz: face867f4e7d462e427904b3e195aa16a6a40fa7d9b89bc28673bd6f0fc1d52b6dc359ee388acf33a24ee8e4bfd24f5e0e5ba839fad28e98d90cc1ad492a9ee3
+  metadata.gz: ecefc4f286f2227d86193e6aa5c16861ca1d2feb668ba874e28dbc0815cae88ba080c41978a57352ac4935f0c08db7bbe7b54b5bc943de60ddaf45263dde2465
+  data.tar.gz: 1a67ad8603495c3b6e41d0a6a95f512ad31f8b65213711f784a671504ffffc242bda2befed97e8ac2b0855f5af7e9dc3842ecd79f9aa1a71411b6c5904400c13

data/README.md

@@ -1,15 +1,16 @@
 [![Build Status](https://travis-ci.org/vyorkin/synchronisable.png?branch=master)](https://travis-ci.org/vyorkin/synchronisable)
 [![Code Climate](https://codeclimate.com/github/vyorkin/synchronisable.png)](https://codeclimate.com/github/vyorkin/synchronisable)
+[![Inline docs](http://inch-pages.github.io/github/vyorkin/synchronisable.png)](http://inch-pages.github.io/github/vyorkin/synchronisable)
 [![Coverage Status](https://coveralls.io/repos/vyorkin/synchronisable/badge.png)](https://coveralls.io/r/vyorkin/synchronisable)
-[![Inch Pages](http://inch-pages.github.io/github/vyorkin/synchronisable)](http://inch-pages.github.io/github/vyorkin/synchronisable)
 [![Gem Version](http://stillmaintained.com/vyorkin/synchronisable.png)](http://stillmaintained.com/vyorkin/synchronisable)
 [![Dependency Status](https://gemnasium.com/vyorkin/synchronisable.svg)](https://gemnasium.com/vyorkin/synchronisable)
 
-
-
 # Synchronisable
 
-Provides base fuctionality (models, DSL) for AR synchronization with external resources (apis, services etc)
+Provides base fuctionality (models, DSL) for AR synchronization
+with external resources (apis, services etc).
+
+## Overview
 
 ## Installation
 
@@ -27,3 +28,108 @@ Or install it yourself as:
 
 ## Usage
 
+For examples we'll be using a well-known domain with posts & comments
+
+```ruby
+class Post < ActiveRecord::Base
+  has_many :comments
+
+  synchronisable
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+
+  synchronisable MyCommentSynchronizer
+end
+```
+
+As you can see above the first step is to declare your models to be
+synchronisable. You can do so by using corresponding dsl instruction,
+that optionally takes a synchonizer class to be used. Actually,
+the only reason to specify it its when it has a name, that can't be figured out
+by the following convention: `ModelSynchronizer`.
+
+After that you should define your model synchronizers
+
+```ruby
+class PostSynchronizer < Synchronisable::Synchronizer
+  remote_id :p_id
+
+  mappings(
+    :t => :title,
+    :c => :content
+  )
+
+  except :ignored_attr1, :ignored_attr42
+
+  has_many :comments
+
+  fetch do
+    # return array of hashes with
+    # remote entity attributes
+  end
+
+  find do |id|
+    # return a hash with
+    # with remote entity attributes
+  end
+
+  # Hooks/callbacks
+
+  before_record_sync do |source|
+    # ...
+  end
+
+  after_record_sync do |source|
+    # ...
+  end
+
+  before_association_sync do |source, remote_id, association|
+    # ...
+  end
+
+  after_association_sync do |source, remote_id, association|
+    # ...
+  end
+
+  before_sync do |source|
+    # ...
+  end
+
+  after_sync do |source|
+    # ...
+  end
+end
+
+class MyCommentSynchronizer < Synchronisable::Synchronizer
+  remote_id :c_id
+
+  mappings(
+    :a => :author,
+    :t => :body
+  )
+
+  only :author, :body
+
+  fetch do
+    # ...
+  end
+
+  find do |id|
+    # ...
+  end
+
+end
+```
+
+To start synchronization
+
+```ruby
+Post.sync
+```
+P.S.: Better readme & wiki is coming! ^__^
+
+## Support
+
+<a href='https://www.codersclan.net/task/yorkinv' target='_blank'><img src='https://www.codersclan.net/button/yorkinv' alt='expert-button' width='205' height='64' style='width: 205px; height: 64px;'></a>

data/TODO.md

@@ -1,20 +1,28 @@
 Primary objectives
 ======================================
-* general tests (DONE)
-* except/only (DONE)
-* sync method (DONE)
-* dependent syncronization & mapping (DONE)
-* tests for Synchronisable.sync (DONE)
-* destroy_missed
-* worker.rb refactoring
-* integrate with travis, stillmaintained, gemnasium
-* write a good README
-* extended interface
-  * sync with include
-  * sync with ids array
-  * sync method for collection proxy (Model.where(condition).sync)
+- [x] general tests
+- [x] except/only
+- [x] sync method
+- [x] dependent syncronization & mapping
+- [x] tests for Synchronisable.sync
+- [ ] fix a mess with Context
+- [ ] destroy_missed
+- [ ] worker.rb refactoring
+- [x] integrate with travis, stillmaintained, gemnasium,
+    codeclimate, coveralls, inch-pages, codersclan
+- [ ] write a good README
+- [ ] extended interface
+-   [ ] sync with include
+  - [x] sync with ids array
+  - [ ] handle case when association type is a :hash
+  - [ ] sync method for collection proxy (Model.where(condition).sync)
+
+Think about
+======================================
+- [ ] has_many :bars, :through => FooModel
+- [ ] polymorphic associations
 
 Secondary objectives
 ======================================
-* option for verbose logging (DONE)
-* colorized STDOUT
+- [x] option for verbose logging
+- [x] colorized STDOUT

data/lib/generators/synchronisable/templates/initializer.rb

@@ -1,7 +1,11 @@
 Synchronisable.configure do |config|
   # Logging configuration
   #
+  # Default logger fallbacks to `Rails.logger` if available, otherwise
+  # `STDOUT` will be used for output.
+  #
   # config.logging = {
+  #   :logger   => defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
   #   :verbose  => true,
   #   :colorize => true
   # }

data/lib/synchronisable/attribute_mapper.rb

@@ -0,0 +1,39 @@
+module Synchronisable
+  class AttributeMapper
+    class << self
+      def map(source, mappings, options = {})
+        new(mappings, options).map(source)
+      end
+    end
+
+    def initialize(mappings, options = {})
+      @mappings = mappings
+      @keep = options[:keep] || []
+      @only, @except = options[:only], options[:except]
+    end
+
+    def map(source)
+      result = source.dup
+
+      apply_mappings(result) if @mappings.present?
+      apply_only(result)     if @only.present?
+      apply_except(result)   if @except.present?
+
+      result
+    end
+
+    private
+
+    def apply_mappings(source)
+      source.transform_keys! { |key| @mappings[key] || key }
+    end
+
+    def apply_only(source)
+      source.keep_if { |key| @only.include?(key) || @keep.include?(key) }
+    end
+
+    def apply_except(source)
+      source.delete_if { |key| key.nil? || @except.include?(key) }
+    end
+  end
+end

data/lib/synchronisable/context.rb

@@ -14,7 +14,7 @@ module Synchronisable
     def summary_message
       I18n.t('messages.result',
         :model   => model,
-        :parent  => @parent.try(:model),
+        :parent  => @parent.try(:model) || 'nil',
         :before  => before,
         :after   => after,
         :deleted => deleted,

data/lib/synchronisable/data_builder.rb

@@ -0,0 +1,58 @@
+require 'synchronisable/input_descriptor'
+
+module Synchronisable
+  class DataBuilder
+    class << self
+      def build(model, synchronizer, data)
+        new(model, synchronizer).build(data)
+      end
+    end
+
+    def initialize(model, synchronizer)
+      @model = model
+      @synchronizer = synchronizer
+    end
+
+    def build(data)
+      input = InputDescriptor.new(data)
+
+      result = case input
+      when ->(i) { i.empty? }
+        @synchronizer.fetch.()
+      when ->(i) { i.remote_id? }
+        @synchronizer.find.(data)
+      when ->(i) { i.local_id? }
+        find_by_local_id(data)
+      when ->(i) { i.array_of_ids? }
+        find_by_array_of_ids(input)
+      else
+        result = data.dup
+      end
+
+      [result].flatten
+    end
+
+    private
+
+    def find_by_array_of_ids(input)
+      records = find_imports(input.element_class.name, input.data)
+      records.map { |r| @synchronizer.find.(r.remote_id) }
+    end
+
+    def find_by_local_id(id)
+      import = @model.find_by(id: id).try(:import)
+      import ? @synchronizer.find.(import.remote_id) : nil
+    end
+
+    private
+
+    def find_imports(class_name, ids)
+      case class_name
+      when 'Fixnum'
+        ids.map { |id| @model.find_by(id: id).try(&:import) }
+      when 'String'
+        ids.map { |id| Import.find_by(id: id) }
+      end
+    end
+  end
+end

data/lib/synchronisable/dsl/associations/association.rb

@@ -17,9 +17,9 @@ module Synchronisable
           end
         end
 
-        self.valid_options = %i(key class_name required)
+        self.valid_options = %i(key class_name required type)
 
-        attr_reader :name, :model, :key, :required
+        attr_reader :name, :model, :key, :required, :type
 
         def initialize(synchronizer, name)
           @synchronizer, @name = synchronizer, name.to_sym
@@ -30,6 +30,7 @@ module Synchronisable
 
           @key = options[:key]
           @required = options[:required]
+          @type = options[:type]
 
           if options[:class_name].present?
             @model = options[:class_name].constantize
@@ -44,6 +45,8 @@ module Synchronisable
 
         def set_defaults
           @required ||= false
+          @type ||= :ids
+
           @model ||= @name.to_s.classify.constantize
           @key = "#{@name}_#{self.class.key_suffix}" unless @key.present?
         end

data/lib/synchronisable/input_descriptor.rb

@@ -0,0 +1,42 @@
+module Synchronisable
+  class InputDescriptor
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    def empty?
+      @data.blank?
+    end
+
+    def remote_id?
+      @data.is_a?(String)
+    end
+
+    def local_id?
+      @data.is_a?(Integer)
+    end
+
+    def array_of_ids?
+       enumerable? && (
+        first_element.is_a?(String) ||
+        first_element.is_a?(Integer)
+      )
+    end
+
+    def element_class
+      first_element.try(:class)
+    end
+
+    private
+
+    def first_element
+      @data.try(:first)
+    end
+
+    def enumerable?
+      @data.is_a?(Enumerable)
+    end
+  end
+end

data/lib/synchronisable/locale/en.yml

@@ -12,6 +12,6 @@ en:
     gateway_method_missing: Method %{method} is not implemented for gateway
   messages:
     result: |
-      %{model} synchronization, parent: %{parent}.
-      Record count before / after: %{before} / %{after},
-      deleted record count: %{deleted}, error count: %{errors}
+      parent: %{parent},
+      records before: %{before}, records after: %{after},
+      deleted records: %{deleted}, errors: %{errors}

data/lib/synchronisable/model.rb

@@ -31,7 +31,7 @@ module Synchronisable
         extend Synchronisable::Model::Methods
 
         class_attribute :synchronizer
-        has_one :import, as: :synchronisable
+        has_one :import, as: :synchronisable, class_name: 'Synchronisable::Import'
 
         set_defaults(args)
       end

data/lib/synchronisable/source.rb

@@ -3,23 +3,29 @@ module Synchronisable
   class Source
     attr_accessor :import_record
     attr_reader :model, :remote_attrs,
-                :remote_id, :local_attrs, :associations
+                :remote_id, :local_attrs,
+                :associations, :import_ids
 
     def initialize(model, parent, remote_attrs)
       @model, @parent, @synchronizer = model, parent, model.synchronizer
       @remote_attrs = remote_attrs.with_indifferent_access
     end
 
-    # Extracts the `remote_id` from remote attributes, maps remote attirubtes
-    # to local attributes and tries to find import record for given model
-    # by extracted remote id.
+    # Prepares synchronization source:
+    # `remote_id`, `local_attributes`, `import_record` and `associations`.
+    # Sets foreign key if current model is specified as `has_one` or `has_many`
+    # association of parent model.
     #
     # @api private
-    def build
+    def prepare
       @remote_id = @synchronizer.extract_remote_id(@remote_attrs)
       @local_attrs = @synchronizer.map_attributes(@remote_attrs)
       @associations = @synchronizer.associations_for(@local_attrs)
 
+      # TODO: implement destroy_missed, somehow pass @import_ids,
+      # get all import records if nil
+
+      # remove associations keys from local attributes
       @local_attrs.delete_if do |key, _|
         @associations.keys.any? { |a| a.key == key }
       end
@@ -29,20 +35,34 @@ module Synchronisable
         :synchronisable_type => @model
       )
 
-      set_parent_attribute
+      set_foreign_key
     end
 
     def updatable?
       @import_record.present? && local_record.present?
     end
 
+    def update_record
+      local_record.update_attributes!(@local_attrs)
+    end
+
+    def create_record_pair
+      record = @model.create!(@local_attrs)
+      @import_record = Import.create!(
+        :synchronisable_id    => record.id,
+        :synchronisable_type  => @model.to_s,
+        :remote_id            => @remote_id,
+        :attrs                => @local_attrs
+      )
+    end
+
     def local_record
       @import_record.try(:synchronisable)
     end
 
     def dump_message
       %Q(
-        remote_id: #{remote_id},
+        remote id: '#{remote_id}',
         remote attributes: #{remote_attrs},
         local attributes: #{local_attrs}
       )
@@ -50,13 +70,13 @@ module Synchronisable
 
     private
 
-    def set_parent_attribute
+    def set_foreign_key
       return unless @parent
-      name = parent_attribute_name
+      name = foreign_key_name
       @local_attrs[name] = @parent.local_record.id if name
     end
 
-    def parent_attribute_name
+    def foreign_key_name
       return nil unless parent_has_model_as_reflection?
       parent_name = @parent.model.table_name.singularize
       "#{parent_name}_id"