synapse-core 0.5.6 → 0.6.0

data/lib/synapse/process_manager/correlation.rb

@@ -1,32 +1,6 @@
 module Synapse
   module ProcessManager
-    # Combination key and value that is used to correlate incoming events with process instances
-    class Correlation
-      # @return [Symbol]
-      attr_reader :key
-
-      # @return [String]
-      attr_reader :value
-
-      # @param [Symbol] key
-      # @param [String] value
-      # @return [undefined]
-      def initialize(key, value)
-        @key = key.to_sym
-        @value = value.to_s
-      end
-
-      def ==(other)
-        self.class === other and
-          other.key == @key and
-          other.value == @value
-      end
-
-      alias eql? ==
-
-      def hash
-        @key.hash ^ @value.hash
-      end
-    end # Correlation
-  end # ProcessManager
+    # Combination key and value that is used to correlate incoming events with process instance
+    Correlation = Struct.new :key, :value
+  end
 end

data/lib/synapse/process_manager/pessimistic_lock_manager.rb

@@ -3,20 +3,20 @@ module Synapse
     # Lock manager that blocks until a lock can be obtained for a process
     class PessimisticLockManager
       def initialize
-        @lock = IdentifierLock.new
+        @manager = IdentifierLockManager.new
       end
 
       # @param [String] process_id
       # @return [undefined]
       def obtain_lock(process_id)
-        @lock.obtain_lock process_id
+        @manager.obtain_lock process_id
       end
 
       # @raise [ThreadError] If thread didn't previously hold the lock
       # @param [String] process_id
       # @return [undefined]
       def release_lock(process_id)
-        @lock.release_lock process_id
+        @manager.release_lock process_id
       end
     end # PessimisticLockManager
   end # ProcessManager

data/lib/synapse/process_manager/process.rb

@@ -19,16 +19,12 @@ module Synapse
       # @return [Boolean] True if this process is active
       attr_reader :active
 
-      alias active? active
+      alias_method :active?, :active
 
       # @param [String] id
       # @return [undefined]
       def initialize(id = nil)
-        unless id
-          id = IdentifierFactory.instance.generate
-        end
-
-        @id = id
+        @id = id ||= IdentifierFactory.instance.generate
         @correlations = CorrelationSet.new
         @active = true
 

data/lib/synapse/process_manager/process_manager.rb

@@ -117,7 +117,7 @@ module Synapse
       def notify_current_process(process_id, event, correlation)
         process = @repository.load process_id
 
-        unless process and process.active and process.correlations.include? correlation
+        unless process && process.active && process.correlations.include?(correlation)
           # Process has changed or was deleted between the time of the selection query and the
           # actual loading and locking of the process
           return

data/lib/synapse/process_manager/process_repository.rb

@@ -11,7 +11,7 @@ module Synapse
       # @abstract
       # @param [Class] type
       # @param [Correlation] correlation
-      # @return [Set]
+      # @return [Set<String>]
       def find(type, correlation)
         raise NotImplementedError
       end

data/lib/synapse/process_manager/repository/in_memory.rb

@@ -2,16 +2,17 @@ module Synapse
   module ProcessManager
     # Process repository that stores all processes in memory
     #
-    # This implementation is not thread-safe -- use a lock manager for thread safety
+    # While the storage of processes are thread-safe, the processes themselves may not be. Use a
+    # lock manager if the processes are not thread-safe.
     class InMemoryProcessRepository < ProcessRepository
       def initialize
         @managed_processes = Hash.new
-        @lock = Mutex.new
+        @mutex = Mutex.new
       end
 
       # @param [Class] type
       # @param [Correlation] correlation
-      # @return [Set]
+      # @return [Set<String>]
       def find(type, correlation)
         matching = Array.new
 
@@ -35,7 +36,7 @@ module Synapse
       # @param [Process] process
       # @return [undefined]
       def commit(process)
-        @lock.synchronize do
+        @mutex.synchronize do
           if process.active?
             @managed_processes.store process.id, process
           else

data/lib/synapse/process_manager/simple_process_manager.rb

@@ -2,10 +2,10 @@ module Synapse
   module ProcessManager
     # Simple implementation of a process manager
     class SimpleProcessManager < ProcessManager
-      # @return [Array] Types of events that will always result in the creation of a process
+      # @return [Array<Class>] Types of events that will always result in the creation of a process
       attr_accessor :always_create_events
 
-      # @return [Array] Types of events that will result in the creation of a process if one
+      # @return [Array<Class>] Types of events that will result in the creation of a process if one
       #   doesn't already exist
       attr_accessor :optionally_create_events
 

data/lib/synapse/repository/errors.rb

