evt-event_source 0.16.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12664935f7cfa35ee5910e870576e2ed0a809c29
+  data.tar.gz: a78442d098c88ff2de825b21200494bf5382168e
+SHA512:
+  metadata.gz: 05c8ebdaee36dd325583a167d299cd863b32250618a96542465e9fe03a7144a218899a8c8ecd5f59714f1a0c65885b47f44b66edbf6d2707639ed6cfe549d56a
+  data.tar.gz: ee2cb57c601c4ced1642ede255f40d52012698f4d7b47cbbaf1d49bddee30cb9c46397d80dffd584cbfe5a9e48a34e2b3cbc9472a5007cf0cec2adf5088bff8d

data/lib/event_source.rb

@@ -0,0 +1,26 @@
+require 'pp'
+require 'json'
+
+require 'casing'
+require 'identifier/uuid'
+require 'schema'
+require 'initializer'; Initializer.activate
+require 'transform'
+require 'cycle'
+require 'virtual'; Virtual.activate
+require 'async_invocation'
+
+require 'event_source/expected_version'
+require 'event_source/no_stream'
+require 'event_source/stream_name'
+require 'event_source/stream'
+require 'event_source/event_data'
+require 'event_source/event_data/hash'
+require 'event_source/event_data/write'
+require 'event_source/event_data/read'
+
+require 'event_source/log'
+
+require 'event_source/iterator'
+require 'event_source/read'
+require 'event_source/write'

data/lib/event_source/controls.rb

@@ -0,0 +1,13 @@
+require 'securerandom'
+
+require 'event_source/controls/random_value'
+require 'event_source/controls/time'
+require 'event_source/controls/category'
+require 'event_source/controls/stream_name'
+require 'event_source/controls/stream'
+require 'event_source/controls/read'
+require 'event_source/controls/event_data'
+require 'event_source/controls/event_data/hash'
+require 'event_source/controls/event_data/metadata'
+require 'event_source/controls/event_data/write'
+require 'event_source/controls/event_data/read'

data/lib/event_source/controls/category.rb

@@ -0,0 +1,23 @@
+module EventSource
+  module Controls
+    module Category
+      def self.example(category: nil, randomize_category: nil)
+        if randomize_category.nil?
+          if !category.nil?
+            randomize_category = false
+          end
+        end
+
+        randomize_category = true if randomize_category.nil?
+
+        category ||= 'test'
+
+        if randomize_category
+          category = "#{category}#{SecureRandom.hex(16)}XX"
+        end
+
+        category
+      end
+    end
+  end
+end

data/lib/event_source/controls/event_data.rb

@@ -0,0 +1,13 @@
+module EventSource
+  module Controls
+    module EventData
+      def self.type
+        'SomeType'
+      end
+
+      def self.data
+        { :attribute => RandomValue.example }
+      end
+    end
+  end
+end

data/lib/event_source/controls/event_data/hash.rb

