synchronisable 0.0.3 → 0.0.4

data/lib/synchronisable/synchronizer.rb

@@ -1,4 +1,5 @@
 require 'synchronisable/dsl/macro'
+require 'synchronisable/attribute_mapper'
 require 'synchronisable/dsl/associations'
 require 'synchronisable/exceptions'
 
@@ -35,11 +36,7 @@ module Synchronisable
 
     # Logger that will be used during synchronization
     # of this particular model.
-    # Fallbacks to `Rails.logger` if available, otherwise
-    # `STDOUT` will be used for output.
-    attribute :logger, default: -> {
-      defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
-    }
+    attribute :logger, default: -> { Synchronisable.logging[:logger] }
 
     # Lambda that returns array of hashes with remote attributes.
     method :fetch, default: -> { [] }
@@ -110,7 +107,6 @@ module Synchronisable
       def extract_remote_id(attrs)
         id = attrs.delete(remote_id)
         ensure_remote_id(id)
-        id
       end
 
       # Maps the remote attributes to local model attributes.
@@ -120,11 +116,11 @@ module Synchronisable
       #
       # @api private
       def map_attributes(attrs)
-        result = attrs.dup
-        apply_mappings(result) if mappings.present?
-        apply_only_filter(result) if only.present?
-        apply_except_filter(result) if except.present?
-        result
+        AttributeMapper.map(attrs, mappings, {
+          :only   => only,
+          :except => except,
+          :keep   => associations.keys
+        })
       end
 
       %w(sync record_sync association_sync).each do |method|
@@ -135,21 +131,6 @@ module Synchronisable
 
       private
 
-      def apply_mappings(attrs)
-        attrs.transform_keys! { |key| mappings[key] || key }
-      end
-
-      def apply_only_filter(attrs)
-        attrs.keep_if do |key|
-          only.include?(key) ||
-          associations.keys.include?(key)
-        end
-      end
-
-      def apply_except_filter(attrs)
-        attrs.delete_if { |key| key.nil? || except.include?(key) }
-      end
-
       def run_callbacks(method, args, block)
         before = send(:"before_#{method}")
         after  = send(:"after_#{method}")
@@ -165,12 +146,11 @@ module Synchronisable
       #
       # @raise [MissedRemoteIdError] raised when data doesn't contain remote id
       def ensure_remote_id(id)
-        if id.blank?
-          raise MissedRemoteIdError, I18n.t(
-            'errors.missed_remote_id',
-            remote_id: remote_id
-          )
-        end
+        return id if id.present?
+        raise MissedRemoteIdError, I18n.t(
+          'errors.missed_remote_id',
+          remote_id: remote_id
+        )
       end
     end
   end

data/lib/synchronisable/version.rb

@@ -2,7 +2,7 @@ module Synchronisable
   module VERSION
     MAJOR = 0
     MINOR = 0
-    PATCH = 3
+    PATCH = 4
     SUFFIX = nil
 
     STRING = [MAJOR, MINOR, PATCH, SUFFIX].compact.join('.')

data/lib/synchronisable/worker.rb

@@ -1,5 +1,8 @@
+require 'colorize'
+
 require 'synchronisable/error_handler'
 require 'synchronisable/context'
+require 'synchronisable/data_builder'
 require 'synchronisable/source'
 require 'synchronisable/models/import'
 
@@ -41,11 +44,8 @@ module Synchronisable
         error_handler = ErrorHandler.new(@logger, context)
         context.before = @model.imports_count
 
-        data = @synchronizer.fetch.() if data.blank?
-        data.each do |attrs|
-          # TODO: Handle case when only array of ids is given
-          # What to do with associations?
-
+        hashes = DataBuilder.build(@model, @synchronizer, data)
+        hashes.each do |attrs|
           source = Source.new(@model, @parent, attrs)
           error_handler.handle(source) do
             @synchronizer.with_sync_callbacks(source) do
@@ -71,20 +71,17 @@ module Synchronisable
 
     def sync
       @logger.progname = "#{@model} synchronization"
-      @logger.info 'starting'
+      log_info('STARTING', :yellow, true)
 
       context = Context.new(@model, @parent.try(:model))
       yield context
 
-      @logger.info 'done'
-      @logger.info(context.summary_message)
-      @logger.progname = nil
+      log_info('DONE', :yellow, true)
+      log_info(context.summary_message, :cyan, true)
 
       context
     end
 
-    # TODO: Think about how to move it from here to Source or some other place
-
     # Method called by {#run} for each remote model attribute hash
     #
     # @param source [Synchronisable::Source] synchronization source
@@ -93,44 +90,21 @@ module Synchronisable
     #   without errors, `false` otherwise
     def sync_record(source)
       @synchronizer.with_record_sync_callbacks(source) do
-        source.build
+        source.prepare
 
