active_event 0.5.2 → 0.5.3

data/lib/active_event/event_type.rb

@@ -1,28 +1,29 @@
-module ActiveEvent
-  module EventType
-    extend ActiveSupport::Concern
-    include ActiveEvent::Support::AttrInitializer
-
-    def event_type
-      self.class.name
-    end
-
-    def self.create_instance(type, data)
-      Object.const_get(type).new(data)
-    rescue NameError
-      require 'ostruct'
-      OpenStruct.new(data.merge(event_type: type.to_s)).freeze
-    end
-
-    def add_store_infos(hash)
-      store_infos.merge! hash
-    end
-
-    def store_infos
-      @store_infos ||= {}
-    end
-
-    private
-    attr_writer :store_infos
-  end
-end
+module ActiveEvent
+  module EventType
+    extend ActiveSupport::Concern
+    include ActiveEvent::Support::AttrInitializer
+
+    def event_type
+      self.class.name
+    end
+
+    def self.create_instance(type, data)
+      Object.const_get(type).new(data)
+    rescue NameError
+      require 'ostruct'
+      OpenStruct.new(data.merge(event_type: type.to_s)).freeze
+    end
+
+    def add_store_infos(hash)
+      store_infos.merge! hash
+    end
+
+    def store_infos
+      @store_infos ||= {}
+    end
+
+    private
+
+    attr_writer :store_infos
+  end
+end

data/lib/active_event/replay_server.rb

@@ -1,98 +1,94 @@
-require 'singleton'
-require 'bunny'
-require 'thread'
-module ActiveEvent
-  class ReplayServer
-    include Singleton
-
-    def self.start(options, id)
-      instance.options = options
-      instance.start id
-    end
-
-    def self.update(id)
-      instance.queue << id
-    end
-
-    def start(id)
-      event_connection.start
-      @last_id = id
-      start_republishing
-      send_done_message
-    rescue Exception => e
-      LOGGER.error e.message
-      LOGGER.error e.backtrace.join("\n")
-      raise e
-    end
-
-    def queue
-      @queue ||= Queue.new
-    end
-
-    def send_done_message
-      resend_exchange.publish 'replay_done'
-    end
-
-    def start_republishing
-      loop do
-        @events = EventRepository.after_id(@last_id).to_a
-        return if @events.empty?
-        republish_events
-      end
-    end
-
-    def republish_events
-      while has_next_event?
-        return if new_id?
-        republish next_event
-        Thread.pass
-      end
-    end
-
-    def new_id?
-      unless queue.empty?
-        new_id = queue.pop
-        if new_id < @last_id
-          @last_id = new_id
-          return true
-        end
-      end
-      false
-    end
-
-    def republish(event)
-      type = event.event
-      body = event.data.to_json
-      resend_exchange.publish body, {type: type, headers: {id: event.id, created_at: event.created_at, replayed: true}}
-      LOGGER.debug "Republished #{type} with #{body}"
-    end
-
-    def next_event
-      e = @events.shift
-      @last_id = e.id
-      e
-    end
-
-    def has_next_event?
-      @events.length > 0
-    end
-
-    def event_connection
-      @event_server ||= Bunny.new URI::Generic.build(options[:event_connection]).to_s
-    end
-
-    def event_channel
-      @event_channel ||= event_connection.create_channel
-    end
-
-    def resend_exchange
-      @resend_exchange ||= event_channel.fanout "resend_#{options[:event_exchange]}"
-    end
-
-    def options
-      @options
-    end
-
-    attr_writer :options
-  end
-end
+require 'singleton'
+require 'bunny'
+require 'thread'
+module ActiveEvent
+  class ReplayServer
+    include Singleton
+
+    def self.start(options, id)
+      instance.options = options
+      instance.start id
+    end
+
+    def self.update(id)
+      instance.queue << id
+    end
+
+    def start(id)
+      event_connection.start
+      @last_id = id
+      start_republishing
+      send_done_message
+    rescue => e
+      LOGGER.error e.message
+      LOGGER.error e.backtrace.join("\n")
+      raise e
+    end
+
+    def queue
+      @queue ||= Queue.new
+    end
+
+    def send_done_message
+      resend_exchange.publish 'replay_done'
+    end
+
+    def start_republishing
+      loop do
+        @events = EventRepository.after_id(@last_id).to_a
+        return if @events.empty?
+        republish_events
+      end
+    end
+
+    def republish_events
+      while next_event?
+        return if new_id?
+        republish next_event
+        Thread.pass
+      end
+    end
+
+    def new_id?
+      unless queue.empty?
+        new_id = queue.pop
+        if new_id < @last_id
+          @last_id = new_id
+          return true
+        end
+      end
+      false
+    end
+
+    def republish(event)
+      type = event.event
+      body = event.data.to_json
+      resend_exchange.publish body, type: type, headers: {id: event.id, created_at: event.created_at, replayed: true}
+      LOGGER.debug "Republished #{type} with #{body}"
+    end
+
+    def next_event
+      e = @events.shift
+      @last_id = e.id
+      e
+    end
+
+    def next_event?
+      @events.length > 0
+    end
+
+    def event_connection
+      @event_server ||= Bunny.new URI::Generic.build(options[:event_connection]).to_s
+    end
+
+    def event_channel
+      @event_channel ||= event_connection.create_channel
+    end
+
+    def resend_exchange
+      @resend_exchange ||= event_channel.fanout "resend_#{options[:event_exchange]}"
+    end
+
+    attr_accessor :options
+  end
+end

