active_projection 0.5.2 → 0.5.3

data/lib/active_projection/projection_type.rb

@@ -1,90 +1,91 @@
-module ActiveProjection
-  module ProjectionType
-    extend ActiveSupport::Concern
-    class WrongArgumentsCountError < StandardError
-    end
-    included do
-      ProjectionTypeRegistry::register(self)
-    end
-
-    def initialize
-      self.handlers = Hash.new do |hash, key|
-        hash[key] = []
-      end
-      self.class.public_instance_methods(false).each do |method_name|
-        method = self.class.instance_method method_name
-        raise WrongArgumentsCountError if 2 < method.arity or method.arity < 1
-        event_type = ProjectionType.method_name_to_event_type method_name
-        handlers[event_type] << [method_name, method.arity]
-      end
-    end
-
-    def evaluate(headers)
-      unless solid?
-        LOGGER.error "[#{self.class.name}] is broken"
-        return false
-      end
-      last_id = fetch_last_id
-      event_id = headers[:id]
-      case
-        when last_id + 1 == event_id
-          true
-        when last_id >= event_id
-          LOGGER.debug "[#{self.class.name}]: event #{event_id} already processed"
-          false
-        when last_id < event_id
-          set_broken
-          LOGGER.error "[#{self.class.name}]: #{event_id - last_id} events are missing"
-          false
-      end
-    end
-
-    def invoke(event, headers)
-      event_id = headers[:id]
-      event_type = event.class.name.to_sym
-      handlers[event_type].each do |method, arity|
-        begin
-          if 1 == arity
-            self.send method, event
-          else
-            self.send method, event, headers
-          end
-        rescue Exception => e
-          LOGGER.error "[#{self.class.name}]: error processing #{event_type}[#{event_id}]\n#{e.message}\n#{e.backtrace}"
-          set_broken
-          raise
-        end
-      end
-      update_last_id event_id
-      LOGGER.debug "[#{self.class.name}]: successfully processed #{event_type}[#{event_id}]"
-    end
-
-    private
-    attr_accessor :handlers
-    attr_writer :projection_id
-
-    def self.method_name_to_event_type(method_name)
-      method_name.to_s.gsub('__', '/').camelcase.to_sym
-    end
-
-    def projection_id
-      @projection_id ||= ProjectionRepository.ensure_exists(self.class.name).id
-    end
-
-    def solid?
-      ProjectionRepository.solid? projection_id
-    end
-
-    def fetch_last_id
-      ProjectionRepository.get_last_id projection_id
-    end
-
-    def set_broken
-      ProjectionRepository.set_broken projection_id
-    end
-
-    def update_last_id(id)
-      ProjectionRepository.set_last_id projection_id, id
-    end
-  end
-end
+module ActiveProjection
+  module ProjectionType
+    extend ActiveSupport::Concern
+    class WrongArgumentsCountError < StandardError
+    end
+    included do
+      ProjectionTypeRegistry.register(self)
+    end
+
+    def initialize
+      self.handlers = Hash.new do |hash, key|
+        hash[key] = []
+      end
+      self.class.public_instance_methods(false).each do |method_name|
+        method = self.class.instance_method method_name
+        fail WrongArgumentsCountError if 2 < method.arity || method.arity < 1
+        event_type = ProjectionType.method_name_to_event_type method_name
+        handlers[event_type] << [method_name, method.arity]
+      end
+    end
+
+    def evaluate(headers)
+      unless solid?
+        LOGGER.error "[#{self.class.name}] is broken"
+        return false
+      end
+      last_id = fetch_last_id
+      event_id = headers[:id]
+      case
+      when last_id + 1 == event_id
+        true
+      when last_id >= event_id
+        LOGGER.debug "[#{self.class.name}]: event #{event_id} already processed"
+        false
+      when last_id < event_id
+        mark_broken
+        LOGGER.error "[#{self.class.name}]: #{event_id - last_id} events are missing"
+        false
+      end
+    end
+
+    def invoke(event, headers)
+      event_id = headers[:id]
+      event_type = event.class.name.to_sym
+      handlers[event_type].each do |method, arity|
+        begin
+          if 1 == arity
+            send method, event
+          else
+            send method, event, headers
+          end
+        rescue => e
+          LOGGER.error "[#{self.class.name}]: error processing #{event_type}[#{event_id}]\n#{e.message}\n#{e.backtrace}"
+          mark_broken
+          raise
+        end
+      end
+      update_last_id event_id
+      LOGGER.debug "[#{self.class.name}]: successfully processed #{event_type}[#{event_id}]"
+    end
+
+    private
+
+    attr_accessor :handlers
+    attr_writer :projection_id
+
+    def self.method_name_to_event_type(method_name)
+      method_name.to_s.gsub('__', '/').camelcase.to_sym
+    end
+
+    def projection_id
+      @projection_id ||= ProjectionRepository.ensure_exists(self.class.name).id
+    end
+
+    def solid?
+      ProjectionRepository.solid? projection_id
+    end
+
+    def fetch_last_id
+      ProjectionRepository.last_id projection_id
+    end
+
+    def mark_broken
+      ProjectionRepository.mark_broken projection_id
+    end
+
+    def update_last_id(id)
+      ProjectionRepository.set_last_id projection_id, id
+    end
+  end
+end

