tilia-event 2.0.2

data/test/event_emitter_test.rb

@@ -0,0 +1,220 @@
+require 'test_helper'
+
+module Tilia
+  module Event
+    class ContinueCallbackTest < Minitest::Test
+      def test_init
+        ee = EventEmitter.new
+        assert_instance_of(EventEmitter, ee)
+      end
+
+      def test_listeners
+        ee = EventEmitter.new
+        callback1 = -> {}
+        callback2 = -> {}
+        ee.on('foo', callback1, 200)
+        ee.on('foo', callback2, 100)
+
+        assert_equal([callback2, callback1], ee.listeners('foo'))
+      end
+
+      def test_handle_event
+        arg_result = nil
+
+        ee = EventEmitter.new
+        ee.on('foo', ->(arg) { arg_result = arg })
+
+        assert(ee.emit('foo', ['bar']))
+        assert_equal('bar', arg_result)
+      end
+
+      def test_cancel_event
+        arg_result = 0
+
+        ee = EventEmitter.new
+        ee.on(
+          'foo',
+          lambda do |_|
+            arg_result = 1
+            false
+          end
+        )
+        ee.on('foo', ->(_) { arg_result = 2 })
+
+        refute(ee.emit('foo', ['bar']))
+        assert_equal(1, arg_result)
+      end
+
+      def test_priority
+        arg_result = 0
+
+        ee = EventEmitter.new
+        ee.on(
+          'foo',
+          lambda do |_|
+            arg_result = 1
+            false
+          end
+        )
+        ee.on(
+          'foo',
+          lambda do |_|
+            arg_result = 2
+            false
+          end,
+          1
+        )
+
+        refute(ee.emit('foo', ['bar']))
+        assert_equal(2, arg_result)
+      end
+
+      def test_priority2
+        result = []
+        ee = EventEmitter.new
+
+        ee.on('foo', -> { result << 'a' }, 200)
+        ee.on('foo', -> { result << 'b' }, 50)
+        ee.on('foo', -> { result << 'c' }, 300)
+        ee.on('foo', -> { result << 'd' })
+
+        ee.emit('foo')
+        assert_equal(%w(b d a c), result)
+      end
+
+      def test_remove_listener
+        result = false
+
+        call_back = -> { result = true }
+
+        ee = EventEmitter.new
+
+        ee.on('foo', call_back)
+        ee.emit('foo')
+
+        assert(result)
+        result = false
+
+        assert(ee.remove_listener('foo', call_back))
+
+        ee.emit('foo')
+        refute(result)
+      end
+
+      def test_remove_unknown_listener
+        result = false
+
+        call_back = -> { result = true }
+
+        ee = EventEmitter.new
+
+        ee.on('foo', call_back)
+        ee.emit('foo')
+
+        assert(result)
+        result = false
+
+        refute(ee.remove_listener('bar', call_back))
+
+        ee.emit('foo')
+        assert(result)
+      end
+
+      def test_remove_listener_twice
+        result = false
+
+        call_back = -> { result = true }
+
+        ee = EventEmitter.new
+
+        ee.on('foo', call_back)
+        ee.emit('foo')
+
+        assert(result)
+        result = false
+
+        assert(ee.remove_listener('foo', call_back))
+        refute(ee.remove_listener('foo', call_back))
+
+        ee.emit('foo')
+        refute(result)
+      end
+
+      def test_remove_all_listeners
+        result = false
+
+        call_back = -> { result = true }
+
+        ee = EventEmitter.new
+
+        ee.on('foo', call_back)
+        ee.emit('foo')
+
+        assert(result)
+        result = false
+
+        ee.remove_all_listeners('foo')
+
+        ee.emit('foo')
+        refute(result)
+      end
+
+      def test_remove_all_listeners_no_arg
+        result = false
+
+        call_back = -> { result = true }
+
+        ee = EventEmitter.new
+
+        ee.on('foo', call_back)
+        ee.emit('foo')
+
+        assert(result)
+        result = false
+
+        ee.remove_all_listeners
+
+        ee.emit('foo')
+        refute(result)
+      end
+
+      def test_once
+        result = 0
+
+        call_back = -> { result += 1 }
+
+        ee = EventEmitter.new
+        ee.once('foo', call_back)
+
+        ee.emit('foo')
+        ee.emit('foo')
+
+        assert_equal(1, result)
+      end
+
+      def test_priority_once
+        arg_result = 0
+
+        ee = EventEmitter.new
+        ee.once(
+          'foo',
+          lambda do |_|
+            arg_result = 1
+            false
+          end
+        )
+        ee.once(
+          'foo',
+          lambda do |_|
+            arg_result = 2
+            false
+          end,
+          1
+        )
+
+        refute(ee.emit('foo', ['bar']))
+        assert_equal(2, arg_result)
+      end
+    end
+  end
+end

data/test/promise_test.rb

