synapse-core 0.1.2

data/lib/synapse/upcasting/chain.rb

@@ -0,0 +1,78 @@
+module Synapse
+  module Upcasting
+    class UpcasterChain
+      # @return [ConverterFactory]
+      attr_accessor :converter_factory
+
+      # @return [Array<Upcaster>]
+      attr_accessor :upcasters
+
+      # @param [ConverterFactory] converter_factory
+      # @return [undefined]
+      def initialize(converter_factory)
+        @converter_factory = converter_factory
+        @upcasters = Array.new
+      end
+
+      # Pushes the given upcaster onto the end of this upcaster chain
+      #
+      # @param [Upcaster] upcaster
+      # @return [undefined]
+      def push(upcaster)
+        @upcasters.push upcaster
+      end
+
+      alias << push
+
+      # @param [SerializedObject] serialized_object
+      # @param [UpcastingContext] upcast_context
+      # @return [Array<SerializedObject>]
+      def upcast(serialized_object, upcast_context)
+        serialized_objects = Array.new
+        serialized_objects.push serialized_object
+
+        @upcasters.each do |upcaster|
+          serialized_objects = upcast_objects(upcaster, serialized_objects, upcast_context)
+        end
+
+        serialized_objects
+      end
+
+    protected
+
+      # @param [Upcaster] upcaster
+      # @param [SerializedObject] representation
+      # @param [Array<SerializedType>] expected_types
+      # @param [UpcastingContent] upcast_context
+      # @return [Array<SerializedObject>]
+      def perform_upcast(upcaster, representation, expected_types, upcast_context)
+        upcaster.upcast(representation, expected_types, upcast_context)
+      end
+
+    private
+
+      # @param [Upcaster] upcaster
+      # @param [Array<SerializedObject>] serialized_objects
+      # @param [UpcastingContext] upcast_context
+      # @return [Array<SerializedObject>]
+      def upcast_objects(upcaster, serialized_objects, upcast_context)
+        upcast_objects = Array.new
+
+        serialized_objects.each do |serialized_object|
+          serialized_type = serialized_object.type
+
+          if upcaster.can_upcast? serialized_type
+            serialized_object = converter_factory.convert serialized_object, upcaster.expected_content_type
+            expected_types = upcaster.upcast_type(serialized_type)
+
+            upcast_objects.concat(perform_upcast(upcaster, serialized_object, expected_types, upcast_context))
+          else
+            upcast_objects.push serialized_object
+          end
+        end
+
+        upcast_objects
+      end
+    end
+  end
+end

data/lib/synapse/upcasting/context.rb

@@ -0,0 +1,58 @@
+module Synapse
+  module Upcasting
+    # Provides contextual information about an object being upcast; generally this is information
+    # from the message containing the object to be upcast
+    #
+    # @abstract
+    class UpcastingContext
+      # @abstract
+      # @return [String]
+      def message_id; end
+
+      # @abstract
+      # @return [Hash]
+      def metadata; end
+
+      # @abstract
+      # @return [Time]
+      def timestamp; end
+
+      # @abstract
+      # @return [Object]
+      def aggregate_id; end
+
+      # @abstract
+      # @return [Integer]
+      def sequence_number; end
+    end
+
+    # Upcasting context that provides information from serialized domain event data
+    class SerializedDomainEventUpcastingContext < UpcastingContext
+      extend Forwardable
+
+      # @return [Object]
+      attr_reader :aggregate_id
+
+      # @return [LazyObject]
+      attr_reader :serialized_metadata
+
+      # @param [SerializedDomainEventData] event_data
+      # @param [Object] aggregate_id
+      # @param [Serializer] serializer
+      # @return [undefined]
+      def initialize(event_data, aggregate_id, serializer)
+        @aggregate_id = aggregate_id
+        @event_data = event_data
+        @serialized_metadata = Serialization::LazyObject.new @event_data.metadata, serializer
+      end
+
+      # @return [Hash]
+      def metadata
+        @serialized_metadata.deserialized
+      end
+
+      # Delegators for serialized domain event data
+      def_delegators :@event_data, :id, :timestamp, :sequence_number
+    end
+  end
+end

data/lib/synapse/upcasting/data.rb

