active_harmony 1.0.1

data/lib/active_harmony/service_manager.rb

@@ -0,0 +1,31 @@
+module ActiveHarmony
+  class ServiceManager
+    # include Singleton
+    
+    ##
+    # Initializes new Service Manager.
+    def initialize
+      @services = {}
+    end
+    
+    ##
+    # Adds service for identifier
+    # @param [Service] Service
+    # @param [Symbol] Identifier
+    def add_service_for_identifier(service, identifier)
+      @services[identifier] = service
+    end
+    
+    ##
+    # Returns service for identifier
+    # @param [Symbol] identifier
+    def service_with_identifier(identifier)
+      service = @services[identifier]
+      if service
+        service
+      else
+        raise "There's no service with identifier #{identifier}"
+      end
+    end
+  end
+end

data/lib/active_harmony/service_url.rb

@@ -0,0 +1,18 @@
+module ActiveHarmony
+  class ServiceUrl
+    attr_accessor :path, :request_method
+    
+    def initialize(path, request_method = :get)
+      @path = path
+      @request_method = request_method
+    end
+    
+    def method
+      request_method
+    end
+    
+    def to_s
+      path
+    end
+  end
+end

data/lib/active_harmony/synchronizable.rb

@@ -0,0 +1,7 @@
+require 'active_harmony/synchronizable/core'
+require 'active_harmony/synchronizable/mongoid'
+
+module ActiveHarmony
+  module Synchronizable
+  end
+end

data/lib/active_harmony/synchronizable/core.rb

@@ -0,0 +1,50 @@
+module ActiveHarmony
+  module Synchronizable
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :synchronizer
+        self.synchronizer = Synchronizer.new
+        self.synchronizer.factory = self
+      end
+
+      module InstanceMethods
+
+        def updates
+          updates = {}
+          changes.each do |atr, values|
+            updates[atr] = values[1]
+          end
+          updates
+        end
+
+        def contexts
+          {}
+        end
+
+        # Returns Synchronization Queue
+        def queue
+          @queue ||= ActiveHarmony::Queue.instance
+        end
+
+        ##
+        # Adds changes to queue
+        # @param [Boolean] Instant push, don't wait for queue
+        def push(instant = false)
+          if instant
+            synchronizer.push_object(self)
+          else
+            queue.queue_push(self)
+          end
+        end
+
+        ##
+        # Reteurns synchronizer
+        def synchronizer
+          self.class.synchronizer
+        end
+      end
+    end
+  end
+end

data/lib/active_harmony/synchronizable/mongoid.rb

@@ -0,0 +1,30 @@
+module ActiveHarmony
+  module Synchronizable
+    module Mongoid
+      extend ActiveSupport::Concern
+      
+      included do
+        field :_remote_id, :type => Integer
+        field :_collection_order, :type => Float, :default => 9999.0
+      end
+      
+      module ClassMethods
+        def object_name
+          self.name.downcase
+        end
+    
+        def with_remote_id(id)
+          self.find(:first, :conditions => {:_remote_id => id.to_i})
+        end
+      end
+      
+      def update_remote_id(id)
+        self._remote_id = id
+      end
+    
+      def changed_attributes
+        self.changes.keys
+      end
+    end
+  end
+end