@@ -0,0 +1,164 @@
+require 'test_helper'
+
+module Tilia
+  module Event
+    class PromiseTest < Minitest::Test
+      def test_success
+        final_value = 0
+        promise = Promise.new
+        promise.fulfill(1)
+
+        promise.then(->(value) { final_value = value + 2 })
+
+        assert_equal(3, final_value)
+      end
+
+      def test_fail
+        final_value = 0
+        promise = Promise.new
+        promise.reject(1)
+
+        promise.then(nil, ->(value) { final_value = value + 2 })
+      end
+
+      def test_chain
+        final_value = 0
+        promise = Promise.new
+        promise.fulfill(1)
+
+        promise.then(
+          ->(value) { final_value = value + 2 }
+        ).then(
+          ->(value) { final_value = value + 4 }
+        )
+
+        assert_equal(7, final_value)
+      end
+
+      def test_chain_promise
+        final_value = 0
+        promise = Promise.new
+        promise.fulfill(1)
+
+        sub_promise = Promise.new
+
+        promise.then(
+          ->(_) { sub_promise }
+        ).then(
+          ->(value) { final_value = value + 4 }
+        )
+
+        sub_promise.fulfill(2)
+
+        assert_equal(6, final_value)
+      end
+
+      def test_pending_result
+        final_value = 0
+        promise = Promise.new
+
+        promise.then(->(value) { final_value = value + 2 })
+
+        promise.fulfill(4)
+        assert_equal(6, final_value)
+      end
+
+      def test_pending_fail
+        final_value = 0
+        promise = Promise.new
+
+        promise.then(nil, ->(value) { final_value = value + 2 })
+
+        promise.reject(4)
+        assert_equal(6, final_value)
+      end
+
+      def test_executor_success
+        real_result = ''
+        _promise = (
+          Promise.new(->(success, _failing) { success.call('hi') })
+        ).then(
+          ->(result) { real_result = result }
+        )
+
+        assert_equal('hi', real_result)
+      end
+
+      def test_executor_fail
+        real_result = ''
+        _promise = (
+          Promise.new(->(_success, failing) { failing.call('hi') })
+        ).then(
+          ->(_result) { real_result = 'incorrect' },
+          ->(reason) { real_result = reason }
+        )
+
+        assert_equal('hi', real_result)
+      end
+
+      def test_fulfill_twice
+        promise = Promise.new
+        promise.fulfill(1)
+        assert_raises(PromiseAlreadyResolvedException) { promise.fulfill(1) }
+      end
+
+      def test_reject_twice
+        promise = Promise.new
+        promise.reject(1)
+        assert_raises(PromiseAlreadyResolvedException) { promise.reject(1) }
+      end
+
+      def test_from_failure_handler
+        ok = 0
+        promise = Promise.new
+        promise.error(
+          lambda do |reason|
+            assert_equal('foo', reason)
+            fail 'hi'
+          end
+        ).then(
+          ->(_) { ok = -1 },
+          ->(_) { ok = 1 }
+        )
+
+        assert_equal(0, ok)
+        promise.reject('foo')
+        assert_equal(1, ok)
+      end
+
+      def test_all
+        promise1 = Promise.new
+        promise2 = Promise.new
+
+        final_value = 0
+        Promise.all([promise1, promise2]).then(
+          ->(value) { final_value = value }
+        )
+
+        promise1.fulfill(1)
+        assert_equal(0, final_value)
+        promise2.fulfill(2)
+        assert_equal([1, 2], final_value)
+      end
+
+      def test_all_reject
+        promise1 = Promise.new
+        promise2 = Promise.new
+
+        final_value = 0
+        Promise.all([promise1, promise2]).then(
+          lambda do |_value|
+            final_value = 'foo'
+            'test'
+          end,
+          ->(value) { final_value = value }
+        )
+
+        promise1.reject(1)
+        assert_equal(1, final_value)
+        promise2.reject(2)
+        assert_equal(1, final_value)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'simplecov'
+require 'minitest/autorun'
+
+require 'tilia/event'

data/tilia-event.gemspec

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'lib', 'tilia', 'event', 'version')
+Gem::Specification.new do |s|
+  s.name        = 'tilia-event'
+  s.version     = Tilia::Event::Version::VERSION
+  s.licenses    = ['BSD-3-Clause']
+  s.summary     = 'Port of the sabre-event library to ruby'
+  s.description = 'tilia-event is a library for lightweight event-based programming.'
+  s.author      = 'Jakob Sack'
+  s.email       = 'tilia@jakobsack.de'
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = 'https://github.com/tilia/tilia-event'
+  s.add_runtime_dependency 'activesupport', '~> 4.2'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: tilia-event
+version: !ruby/object:Gem::Version
+  version: 2.0.2
+platform: ruby
+authors:
+- Jakob Sack
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: tilia-event is a library for lightweight event-based programming.
+email: tilia@jakobsack.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".simplecov"
+- ".travis.yml"
+- CHANGELOG.sabre.md
+- CONTRIBUTING.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- LICENSE.sabre
+- README.md
+- Rakefile
+- lib/tilia/event.rb
+- lib/tilia/event/event_emitter.rb
+- lib/tilia/event/event_emitter_interface.rb
+- lib/tilia/event/event_emitter_trait.rb
+- lib/tilia/event/promise.rb
+- lib/tilia/event/promise_already_resolved_exception.rb
+- lib/tilia/event/version.rb
+- test/continue_callback_test.rb
+- test/event_emitter_test.rb
+- test/promise_test.rb
+- test/test_helper.rb
+- tilia-event.gemspec
+homepage: https://github.com/tilia/tilia-event
+licenses:
+- BSD-3-Clause
+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.2.5
+signing_key: 
+specification_version: 4
+summary: Port of the sabre-event library to ruby
+test_files: []
+has_rdoc: