synchronisable 0.0.2

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

@@ -0,0 +1,59 @@
+require 'synchronizable/dsl/macro'
+
+module Synchronizable
+  module DSL
+    module Associations
+      # Association builder.
+      class Association
+        include Synchronizable::DSL::Macro
+
+        attribute :key_suffix, default: -> { raise NotImplementedError }
+
+        class << self
+          attr_accessor :valid_options
+
+          def create(synchronizer, name, options)
+            new(synchronizer, name).create(options)
+          end
+        end
+
+        self.valid_options = %i(key class_name required)
+
+        attr_reader :name, :model, :key, :required
+
+        def initialize(synchronizer, name)
+          @synchronizer, @name = synchronizer, name.to_sym
+        end
+
+        def create(options)
+          validate_options(options)
+
+          @key = options[:key]
+          @required = options[:required]
+
+          if options[:class_name].present?
+            @model = options[:class_name].constantize
+          end
+
+          set_defaults
+
+          @synchronizer.associations[@key] = self
+        end
+
+        protected
+
+        def set_defaults
+          @required ||= false
+          @model ||= @name.to_s.classify.constantize
+          @key = "#{@name}_#{self.class.key_suffix}" unless @key.present?
+        end
+
+        private
+
+        def validate_options(options)
+          options.assert_valid_keys(Association.valid_options)
+        end
+      end
+    end
+  end
+end

data/lib/synchronizable/dsl/associations/has_many.rb

@@ -0,0 +1,12 @@
+require 'synchronizable/dsl/associations/association'
+
+module Synchronizable
+  module DSL
+    module Associations
+      # `has_many` association builder.
+      class HasMany < Association
+        key_suffix 'ids'
+      end
+    end
+  end
+end

data/lib/synchronizable/dsl/associations/has_one.rb

@@ -0,0 +1,13 @@
+require 'synchronizable/dsl/associations/association'
+
+module Synchronizable
+  module DSL
+    module Associations
+      # `has_one` association builder.
+      class HasOne < Association
+        key_suffix 'id'
+      end
+    end
+  end
+end
+

data/lib/synchronizable/dsl/macro.rb