data/lib/active_harmony/synchronizer.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+module ActiveHarmony
+  class Synchronizer
+    attr_accessor :factory, :service, :configuration
+    
+    ##
+    # Initializes new Service Synchronizer to do some
+    # synchronizing magic.
+    def initialize
+      @contexts = {}
+      @configuration = SynchronizerConfiguration.new
+    end
+    
+    ##
+    # Returns object name for currently used factory
+    # @return [Symbol] Object name
+    def object_name
+      @factory.object_name.to_sym
+    end
+    
+    ##
+    # Sets context for this synchronizer
+    # @param [Symbol] Name of context
+    # @param [String, Integer] Value
+    def set_context(context_name, context_value)
+      @contexts[context_name.to_sym] = context_value
+    end
+    
+    ##
+    # Takes block to configure synchronization
+    # @yield Configuration block
+    def configure
+      yield(@configuration)
+    end
+    
+    ##
+    # Pulls object from remote service
+    # @param [Integer] Remote ID of object.
+    # @return [Boolean] Result of pulling
+    def pull_object(id)
+      local_object = @factory.with_remote_id(id)
+      if local_object
+        # FIXME What if there's no local object and we still want to set some
+        # contexts?
+        @service.set_contexts(local_object.contexts)
+      else
+        local_object = @factory.new
+      end
+      local_object.before_pull(self) if local_object.respond_to?(:before_pull)
+      object_hash = @service.show(object_name, id)
+      @service.clear_contexts
+      local_object._remote_id = object_hash.delete('id')
+      fields = configuration.synchronizable_for_pull
+      fields.each do |key|
+        value = object_hash[key.to_s]
+        local_object.send("#{key}=", value)
+      end
+      local_object.after_pull(self) if local_object.respond_to?(:after_pull)
+      local_object.save
+    end
+    
+    ##
+    # Pushes local object to remote services.
+    # Er, I mean, its attributes.
+    # Like not object itself. Just attributes.
+    # @param [Object] Local object
+    def push_object(local_object)
+      object_name = @factory.object_name.to_sym
+      
+      local_object.before_push(self) if local_object.respond_to?(:before_push)
+      
+      changes = {}
+      fields = configuration.synchronizable_for_push
+      fields.each do |atr|
+        value = local_object.send(atr)
+        changes[atr.to_s] = value
+      end
+      
+      @service.set_contexts(local_object.contexts)
+      
+      if local_object._remote_id
+        @service.update(object_name, local_object._remote_id, changes)
+      else
+        result = @service.create(object_name, changes)
+        if result
+          local_object._remote_id = result['id']
+          fields = configuration.synchronizable_for_pull
+          fields.each do |atr|
+            local_object.write_attribute(atr, result[atr.to_s])
+          end
+          local_object.save
+        end
+      end
+      
+      local_object.after_push(self) if local_object.respond_to?(:after_push)
+      @service.clear_contexts
+    end
+    
+    ##
+    # Pulls whole remote collection. If it cannot find
+    # matching local object, it will create one. 
+    # This method is slow, useful for initial import, not
+    # for regular updates. For regular updates, only
+    # changed remote objects should be updates using pull_object
+    # @see pull_object
+    def pull_collection
+      @service.set_contexts(@contexts)
+      collection = @service.list(object_name)
+      @service.clear_contexts
+      collection.each_with_index do |remote_object_hash, index|
+        remote_id = remote_object_hash.delete("id")
+        local_object = @factory.with_remote_id(remote_id)
+        unless local_object
+          local_object = @factory.new
+          local_object.update_remote_id(remote_id)
+        end
+        local_object.before_pull(self) if local_object.respond_to?(:before_pull)
+        local_object._collection_order = index
+        fields = configuration.synchronizable_for_pull
+        fields.each do |field|
+          value = remote_object_hash[field.to_s]
+          local_object.send("#{field}=", value)
+        end
+        local_object.after_pull(self) if local_object.respond_to?(:after_pull)
+        local_object.save
+      end
+      collection.count
+    end
+  end
+end

data/lib/active_harmony/synchronizer_configuration.rb