-        @logger.info(source.dump_message) if verbose_logging?
+        log_info(source.dump_message, :green)
 
         if source.updatable?
-          update_record(source)
+          log_info("updating #{@model}: #{source.local_record.id}", :blue)
+          source.update_record
         else
-          create_record_pair(source)
+          source.create_record_pair
+          log_info("#{@model} (id: #{source.local_record.id}) was created", :blue)
+          log_info("#{source.import_record.class}: #{source.import_record.id} was created", :blue)
         end
       end
     end
 
-    def update_record(source)
-      if verbose_logging?
-        @logger.info "updating #{@model}: #{source.local_record.id}"
-      end
-
-      # TODO: Напрашивается, да?
-      source.local_record.update_attributes!(source.local_attrs)
-    end
-
-    def create_record_pair(source)
-      local_record = @model.create!(source.local_attrs)
-      import_record = Import.create!(
-        :synchronisable_id    => local_record.id,
-        :synchronisable_type  => @model.to_s,
-        :remote_id            => source.remote_id,
-        :attrs                => source.local_attrs
-      )
-
-      source.import_record = import_record
-
-      if verbose_logging?
-        @logger.info "#{@model}: #{local_record.id} was created"
-        @logger.info "#{import_record.class}: #{import_record.id} was created"
-      end
-    end
-
     def set_record_foreign_keys(source)
       reflection = belongs_to_parent_reflection
       return unless reflection
@@ -148,9 +122,7 @@ module Synchronisable
     # @see Synchronisable::DSL::Associations
     # @see Synchronisable::DSL::Associations::Association
     def sync_associations(source)
-      if verbose_logging? && source.associations.present?
-        @logger.info "starting associations sync"
-      end
+      log_info("starting associations sync", :blue) if source.associations.present?
 
       source.associations.each do |association, ids|
         ids.each { |id| sync_association(source, id, association) }
@@ -158,9 +130,7 @@ module Synchronisable
     end
 
     def sync_association(source, id, association)
-      if verbose_logging?
-        @logger.info "synchronizing association with id: #{id}"
-      end
+      log_info("synchronizing association with id: #{id}", :blue)
 
       @synchronizer.with_association_sync_callbacks(source, id, association) do
         attrs = association.model.synchronizer.find.(id)
@@ -184,8 +154,15 @@ module Synchronisable
       @model.reflections.values
     end
 
-    def verbose_logging?
-      Synchronisable.logging[:verbose]
+    def log_info(msg, color = :white, force = true)
+      text = msg.colorize(color) if colorize_logging?
+      @logger.info(text)         if force || verbose_logging?
+    end
+
+    %i(verbose colorize).each do |name|
+      define_method("#{name}_logging?".to_sym) do
+        Synchronisable.logging[name]
+      end
     end
   end
 end

data/lib/synchronisable.rb

@@ -48,7 +48,13 @@ module Synchronisable
     {}
   end
   config_accessor :logging do
+    default_logger = -> { Logger.new(STDOUT) }
+    rails_logger   = -> { Rails.logger || default_logger.() }
+
+    logger = defined?(Rails) ? rails_logger.() : default_logger.()
+
     {
+      :logger   => logger,
       :verbose  => true,
       :colorize => true
     }
@@ -59,7 +65,7 @@ module Synchronisable
   # @param models [Array] array of models that should be synchronized.
   #   This take a precedence over models defined in {Synchronisable#models}.
   #   If this parameter is not specified and {Synchronisable#models} is empty,
-  #   than it will try to sync only those models which have a corresponding synchronizers.
+  #   than it will try to sync only those models which have a corresponding synchronizers
   #
   # @return [Array<[Synchronisable::Context]>] array of synchronization contexts
   #

data/spec/dummy/app/synchronizers/break_convention_team_synchronizer.rb

@@ -1,6 +1,8 @@
 class BreakConventionTeamSynchronizer < Synchronisable::Synchronizer
   @gateway = TeamGateway.new
 