@@ -0,0 +1,30 @@
+module Synapse
+  module Upcasting
+    class UpcastSerializedDomainEventData < Serialization::SerializedDomainEventData
+      extend Forwardable
+
+      # @param [SerializedDomainEventData] original
+      # @param [Object] aggregate_id
+      # @param [SerializedObject] upcast_payload
+      # @return [undefined]
+      def initialize(original, aggregate_id, upcast_payload)
+        @original = original
+        @aggregate_id = aggregate_id
+        @upcast_payload = upcast_payload
+      end
+
+      # @return [SerializedObject]
+      def payload
+        @upcast_payload
+      end
+
+      # @return [Object]
+      def aggregate_id
+        @aggregate_id
+      end
+
+      # Delegators for serialized domain event data
+      def_delegators :@original, :id, :metadata, :timestamp, :sequence_number
+    end
+  end
+end

data/lib/synapse/upcasting/single_upcaster.rb

@@ -0,0 +1,57 @@
+module Synapse
+  module Upcasting
+    # Specialized upcaster mixin for an upcaster that upcasts a serialized object into a single,
+    # newer serialized object.
+    #
+    # This mixin is not suitable if an upcaster needs to upcast a  serialized object into multiple
+    # newer serialized objects, or when the output representation type is not the same as the
+    # expected representation type.
+    module SingleUpcaster
+      extend ActiveSupport::Concern
+      include Upcaster
+
+      # @param [SerialiedObject] intermediate
+      # @param [Array<SerializedType>] expected_types
+      # @param [UpcastingContext] upcast_context
+      # @return [Array<SerializedObject>]
+      def upcast(intermediate, expected_types, upcast_context)
+        upcast_content = perform_upcast(intermediate, upcast_context)
+        upcast_objects = Array.new
+
+        unless upcast_content
+          return upcast_objects
+        end
+
+        upcast_objects.push Serialization::SerializedObject.new(upcast_content, expected_content_type, expected_types.at(0))
+        upcast_objects
+      end
+
+      # @param [SerializedType] serialized_type
+      # @return [Array<SerializedType>]
+      def upcast_type(serialized_type)
+        upcast_type = perform_upcast_type(serialized_type)
+        upcast_types = Array.new
+
+        unless upcast_type
+          return upcast_types
+        end
+
+        upcast_types.push upcast_type
+        upcast_types
+      end
+
+    protected
+
+      # @abstract
+      # @param [SerializedObject] intermediate
+      # @param [UpcastingContext] upcast_context
+      # @return [Object] If nil is returned, the serialized object will be dropped
+      def perform_upcast(intermediate, upcast_context); end
+
+      # @abstract
+      # @param [SerializedType] serialized_type
+      # @return [SerializedType] If nil is returned, the serialized object will be dropped
+      def perform_upcast_type(serialized_type); end
+    end
+  end
+end

data/lib/synapse/upcasting/upcaster.rb

@@ -0,0 +1,55 @@
+module Synapse
+  module Upcasting
+    # Represents a mechanism for converting deprecated serialized objects into the current
+    # format used by the application. If the serializer itself is not able to cope with the changed
+    # formats, an upcaster provides flexibility for more complex structural transformations.
+    #
+    # Upcasters work on intermediate representations of the object to upcast. In most cases, this
+    # representation is an object structure of some kind. The serializer is responsible for
+    # converting the intermediate representation form to one that is compatible with the upcaster.
+    #
+    # For performance reasons, it is advisable to ensure that all upcasters in the same chain use
+    # the same intermediate representation type.
+    module Upcaster
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :expected_content_type
+      end
+
+      module ClassMethods
+        # @param [Class] type
+        # @return [undefined]
+        def expects_content_type(type)
+          self.expected_content_type = type
+        end
+      end
+
+      # Returns true if this upcaster is capable of upcasting the given type
+      #
+      # @abstract
+      # @param [SerializedType] serialized_type
+      # @return [Boolean]
+      def can_upcast?(serialized_type); end
+
+      # Upcasts a given serialized object to zero or more upcast objects
+      #
+      # The types of the upcast objects should match the same length and order of the given array
+      # of upcast types.
+      #
+      # @abstract
+      # @param [SerialiedObject] intermediate
+      # @param [Array<SerializedType>] expected_types
+      # @param [UpcastingContext] upcast_context
+      # @return [Array<SerializedObject>]
+      def upcast(intermediate, expected_types, upcast_context); end
+
+      # Upcasts a given serialized type to zero or more upcast types
+      #
+      # @abstract
+      # @param [SerializedType] serialized_type
+      # @return [Array<SerializedType>]
+      def upcast_type(serialized_type); end
+    end
+  end
+end

