eventkit 0.0.4 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cf7b1a61743aa9b00613324e6279acce0df9d7b
-  data.tar.gz: c6627672c75ddd5007bc414f8f37a2f9d2565a4d
+  metadata.gz: 3535ba4fd3f864f13fc1a39c45eb37a560cb0aed
+  data.tar.gz: 5653234f81a48b182d3e6b60f3eb225cf758275b
 SHA512:
-  metadata.gz: 6baac81b5c1c47cc2b38a759b7da5460eab177c6d1d480dca132fab014013351f4ac6273c6d1fe3abed16cd670da6f284a402b69282b0a3fdff82a95ef08e84b
-  data.tar.gz: 15f3fdff27e494d72b37aaa40004c47bcdeef47957833b99c845d6102289b3570a65710262c23210d1f3f95c141d446ffb7153d3a2f6172c338ca87f714cc2ba
+  metadata.gz: e7129a03c555c04811b0aa19f4ce468130f02b57a531ea412c3d45a44e03333f4064d00c774ab2f24d04134d002bafdc388abdd4047daa527d15b4e6e721d4a3
+  data.tar.gz: f96f126b88c526f4318b77d0fb76b9250374f021eb20a66336f24f9de68df153f235469bac8c39d08e57edc57dfb2d71c8fea403f28970d5cd35038fefe0a906

data/README.md

