evt-entity_projection 0.1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39536db3a78c2916a9811527e360a5f148367bb5
+  data.tar.gz: 8cb4baf8f48e0f2cc53ac1ed00ce87611d1e89c6
+SHA512:
+  metadata.gz: 9a075b12f7826133d817a6065d06fdb4fd0e16dc67c8372494fadd975aaea29a5c04f7425fd351e27d03133ba80a99c4ad41029637e6f8cf1926c9e4956dfebc
+  data.tar.gz: ca7048d95bed2e41b6296287372777d67846a234c15b0b1f4eb0c756f15d03b020607b76ec07ac3fd128e30c0baaf9d83bafd9d8850c3bdb60c07ae86a732998

data/lib/entity_projection.rb

@@ -0,0 +1,4 @@
+require 'messaging'
+
+require 'entity_projection/log'
+require 'entity_projection/entity_projection'

data/lib/entity_projection/controls.rb

@@ -0,0 +1,6 @@
+require 'messaging/controls'
+
+require 'entity_projection/controls/event_data'
+require 'entity_projection/controls/message'
+require 'entity_projection/controls/entity'
+require 'entity_projection/controls/projection'

data/lib/entity_projection/controls/entity.rb

@@ -0,0 +1,22 @@
+module EntityProjection
+  module Controls
+    module Entity
+      def self.example
+        SomeEntity.build
+      end
+
+      class SomeEntity
+        include Schema::DataStructure
+
+        attribute :some_attribute
+        attribute :other_attribute
+      end
+
+      module New
+        def self.example
+          Entity::SomeEntity.new
+        end
+      end
+    end
+  end
+end

data/lib/entity_projection/controls/event_data.rb

@@ -0,0 +1,5 @@
+module EntityProjection
+  module Controls
+    EventData = Messaging::Controls::EventData
+  end
+end

data/lib/entity_projection/controls/message.rb

@@ -0,0 +1,5 @@
+module EntityProjection
+  module Controls
+    Message = Messaging::Controls::Message
+  end
+end

data/lib/entity_projection/controls/projection.rb

@@ -0,0 +1,49 @@
+module EntityProjection
+  module Controls
+    module Projection
+      class Example
+        include EntityProjection
+        include Controls::Message
+
+        entity_name :some_entity
+
+        apply SomeMessage do |some_message|
+          some_entity.some_attribute = some_message.some_attribute
+        end
+      end
+
+      module ApplyMethod
+        class Example
+          include EntityProjection
+
+          def apply(event_data)
+            entity.some_attribute = event_data.data[:attribute]
+          end
+        end
+      end
+
+      module BlockAndApplyMethod
+        class Example
+          include EntityProjection
+          include Controls::Message
+
+          apply SomeMessage do |some_message|
+            entity.some_attribute = 'some attribute value set by apply block'
+          end
+
+          def apply(event_data)
+            event_data.data = 'some data value set by apply method'
+          end
+        end
+      end
+
+      module Anomaly
+        module NoApply
+          class Example
+            include EntityProjection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/entity_projection/entity_projection.rb