@@ -0,0 +1,100 @@
+require 'synchronizable/dsl/macro/method'
+require 'synchronizable/dsl/macro/attribute'
+
+module Synchronizable
+  module DSL
+    # Allows to define DSL-like attributes and methods.
+    # to be used in target class/module.
+    #
+    # @example Common use cases
+    #   class Foo
+    #     include Synchronizable::DSL::Macro
+    #
+    #     attribute :bar, default: 1
+    #     attribute :blah, default: -> { bar * 2 }
+    #     attribute :x, :y, :z
+    #     attribute :f, -> {
+    #       ...
+    #     }
+    #     attribute :w, converter: ->(h) { x.with_indifferent_access }
+    #     method :sqr, default: ->(x) { x * x }
+    #     method :sqrt, :sin, :cos, default: -> { raise NotImplementedError }
+    #   end
+    #
+    #   class Bar < Foo
+    #     bar 4
+    #     blah "blah blah"
+    #
+    #     sqr do |x|
+    #       x * x
+    #     end
+    #   end
+    #
+    # @api private
+    #
+    # @see Synchronizable::Synchronizer
+    # @see Synchronizable::DSL::Macro::Expression
+    # @see Synchronizable::DSL::Macro::Attribute
+    # @see Synchronizable::DSL::Macro::Method
+    module Macro
+      extend ActiveSupport::Concern
+
+      included do |base|
+        class_attribute :class_attributes
+        self.class_attributes = {
+          base => {}
+        }
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          class_attributes[subclass] = class_attributes[self].deep_dup
+        end
+
+        # Defines a new attribute.
+        #
+        # @overload attribute(*attrs, options)
+        #  @param attrs [Array] attributes
+        #  @param options [Hash]
+        #  @option options :default default value,
+        #    procs & lambdas are lazily evaluated
+        #  @option options [Lambda] :converter method that
+        #    will be lazily applied to the source value in order to convert it
+        #    to the desired type
+        # @overload attribute(*attrs)
+        #
+        # @api private
+        def attribute(*args)
+          define_expressions(Attribute, args)
+        end
+
+        # Defines a new method.
+        #
+        # @overload method(*attrs, options)
+        #  @param attrs [Array] attributes
+        #  @param options [Hash]
+        #  @option options :default default value,
+        #    procs & lambdas are lazily evaluated
+        # @overload method(*attrs)
+        #
+        # @api private
+        def method(*args)
+          define_expressions(Method, args)
+        end
+
+        private
+
+        def define_expressions(klass, args)
+          options = args.extract_options!
+          args.each do |attr|
+            name = attr.to_sym
+            class_attributes[self][name] = klass.new(options)
+            define_singleton_method(name) do |*params, &block|
+              class_attributes[self][name].handle(params, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/synchronizable/dsl/macro/attribute.rb

@@ -0,0 +1,41 @@
+require 'synchronizable/dsl/macro/expression'
+
+module Synchronizable
+  module DSL
+    module Macro
+      # Expression for an attribute definition.
+      #
+      # @api private
+      #
+      # @see Synchronizable::DSL::Macro
+      # @see Synchronizable::DSL::Expression
+      class Attribute < Expression
+        def initialize(options)
+          @converter = options[:converter]
+          super
+        end
+
+        def source
+          transform(@source)
+        end
+
+        def default
+          transform(@default)
+        end
+
+        protected
+
+        def transform(arg)
+          convert(super)
+        end
+
+        private
+
+        def convert(arg)
+          @converter.try(:call, arg) || arg
+        end
+      end
+    end
+  end
+end
+

data/lib/synchronizable/dsl/macro/expression.rb

@@ -0,0 +1,51 @@
+module Synchronizable
+  module DSL
+    module Macro
+      # Serves as storage and provides lazy evaluation for expression.
+      # You can override attributes in subclasses,
+      # for example you can change the default value.
+      #
+      # @api private
+      #
+      # @see Synchronizable::DSL::Macro
+      # @see Synchronizable::DSL::Attribute
+      # @see Synchronizable::DSL::Method
+      class Expression
+        attr_reader :source, :default
+
+        def initialize(options)
+          @default = options[:default]
+        end
+
+        def handle(args, &block)
+          has_value = block || args.present?
+          has_value ? save(args, block) : value
+        end
+
+        protected
+
+        def transform(arg)
+          evaluate(arg)
+        end
+
+        private
+
+        def save(args, block)
+          if args.present?
+            @source = args.count > 1 ? args : args.first
+          elsif block
+            @source = block
+          end
+        end
+
+        def value
+          source || default
+        end
+
+        def evaluate(arg)
+          arg.try(:call) || arg
+        end
+      end
+    end
+  end
+end

data/lib/synchronizable/dsl/macro/method.rb

@@ -0,0 +1,15 @@
+require 'synchronizable/dsl/macro/expression'
+
+module Synchronizable
+  module DSL
+    module Macro
+      # Expression for a method definition.
+      #
+      # @api private
+      #
+      # @see Synchronizable::DSL::Macro
+      # @see Synchronizable::DSL::Expression
+      class Method < Expression; end
+    end
+  end
+end

data/lib/synchronizable/error_handler.rb

@@ -0,0 +1,50 @@
+module Synchronizable
+  # Helper class for synchronization errors handling.
+  #
+  # @see Synchronizable::Context
+  #
+  # @api private
+  class ErrorHandler
+    # @param logger [Logger] logger to used to log errors
+    # @param context [Synchronizable::Context] synchronization context
+    def initialize(logger, context)
+      @logger, @context = logger, context
+    end
+
+    # Wraps the given block in transaction.
+    # Rescued exceptions are written to log and saved to errors array.
+    #
+    # @param source [Synchronizable::Source] synchronization source
+    #
+    # @return [Boolean] `true` if syncronization was completed
+    #   without errors, `false` otherwise
+    def handle(source)
+      ActiveRecord::Base.transaction do
+        yield
+        return true
+      end
+      rescue Exception => e
+        @context.errors << e
+        log(e, source)
+        return false
+    end
+
+    private
+
+    def log(e, source)
+      msg = error_message(e, source)
+      @logger.error msg
+    end
+
+    def error_message(e, source)
+      I18n.t('errors.import_error',
+        :model         => @context.model.to_s,
+        :error         => e.message,
+        :remote_attrs  => source.remote_attrs,
+        :local_attrs   => source.local_attrs,
+        :import_record => source.import_record.inspect,
+        :local_record  => source.local_record.inspect
+      )
+    end
+  end
+end

data/lib/synchronizable/exceptions.rb

@@ -0,0 +1,8 @@
+module Synchronizable
+  # Error is thrown when remote id isn't supplied
+  # with remote attibutes hash.
+  class MissedRemoteIdError < StandardError; end
+  # Error is thrown when required associations isn't supplied
+  # with remote attributes hash.
+  class MissedAssociationsError < StandardError; end
+end

data/lib/synchronizable/locale/en.yml

@@ -0,0 +1,17 @@
+---
+en:
+  errors:
+    missed_remote_id: Couldn't find remote id '%{remote_id}' in given data hash
+    missed_associations: Couldn't find associations %{keys} in %{attrs}
+    import_error: |
+      %{model} import error: %{error}.
+      remote attrs: %{remote_attrs},
+      local attrs: %{local_attrs},
+      import record: %{import_record},
+      local record: %{local_record}
+    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}