@@ -3,174 +3,21 @@
 [![Build Status](https://travis-ci.org/omartell/eventkit.svg?branch=master)](https://travis-ci.org/omartell/eventkit)
 
 A basic toolkit for asynchronous event driven applications. The
-current version includes an Event Loop to perform non blocking IO and
+toolkit includes an Event Loop to perform non blocking IO and
 a promises A+ implementation to coordinate asychronous tasks.
 
+This gem bundles up the [eventkit-eventloop](http://github.com/omartell/eventkit-eventloop) and [eventkit-promise](http://github.com/omartell/eventkit-promise) gems.
+
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'eventkit'
-```
-
-## Event Loop Usage
-
-Eventkit provides a basic Event Loop on top of Ruby's IO.select to perform non blocking IO.
-Callbacks can be registered to monitor the readability or writability of IO objects.
-These callbacks are executed when the IO object is ready to be read or written to.
-
-Another feature is timers, which allows you to execute code at some point in the future.
-
-```ruby
-require 'eventkit'
-
-# Getting notified when an IO object is ready to be read or written
-event_loop = Eventkit::EventLoop.new
-
-server = TCPServer.new('localhost', 9595)
-
-client = TCPSocket.new('localhost', 9595)
-
-event_loop.register_read(server) do |server|
-  # This will be executed every time a new connection is ready to be accepted
-  connection, _ = server.accept_nonblock
-  event_loop.register_write(connection) do |connection|
-    bytes_written = connection.write_nonblock('hello world')
-  end
-end
-
-event_loop.start
-
-
-# Unsubscribing from notifications
-# A single read
-event_loop.deregister_read(io_object, handler)
-
-# A single write
-event_loop.deregister_write(io_object, handler)
-
-# All handlers
-event_loop.deregister_write(io_object)
-event_loop.deregister_read(io_object)
-
-
-# Registering a handler to be run on the next tick
-event_loop = Eventkit::EventLoop.new
-
-event_loop.on_next_tick do
-  puts 'hello world'
-  event_loop.stop
-end
-
-event_loop.start
-
-
-# Registering timers
-
-event_loop = Eventkit::EventLoop.new
-
-event_loop.register_timer(run_in: 5) do
-  # Block executes after 5 seconds have passed
-  puts 'hello world'
-  event_loop.stop
-end
-
-event_loop.start
-```
-
-## Promises Usage
-
-Eventkit also provides an implementation of the [Promise A+ specification](https://promisesaplus.com/),
-which allows you coordinate different asynchronous tasks while still programming with values.
-
-If you're only interested in promises, then eventkit-promise is also available as a [separate gem] (https://rubygems.org/gems/eventkit-promise).
-
-```ruby
-require 'eventkit/promise'
-
-# Resolving a promise
-
-promise = Eventkit::Promise.new
-
-promise.then(->(value) { value + 1 })
-
-promise.resolve(1)
-
-promise.value # => 1
-
-# Rejecting a promise
-
-promise = Eventkit::Promise.new
-
-promise.then(
-  ->(value) {
-    value + 1
-  },
-  ->(error) {
-    log(error.message)
-  }
-)
-
-promise.reject(NoMethodError.new('Undefined method #call'))
-
-promise.reason # => <NoMethodError: undefined method #call>
-
-# Chaining promises
-
-promise_a = Eventkit::Promise.new
-
-promise_b = promise_a
-  .then(->(v) { v + 1 })
-  .then(->(v) { v + 1 })
-  .then(->(v) { v + 1 })
-
-promise_b.catch { |error|
-# Handle errors raised by any of the previous handlers
-}
-
-promise_a.resolve(1)
-
-promise_a.value # => 1
-promise_b.value # => 4
-
-# Resolving and fullfiling with another promise
-
-promise_a = Eventkit::Promise.new
-promise_b = Eventkit::Promise.new
-
-promise_a.resolve(promise_b)
-
-promise_b.resolve('foobar')
-
-promise_a.value # => foobar
-
-# Resolving and rejecting with another promise
-
-promise_a = Eventkit::Promise.new
-promise_b = Eventkit::Promise.new
-
-promise_a.resolve(promise_b)
-
-promise_b.reject('Ooops can not continue')
-
-promise_a.reason # => 'Ooops can not continue'
-
-# Initializing with a block
-
-promise = Promise.new do |p|
-  p.resolve('foobar')
-end
-
-promise.value # => 'foobar'
-
+gem 'eventkit', '~> 1.0'
 ```
 
-## Contributing
+## Usage
 
-1. Fork it ( https://github.com/[my-github-username]/eventkit/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
-6. Happy Hacking!
+Check the documentation of
+[eventkit-eventloop](http://github.com/omartell/eventkit-eventloop)
+and [eventkit-promise](http://github.com/omartell/eventkit-promise).

data/eventkit.gemspec

@@ -1,11 +1,10 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'eventkit/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'eventkit'
-  spec.version       = Eventkit::VERSION
+  spec.version       = '1.0'
   spec.authors       = ['Oliver Martell']
   spec.email         = ['oliver.martell@gmail.com']
   spec.summary       = 'Experimental toolkit for asynchronous event driven applications'
@@ -23,5 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry', '~> 0.10.1'
   spec.add_development_dependency 'pry-doc', '~> 0.6.0'
   spec.add_development_dependency 'method_source', '~> 0.8.2'
-  spec.add_runtime_dependency 'eventkit-promise', '~> 0.1.0'
+
+  spec.add_runtime_dependency 'eventkit-promise', '~> 1.0'
+  spec.add_runtime_dependency 'eventkit-eventloop', '~> 0.1.0'
 end

data/lib/eventkit.rb

@@ -1,7 +1,2 @@
-require 'eventkit/version'
 require 'eventkit/event_loop'
 require 'eventkit/promise'
-
-module Eventkit
-  # Your code goes here...
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventkit
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: '1.0'
 platform: ruby
 authors:
 - Oliver Martell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -82,6 +82,20 @@ dependencies:
         version: 0.8.2
 - !ruby/object:Gem::Dependency
   name: eventkit-promise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: eventkit-eventloop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -111,12 +125,7 @@ files:
 - Rakefile
 - eventkit.gemspec
 - lib/eventkit.rb
-- lib/eventkit/event_loop.rb
-- lib/eventkit/timer.rb
-- lib/eventkit/version.rb
-- spec/eventkit/event_loop_spec.rb
 - spec/spec_helper.rb
-- spec/support/async_helper.rb
 homepage: http://github.com/omartell/eventkit
 licenses:
 - MIT
@@ -142,7 +151,5 @@ signing_key:
 specification_version: 4
 summary: Experimental toolkit for asynchronous event driven applications
 test_files:
-- spec/eventkit/event_loop_spec.rb
 - spec/spec_helper.rb
-- spec/support/async_helper.rb
 has_rdoc: 

data/lib/eventkit/event_loop.rb

@@ -1,95 +0,0 @@
-require 'set'
-require 'eventkit/timer'
-
-module Eventkit
-  class EventLoopAlreadyStartedError < StandardError; end
-
-  class EventLoop
-    attr_reader :select_interval
-    private :select_interval
-
-    def initialize(config = {})
-      @read_handlers = Hash.new { |h, k| h[k] = [] }
-      @write_handlers = Hash.new { |h, k| h[k] = [] }
-      @select_interval = config.fetch(:select_interval, 1 / 100_000)
-      @timers = SortedSet.new
-      @stopped = false
-      @started = false
-    end
-
-    def start(&_block)
-      if @started
-        fail EventLoopAlreadyStartedError, 'This event loop instance has already started running'
-      else
-        @started = true
-      end
-
-      loop do
-        if stop_scheduled?
-          @stopped = false
-          break
-        end
-        tick
-      end
-    end
-
-    def stop
-      @stopped = true
-      @started = false
-    end
-
-    def stop_scheduled?
-      @stopped
-    end
-
-    def tick
-      ready_read, ready_write, _ = IO.select(@read_handlers.keys, @write_handlers.keys, [], select_interval)
-      ready_read.each { |io|
-        @read_handlers.fetch(io).each { |handler| handler.call(io) }
-      } if ready_read
-
-      ready_write.each { |io|
-        @write_handlers.fetch(io).each { |handler| handler.call(io) }
-      } if ready_write
-
-      @timers.select(&:expired?).each { |timer|
-        timer.handler.call
-        @timers.delete(timer)
-      }
-      nil
-    end
-
-    def on_next_tick(&handler)
-      register_timer(run_in: 0, &handler)
-    end
-
-    def register_timer(options, &handler)
-      @timers << Timer.new(options.fetch(:run_in), handler)
-    end
-
-    def register_read(io, &listener)
-      @read_handlers[io] += [listener]
-    end
-
-    def deregister_read(io, listener = nil)
-      if listener
-        @read_handlers[io] -= [listener]
-      else
-        @read_handlers[io] = []
-      end
-    end
-
-    def register_write(io, &listener)
-      @write_handlers[io] += [listener]
-    end
-
-    def deregister_write(io, listener = nil)
-      if listener
-        @write_handlers[io] -= [listener]
-      else
-        @write_handlers[io] = []
-      end
-    end
-  end
-end
-

data/lib/eventkit/timer.rb

@@ -1,15 +0,0 @@
-module Eventkit
-  Timer = Struct.new(:expires_in, :handler) do
-    def initialize(seconds, handler)
-      super(Time.now.to_f + seconds, handler)
-    end
-
-    def <=>(other)
-      expires_in <=> other.expires_in
-    end
-
-    def expired?
-      expires_in <= Time.now.to_f
-    end
-  end
-end

data/lib/eventkit/version.rb

@@ -1,3 +0,0 @@
-module Eventkit
-  VERSION = '0.0.4'
-end

data/spec/eventkit/event_loop_spec.rb

@@ -1,278 +0,0 @@
-require 'support/async_helper'
-require 'socket'
-require 'eventkit'
-
-module Eventkit
-  RSpec.describe EventLoop do
-    include AsyncHelper
-
-    let!(:event_loop) { EventLoop.new(select_interval: 1 / 100_000) }
-
-    let!(:tcp_server) { TCPServer.new('localhost', 9595) }
-
-    let!(:another_tcp_server) { TCPServer.new('localhost', 9494) }
-
-    let!(:tcp_socket) { TCPSocket.new('localhost', 9595) }
-
-    let!(:another_tcp_socket) { TCPSocket.new('localhost', 9494) }
-
-    after do
-      tcp_server.close
-      another_tcp_server.close
-      tcp_socket.close
-      another_tcp_socket.close
-    end
-
-    it 'allows to start and stop the event loop' do
-      verifier = double(did_stop: nil)
-
-      event_loop.on_next_tick do
-        event_loop.stop
-        verifier.did_stop
-      end
-
-      event_loop.start
-
-      expect(verifier).to have_received(:did_stop)
-    end
-
-    it 'does not allow to start the event loop once it has started' do
-      expect do
-        listener = double(:listener)
-
-        allow(listener).to receive(:handle_event) do |_io|
-          event_loop.start
-        end
-
-        event_loop.register_write(tcp_socket, &listener.method(:handle_event))
-
-        event_loop.start
-      end.to raise_error(EventLoopAlreadyStartedError)
-    end
-
-    it 'allows to restart the event loop' do
-      expect do |block|
-        event_loop.register_write(tcp_socket) do |io|
-          block.to_proc.call(:once)
-          event_loop.stop
-          event_loop.deregister_write(io)
-
-          event_loop.register_write(another_tcp_socket) do |io|
-            block.to_proc.call(:twice)
-            event_loop.stop
-            event_loop.deregister_write(io)
-          end
-          event_loop.start
-        end
-
-        event_loop.start
-      end.to yield_successive_args(:once, :twice)
-    end
-
-    it 'notifies when a single read operation is ready' do
-      fake_server = double(to_io: tcp_server, connection_read_ready: nil)
-
-      event_loop.register_read(fake_server, &fake_server.method(:connection_read_ready))
-
-      event_loop.tick
-
-      expect(fake_server).to have_received(:connection_read_ready).once.with(fake_server)
-    end
-
-    it 'notifies when a single write operation is ready' do
-      fake_socket = double(to_io: tcp_socket, connection_write_ready: nil)
-
-      event_loop.register_write(fake_socket, &fake_socket.method(:connection_write_ready))
-
-      event_loop.tick
-
-      expect(fake_socket).to have_received(:connection_write_ready).once.with(fake_socket)
-    end
-
-    it 'notifies when multiple write operations are ready' do
-      fake_socket = double(to_io: tcp_socket, connection_write_ready: nil)
-      another_fake_socket = double(to_io: another_tcp_socket, ready_to_write: nil)
-
-      event_loop.register_write(fake_socket, &fake_socket.method(:connection_write_ready))
-      event_loop.register_write(another_fake_socket, &another_fake_socket.method(:ready_to_write))
-
-      event_loop.tick
-
-      expect(fake_socket).to have_received(:connection_write_ready).once.with(fake_socket)
-      expect(another_fake_socket).to have_received(:ready_to_write).once.with(another_fake_socket)
-    end
-
-    it 'notifies when multiple read operations are ready' do
-      fake_server = double(to_io: tcp_server, connection_read_ready: nil)
-      another_fake_server = double(to_io: another_tcp_server, new_connection: nil)
-
-      event_loop.register_read(fake_server, &fake_server.method(:connection_read_ready))
-      event_loop.register_read(another_fake_server, &another_fake_server.method(:new_connection))
-
-      event_loop.tick
-
-      expect(fake_server).to have_received(:connection_read_ready).once.with(fake_server)
-      expect(another_fake_server).to have_received(:new_connection).once.with(another_fake_server)
-    end
-
-    it 'allows an object to register reads on multiple io objects' do
-      listener = double(connection_read_ready: nil, another_connection: nil)
-
-      event_loop.register_read(tcp_server, &listener.method(:connection_read_ready))
-      event_loop.register_read(another_tcp_server, &listener.method(:another_connection))
-
-      expect(listener).to receive(:connection_read_ready).once.with(tcp_server)
-      expect(listener).to receive(:another_connection).once.with(another_tcp_server)
-
-      event_loop.tick
-    end
-
-    it 'allows an object to register writes on multiple io objects' do
-      listener = double(one_ready_to_write: nil, another_ready_to_write: nil)
-
-      event_loop.register_write(tcp_socket, &listener.method(:one_ready_to_write))
-      event_loop.register_write(another_tcp_socket, &listener.method(:another_ready_to_write))
-
-      expect(listener).to receive(:one_ready_to_write).once.with(tcp_socket)
-      expect(listener).to receive(:another_ready_to_write).once.with(another_tcp_socket)
-
-      event_loop.tick
-    end
-
-    it 'allows to register multiple read handlers on a single io object' do
-      listener = double(connection_read_ready: nil)
-      another_listener = double(new_connection: nil)
-
-      event_loop.register_read(tcp_server, &listener.method(:connection_read_ready))
-      event_loop.register_read(tcp_server, &another_listener.method(:new_connection))
-
-      expect(listener).to receive(:connection_read_ready).once.with(tcp_server)
-      expect(another_listener).to receive(:new_connection).once.with(tcp_server)
-
-      event_loop.tick
-    end
-
-    it 'allows to register multiple write handlers on a single io object' do
-      listener = double(connection_write_ready: nil)
-      another_listener = double(ready_to_write: nil)
-
-      event_loop.register_write(tcp_socket, &listener.method(:connection_write_ready))
-      event_loop.register_write(tcp_socket, &another_listener.method(:ready_to_write))
-
-      expect(listener).to receive(:connection_write_ready).once.with(tcp_socket)
-      expect(another_listener).to receive(:ready_to_write).once.with(tcp_socket)
-
-      event_loop.tick
-    end
-
-    it 'allows to deregister read handlers' do
-      listener = double(connection_read_ready: nil)
-      handler = listener.method(:connection_read_ready).to_proc
-
-      event_loop.register_read(tcp_server, &handler)
-      event_loop.deregister_read(tcp_server, &handler)
-
-      expect(listener).not_to receive(:connection_read_ready)
-
-      event_loop.tick
-    end
-
-    it 'allows to deregister write handlers' do
-      listener = double(connection_write_ready: nil)
-
-      handler = listener.method(:connection_write_ready).to_proc
-
-      event_loop.register_write(tcp_socket, &handler)
-      event_loop.deregister_write(tcp_socket, handler)
-
-      expect(listener).not_to receive(:connection_write_ready)
-
-      event_loop.tick
-    end
-
-    it 'deregisters all write handlers for an io object' do
-      listener = double(connection_write_ready: nil, another_write_event: nil)
-
-      first_handler = listener.method(:connection_write_ready).to_proc
-      second_handler = listener.method(:another_write_event).to_proc
-
-      event_loop.register_write(tcp_socket, &first_handler)
-      event_loop.register_write(tcp_socket, &second_handler)
-
-      event_loop.deregister_write(tcp_socket)
-
-      expect(listener).not_to receive(:connection_write_ready)
-      expect(listener).not_to receive(:another_event)
-
-      event_loop.tick
-    end
-
-    it 'deregisters all read handlers for an io object' do
-      listener = double(connection_read_ready: nil, another_read_event: nil)
-
-      first_handler = listener.method(:connection_read_ready).to_proc
-      second_handler = listener.method(:another_read_event).to_proc
-
-      connection = tcp_server.accept
-      connection.write('hello world')
-
-      event_loop.register_read(tcp_socket, &first_handler)
-      event_loop.register_read(tcp_socket, &second_handler)
-
-      event_loop.deregister_read(tcp_socket)
-
-      expect(listener).not_to receive(:connection_read_ready)
-      expect(listener).not_to receive(:another_event)
-
-      event_loop.tick
-    end
-
-    it 'allows to register timers which will executed in order' do
-      listener = double(timer_expired_a: nil,
-                        timer_expired_b: nil,
-                        timer_expired_c: nil,
-                        timer_expired_d: nil)
-
-      event_loop.register_timer(run_in: 2, &listener.method(:timer_expired_a))
-
-      event_loop.register_timer(run_in: 3, &listener.method(:timer_expired_b))
-
-      event_loop.register_timer(run_in: 1, &listener.method(:timer_expired_c))
-
-      event_loop.register_timer(run_in: 5, &listener.method(:timer_expired_d))
-
-      sleep(3.1)
-
-      event_loop.tick
-
-      expect(listener).to have_received(:timer_expired_c).ordered.once
-      expect(listener).to have_received(:timer_expired_a).ordered.once
-      expect(listener).to have_received(:timer_expired_b).ordered.once
-      expect(listener).to_not have_received(:timer_expired_d)
-    end
-
-    it 'deregister timers as soon as they have expired' do
-      listener = double(timer_expired: nil)
-
-      event_loop.register_timer(run_in: 1, &listener.method(:timer_expired))
-
-      sleep(2)
-
-      event_loop.tick
-      event_loop.tick
-
-      expect(listener).to have_received(:timer_expired).once
-    end
-
-    it 'allows to schedule code to be run on the next tick' do
-      listener = double(on_next_tick: nil)
-
-      event_loop.on_next_tick(&listener.method(:on_next_tick))
-
-      event_loop.tick
-
-      expect(listener).to have_received(:on_next_tick).once
-    end
-  end
-end
-

data/spec/support/async_helper.rb

@@ -1,40 +0,0 @@
-module AsyncHelper
-  # Instead of waiting an specific an amount of time and then
-  # asserting for a certain behaviour, this test helper polls for an assertion
-  # success every X number of seconds (configurable as interval).
-  # The test will fail if the assertion doesn't pass after Y number of
-  # seconds (configurable as timeout).
-  def eventually(options = {})
-    timeout    = options[:timeout] || 1 # seconds
-    interval   = options[:interval] || 0.0001 # seconds
-    time_limit = Time.now + timeout
-
-    loop do
-      begin
-        yield
-      rescue RSpec::Expectations::ExpectationNotMetError => error
-
-      end
-
-      return if error.nil?
-
-      fail error if Time.now >= time_limit
-      sleep interval
-    end
-  end
-
-  # Same behaviour as eventually, but decided to change the method name to make
-  # it more clear that this is focused on 'synchronizing' the test with the application
-  def wait_until(options = {}, &block)
-    eventually(options, &block)
-  end
-
-  # Small wrapper around sleep
-  def on_timeout(options = {})
-    timeout = options[:timeout] || 0.5
-
-    sleep timeout
-
-    yield
-  end
-end