data/lib/active_projection/projection_type_registry.rb

@@ -1,28 +1,26 @@
-require 'singleton'
-
-module ActiveProjection
-  class ProjectionTypeRegistry
-    include Singleton
-
-    # register a new projection class
-    #
-    # The best way to create a new projection is using the ProjectionType module
-    # This module automatically registers each class
-    def self.register(projection)
-      self.registry << projection
-    end
-
-    # @return an enumerable with all projections
-    def self.projections
-      instance.projections.each
-    end
-
-    def projections
-      @projections ||= self.class.registry.freeze.map { |projection_class| projection_class.new }.freeze
-    end
-
-    private
-
-    cattr_accessor(:registry) { [] }
-  end
-end
+require 'singleton'
+
+module ActiveProjection
+  class ProjectionTypeRegistry
+    include Singleton
+
+    # register a new projection class
+    #
+    # The best way to create a new projection is using the ProjectionType module
+    # This module automatically registers each class
+    def self.register(projection)
+      registry << projection
+    end
+
+    # @return an enumerable with all projections
+    def self.projections
+      instance.projections.each
+    end
+
+    def projections
+      @projections ||= self.class.registry.freeze.map { |projection_class| projection_class.new }.freeze
+    end
+
+    cattr_accessor(:registry) { [] }
+  end
+end

data/lib/active_projection/railtie.rb

@@ -1,8 +1,8 @@
-require 'active_projection'
-require 'rails'
-
-module ActiveProjection
-  class Railtie < Rails::Railtie # :nodoc:
-    config.eager_load_namespaces << ActiveProjection
-  end
-end
+require 'active_projection'
+require 'rails'
+
+module ActiveProjection
+  class Railtie < Rails::Railtie # :nodoc:
+    config.eager_load_namespaces << ActiveProjection
+  end
+end

data/lib/active_projection/server.rb