@@ -0,0 +1,163 @@
+module EntityProjection
+  def self.included(cls)
+    cls.class_exec do
+      include Log::Dependency
+
+      cls.extend Build
+      cls.extend Call
+      cls.extend Info
+      cls.extend ApplyMacro
+      cls.extend MessageRegistry
+      cls.extend EntityNameMacro
+
+      virtual :configure
+
+      initializer :entity
+    end
+  end
+
+  module Build
+    def build(entity)
+      instance = new(entity)
+      instance.configure
+      instance
+    end
+  end
+
+  module Info
+    extend self
+
+    def handler(message_or_event_data)
+      name = handler_name(message_or_event_data)
+
+      if method_defined?(name)
+        return name
+      else
+        return nil
+      end
+    end
+
+    def handles?(message_or_event_data)
+      method_defined? handler_name(message_or_event_data)
+    end
+
+    def handler_name(message_or_event_data)
+      name = nil
+
+      if message_or_event_data.is_a? EventSource::EventData::Read
+        name = Messaging::Message::Info.canonize_name(message_or_event_data.type)
+      else
+        name = message_or_event_data.message_name
+      end
+
+      "apply_#{name}"
+    end
+  end
+
+  module ApplyMacro
+    class Error < RuntimeError; end
+
+    def logger
+      @logger ||= Log.get(self)
+    end
+
+    def apply_macro(message_class, &blk)
+      define_apply_method(message_class, &blk)
+      message_registry.register(message_class)
+    end
+    alias :apply :apply_macro
+
+    def define_apply_method(message_class, &blk)
+      apply_method_name = handler_name(message_class)
+
+      if blk.nil?
+        error_msg = "Handler for #{message_class.name} is not correctly defined. It must have a block."
+        logger.error { error_msg }
+        raise Error, error_msg
+      end
+
+      send(:define_method, apply_method_name, &blk)
+
+      apply_method = instance_method(apply_method_name)
+
+      unless apply_method.arity == 1
+        error_msg = "Handler for #{message_class.name} is not correctly defined. It can only have a single parameter."
+        logger.error { error_msg }
+        raise Error, error_msg
+      end
+
+      apply_method_name
+    end
+  end
+
+  module Call
+    def call(entity, message_or_event_data)
+      instance = build(entity)
+      instance.(message_or_event_data)
+    end
+  end
+
+  module MessageRegistry
+    def message_registry
+      @message_registry ||= Messaging::MessageRegistry.new
+    end
+  end
+
+  module EntityNameMacro
+    def entity_name_macro(entity_name)
+      send(:define_method, entity_name) do
+        entity
+      end
+    end
+    alias :entity_name :entity_name_macro
+  end
+
+  def call(message_or_event_data)
+    if message_or_event_data.is_a? Messaging::Message
+      handle_message(message_or_event_data)
+    else
+      handle_event_data(message_or_event_data)
+    end
+  end
+
+  def handle_message(message)
+    logger.trace(tags: [:handle, :message]) { "Applying message (Message class: #{message.class.name})" }
+    logger.trace(tags: [:data, :message, :handle]) { message.pretty_inspect }
+
+    handler = self.class.handler(message)
+
+    unless handler.nil?
+      public_send(handler, message)
+    end
+
+    logger.info(tags: [:handle, :message]) { "Applied message (Message class: #{message.class.name})" }
+    logger.trace(tags: [:data, :message, :handle]) { message.pretty_inspect }
+
+    message
+  end
+
+  def handle_event_data(event_data)
+    logger.trace(tags: [:handle, :event_data]) { "Applying event data (Type: #{event_data.type})" }
+    logger.trace(tags: [:data, :event_data, :handle]) { event_data.pretty_inspect }
+
+    res = nil
+
+    handler = self.class.handler(event_data)
+
+    unless handler.nil?
+      message_name = Messaging::Message::Info.canonize_name(event_data.type)
+      message_class = self.class.message_registry.get(message_name)
+      res = Messaging::Message::Import.(event_data, message_class)
+      public_send(handler, res)
+    else
+      if respond_to?(:apply)
+        res = apply(event_data)
+      end
+    end
+
+    logger.info(tags: [:handle, :event_data]) { "Applied event data (Type: #{event_data.type})" }
+    logger.info(tags: [:data, :event_data, :handle]) { event_data.pretty_inspect }
+
+    res
+  end
+end

data/lib/entity_projection/log.rb

@@ -0,0 +1,9 @@
+module EntityProjection
+  class Log < ::Log
+    def tag!(tags)
+      tags << :entity_projection
+      tags << :library
+      tags << :verbose
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: evt-entity_projection
+version: !ruby/object:Gem::Version
+  version: 0.1.0.1
+platform: ruby
+authors:
+- The Eventide Project
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-messaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ntl-test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " "
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/entity_projection.rb
+- lib/entity_projection/controls.rb
+- lib/entity_projection/controls/entity.rb
+- lib/entity_projection/controls/event_data.rb
+- lib/entity_projection/controls/message.rb
+- lib/entity_projection/controls/projection.rb
+- lib/entity_projection/entity_projection.rb
+- lib/entity_projection/log.rb
+homepage: https://github.com/eventide-project/entity-projection
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Projects event data into an entity
+test_files: []