data/lib/active_event/sse.rb

@@ -1,26 +1,26 @@
-require 'json'
-
-module ActiveEvent
-  class SSE
-    def initialize(io)
-      @io = io
-    end
-
-    def event(event, data = nil, options = {})
-      self.data options.merge(event: event, data: JSON.dump(data))
-    end
-
-    def data(data)
-      data.each_pair do |key, value|
-        (value+"\n").split("\n", -1)[0..-2].each do |v|
-          @io.write "#{key}: #{v}\n"
-        end
-      end
-      @io.write "\n"
-    end
-
-    def close
-      @io.close
-    end
-  end
-end
+require 'json'
+
+module ActiveEvent
+  class SSE
+    def initialize(io)
+      @io = io
+    end
+
+    def event(event, data = nil, options = {})
+      self.data options.merge(event: event, data: JSON.dump(data))
+    end
+
+    def data(data)
+      data.each_pair do |key, value|
+        (value + "\n").split("\n", -1)[0..-2].each do |v|
+          @io.write "#{key}: #{v}\n"
+        end
+      end
+      @io.write "\n"
+    end
+
+    def close
+      @io.close
+    end
+  end
+end

data/lib/active_event/support/attr_initializer.rb

@@ -1,74 +1,76 @@
-module ActiveEvent::Support
-  class ForbiddenAttributesError < StandardError
-  end
-
-  class UnknownAttributeError < StandardError
-  end
-
-  # Allows to initialize attributes with a hash
-  #
-  # example:
-  #   class RgbColor
-  #     include ActiveEvent::AttrInitializer
-  #     attributes :r, :g, :b
-  #   end
-  #   green = RgbColor.new r: 250, g: 20, b: 20
-  module AttrInitializer
-    extend ActiveSupport::Concern
-
-    def initialize(*args)
-      hash = (args.last.is_a?(Hash) ? args.pop : {})
-      super
-      check_attributes hash
-      init_attributes hash
-    end
-
-    def freeze
-      attributes.freeze
-    end
-
-    def attributes_except(*args)
-      attributes.reject { |k,_| args.include? k }
-    end
-
-    def to_hash
-      attributes.dup
-    end
-
-    module ClassMethods
-      def self.extended(base)
-        base.attribute_keys = []
-      end
-
-      attr_accessor :attribute_keys
-
-      def attributes(*args)
-        self.attribute_keys += args
-        args.each do |attr|
-          define_method attr, -> { attributes[attr] }
-        end
-      end
-    end
-
-    protected
-
-    attr_accessor :attributes
-
-    def init_attributes(attributes)
-      self.attributes = attributes.symbolize_keys
-      freeze
-    end
-
-    private
-
-    def check_attributes(attributes)
-      return if attributes.blank?
-      if attributes.respond_to?(:permitted?) and not attributes.permitted?
-        raise ActiveEvent::Support::ForbiddenAttributesError
-      end
-      (attributes.keys.map(&:to_sym) - self.class.attribute_keys).each do |k|
-        raise ActiveEvent::Support::UnknownAttributeError, "unknown attribute: #{k}"
-      end
-    end
-  end
-end
+module ActiveEvent
+  module Support
+    class ForbiddenAttributesError < StandardError
+    end
+
+    class UnknownAttributeError < StandardError
+    end
+
+    # Allows to initialize attributes with a hash
+    #
+    # example:
+    #   class RgbColor
+    #     include ActiveEvent::AttrInitializer
+    #     attributes :r, :g, :b
+    #   end
+    #   green = RgbColor.new r: 250, g: 20, b: 20
+    module AttrInitializer
+      extend ActiveSupport::Concern
+
+      def initialize(*args)
+        hash = (args.last.is_a?(Hash) ? args.pop : {})
+        super
+        check_attributes hash
+        init_attributes hash
+      end
+
+      def freeze
+        attributes.freeze
+      end
+
+      def attributes_except(*args)
+        attributes.reject { |k, _| args.include? k }
+      end
+
+      def to_hash
+        attributes.dup
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          base.attribute_keys = []
+        end
+
+        attr_accessor :attribute_keys
+
+        def attributes(*args)
+          self.attribute_keys += args
+          args.each do |attr|
+            define_method attr, -> { attributes[attr] }
+          end
+        end
+      end
+
+      protected
+
+      attr_accessor :attributes
+
+      def init_attributes(attributes)
+        self.attributes = attributes.symbolize_keys
+        freeze
+      end
+
+      private
+
+      def check_attributes(attributes)
+        return if attributes.blank?
+        if attributes.respond_to?(:permitted?) && !attributes.permitted?
+          fail ActiveEvent::Support::ForbiddenAttributesError
+        end
+        (attributes.keys.map(&:to_sym) - self.class.attribute_keys).each do |k|
+          fail ActiveEvent::Support::UnknownAttributeError, "unknown attribute: #{k}"
+        end
+      end
+    end
+  end
+end