+  has_many :players
+
   remote_id :maet_id
   mappings(
     :eman    => :name,

data/spec/dummy/app/synchronizers/match_synchronizer.rb

@@ -4,8 +4,6 @@ class MatchSynchronizer < Synchronisable::Synchronizer
   has_one :team, key: 'home_team_id'
   has_one :team, key: 'away_team_id'
 
-  has_many :players
-
   remote_id :match_id
 
   mappings(

data/spec/dummy/config/application.rb

@@ -6,7 +6,6 @@ require 'action_mailer/railtie'
 require 'action_view/railtie'
 require 'sprockets/railtie'
 
-Bundler.require(*Rails.groups)
 require 'synchronisable'
 
 module Dummy

data/spec/factories/import.rb

@@ -1,5 +1,5 @@
 FactoryGirl.define do
   factory :import, class: Synchronisable::Import do
-    remote_id { generate :integer }
+    remote_id { generate :remote_id }
   end
 end

data/spec/models/team_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'pry-byebug'
 
 describe Team do
   describe 'synchronization' do
@@ -36,7 +37,91 @@ describe Team do
       it { is_expected.to change { Synchronisable::Import.count }.by(6) }
     end
 
-    context 'when remote id is not specified' do
+    describe 'restrict sync to specific record(s)' do
+      context 'when remote id is specified' do
+        context "when local record doesn't exist" do
+          subject { -> { Team.sync('team_0') } }
+
+          it { is_expected.to change { Team.count }.by(1) }
+          it { is_expected.to change { Synchronisable::Import.count }.by(3) }
+        end
+
+        context 'when local record exists' do
+          include_context 'team_0 import'
+
+          subject do
+            -> {
+              Team.sync('team_0')
+              team_0.reload
+            }
+          end
+
+          it { is_expected.not_to change { Team.count } }
+
+          it { is_expected.to change { Player.count }.by(2) }
+          it { is_expected.to change { Synchronisable::Import.count }.by(2) }
+
+          it { is_expected.to change { team_0.name    } }
+          it { is_expected.to change { team_0.country } }
+          it { is_expected.to change { team_0.city    } }
+        end
+      end
+
+      context 'when there is 2 imports with corresponding local records' do
+        include_context 'team imports'
+
+        context 'when local id is specified' do
+          subject do
+            -> {
+              Team.sync(team_0.id)
+              team_0.reload
+            }
+          end
+
+          it { is_expected.not_to change { Team.count } }
+
+          it { is_expected.to change { Player.count }.by(2) }
+          it { is_expected.to change { Synchronisable::Import.count }.by(2) }
+
+          it { is_expected.to change { team_0.name    } }
+          it { is_expected.to change { team_0.country } }
+          it { is_expected.to change { team_0.city    } }
+        end
+
+        context 'when array of local ids is specified' do
+          subject do
+            -> {
+              Team.sync([team_0.id, team_1.id])
+              [team_0, team_1].each(&:reload)
+            }
+          end
+
+          it { is_expected.not_to change { Team.count } }
+
+          it { is_expected.to change { Player.count }.by(4) }
+          it { is_expected.to change { Synchronisable::Import.count }.by(4) }
+
+          it { is_expected.to change { team_0.name    } }
+          it { is_expected.to change { team_0.country } }
+          it { is_expected.to change { team_0.city    } }
+
+          it { is_expected.to change { team_1.name    } }
+          it { is_expected.to change { team_1.country } }
+          it { is_expected.to change { team_1.city    } }
+        end
+
+        context 'when array of remote ids is specified' do
+          subject do
+            -> {
+              Team.sync([import_0.remote_id, import_1.remote_id])
+              [team_0, team_1].each(&:reload)
+            }
+          end
+        end
+      end
+    end
+
+    context 'when remote id is not specified in attributes hash' do
       subject { Team.sync([remote_attrs.last]) }
 
       its(:errors) { should have(1).items }

data/spec/spec_helper.rb

@@ -64,8 +64,8 @@ Spork.prefork do
   end
 
   FactoryGirl.define do
-    %w(match team player match_player stage tournament).each do |model|
-      sequence(:"#{model}_id") { |n| "#{model}_#{n}" }
+    %w(remote match team player match_player stage tournament).each do |prefix|
+      sequence(:"#{prefix}_id") { |n| "#{prefix}_#{n}" }
     end
   end
 end

data/spec/synchronisable/support/shared/contexts.rb

@@ -0,0 +1,33 @@
+shared_context 'team_0 import' do
+  let!(:import_0) do
+    create(:import,
+      :remote_id => 'team_0',
+      :synchronisable => create(:team,
+        :name => 'x',
+        :country => 'Russia',
+        :city => 'Moscow',
+      )
+    )
+  end
+  let!(:team_0) { import_0.synchronisable }
+end
+
+shared_context 'team_1 import' do
+  let!(:import_1) do
+    create(:import,
+      :remote_id => 'team_1',
+      :synchronisable => create(:team,
+        :name => 'y',
+        :country => 'France',
+        :city => 'Paris',
+      )
+    )
+  end
+  let!(:team_1) { import_1.synchronisable }
+end
+
+shared_context 'team imports' do
+  include_context 'team_0 import'
+  include_context 'team_1 import'
+end
+

data/synchronisable.gemspec

@@ -21,13 +21,13 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "activerecord",  ">= 3.0.0"
   spec.add_runtime_dependency "activesupport", ">= 3.0.0"
   spec.add_runtime_dependency "i18n"
+  spec.add_runtime_dependency "colorize"
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "rails", "~> 4.0.0"
   spec.add_development_dependency "rspec-rails", "~> 3.0.0.beta2"
-  # spec.add_development_dependency "rspec-given"
   spec.add_development_dependency "rspec-its"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "factory_girl"