@@ -21,6 +21,6 @@ module Synapse
       def initialize(aggregate, expected_version)
         super 'Aggregate [%s] has version %s, expected %s' % [aggregate.id, aggregate.version, expected_version]
       end
-    end
-  end
+    end # ConflictingAggregateVersionError
+  end # Repository
 end

data/lib/synapse/repository/locking.rb

@@ -74,11 +74,59 @@ module Synapse
         raise NotImplementedError
       end
 
+      # Deletes the given aggregate from the underlying storage mechanism, ensuring that the lock
+      # for the aggregate is valid before doing so
+      #
+      # @abstract
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def delete_aggregate_with_lock(aggregate)
+        raise NotImplementedError
+      end
+
+      # Saves the given aggregate using the underlying storage mechanism, ensuring that the lock
+      # for the aggregate is valid before doing so
+      #
+      # @abstract
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def save_aggregate_with_lock(aggregate)
+        raise NotImplementedError
+      end
+
       # Hook that is called after an aggregate is registered to the current unit of work
       #
       # @param [AggregateRoot] aggregate
       # @return [undefined]
       def post_registration(aggregate); end
+
+      # @raise [ConcurrencyError] If aggregate is versioned and its lock has been invalidated by
+      #   the lock manager
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def delete_aggregate(aggregate)
+        assert_valid_lock aggregate
+        delete_aggregate_with_lock aggregate
+      end
+
+      # @raise [ConcurrencyError] If aggregate is versioned and its lock has been invalidated by
+      #   the lock manager
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def save_aggregate(aggregate)
+        assert_valid_lock aggregate
+        save_aggregate_with_lock aggregate
+      end
+
+      # @raise [ConcurrencyError] If aggregate is versioned and its lock has been invalidated by
+      #   the lock manager
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def assert_valid_lock(aggregate)
+        if aggregate.version && !@lock_manager.validate_lock(aggregate)
+          raise ConcurrencyError
+        end
+      end
     end # LockingRepository
 
     # Unit of work listener that releases the lock on an aggregate when the unit of work

data/lib/synapse/repository/optimistic_lock_manager.rb

@@ -5,15 +5,16 @@ module Synapse
     # This implementation uses the sequence number of an aggregate's last committed event to
     # detect concurrenct access.
     class OptimisticLockManager < LockManager
+      # @return [undefined]
       def initialize
         @aggregates = Hash.new
-        @lock = Mutex.new
+        @mutex = Mutex.new
       end
 
       # @param [AggregateRoot] aggregate
       # @return [Boolean]
       def validate_lock(aggregate)
-        @aggregates.has_key? aggregate.id and @aggregates[aggregate.id].validate aggregate
+        @aggregates.has_key?(aggregate.id) && @aggregates[aggregate.id].validate(aggregate)
       end
 
       # @param [Object] aggregate_id
@@ -22,7 +23,7 @@ module Synapse
         obtained = false
         until obtained
           lock = lock_for aggregate_id
-          obtained = lock and lock.lock
+          obtained = lock && lock.lock
           unless obtained
             remove_lock aggregate_id, lock
           end
@@ -47,8 +48,8 @@ module Synapse
       # @param [OptimisticLock] lock
       # @return [undefined]
       def remove_lock(aggregate_id, lock)
-        @lock.synchronize do
-          if @aggregates.has_key? aggregate_id and @aggregates[aggregate_id].equal? lock
+        @mutex.synchronize do
+          if @aggregates.has_key?(aggregate_id) && @aggregates[aggregate_id] === lock
             @aggregates.delete aggregate_id
           end
         end
@@ -57,7 +58,7 @@ module Synapse
       # @param [Object] aggregate_id
       # @return [OptimisticLock]
       def lock_for(aggregate_id)
-        @lock.synchronize do
+        @mutex.synchronize do
           if @aggregates.has_key? aggregate_id
             @aggregates[aggregate_id]
           else
@@ -73,7 +74,7 @@ module Synapse
       # @return [Boolean] True if this lock can be disposed
       attr_reader :closed
 
-      alias closed? closed
+      alias_method :closed?, :closed
 
       # @return [Hash] Hash of threads to the number of times they hold the lock
       attr_reader :threads
@@ -87,8 +88,8 @@ module Synapse
       # @return [Boolean]
       def validate(aggregate)
         last_committed = aggregate.version
-        if @version.nil? or @version.eql? last_committed
-          @version = (last_committed or 0) + aggregate.uncommitted_event_count
+        if @version.nil? || @version == last_committed
+          @version = (last_committed || 0) + aggregate.uncommitted_event_count
           true
         else
           false

data/lib/synapse/repository/pessimistic_lock_manager.rb