data/lib/synapse/version.rb

@@ -0,0 +1,3 @@
+module Synapse
+  VERSION = '0.1.2'
+end

data/lib/synapse/wiring/message_wiring.rb

@@ -0,0 +1,41 @@
+module Synapse
+  module Wiring
+    # Base mixin that make it easier to wire handlers to their respective types
+    # @abstract
+    module MessageWiring
+      extend ActiveSupport::Concern
+
+      included do
+        # @return [WireRegistry]
+        class_attribute :wire_registry
+      end
+
+      module ClassMethods
+        def wire(type, *args, &block)
+          options = args.extract_options!
+
+          unless options[:to]
+            unless block
+              raise ArgumentError, 'Expected block or option :to'
+            end
+
+            options[:to] = block
+          end
+
+          wire = Wire.new type, options[:to]
+
+          self.wire_registry.register wire
+        end
+      end
+
+    protected
+
+      # @param [Message] message
+      # @param [Wire] wire
+      # @return [Object] Result of the handler invocation
+      def invoke_wire(message, wire)
+        wire.invoke self, message.payload
+      end
+    end
+  end
+end

data/lib/synapse/wiring/wire.rb

@@ -0,0 +1,55 @@
+module Synapse
+  module Wiring
+    # Represents a mapping between a payload type and a handler method or block
+    #
+    # Wires are ordered by the depth of the payload type that they handle. Wires that are
+    # for a more specific class are preferred over wires for an abstract class.
+    class Wire
+      # @return [Class] The type of payload that a handler is being wired to
+      attr_reader :type
+
+      # @return [Object] Either a method symbol or block
+      attr_reader :handler
+
+      # @param [Class] type
+      # @param [Object] handler Either a method symbol or block
+      # @return [undefined]]
+      def initialize(type, handler)
+        @type = type
+        @handler = handler
+      end
+
+      # @param [Object] target
+      # @param [Object...] args
+      # @return [Object] The result of the handler invocation
+      def invoke(target, *args)
+        if @handler.is_a? Symbol
+          target.send(@handler, *args)
+        else
+          target.instance_exec(*args, &@handler)
+        end
+      end
+
+      # @param [Wire] other
+      # @return [Integer]
+      def <=>(other)
+        (@type <=> other.type) or 0
+      end
+
+      # @param [Wire] other
+      # @return [Boolean]
+      def ==(other)
+        self.class === other and
+          @type == other.type
+      end
+
+      alias eql? ==
+
+      # TODO Is this a good hash function? Probs not
+      # @return [Integer]
+      def hash
+        @type.hash
+      end
+    end
+  end
+end

data/lib/synapse/wiring/wire_registry.rb

@@ -0,0 +1,61 @@
+module Synapse
+  module Wiring
+    class WireRegistry
+      # @param [Boolean] duplicates_allowed
+      # @return [undefined]
+      def initialize(duplicates_allowed)
+        @duplicates_allowed = duplicates_allowed
+        @wires = Array.new
+      end
+
+      # Yields the type that each wire is registered for
+      #
+      # @yield [Class]
+      # @return [undefined]
+      def each_type
+        @wires.each do |wire|
+          yield wire.type
+        end
+      end
+
+      # @raise [DuplicateWireError] If duplicates aren't allowed and another wire exists that
+      #   wires the exact same type as the given wire
+      # @param [Wire] wire
+      # @return [undefined]
+      def register(wire)
+        unless @duplicates_allowed
+          if @wires.include? wire
+            raise DuplicateWireError
+          end
+        end
+
+        @wires.push wire
+        @wires.sort!
+      end
+
+      # Retrieves the most specific wire for a given type, if any
+      #
+      # @param [Class] target_type
+      # @return [Wire]
+      def wire_for(target_type)
+        @wires.find do |wire|
+          wire.type >= target_type
+        end
+      end
+
+      # Retrieves any wires for a given type, regardless of specificity
+      #
+      # @param [Class] target_type
+      # @return [Array]
+      def wires_for(target_type)
+        @wires.find_all do |wire|
+          wire.type >= target_type
+        end
+      end
+    end
+
+    # Raised if a wire registry doesn't allow duplicates and an attempt is made to wire the same
+    # type to multiple handlers
+    class DuplicateWireError < NonTransientError; end
+  end
+end