@@ -0,0 +1,71 @@
+module ActiveHarmony
+  class SynchronizerConfiguration
+    TYPE_PUSH = :push
+    TYPE_PULL = :pull
+    TYPE_ALL = :all
+    
+    ##
+    # Initializes new Synchronizer Configuration.
+    def initialize
+      @synchronizable_fields = []
+    end
+    
+    ##
+    # Configures field for push type of synchronization.
+    # @param [Symbol] Field
+    def push(field)
+      synchronize field, :type => :push
+    end
+    
+    ##
+    # Configures field for pull type of synchronization.
+    # @param [Symbol] Field
+    def pull(field)
+      synchronize field, :type => :pull
+    end
+    
+    ##
+    # Configures field for any type of synchronization.
+    # If no type is specified, defaults to TYPE_ALL.
+    # @param [Symbol] Field
+    # @param [Hash] Options
+    # @option Options [Symbol] :type Type of synchronization.
+    def synchronize(field, options = {})
+      options = {
+        :type => TYPE_ALL
+      }.merge(options)
+      
+      @synchronizable_fields << {
+        :field => field,
+        :type => options[:type]
+      }
+    end
+    
+    ##
+    # Fields that should be synchronized on push type
+    # @return [Array<Symbol>] Fields for push
+    def synchronizable_for_push
+      synchronizable_for_types([TYPE_PUSH, TYPE_ALL])
+    end
+    
+    ##
+    # Fields that should be synchronized on pull type
+    # @return [Array<Symbol>] Fields for pull
+    def synchronizable_for_pull
+      synchronizable_for_types([TYPE_PULL, TYPE_ALL])
+    end
+    
+    ##
+    # Fields that should be synchronized on types specified
+    # in argument
+    # @param [Array<Symbol>] Types
+    # @return [Array<Symbol>] Fields
+    def synchronizable_for_types(types)
+      @synchronizable_fields.select do |field_description|
+        types.include?(field_description[:type])
+      end.collect do |field_description|
+        field_description[:field]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'webmock'
+require 'webmock/rspec'
+require 'mongoid'
+
+Mongoid.configure do |config|
+  name = "active_harmony_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.persist_in_safe_mode = false
+end
+
+require 'active_harmony'
+
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.include WebMock
+end

data/spec/unit/active_harmony/queue_item_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+class MyClass
+  include Mongoid::Document
+  include ActiveHarmony::Synchronizable::Core
+  field :foo
+end
+
+module ActiveHarmony
+  describe QueueItem do
+    let(:queue) { ActiveHarmony::Queue.instance }
+    
+    context "type push" do
+      describe "#process_item" do
+        it "should tell synchronizer to push object" do
+          my_object = MyClass.new
+          my_object.foo = "bar"
+          my_object.save
+          queue.queue_push(my_object)
+          item = QueueItem.last
+          item.object_type.should == "MyClass"
+          my_object.synchronizer.expects(:push_object).with(my_object)
+          item.process_item
+        end
+      end
+    end
+    
+    context "type pull" do
+      describe "#process_item" do
+         it "should tell synchronizer to pull object" do
+            queue.queue_pull(::MyClass, 123)
+            item = QueueItem.last
+            item.object_type.should == "MyClass"
+            item.kind.should == "pull"
+            MyClass.synchronizer.expects(:pull_object).with('123')
+            item.process_item
+          end
+      end
+    end
+  end
+end

data/spec/unit/active_harmony/queue_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+class Bacon
+  include Mongoid::Document
+end
+
+module ActiveHarmony
+  describe Queue do
+    before do
+      @queue = Queue.instance
+      @bacon = Bacon.create
+    end
+    
+    before :each do
+      QueueItem.delete_all
+    end
+    
+    describe '#queue_push' do
+      it 'should create queue item for push' do
+        @queue.queue_push(@bacon)
+        last_item = QueueItem.last
+        last_item.kind.should == 'push'
+        last_item.object_type.should == 'Bacon'
+        last_item.object_local_id.should == @bacon.id.to_s
+        last_item.object_remote_id.should be_nil
+        last_item.state.should == 'new'
+      end
+    end
+    
+    describe '#queue_pull' do
+      it 'should create queue item for pull' do
+        @queue.queue_pull(Bacon, '123')
+        last_item = QueueItem.last
+        last_item.kind.should == 'pull'
+        last_item.object_type.should == 'Bacon'
+        last_item.object_remote_id.should == '123'
+        last_item.state.should == 'new'
+      end
+    end
+    
+    describe '#run' do
+      it 'should queued items to process' do        
+        items = (1..5).collect do
+          item = QueueItem.new(:state => 'new')
+          item.expects(:process_item)
+          item
+        end
+        @queue.expects(:queued_items).returns(items)
+        @queue.run
+      end
+    end
+    
+    describe '#queued_items' do
+      it 'should return all items with state new' do
+        item_with_no_state = QueueItem.create(:state => nil)
+        item_with_new_state = QueueItem.create(:state => 'new')
+        queued_items = QueueItem.where(:state => "new").to_a
+        @queue.queued_items.to_a.should == queued_items
+      end
+    end
+  end
+end