@@ -2,26 +2,27 @@ module Synapse
   module Repository
     # Implementation of a lock manager that blocks until a lock can be obtained
     class PessimisticLockManager < LockManager
+      # @return [undefined]
       def initialize
-        @aggregates = IdentifierLock.new
+        @manager = IdentifierLockManager.new
       end
 
       # @param [AggregateRoot] aggregate
       # @return [Boolean]
       def validate_lock(aggregate)
-        @aggregates.owned? aggregate.id
+        @manager.owned? aggregate.id
       end
 
       # @param [Object] aggregate_id
       # @return [undefined]
       def obtain_lock(aggregate_id)
-        @aggregates.obtain_lock aggregate_id
+        @manager.obtain_lock aggregate_id
       end
 
       # @param [Object] aggregate_id
       # @return [undefined]
       def release_lock(aggregate_id)
-        @aggregates.release_lock aggregate_id
+        @manager.release_lock aggregate_id
       end
     end # PessimisticLockManager
   end # Repository

data/lib/synapse/repository/repository.rb

@@ -97,7 +97,7 @@ module Synapse
       # @param [Integer] expected_version
       # @return [undefined]
       def assert_version_expected(aggregate, expected_version)
-        if expected_version and aggregate.version and aggregate.version > expected_version
+        if expected_version && aggregate.version && aggregate.version > expected_version
           raise ConflictingAggregateVersionError.new aggregate, expected_version
         end
       end

data/lib/synapse/repository/simple_repository.rb

@@ -30,13 +30,14 @@ module Synapse
         # Most ORMs that I can think of use #find like this -- no need for orm_adapter or anything
         # crazy like that
         aggregate = @aggregate_type.find aggregate_id
-        aggregate.tap do
-          unless aggregate
-            raise AggregateNotFoundError
-          end
 
-          assert_version_expected aggregate, expected_version
+        unless aggregate
+          raise AggregateNotFoundError
         end
+
+        assert_version_expected aggregate, expected_version
+
+        aggregate
       end
 
       # @return [Class]
@@ -46,13 +47,13 @@ module Synapse
 
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def delete_aggregate(aggregate)
+      def delete_aggregate_with_lock(aggregate)
         aggregate.destroy
       end
 
       # @param [AggregateRoot] aggregate
       # @return [undefined]
-      def save_aggregate(aggregate)
+      def save_aggregate_with_lock(aggregate)
         aggregate.save
       end
     end # SimpleRepository

data/lib/synapse/serialization/converter.rb

@@ -6,7 +6,10 @@ module Synapse
       extend ActiveSupport::Concern
 
       included do
+        # @return [Class]
         class_attribute :source_type
+
+        # @return [Class]
         class_attribute :target_type
       end
 

data/lib/synapse/serialization/converter_factory.rb

@@ -3,10 +3,12 @@ module Synapse
     # Represents a mechanism for storing and retrieving converters capable of converting content
     # of one type to another type, for the purpose of serialization and upcasting.
     class ConverterFactory
+      # @return [Set<Converter>]
       attr_reader :converters
 
+      # @return [undefined]
       def initialize
-        @converters = Array.new
+        @converters = Set.new
       end
 
       # Adds the given converter to this converter factory
@@ -14,7 +16,7 @@ module Synapse
       # @param [Converter] converter
       # @return [undefined]
       def register(converter)
-        @converters.push converter
+        @converters.add converter
       end
 
       # Convenience method for converting a given serialized object to the given target type
@@ -40,9 +42,8 @@ module Synapse
         end
 
         @converters.each do |converter|
-          if converter.source_type == source_type && converter.target_type == target_type
-            return converter
-          end
+          return converter if converter.source_type == source_type &&
+            converter.target_type == target_type
         end
 
         raise ConversionError, 'No converter capable of [%s] -> [%s]' % [source_type, target_type]

data/lib/synapse/serialization/serialized_object.rb

@@ -21,13 +21,13 @@ module Synapse
       end
 
       def ==(other)
-        self.class === other and
-          other.content == @content and
-          other.content_type == @content_type and
+        self.class === other &&
+          other.content == @content &&
+          other.content_type == @content_type &&
           other.type == @type
       end
 
-      alias eql? ==
+      alias_method :eql?, :==
 
       def hash
         @content.hash ^ @content_type.hash ^ @type.hash

data/lib/synapse/serialization/serialized_type.rb

@@ -16,16 +16,16 @@ module Synapse
       end
 
       def ==(other)
-        self.class === other and
-          other.name == @name and
+        self.class === other &&
+          other.name == @name &&
           other.revision == @revision
       end
 
-      alias eql? ==
+      alias_method :eql?, :==
 
       def hash
         @name.hash ^ @revision.hash
       end
     end # SerializedType
   end # Serialization
-end
+end