http_eventstore 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a6d79d7fa69ffc2f0244660f573a7abe3df25867
+  data.tar.gz: 48e64de34b0a6465cb652695a2753c635511376f
+SHA512:
+  metadata.gz: f4c08e0f66ab32e400083f93dc0d9a992ca21cd07711b430884752ed5aa934bc6f6cc2dea373225fbf39fee14473ea3fea970021f3f2da149913e2e8bf6e7105
+  data.tar.gz: 942926179e12ef3ab9a2ddca512ad2dff6a1595cf82dae2915f9dd0ac55f5140e0c711dc44423e127f2f30305ea761aa665cc16d9db16f7b45b02d632c471ea3

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-gemset
+.ruby-version
+.idea/*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in http_eventstore.gemspec
+gemspec

data/README.md

@@ -0,0 +1,134 @@
+# HttpEventstore
+
+HttpEventstore is a HTTP connector to the Greg's [Event Store](https://geteventstore.com/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'http_eventstore'
+```
+
+## Usage
+
+To communicate with ES you have to create instance of `HttpEventstore::Connection` class. After configuring a client, you can do the following things.
+ 
+```ruby
+client = HttpEventstore::Connection.new do |config|
+   #default value is '127.0.0.1'
+   config.endpoint = 'your_endpoint'
+   #default value is 2113
+   config.port = 'your_port'
+   #default value is 20 entries per page
+   config.page_size = 'your_page_size'
+end
+```
+
+#### Creating new event
+
+Creating a single event:
+
+```ruby
+stream_name = "order_1"
+event_data = { event_type: "OrderCreated",
+               data: { data: "sample" },
+               event_id: "b2d506fd-409d-4ec7-b02f-c6d2295c7edd" }
+client.append_to_stream(stream_name, event_data)
+```
+
+OR
+
+```ruby
+EventData = Struct.new(:data, :event_type)
+stream_name = "order_1"
+event_data = EventData.new({ data: "sample" }, "OrderCreated")
+client.append_to_stream(stream_name, event_data)
+```
+
+Creating a single event with optimistic locking:
+
+```ruby
+stream_name = "order_1"
+event_data = { event_type: "OrderCreated", data: { data: "sample" }}
+expected_version = 1
+client.append_to_stream(stream_name, event_data, expected_version)
+```
+
+#### Deleting stream
+
+The soft delete of single stream:
+
+```ruby
+stream_name = "order_1"
+client.delete_stream("stream_name")
+```
+
+The hard delete of single stream:
+
+```ruby
+stream_name = "order_1"
+hard_delete = true
+client.delete_stream("stream_name", hard_delete)
+```
+
+The soft delete cause that you will be allowed to recreate the stream by creating new event. If you recreate soft deleted stream all events are lost.
+After an hard delete any try to load the stream or create event will result in a 410 response.
+
+#### Reading stream's event forward
+
+```ruby
+stream_name = "order_1"
+start = 21
+count = 40
+client.read_events_forward(stream_name, start, count)
+```
+
+If you call following method to get the newest entries and no data is available the server wait some specified period of time.
+
+```ruby
+stream_name = "order_1"
+start = 21
+count = 40
+pool_time = 15
+client.read_events_forward(stream_name, start, count, poll_time)
+```
+
+#### Reading stream's event backward
+
+```ruby
+stream_name = "order_1"
+start = 21
+count = 40
+client.read_events_backward(stream_name, start, count)
+```
+
+#### Reading all stream's event forward
+
+This method allows us to load all stream's events ascending.
+
+```ruby
+stream_name = "order_1"
+client.read_all_events_forward(stream_name)
+```
+
+#### Reading all stream's event backward
+
+This method allows us to load all stream's events descending.
+
+```ruby
+stream_name = "order_1"
+client.read_all_events_backward(stream_name)
+```
+
+## Supported version's of Event Store
+
+To take advantage of all the functionality offered by our gem the minimum recommended version of Event Store is **2.1**
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/http_eventstore/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/http_eventstore.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'http_eventstore'
+  spec.version       = '0.1.0'
+  spec.authors       = ['Arkency']
+  spec.email         = ['andrzejkrzywda@gmail.com']
+
+  spec.summary       = %q{HttpEventstore is a HTTP connector to the Greg's Event Store.}
+  spec.description   = %q{HttpEventstore is a HTTP connector to the Greg's Event Store.}
+  spec.homepage      = "https://github.com/arkency/http_eventstore"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+
+  spec.add_dependency 'faraday'
+  spec.add_dependency 'faraday_middleware'
+  spec.add_dependency 'json'
+  spec.add_dependency 'hashie'
+end

data/lib/http_eventstore/actions/append_event_to_stream.rb

@@ -0,0 +1,38 @@
+module HttpEventstore
+  module Actions
+    class AppendEventToStream
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name, event_data, expected_version = nil)
+        event_data = OpenStruct.new(event_data) if event_data.is_a?(Hash)
+        event = create_event(event_data)
+        raise IncorrectStreamData if event.validate || stream_name_incorrect?(stream_name)
+        create_event_in_es(stream_name, event, expected_version)
+      rescue ClientError => e
+        raise WrongExpectedEventNumber if e.code == 400
+        raise StreamAlreadyDeleted if e.code == 410
+      end
+
+      private
+      attr_reader :client
+
+      def create_event(event_data)
+        type = event_data.event_type
+        data = event_data.data
+        event_id = event_data.event_id if event_data.respond_to?(:event_id)
+        Event.new(type, data, event_id)
+      end
+
+      def create_event_in_es(stream_name, event, expected_version)
+        client.append_to_stream(stream_name, event, expected_version)
+      end
+
+      def stream_name_incorrect?(stream_name)
+        stream_name.nil? || stream_name.empty?
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/delete_stream.rb

@@ -0,0 +1,24 @@
+module HttpEventstore
+  module Actions
+    class DeleteStream
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name, hard_delete)
+        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+        delete_stream(stream_name, hard_delete)
+      rescue ClientError => e
+        raise StreamAlreadyDeleted
+      end
+
+      private
+      attr_reader :client
+
+      def delete_stream(stream_name, hard_delete)
+        client.delete_stream(stream_name, hard_delete)
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/read_all_stream_events.rb

@@ -0,0 +1,34 @@
+module HttpEventstore
+  module Actions
+    class ReadAllStreamEvents
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name)
+        raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
+        entries = get_all_stream_entries(stream_name)
+        return_events(entries)
+      rescue ClientError => e
+        raise StreamAlreadyDeleted if e.code == 410
+        raise StreamNotFound if e.code == 404
+      end
+
+      private
+      attr_reader :client
+
+      def get_all_stream_entries(stream_name, start_point = nil, entries = [])
+        stream_data = get_stream_batch(stream_name, start_point)
+        entries = append_entries(entries, stream_data['entries'])
+        start_point = get_next_start_point(stream_data['links'])
+        return entries if start_point.nil?
+        get_all_stream_entries(stream_name, start_point, entries)
+      end
+
+      def return_events(entries)
+        Helpers::ParseEntries.new.call(entries)
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/read_all_stream_events_backward.rb

@@ -0,0 +1,43 @@
+module HttpEventstore
+  module Actions
+    class ReadAllStreamEventsBackward < ReadAllStreamEvents
+
+      def initialize(client, page_size)
+        super(client)
+        @start_point = :head
+        @count = page_size
+      end
+
+      private
+      attr_reader :start_point, :count
+
+      def append_entries(entries, batch)
+        entries + batch
+      end
+
+      def get_stream_batch(stream_name, start)
+        if start.nil?
+          read_stream_backward(stream_name, start_point, count)
+        else
+          read_stream_by_url(start)
+        end
+      end
+
+      def read_stream_backward(stream_name, next_id, count)
+        client.read_stream_backward(stream_name, next_id, count)
+      end
+
+      def read_stream_by_url(uri)
+        client.read_stream_page(uri)
+      end
+
+      def get_next_start_point(links)
+        link = links.detect { |link| link['relation'] == 'next' }
+        unless link.nil?
+          link['uri'].slice! client.endpoint.url
+          link['uri']
+        end
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/read_all_stream_events_forward.rb

@@ -0,0 +1,43 @@
+module HttpEventstore
+  module Actions
+    class ReadAllStreamEventsForward < ReadAllStreamEvents
+
+      def initialize(client, page_size)
+        super(client)
+        @start_point = 0
+        @count = page_size
+      end
+
+      private
+      attr_reader :start_point, :count
+
+      def append_entries(entries, batch)
+        entries + batch.reverse!
+      end
+
+      def get_stream_batch(stream_name, start)
+        if start.nil?
+          read_stream_forward(stream_name, start_point, count)
+        else
+          read_stream_by_url(start)
+        end
+      end
+
+      def read_stream_forward(stream_name, next_id, count)
+        client.read_stream_forward(stream_name, next_id, count)
+      end
+
+      def read_stream_by_url(uri)
+        client.read_stream_page(uri)
+      end
+
+      def get_next_start_point(links)
+        link = links.detect { |link| link['relation'] == 'previous' }
+        unless link.nil?
+          link['uri'].slice! client.endpoint.url
+          link['uri']
+        end
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/read_stream_events_backward.rb

@@ -0,0 +1,29 @@
+module HttpEventstore
+  module Actions
+    class ReadStreamEventsBackward
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name, start, count)
+        response = get_stream_batch(stream_name, start, count)
+        return_events(response['entries'])
+      rescue ClientError => e
+        raise StreamAlreadyDeleted if e.code == 410
+        raise StreamNotFound if e.code == 404
+      end
+
+      private
+      attr_reader :client
+
+      def get_stream_batch(stream_name, start, count)
+        client.read_stream_backward(stream_name, start, count)
+      end
+
+      def return_events(entries)
+        Helpers::ParseEntries.new.call(entries)
+      end
+    end
+  end
+end

data/lib/http_eventstore/actions/read_stream_events_forward.rb

@@ -0,0 +1,29 @@
+module HttpEventstore
+  module Actions
+    class ReadStreamEventsForward
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name, start, count, pool)
+        response = get_stream_batch(stream_name, start, count, pool)
+        return_events(response['entries'])
+      rescue ClientError => e
+        raise StreamAlreadyDeleted if e.code == 410
+        raise StreamNotFound if e.code == 404
+      end
+
+      private
+      attr_reader :client
+
+      def get_stream_batch(stream_name, start, count, pool)
+        client.read_stream_forward(stream_name, start, count, pool)
+      end
+
+      def return_events(entries)
+        Helpers::ParseEntries.new.call(entries)
+      end
+    end
+  end
+end

data/lib/http_eventstore/api/client.rb

@@ -0,0 +1,49 @@
+module HttpEventstore
+  module Api
+    class Client
+
+      def initialize(endpoint, port, page_size)
+        @endpoint = Endpoint.new(endpoint, port)
+        @page_size = page_size
+      end
+      attr_reader :endpoint, :page_size
+
+      def append_to_stream(stream_name, event, expected_version = nil)
+        headers = {"ES-EventType" => event.type, "ES-EventId" => event.event_id, "ES-ExpectedVersion" => "#{expected_version}"}.reject { |key, val| val.empty? }
+        make_request(:post, "/streams/#{stream_name}", event.data, headers)
+      end
+
+      def delete_stream(stream_name, hard_delete)
+        headers = {"ES-HardDelete" => "#{hard_delete}"}
+        make_request(:delete, "/streams/#{stream_name}", {}, headers)
+      end
+
+      def read_stream_backward(stream_name, start, count)
+        make_request(:get, "/streams/#{stream_name}/#{start}/backward/#{count}")
+      end
+
+      def read_stream_forward(stream_name, start, count, long_pool = 0)
+        headers = long_pool > 0 ? {"ES-LongPoll" => "#{long_pool}"} : {}
+        make_request(:get, "/streams/#{stream_name}/#{start}/forward/#{count}", {}, headers)
+      end
+
+      def read_stream_page(uri)
+        make_request(:get, uri)
+      end
+
+      private
+
+      def make_request(method, path, body={}, headers={})
+        connection.send(method, path) do |req|
+          req.headers = req.headers.merge(headers)
+          req.body = body.to_json
+          req.params['embed'] = 'body' if method == :get
+        end.body
+      end
+
+      def connection
+        @connection ||= Api::Connection.new(endpoint).call
+      end
+    end
+  end
+end

data/lib/http_eventstore/api/connection.rb

@@ -0,0 +1,29 @@
+module HttpEventstore
+  module Api
+    class Connection
+      APP_JSON = 'application/json'.freeze
+
+      def initialize(endpoint)
+        @endpoint = endpoint
+      end
+
+      def call
+        Faraday.new(
+            url: endpoint.url,
+            headers: {
+                accept: APP_JSON,
+                content_type: APP_JSON
+            }
+        ) do |builder|
+          builder.adapter Faraday.default_adapter
+          builder.response :json, content_type: APP_JSON
+          builder.response :mashify
+          builder.use ErrorsHandler
+        end
+      end
+
+      private
+      attr_reader :endpoint
+    end
+  end
+end

data/lib/http_eventstore/api/errors_handler.rb

@@ -0,0 +1,19 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module HttpEventstore
+  module Api
+    class ErrorsHandler < Faraday::Response::Middleware
+
+      def on_complete(env)
+        code = env[:status]
+        case code
+          when (400..499)
+            raise ClientError.new(code)
+          when (500..599)
+            raise ServerError.new(code)
+        end
+      end
+    end
+  end
+end

data/lib/http_eventstore/connection.rb

@@ -0,0 +1,47 @@
+module HttpEventstore
+  class Connection
+    attr_accessor :endpoint, :port, :page_size
+
+    def initialize
+      setup_defaults
+      yield(self) if block_given?
+    end
+
+    def append_to_stream(stream_name, event_data, expected_version = nil)
+      Actions::AppendEventToStream.new(client).call(stream_name, event_data, expected_version)
+    end
+
+    def delete_stream(stream_name, hard_delete = false)
+      Actions::DeleteStream.new(client).call(stream_name, hard_delete)
+    end
+
+    def read_events_forward(stream_name, start, count, pool = 0)
+      Actions::ReadStreamEventsForward.new(client).call(stream_name, start, count, pool)
+    end
+
+    def read_events_backward(stream_name, start, count)
+      Actions::ReadStreamEventsBackward.new(client).call(stream_name, start, count)
+    end
+
+    def read_all_events_forward(stream_name)
+      Actions::ReadAllStreamEventsForward.new(client, page_size).call(stream_name)
+    end
+
+    def read_all_events_backward(stream_name)
+      Actions::ReadAllStreamEventsBackward.new(client, page_size).call(stream_name)
+    end
+
+    private
+
+    def client
+      @client ||= Api::Client.new(endpoint, port, page_size)
+    end
+
+    def setup_defaults
+      @endpoint  = 'localhost'
+      @port      = 2113
+      @page_size = 20
+    end
+
+  end
+end

data/lib/http_eventstore/endpoint.rb

@@ -0,0 +1,16 @@
+module HttpEventstore
+  class Endpoint
+
+    def initialize(endpoint, port)
+      @endpoint = endpoint
+      @port = port
+    end
+
+    def url
+      "http://#{endpoint}:#{port.to_s}"
+    end
+
+    private
+    attr_reader :endpoint, :port
+  end
+end

data/lib/http_eventstore/errors.rb

@@ -0,0 +1,20 @@
+module HttpEventstore
+  class ClientError < StandardError
+    attr_accessor :code
+    def initialize(code)
+      @code = code
+      super()
+    end
+  end
+  class ServerError < StandardError
+    attr_accessor :code
+    def initialize(code)
+      @code = code
+      super()
+    end
+  end
+  IncorrectStreamData       = Class.new(StandardError)
+  WrongExpectedEventNumber  = Class.new(StandardError)
+  StreamAlreadyDeleted      = Class.new(StandardError)
+  StreamNotFound            = Class.new(StandardError)
+end

data/lib/http_eventstore/event.rb

@@ -0,0 +1,14 @@
+class Event < Struct.new(:type, :data, :event_id, :id)
+  def initialize(type, data, event_id = nil, id = nil)
+    event_id = SecureRandom.uuid if event_id.nil?
+    super
+  end
+
+  def validate
+    [self.event_id, self.type, self.data].any? { |var| var.nil? || var.empty? }
+  end
+
+  def to_json(options)
+    self.to_h.to_json
+  end
+end

data/lib/http_eventstore/helpers/parse_entries.rb

@@ -0,0 +1,22 @@
+module HttpEventstore
+  module Helpers
+    class ParseEntries
+
+      def call(entries)
+        entries.collect do |entry|
+          create_event(entry)
+        end
+      end
+
+      private
+
+      def create_event(entry)
+        id = entry['positionEventNumber']
+        event_id = entry['eventId']
+        type = entry['eventType']
+        data = JSON.parse(entry['data'])
+        Event.new(type, data, event_id, id)
+      end
+    end
+  end
+end

data/lib/http_eventstore.rb

@@ -0,0 +1,15 @@
+require 'http_eventstore/api/client'
+require 'http_eventstore/api/connection'
+require 'http_eventstore/api/errors_handler'
+require 'http_eventstore/connection'
+require 'http_eventstore/event'
+require 'http_eventstore/errors'
+require 'http_eventstore/endpoint'
+require 'http_eventstore/helpers/parse_entries'
+require 'http_eventstore/actions/append_event_to_stream'
+require 'http_eventstore/actions/delete_stream'
+require 'http_eventstore/actions/read_all_stream_events'
+require 'http_eventstore/actions/read_all_stream_events_backward'
+require 'http_eventstore/actions/read_all_stream_events_forward'
+require 'http_eventstore/actions/read_stream_events_backward'
+require 'http_eventstore/actions/read_stream_events_forward'

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: http_eventstore
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arkency
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  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: faraday_middleware
+  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: json
+  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: hashie
+  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'
+description: HttpEventstore is a HTTP connector to the Greg's Event Store.
+email:
+- andrzejkrzywda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- http_eventstore.gemspec
+- lib/http_eventstore.rb
+- lib/http_eventstore/actions/append_event_to_stream.rb
+- lib/http_eventstore/actions/delete_stream.rb
+- lib/http_eventstore/actions/read_all_stream_events.rb
+- lib/http_eventstore/actions/read_all_stream_events_backward.rb
+- lib/http_eventstore/actions/read_all_stream_events_forward.rb
+- lib/http_eventstore/actions/read_stream_events_backward.rb
+- lib/http_eventstore/actions/read_stream_events_forward.rb
+- lib/http_eventstore/api/client.rb
+- lib/http_eventstore/api/connection.rb
+- lib/http_eventstore/api/errors_handler.rb
+- lib/http_eventstore/connection.rb
+- lib/http_eventstore/endpoint.rb
+- lib/http_eventstore/errors.rb
+- lib/http_eventstore/event.rb
+- lib/http_eventstore/helpers/parse_entries.rb
+homepage: https://github.com/arkency/http_eventstore
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: HttpEventstore is a HTTP connector to the Greg's Event Store.
+test_files: []