data/lib/synchronizable/locale/ru.yml

@@ -0,0 +1,17 @@
+---
+ru:
+  errors:
+    missed_remote_id: В хэше не указан remote id '%{remote_id}'
+    missed_associations: В хэше %{attrs} не указаны ассоциации %{keys}
+    import_error: >
+      Ошибка при импорте %{model}: %{error},
+      remote attrs: %{remote_attrs},
+      local attrs: %{local_attrs},
+      import record: %{import_record},
+      local record: %{local_record}
+    gateway_method_missing: Не реализован метод '%{method}' для Gateway
+  messages:
+    result: >
+      Синхронизация %{model}, родительская запись: %{parent}.
+      Количество записей до: %{before}, количество записей после: %{after},
+      количество удаленных записей: %{deleted}, количество ошибок: %{errors}

data/lib/synchronizable/model.rb

@@ -0,0 +1,54 @@
+require 'synchronizable/model/methods'
+require 'synchronizable/synchronizers/synchronizer_default'
+
+module Synchronizable
+  module Model
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      SYNCHRONIZER_SUFFIX = 'Synchronizer'
+
+      # Declare this on your model class to make it synchronizable.
+      # After that you can call {Synchronizable::Model::Methods#sync} to
+      # start model synchronization.
+      #
+      # @overload synchronizable(klass, options)
+      #   @param klass [Class] synchronizer class to be used
+      #   @param options [Hash] describes behavior of synchronizable model
+      #   @option options [Class] :synchronizer class that provides
+      #     synchronization configuration
+      # @overload synchronizable(options)
+      # @overload synchronizable
+      #
+      # @see Synchronizable::Synchronizer
+      # @see Synchronizable::Model::Methods
+      #
+      # @example Common usage
+      #   class FooModel < ActiveRecord::Base
+      #     synchronizable BarSynchronizer
+      #   end
+      def synchronizable(*args)
+        extend Synchronizable::Model::Methods
+
+        class_attribute :synchronizer
+        has_one :import, as: :synchronizable
+
+        set_defaults(args)
+      end
+
+      private
+
+      def set_defaults(args)
+        options = args.extract_options!
+
+        self.synchronizer = args.first ||
+          options[:synchronizer] || default_synchronizer
+      end
+
+      def default_synchronizer
+        const_name = "#{self.name.demodulize}#{SYNCHRONIZER_SUFFIX}"
+        const_name.safe_constantize || SynchronizerDefault
+      end
+    end
+  end
+end