http_event_store 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8092ccdf90fa8150f7f8243e5229a6bada5bf74b
+  data.tar.gz: 3a441eab628a4597c037c72ec2790a479bb5700c
+SHA512:
+  metadata.gz: 58d3133164929972ab97f4332de1fad981cff2fa43bd452620138f6881a3aa855a0d90fa9402d4738e7ac879b0fc562ddaa7b7bd0d06ca5282fd4925d63953d9
+  data.tar.gz: fa7782fc7348caf60ae321e8818c79d50c456df54cfd28042bbe37d3ec993669492fc2c1cca166468b879cad272c5ff3230e1a642a7f0ab47e25b4fa79db33f7

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+- 2.1.2
+before_install: gem install bundler
+gemfile: Gemfile
+notifications:
+  slack:
+    secure: DhTubz8XU/uzGEV3g4FhWfedYcQRqzB6jEZ6/iSjIhk8D77b/GO/RVXezYG5dNTmmlunOYTm1kGIlxu33yFH+8r33Q4tj7TDtt/yrGO3UvwiEP7UJcvThpMUs3BusGVz4INCnpoinh3Hz56d1tELLlmcnPkjg/mlReje6MIHg+Y=

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Arkency
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,35 @@
+[![Build Status](https://travis-ci.org/arkency/http_event_store.svg?branch=master)](https://travis-ci.org/arkency/http_event_store)
+[![Gem Version](https://badge.fury.io/rb/http_event_store.svg)](http://badge.fury.io/rb/http_event_store)
+[![Join the chat at https://gitter.im/arkency/http_event_store](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/arkency/http_event_store?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+# HttpEventStore
+
+HttpEventStore is a HTTP connector to the Greg's [Event Store](https://geteventstore.com/).
+The `master` branch is curently targeting EventStore 3.x, for EventStore 2.x version check `EventStore2.x` branch.
+
+## Attention: gem has been renamed!
+#### The name has changed from http_eventstore to http_event_store.
+
+# Documentation
+
+All documentation and sample codes are available at [http://httpeventstore.arkency.com](http://httpeventstore.arkency.com)
+
+## 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 **3.0**
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/http_event_store/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
+
+## About
+
+<img src="http://arkency.com/images/arkency.png" alt="Arkency" width="20%" align="left" />
+
+This repository is funded and maintained by Arkency. Check out our other [open-source projects](https://github.com/arkency).
+
+You can also [hire us](http://arkency.com) or [read our blog](http://blog.arkency.com).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/http_event_store.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'http_event_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'http_event_store'
+  spec.version       = HttpEventStore::VERSION
+  spec.authors       = ['Mirosław Pragłowski']
+  spec.email         = ['m@praglowski.com', 'dev@arkency.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_event_store"
+
+  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_event_store.rb

@@ -0,0 +1,18 @@
+require 'http_event_store/api/client'
+require 'http_event_store/api/connection'
+require 'http_event_store/api/errors_handler'
+require 'http_event_store/connection'
+require 'http_event_store/event'
+require 'http_event_store/errors'
+require 'http_event_store/endpoint'
+require 'http_event_store/helpers/parse_entries'
+require 'http_event_store/helpers/parse_state'
+require 'http_event_store/actions/append_event_to_stream'
+require 'http_event_store/actions/delete_stream'
+require 'http_event_store/actions/read_all_stream_events'
+require 'http_event_store/actions/read_all_stream_events_backward'
+require 'http_event_store/actions/read_all_stream_events_forward'
+require 'http_event_store/actions/read_stream_events_backward'
+require 'http_event_store/actions/read_stream_events_forward'
+require 'http_event_store/actions/read_projection_state'
+require 'http_event_store/actions/set_projection_state'

data/lib/http_event_store/actions/append_event_to_stream.rb

@@ -0,0 +1,44 @@
+require 'ostruct'
+
+module HttpEventStore
+  module Actions
+    class AppendEventToStream
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(stream_name, event_data, expected_version = nil)
+        events = [event_data].flatten.map do |event_data|
+          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)
+          event
+        end
+
+        create_event_in_es(stream_name, events, 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_event_store/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_event_store/actions/read_all_stream_events.rb

@@ -0,0 +1,41 @@
+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 = [])
+        loop do
+          start_point, entries = get_next_stream_entries(stream_name, start_point, entries)
+          break if start_point.nil?
+        end
+        entries
+      end
+
+      def get_next_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'])
+        [start_point, entries]
+      end
+
+      def return_events(entries)
+        Helpers::ParseEntries.new.call(entries)
+      end
+    end
+  end
+end

data/lib/http_event_store/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_event_store/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_event_store/actions/read_projection_state.rb

@@ -0,0 +1,29 @@
+module HttpEventStore
+  module Actions
+    class ReadProjectionState
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(projection_name)
+        response = get_projection_state(projection_name)
+        return_state(response)
+      rescue ClientError => e
+        raise StreamAlreadyDeleted if e.code == 410
+        raise StreamNotFound if e.code == 404
+      end
+
+      private
+      attr_reader :client
+
+      def get_projection_state(projection_name)
+        client.read_projection_page("/projection/#{projection_name}/state")
+      end
+
+      def return_state(state)
+        Helpers::ParseState.new.(state)
+      end
+    end
+  end
+end

data/lib/http_event_store/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_event_store/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_event_store/actions/set_projection_state.rb

@@ -0,0 +1,23 @@
+module HttpEventStore
+  module Actions
+    class SetProjectionState
+
+      def initialize(client)
+        @client = client
+      end
+
+      def call(projection_name, state)
+        response = set_projection_state(projection_name, state)
+      rescue ClientError => e
+
+      end
+
+      private
+      attr_reader :client
+
+      def set_projection_state(projection_name, state)
+        client.set_projection_state(projection_name, state)
+      end
+    end
+  end
+end

data/lib/http_event_store/api/client.rb

@@ -0,0 +1,64 @@
+module HttpEventStore
+  module Api
+    class Client
+      VDN_EVENTSTORE_EVENTS_JSON  = 'application/vnd.eventstore.events+json'.freeze
+      JSON                        = 'application/json'.freeze
+
+      VDN_EVENTSTORE_EVENTS_JSON_HEADERS  = { "accept" => VDN_EVENTSTORE_EVENTS_JSON, "content-type" => VDN_EVENTSTORE_EVENTS_JSON }.freeze
+      JSON_HEADERS                        = { "accept" => JSON, "content-type" => JSON }.freeze
+
+      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_data, expected_version = nil)
+        headers =  VDN_EVENTSTORE_EVENTS_JSON_HEADERS.merge({"ES-ExpectedVersion" => "#{expected_version}"}.reject { |key, val| val.empty? })
+
+        data = [event_data].flatten.map do |event|
+          {
+            eventId:   event.event_id,
+            eventType: event.type,
+            data:      event.data
+          }
+        end
+
+        make_request(:post, "/streams/#{stream_name}", data, headers)
+      end
+
+      def delete_stream(stream_name, hard_delete)
+        headers = JSON_HEADERS.merge({"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}", {}, JSON_HEADERS)
+      end
+
+      def read_stream_forward(stream_name, start, count, long_pool = 0)
+        headers = long_pool > 0 ? JSON_HEADERS.merge({"ES-LongPoll" => "#{long_pool}"}) : JSON_HEADERS
+        make_request(:get, "/streams/#{stream_name}/#{start}/forward/#{count}", {}, headers)
+      end
+
+      def read_stream_page(uri)
+        make_request(:get, uri, {}, JSON_HEADERS)
+      end
+      alias_method :read_projection_page, :read_stream_page
+
+      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_event_store/api/connection.rb

@@ -0,0 +1,27 @@
+module HttpEventStore
+  module Api
+    class Connection
+      APP_JSON = 'application/json'.freeze
+
+      def initialize(endpoint)
+        @endpoint = endpoint
+      end
+
+      def call
+        Faraday.new(
+            url: endpoint.url,
+        ) do |builder|
+          builder.request :retry, max: 4, interval: 0.05,
+                           interval_randomness: 0.5, backoff_factor: 2
+          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_event_store/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_event_store/connection.rb

@@ -0,0 +1,55 @@
+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
+
+    def read_projection_state(projection_name)
+      Actions::ReadProjectionState.new(client).call(projection_name)
+    end
+
+    def set_projection_state(projection_name, state)
+      Actions::SetProjectionState.new(client).call(projection_name, state)
+    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_event_store/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_event_store/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_event_store/event.rb

@@ -0,0 +1,16 @@
+require 'securerandom'
+
+class Event < Struct.new(:type, :data, :source_event_uri, :event_id, :id, :position, :stream_name, :created_time)
+  def initialize(type, data, source_event_uri=nil, event_id=nil, id=nil, position=nil, stream_name=nil, created_time=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_event_store/helpers/parse_entries.rb

@@ -0,0 +1,29 @@
+require 'time'
+
+module HttpEventStore
+  module Helpers
+    class ParseEntries
+
+      def call(entries)
+        entries.collect do |entry|
+          create_event(entry)
+        end.compact
+      end
+
+      private
+
+      def create_event(entry)
+        id = entry['eventNumber']
+        event_id = entry['eventId']
+        type = entry['eventType']
+        source_event_uri = entry['id']
+        return nil unless entry['data']
+        data = JSON.parse(entry['data'])
+        stream_name = entry['streamId']
+        position = entry['positionEventNumber']
+        created_time = entry['updated'] ? Time.parse(entry['updated']) : nil
+        Event.new(type, data, source_event_uri, event_id, id, position, stream_name, created_time)
+      end
+    end
+  end
+end

data/lib/http_event_store/helpers/parse_state.rb

@@ -0,0 +1,10 @@
+module HttpEventStore
+  module Helpers
+    class ParseState
+
+      def call(state)
+        state
+      end
+    end
+  end
+end

data/lib/http_event_store/version.rb

@@ -0,0 +1,3 @@
+module HttpEventStore
+  VERSION = '0.2.1'
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: http_event_store
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Mirosław Pragłowski
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-21 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:
+- m@praglowski.com
+- dev@arkency.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- http_event_store.gemspec
+- lib/http_event_store.rb
+- lib/http_event_store/actions/append_event_to_stream.rb
+- lib/http_event_store/actions/delete_stream.rb
+- lib/http_event_store/actions/read_all_stream_events.rb
+- lib/http_event_store/actions/read_all_stream_events_backward.rb
+- lib/http_event_store/actions/read_all_stream_events_forward.rb
+- lib/http_event_store/actions/read_projection_state.rb
+- lib/http_event_store/actions/read_stream_events_backward.rb
+- lib/http_event_store/actions/read_stream_events_forward.rb
+- lib/http_event_store/actions/set_projection_state.rb
+- lib/http_event_store/api/client.rb
+- lib/http_event_store/api/connection.rb
+- lib/http_event_store/api/errors_handler.rb
+- lib/http_event_store/connection.rb
+- lib/http_event_store/endpoint.rb
+- lib/http_event_store/errors.rb
+- lib/http_event_store/event.rb
+- lib/http_event_store/helpers/parse_entries.rb
+- lib/http_event_store/helpers/parse_state.rb
+- lib/http_event_store/version.rb
+homepage: https://github.com/arkency/http_event_store
+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.5.1
+signing_key: 
+specification_version: 4
+summary: HttpEventStore is a HTTP connector to the Greg's Event Store.
+test_files: []