@@ -1,66 +1,65 @@
-require 'active_record'
-
-module ActiveProjection
-  class Server
-
-    def self.run(options = nil)
-      self.new(options).run
-    end
-
-    def initialize(new_options = nil)
-      self.options = new_options.deep_symbolize_keys! unless new_options.nil?
-    end
-
-    def run
-      EventClient.start options
-    end
-
-    def env
-      @env = ENV['PROJECTION_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-    end
-
-    def options
-      @options ||= parse_options(ARGV)
-    end
-
-    cattr_accessor :base_path
-    cattr_accessor :config_file
-    cattr_accessor :rails_config_file
-
-    def config_file
-      self.class.config_file ||= File.expand_path('config/disco.yml', base_path)
-    end
-
-    def rails_config_file
-      self.class.rails_config_file ||= File.expand_path('config/database.yml', base_path)
-    end
-
-    private
-
-    attr_writer :options
-    attr_writer :domain
-
-    def default_options
-      {
-          projection_database: {
-              adapter: 'sqlite3',
-              database: File.expand_path('db/production.sqlite3', base_path)
-          },
-          event_connection: {
-              scheme: 'amqp',
-              userinfo: nil,
-              host: '127.0.0.1',
-              port: 9797,
-          },
-          event_exchange: 'events'
-      }
-    end
-
-    def parse_options(args)
-      options = default_options
-      options.merge! YAML.load_file(config_file)[env].deep_symbolize_keys! unless config_file.blank?
-      options[:projection_database] = YAML.load_file(rails_config_file)[env].deep_symbolize_keys! unless rails_config_file.blank?
-      options
-    end
-  end
-end
+require 'active_record'
+
+module ActiveProjection
+  class Server
+    def self.run(options = nil)
+      new(options).run
+    end
+
+    def initialize(new_options = nil)
+      self.options = new_options.deep_symbolize_keys! unless new_options.nil?
+    end
+
+    def run
+      EventClient.start options
+    end
+
+    def env
+      @env = ENV['PROJECTION_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def options
+      @options ||= parse_options(ARGV)
+    end
+
+    cattr_accessor :base_path
+    cattr_accessor :config_file
+    cattr_accessor :rails_config_file
+
+    def config_file
+      self.class.config_file ||= File.expand_path('config/disco.yml', base_path)
+    end
+
+    def rails_config_file
+      self.class.rails_config_file ||= File.expand_path('config/database.yml', base_path)
+    end
+
+    private
+
+    attr_writer :options
+    attr_writer :domain
+
+    def default_options
+      {
+        projection_database: {
+          adapter: 'sqlite3',
+          database: File.expand_path('db/production.sqlite3', base_path),
+        },
+        event_connection: {
+          scheme: 'amqp',
+          userinfo: nil,
+          host: '127.0.0.1',
+          port: 9797,
+          },
+        event_exchange: 'events',
+      }
+    end
+
+    def parse_options(_args)
+      options = default_options
+      options.merge! YAML.load_file(config_file)[env].deep_symbolize_keys! unless config_file.blank?
+      options[:projection_database] = YAML.load_file(rails_config_file)[env].deep_symbolize_keys! unless rails_config_file.blank?
+      options
+    end
+  end
+end

data/lib/active_projection/version.rb

@@ -1,7 +1,7 @@
 module ActiveProjection
   # Returns the version of the currently loaded ActiveProjection as a Gem::Version
   def self.version
-    Gem::Version.new '0.5.2'
+    Gem::Version.new '0.5.3'
   end
 
   module VERSION #:nodoc:

data/spec/factories/event_factory.rb

@@ -1,8 +1,8 @@
-require 'factory_girl'
-
-FactoryGirl.define do
-  factory :projection, class: ActiveProjection::Projection do
-    last_id 4
-    solid true
-  end
-end
+require 'factory_girl'
+
+FactoryGirl.define do
+  factory :projection, class: ActiveProjection::Projection do
+    last_id 4
+    solid true
+  end
+end

data/spec/lib/projection_type_registry_spec.rb

@@ -1,19 +1,19 @@
-require_relative '../spec_helper'
-
-describe ActiveProjection::ProjectionTypeRegistry do
-  class TestEvent
-  end
-  class TestProjection
-  end
-  before :all do
-    ActiveProjection::ProjectionTypeRegistry.register(TestProjection)
-  end
-
-  it 'initializes' do
-    ActiveProjection::ProjectionTypeRegistry.instance.should be
-  end
-
-  it 'report projections' do
-    ActiveProjection::ProjectionTypeRegistry.projections.count.should eq 1
-  end
-end
+require_relative '../spec_helper'
+
+describe ActiveProjection::ProjectionTypeRegistry do
+  class TestEvent
+  end
+  class TestProjection
+  end
+  before :all do
+    ActiveProjection::ProjectionTypeRegistry.register(TestProjection)
+  end
+
+  it 'initializes' do
+    expect(ActiveProjection::ProjectionTypeRegistry.instance).to be
+  end
+
+  it 'report projections' do
+    expect(ActiveProjection::ProjectionTypeRegistry.projections.count).to eq(1)
+  end
+end