@@ -0,0 +1,28 @@
+module EventSource
+  module Controls
+    module EventData
+      module Hash
+        def self.data
+          {
+            some_attribute: 'some value'
+          }
+        end
+
+        def self.example
+          EventSource::EventData::Hash[data]
+        end
+
+        module JSON
+          def self.data(id=nil)
+            data = Hash.data
+            Casing::Camel.(data, symbol_to_string: true)
+          end
+
+          def self.text
+            ::JSON.generate(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_source/controls/event_data/metadata.rb

@@ -0,0 +1,24 @@
+module EventSource
+  module Controls
+    module EventData
+      module Metadata
+        def self.data
+          {
+            meta_attribute: RandomValue.example
+          }
+        end
+
+        module JSON
+          def self.data(id=nil)
+            data = Metadata.data
+            Casing::Camel.(data, symbol_to_string: true)
+          end
+
+          def self.text
+            data.to_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_source/controls/event_data/read.rb

@@ -0,0 +1,63 @@
+module EventSource
+  module Controls
+    module EventData
+      module Read
+        def self.example(type: nil, data: nil, metadata: nil)
+          type ||= self.type
+
+          if data == :none
+            data = nil
+          else
+            data ||= self.data
+          end
+
+          if metadata == :none
+            metadata = nil
+          else
+            metadata ||= self.metadata
+          end
+
+          event_data = EventSource::EventData::Read.build
+
+          event_data.type = type
+          event_data.data = data
+          event_data.metadata = metadata
+          event_data.position = position
+          event_data.global_position = global_position
+          event_data.time = time
+          event_data.stream_name = stream_name
+
+          event_data
+        end
+
+        def self.type
+          EventData.type
+        end
+
+        def self.data
+          EventData.data
+        end
+
+        def self.metadata
+          EventData::Metadata.data
+        end
+
+        def self.position
+          1
+        end
+
+        def self.global_position
+          111
+        end
+
+        def self.time
+          Time::Raw.example
+        end
+
+        def self.stream_name
+          StreamName.example
+        end
+      end
+    end
+  end
+end

data/lib/event_source/controls/event_data/write.rb

@@ -0,0 +1,43 @@
+module EventSource
+  module Controls
+    module EventData
+      module Write
+        def self.example(type: nil, data: nil, metadata: nil)
+          type ||= self.type
+
+          if data == :none
+            data = nil
+          else
+            data ||= self.metadata
+          end
+
+          if metadata == :none
+            metadata = nil
+          else
+            metadata ||= self.metadata
+          end
+
+          event_data = EventSource::EventData::Write.build
+
+          event_data.type = type
+          event_data.data = data
+          event_data.metadata = metadata
+
+          event_data
+        end
+
+        def self.type
+          EventData.type
+        end
+
+        def self.data
+          EventData.data
+        end
+
+        def self.metadata
+          EventData::Metadata.data
+        end
+      end
+    end
+  end
+end

data/lib/event_source/controls/random_value.rb

@@ -0,0 +1,9 @@
+module EventSource
+  module Controls
+    module RandomValue
+      def self.example
+        SecureRandom.hex
+      end
+    end
+  end
+end

data/lib/event_source/controls/read.rb

@@ -0,0 +1,14 @@
+module EventSource
+  module Controls
+    module Read
+      def self.example(stream: nil)
+        stream ||= Stream.example
+        Example.new(stream)
+      end
+
+      class Example
+        include EventSource::Read
+      end
+    end
+  end
+end

data/lib/event_source/controls/stream.rb

@@ -0,0 +1,17 @@
+module EventSource
+  module Controls
+    module Stream
+      def self.example(stream_name: nil, category: nil, id: nil, randomize_category: nil)
+        stream_name ||= StreamName.example category: category, id: id, randomize_category: randomize_category
+        EventSource::Stream.new stream_name
+      end
+
+      module Category
+        def self.example(category: nil, randomize_category: nil)
+          category ||= Controls::Category.example category: category, randomize_category: randomize_category
+          EventSource::Stream.new category
+        end
+      end
+    end
+  end
+end

data/lib/event_source/controls/stream_name.rb

@@ -0,0 +1,12 @@
+module EventSource
+  module Controls
+    module StreamName
+      def self.example(category: nil, id: nil, randomize_category: nil)
+        category ||= Category.example(category: category, randomize_category: randomize_category)
+        id ||= Identifier::UUID.random
+
+        "#{category}-#{id}"
+      end
+    end
+  end
+end

data/lib/event_source/controls/time.rb

@@ -0,0 +1,60 @@
+module EventSource
+  module Controls
+    module Time
+      def self.example(time=nil)
+        time ||= Raw.example
+        ISO8601.example(time)
+      end
+
+      module Raw
+        def self.example
+          time = ::Time.parse("Jan 1 00:00:00 UTC 2000")
+          Clock::UTC.now(time)
+        end
+      end
+
+      module ISO8601
+        def self.example(time=nil)
+          time ||= Raw.example
+          Clock::UTC.iso8601(time)
+        end
+      end
+
+      module Processed
+        def self.example(time=nil, offset_milliseconds: nil)
+          time ||= Time::Raw.example
+          time = Raw.example(time, offset_milliseconds: offset_milliseconds)
+          ISO8601.example(time)
+        end
+
+        module Raw
+          def self.example(time=nil, offset_milliseconds: nil)
+            time ||= Time::Raw.example
+            offset_milliseconds ||= 11
+            offset = Rational(offset_milliseconds, 1000)
+            time += offset
+            time
+          end
+        end
+      end
+
+      module Effective
+        def self.example(time=nil, offset_milliseconds: nil)
+          time ||= Time::Raw.example
+          time = Raw.example(time, offset_milliseconds: offset_milliseconds)
+          ISO8601.example(time)
+        end
+
+        module Raw
+          def self.example(time=nil, offset_milliseconds: nil)
+            time ||= Time::Raw.example
+            offset_milliseconds ||= 1
+            offset = Rational(offset_milliseconds, 1000)
+            time += offset
+            time
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_source/event_data.rb

@@ -0,0 +1,17 @@
+module EventSource
+  module EventData
+    def self.included(cls)
+      cls.class_exec do
+        include Schema::DataStructure
+
+        attribute :type
+        attribute :data
+        attribute :metadata
+
+        def ===(other)
+          type == other
+        end
+      end
+    end
+  end
+end

data/lib/event_source/event_data/hash.rb

@@ -0,0 +1,31 @@
+module EventSource
+  module EventData
+    class Hash < ::Hash
+      module Transformer
+        def self.json
+          JSON
+        end
+
+        def self.instance(raw_data)
+          Hash[raw_data]
+        end
+
+        def self.raw_data(instance)
+          Hash[instance]
+        end
+
+        module JSON
+          def self.write(raw_hash_data)
+            json_formatted_data = Casing::Camel.(raw_hash_data)
+            ::JSON.generate(json_formatted_data)
+          end
+
+          def self.read(text)
+            json_formatted_data = ::JSON.parse(text, :symbolize_names => true)
+            Casing::Underscore.(json_formatted_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_source/event_data/read.rb

@@ -0,0 +1,16 @@
+module EventSource
+  module EventData
+    class Read
+      include EventData
+
+      attribute :stream_name
+      attribute :position
+      attribute :global_position
+      attribute :time
+
+      def category
+        StreamName.get_category(stream_name)
+      end
+    end
+  end
+end

data/lib/event_source/event_data/write.rb

@@ -0,0 +1,7 @@
+module EventSource
+  module EventData
+    class Write
+      include EventData
+    end
+  end
+end

data/lib/event_source/expected_version.rb

@@ -0,0 +1,11 @@
+module EventSource
+  module ExpectedVersion
+    class Error < RuntimeError; end
+
+    def self.canonize(expected_version)
+      return nil if expected_version.nil?
+      return expected_version unless expected_version == NoStream.name
+      NoStream.version
+    end
+  end
+end

data/lib/event_source/iterator.rb

@@ -0,0 +1,102 @@
+module EventSource
+  class Iterator
+    include Log::Dependency
+
+    dependency :cycle, Cycle
+
+    attr_accessor :position
+    attr_accessor :batch
+
+    def batch_position
+      @batch_position ||= 0
+    end
+    attr_writer :batch_position
+
+    def stream_offset
+      @stream_offset ||= (position || 0)
+    end
+    attr_writer :stream_offset
+
+    initializer :get, :stream_name
+
+    def self.build(get, stream_name, position: nil, cycle: nil)
+      new(get, stream_name).tap do |instance|
+        instance.position = position
+        Cycle.configure instance, cycle: cycle
+      end
+    end
+
+    def self.configure(receiver, get, stream_name, attr_name: nil, position: nil, cycle: nil)
+      attr_name ||= :iterator
+      instance = build(get, stream_name, position: position, cycle: cycle)
+      receiver.public_send "#{attr_name}=", instance
+    end
+
+    def next
+      logger.trace { "Getting next event data (Batch Length: #{batch.nil? ? '<none>' : batch.length}, Batch Position: #{batch_position}, Stream Offset: #{stream_offset})" }
+
+      resupply(batch)
+
+      event_data = batch[batch_position]
+
+      logger.debug { "Finished getting next event data (Batch Length: #{batch.nil? ? '<none>' : batch.length}, Batch Position: #{batch_position}, Stream Offset: #{stream_offset})" }
+      logger.debug(tags: [:data, :event_data]) { "Event Data: #{event_data.pretty_inspect}" }
+
+      advance_positions
+
+      event_data
+    end
+
+    def resupply(batch)
+      logger.trace { "Resupplying batch" }
+
+      if batch.nil?
+        batch_log_text = "Batch: #{batch.inspect}"
+      else
+        batch_log_text = "Batch Length: #{batch.length}"
+      end
+
+      if batch.nil? || batch_position == batch.length
+        logger.debug { "Current batch is depleted (#{batch_log_text}, Batch Position: #{batch_position})" }
+
+        batch = get_batch
+        reset(batch)
+      else
+        logger.debug { "Current batch not depleted (#{batch_log_text}, Batch Position: #{batch_position})" }
+      end
+
+      logger.debug { "Finished resupplying batch" }
+    end
+
+    def reset(batch)
+      logger.trace { "Resetting batch" }
+
+      self.batch = batch
+      self.batch_position = 0
+
+      logger.debug { "Reset batch" }
+      logger.debug(tags: [:data, :batch]) { "Batch: #{batch.pretty_inspect}" }
+      logger.debug(tags: [:data, :batch]) { "Batch Position: #{batch_position.inspect}" }
+    end
+
+    def get_batch
+      logger.trace "Getting batch"
+
+      batch = nil
+      cycle.() do
+        batch = get.(stream_name, position: stream_offset)
+      end
+
+      logger.debug { "Finished getting batch (Count: #{batch.length})" }
+
+      batch
+    end
+
+    def advance_positions
+      logger.trace { "Advancing positions (Batch Position: #{batch_position}, Stream Offset: #{stream_offset})" }
+      self.batch_position += 1
+      self.stream_offset += 1
+      logger.debug { "Advanced positions (Batch Position: #{batch_position}, Stream Offset: #{stream_offset})" }
+    end
+  end
+end

data/lib/event_source/log.rb

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

data/lib/event_source/no_stream.rb

@@ -0,0 +1,11 @@
+module EventSource
+  module NoStream
+    def self.name
+      :no_stream
+    end
+
+    def self.version
+      -1
+    end
+  end
+end

data/lib/event_source/read.rb

@@ -0,0 +1,80 @@
+module EventSource
+  module Read
+    def self.included(cls)
+      cls.class_exec do
+        include Log::Dependency
+
+        cls.extend Build
+        cls.extend Call
+        cls.extend Configure
+
+        dependency :iterator, Iterator
+
+        initializer :stream_name
+
+        attr_accessor :get
+        abstract :configure
+      end
+    end
+
+    class Error < RuntimeError; end
+
+    module Build
+      def build(stream_name, position: nil, batch_size: nil, precedence: nil, cycle_delay_milliseconds: nil, cycle_timeout_milliseconds: nil, cycle: nil, session: nil)
+        cycle ||= Cycle.build(delay_milliseconds: cycle_delay_milliseconds, timeout_milliseconds: cycle_timeout_milliseconds)
+
+        new(stream_name).tap do |instance|
+          instance.configure(batch_size: batch_size, precedence: precedence, session: session)
+          Iterator.configure instance, instance.get, stream_name, position: position, cycle: cycle
+        end
+      end
+    end
+
+    module Call
+      def call(stream_name, position: nil, batch_size: nil, precedence: nil, cycle_delay_milliseconds: nil, cycle_timeout_milliseconds: nil, cycle: nil, session: nil, &action)
+        instance = build(stream_name, position: position, batch_size: batch_size, precedence: precedence, cycle_delay_milliseconds: cycle_delay_milliseconds, cycle_timeout_milliseconds: cycle_timeout_milliseconds, cycle: cycle, session: session)
+        instance.(&action)
+      end
+    end
+
+    module Configure
+      def configure(receiver, stream_name, attr_name: nil, position: nil, batch_size: nil, precedence: nil, cycle_delay_milliseconds: nil, cycle_timeout_milliseconds: nil, cycle: nil, session: nil)
+        attr_name ||= :read
+        instance = build(stream_name, position: position, batch_size: batch_size, precedence: precedence, cycle_delay_milliseconds: cycle_delay_milliseconds, cycle_timeout_milliseconds: cycle_timeout_milliseconds, cycle: cycle, session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+    end
+
+    def call(&action)
+      logger.trace { "Reading (Stream Name: #{stream_name})" }
+
+      if action.nil?
+        error_message = "Reader must be actuated with a block"
+        logger.error error_message
+        raise Error, error_message
+      end
+
+      enumerate_event_data(&action)
+
+      logger.info { "Reading completed (Stream Name: #{stream_name})" }
+
+      return AsyncInvocation::Incorrect
+    end
+
+    def enumerate_event_data(&action)
+      logger.trace { "Enumerating (Stream Name: #{stream_name})" }
+
+      event_data = nil
+
+      loop do
+        event_data = iterator.next
+
+        break if event_data.nil?
+
+        action.(event_data)
+      end
+
+      logger.debug { "Enumerated (Stream Name: #{stream_name})" }
+    end
+  end
+end

data/lib/event_source/stream.rb

@@ -0,0 +1,27 @@
+module EventSource
+  class Stream
+    initializer :name
+
+    def self.get_type(name)
+      subtype = name.split(':').last.split('-').first
+
+      if name.start_with?(subtype)
+        return :stream
+      else
+        return subtype.to_sym
+      end
+    end
+
+    def type
+      @type ||= self.class.get_type(name)
+    end
+
+    def category
+      @category ||= StreamName.get_category(name)
+    end
+
+    def category?
+      @is_category ||= !name.include?('-')
+    end
+  end
+end

data/lib/event_source/stream_name.rb

@@ -0,0 +1,18 @@
+module EventSource
+  module StreamName
+    extend self
+
+    def stream_name(category_name, id)
+      "#{category_name}-#{id}"
+    end
+
+    def self.get_id(stream_name)
+      id = stream_name.partition('-')[2]
+      id.empty? ? nil : id
+    end
+
+    def self.get_category(stream_name)
+      stream_name.split('-')[0]
+    end
+  end
+end

data/lib/event_source/write.rb

@@ -0,0 +1,86 @@
+module EventSource
+  module Write
+    def self.included(cls)
+      cls.class_exec do
+        include Log::Dependency
+
+        cls.extend Build
+        cls.extend Call
+        cls.extend Configure
+
+        dependency :put
+
+        abstract :configure
+      end
+    end
+
+    module Build
+      def build(session: nil)
+        instance = new
+        instance.configure(session: session)
+        instance
+      end
+    end
+
+    module Configure
+      def configure(receiver, session: nil, attr_name: nil)
+        attr_name ||= :write
+        instance = build(session: session)
+        receiver.public_send "#{attr_name}=", instance
+      end
+    end
+
+    module Call
+      def call(event_data, stream_name, expected_version: nil, session: nil)
+        instance = build(session: session)
+        instance.(event_data, stream_name, expected_version: expected_version)
+      end
+    end
+
+    def call(event_data, stream_name, expected_version: nil)
+      logger.trace { "Writing event data (Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect})" }
+      logger.trace(tags: [:data, :event_data]) { event_data.pretty_inspect }
+
+      batch = Array(event_data)
+      position = write_batch(batch, stream_name, expected_version: expected_version)
+
+      logger.info { "Wrote event data (Stream Name: #{stream_name}, Expected Version: #{expected_version.inspect})" }
+      logger.info(tags: [:data, :event_data]) { event_data.pretty_inspect }
+
+      position
+    end
+
+    def write_batch(batch, stream_name, expected_version: nil)
+      logger.trace { "Writing batch (Stream Name: #{stream_name}, Number of Events: #{batch.length}, Expected Version: #{expected_version.inspect})" }
+
+      unless expected_version.nil?
+        expected_version = ExpectedVersion.canonize(expected_version)
+      end
+
+      last_position = nil
+      put.session.transaction do
+        batch.each do |event_data|
+          last_position = write(event_data, stream_name, expected_version: expected_version)
+
+          unless expected_version.nil?
+            expected_version += 1
+          end
+        end
+      end
+
+      logger.debug { "Wrote batch (Stream Name: #{stream_name}, Number of Events: #{batch.length}, Expected Version: #{expected_version.inspect})" }
+
+      last_position
+    end
+
+    def write(event_data, stream_name, expected_version: nil)
+      logger.trace { "Writing event data (Stream Name: #{stream_name}, Type: #{event_data.type}, Expected Version: #{expected_version.inspect})" }
+      logger.trace(tags: [:data, :event_data]) { event_data.pretty_inspect }
+
+      put.(event_data, stream_name, expected_version: expected_version).tap do
+        logger.debug { "Wrote event data (Stream Name: #{stream_name}, Type: #{event_data.type}, Expected Version: #{expected_version.inspect})" }
+        logger.debug(tags: [:data, :event_data]) { event_data.pretty_inspect }
+      end
+    end
+  end
+end

data/lib/loader.rb

@@ -0,0 +1 @@
+event_source.rb

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: evt-event_source
+version: !ruby/object:Gem::Version
+  version: 0.16.0.0
+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-casing
+  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: evt-schema
+  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: evt-initializer
+  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: evt-identifier-uuid
+  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: evt-transform
+  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: evt-virtual
+  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: evt-cycle
+  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: evt-async_invocation
+  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/event_source.rb
+- lib/event_source/controls.rb
+- lib/event_source/controls/category.rb
+- lib/event_source/controls/event_data.rb
+- lib/event_source/controls/event_data/hash.rb
+- lib/event_source/controls/event_data/metadata.rb
+- lib/event_source/controls/event_data/read.rb
+- lib/event_source/controls/event_data/write.rb
+- lib/event_source/controls/random_value.rb
+- lib/event_source/controls/read.rb
+- lib/event_source/controls/stream.rb
+- lib/event_source/controls/stream_name.rb
+- lib/event_source/controls/time.rb
+- lib/event_source/event_data.rb
+- lib/event_source/event_data/hash.rb
+- lib/event_source/event_data/read.rb
+- lib/event_source/event_data/write.rb
+- lib/event_source/expected_version.rb
+- lib/event_source/iterator.rb
+- lib/event_source/log.rb
+- lib/event_source/no_stream.rb
+- lib/event_source/read.rb
+- lib/event_source/stream.rb
+- lib/event_source/stream_name.rb
+- lib/event_source/write.rb
+- lib/loader.rb
+homepage: https://github.com/eventide-project/event-source
+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: Common primitives for event source clients
+test_files: []