rx 0.0.2

data/lib/rx_ruby/testing/test_subscription.rb

@@ -0,0 +1,22 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+
+  # Records information about subscriptions to and unsubscriptions from observable sequences.
+  class TestSubscription < Struct.new(:subscribe, :unsubscribe)
+
+    FIXNUM_MAX = Float::MAX.to_i
+
+    def initialize(subscribe, unsubscribe = FIXNUM_MAX)
+      super
+    end
+
+    def infinite?
+      unsubscribe == FIXNUM_MAX
+    end
+    
+    def to_s
+      "#{subscribe}, #{infinite? ? 'Infinite' : unsubscribe}"
+    end
+  end
+end

data/lib/rx_ruby/version.rb

@@ -0,0 +1,3 @@
+module RxRuby
+  VERSION = '0.0.2'
+end

data/license.txt

@@ -0,0 +1,13 @@
+Copyright (c) Microsoft Open Technologies.  All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You may
+obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions
+and limitations under the License.

data/readme.md

@@ -0,0 +1,152 @@
+[![Build Status](https://travis-ci.org/ReactiveX/RxRuby.svg?branch=master)](https://travis-ci.org/ReactiveX/RxRuby)
+[![GitHub version](http://img.shields.io/github/tag/ReactiveX/RxRuby.svg)](https://github.com/ReactiveX/RxRuby)
+[![Downloads](http://img.shields.io/gem/dt/rx.svg)](https://npmjs.org/package/rx)
+[![Code Climate](https://codeclimate.com/github/ReactiveX/RxRuby/badges/gpa.svg)](https://codeclimate.com/github/ReactiveX/RxRuby)
+
+**[The Need to go Reactive](#the-need-to-go-reactive)** |
+**[About the Reactive Extensions](#about-the-reactive-extensions)** |
+**[Why RxRuby?](#why-rxruby)** |
+**[Contributing](#contributing)** |
+**[License](#license)**
+
+# The Reactive Extensions for Ruby (RxRuby) <sup>0.1</sup>... #
+*...is a set of libraries to compose asynchronous and event-based programs using observable collections and Enumerable module style composition in Ruby*
+
+## The Need to go Reactive ##
+
+Reactive Programming is a hot topic as of late, especially with such things as the [Reactive Manifesto](http://www.reactivemanifesto.org/).  Applications needs have changed over time with simple polling for data, to a full reactive system where data is pushed at you.  Each time, we're adding more complexity, more data, and asynchronous behavior to our applications.  How do we manage it all?  How do we scale it?  By moving towards "Reactive Architectures" which are event-driven, resilient and responsive.  With the Reactive Extensions, you have all the tools you need to help build these systems.
+
+## About the Reactive Extensions ##
+
+The Reactive Extensions for Ruby (RxRuby) is a set of libraries for composing asynchronous and event-based programs using observable sequences and fluent query operators that many of you already know by with the  in Ruby. Using RxRuby, developers represent asynchronous data streams with Observables, query asynchronous data streams using our many operators, and parameterize the concurrency in the asynchronous data streams using Schedulers. Simply put, RxRuby = Observables + Operators + Schedulers.
+
+When you're authoring applications with Ruby, there may be times when you want to deal with asynchronous programming and event-based programming, and synchronization is difficult and error prone.
+
+Using RxRuby, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer module. The Observable notifies the subscribed Observer instance whenever an event occurs.
+
+Because observable sequences are data streams, you can query them using standard query operators implemented by the Observable module. Thus you can filter, project, reduce, compose and perform time-based operations on multiple events easily by using these our many operators. In addition, there are a number of other reactive stream specific operators that allow powerful queries to be written. Cancellation, exceptions, and synchronization are also handled gracefully by using the methods on the Observable module.
+
+But the best news of all is that you already know how to program like this.  Take for example the following Ruby code, where we get some stock data and then manipulate and then iterate the results.
+
+```ruby
+# Get evens and square each
+someSource
+  .select {|x| x.even? }
+  .map {|x| x * x }
+  .each {|x| puts x.to_s }
+```
+
+Using RxRuby, you can accomplish the same kind of thing with a push based collection with little to no change to your code at all, changing `each` to `subscribe`.
+
+```ruby
+someSource
+  .select {|x| x.even? }
+  .map {|x| x * x }
+  .subscribe {|x| puts x.to_s }
+```
+
+## Why RxRuby? ##
+
+The overall goal of [RxRuby](https://github.com/ReactiveX/RxRuby) is to have a push based version of the [Enumerable module](http://www.ruby-doc.org/core-2.1.0/Enumerable.html) with an added notion of time.  Right now, the [Observable module](http://ruby-doc.org/stdlib-1.9.3/libdoc/observer/rdoc/Observable.html) is not quite what we want because it does not allow for composition.  That is no more than a simple implementation of the Subject/Observer pattern from the Gang of Four book, such as the following.
+
+```ruby
+require 'observer'
+
+class ArrayObservable
+  include Observable
+
+  def initialize(array)
+    @array = array
+  end
+
+  def run
+  	index = 0
+
+  	while index < @array.length
+      change #notify of change
+      notify_observers @array[index] # send the current value
+      index += 1
+      sleep 1
+  	end
+  end
+end
+
+class ArrayObserver
+  def initialize(observable)
+    observable.add_observer(self)
+  end
+
+  def update(item)
+  	puts item.to_s
+  end
+end
+
+observable = ArrayObservable [1,2]
+observer = ArrayObserver.new(observable)
+# 1
+# 2
+```
+
+But, how do you enable better composition so that you can compose together Observable instances?  In this current model, this can't happen.  That's why we need the Reactive Extensions for Ruby.  Not only that, but we can at any point in the computation, change the concurrency model to be immediate, on a new thread, or on another machine.
+
+There are many implementations of the Reactive Extensions such as [RxJS](https://github.com/Reactive-Extensions/RxJS), [Rx.NET](https://github.com/reactive-extensions/rx.net), [Java/JVM/Clojure/Scala/JRuby/Groovy](https://github.com/Netflix/RxJava) and [ObjC/ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa).  Our goal is to have one operate like the JRuby one, but be available to all users of Ruby regardless of VM.
+
+We'd like it to be much like our JavaScript version, [RxJS](https://github.com/Reactive-Extensions/RxJS) but be able to handle multi-threading, parallelism, and in addition, go across the network.
+
+Instead, our goal is to make the Observable module look exactly like the Enumerable module in that you can write any query method over it to produce a value, but have it push based.  This could become yet another competitor to [EventMachine](http://rubyeventmachine.com/) in which we have rich composition over events, whether locally or across the network.
+
+So, take an example, zipping two Arrays.
+
+```ruby
+a = [ 4, 5, 6 ]
+b = [ 7, 8, 9 ]
+
+[1, 2, 3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+[1, 2].zip(a, b)         #=> [[1, 4, 7], [2, 5, 8]]
+a.zip([1, 2], [8])       #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
+```
+
+Now, we could do something similar in [RxRuby](https://github.com/ReactiveX/RxRuby) with two observable sequences:
+
+```ruby
+require 'rx_ruby'
+
+a = RxRuby::Observable.from_array [ 4, 5, 6 ]
+b = RxRuby::Observable.from_array [ 7, 8, 9 ]
+
+sub = a.zip(b).subscribe {|arr| puts arr.to_s }
+# => "[4, 7]"
+# => "[5, 8]"
+# => "[6, 9]"
+
+# unsubscribes from the sequence and cleans up anything
+sub.unsubscribe
+```
+
+The difference here is that `zip` returns an `RxRuby::Observable` instead of an `Enumerable`.  And once you call `subscribe` it's much like `each` but takes an observer, or perhaps just some blocks, lambdas, etc.  The subscription handed back contains the cancellation logic.  For example, if you are listening to events and you no longer want to listen, then you can call `unsubscribe` on the `sub` variable above.
+
+What's the end goal?  The first part is where we want to support the main `Enumerable` module methods in the `Observable` module and have them react the same way, but push instead of pull based.  Then from there, we can explore such things as multi-threading, and calls across the network.
+
+If you want to find out more, please check out the JavaScript version, [RxJS](https://github.com/Reactive-Extensions/RxJS), which has more details on the overall goals.  
+
+Our overall goal is to make this one of the best Rx libraries out there, better than RxJS, RxPy, ReactiveCocoa, RxJava, etc, all while maintaining the "Ruby Way".
+
+## Contributing ##
+
+You can contribute by reviewing and sending feedback on code checkins, suggesting and trying out new features as they are implemented, submit bugs and help us verify fixes as they are checked in, as well as submit code fixes or code contributions of your own. Note that all code submissions will be rigorously reviewed and tested by the Rx Team, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source.
+
+## License ##
+
+Copyright (c) Microsoft Open Technologies, Inc.  All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you
+may not use this file except in compliance with the License. You may
+obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions
+and limitations under the License.

data/rx_ruby.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rx_ruby/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Microsoft Open Technologies, Inc."]
+  gem.description   = %q{Reactive Extensions for Ruby}
+  gem.summary       = %q{This is an implementation of the Reactive Extensions for Ruby. Note that this is an early prototype, but contributions are welcome.}
+  gem.homepage      = "https://github.com/ReactiveX/RxRuby"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rx"
+  gem.require_paths = ["lib"]
+  gem.version       = RxRuby::VERSION
+  gem.license       = 'Apache License, v2.0'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'simplecov'
+end

data/test/rx_ruby/concurrency/helpers/historical_virtual_scheduler_helper.rb

@@ -0,0 +1,135 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module HistoricalVirtualSchedulerTestHelper
+
+  # Scheduler state
+
+  def test_disabled_by_default
+    assert_equal(false, @scheduler.enabled?)
+  end
+
+  def test_disabled_once_out_of_tasks
+    @scheduler.start
+    assert_equal(false, @scheduler.enabled?)
+  end
+
+  def test_enabled_while_running
+    @scheduler.schedule ->() { assert_equal(true, @scheduler.enabled?) }
+    @scheduler.start
+  end
+
+  def test_stop
+    @scheduler.schedule ->() { @scheduler.stop }
+    @scheduler.schedule ->() { flunk "Should be stopped" }
+    @scheduler.start
+
+    assert_equal(false, @scheduler.enabled?)
+  end
+
+  def test_now
+    assert_equal(@start, @scheduler.now)
+  end
+
+  def test_clock
+    assert_equal @start, @scheduler.clock
+  end
+
+  # Relative Scheduling
+
+  def test_relative_with_state
+    state = []
+    task  = ->(_, s) { s.push 1 }
+    @scheduler.schedule_at_relative_with_state(state, 2, task)
+    @scheduler.start
+
+    assert_equal([1], state)
+    assert_equal(@start + 2, @scheduler.now)
+  end
+
+  def test_relative
+    ran  = false
+    task = ->() { ran = true }
+    @scheduler.schedule_at_relative(2, task)
+    @scheduler.start
+
+    assert_equal(true, ran)
+    assert_equal(@start + 2, @scheduler.now)
+  end
+
+  # Absolute Scheduling
+
+  def test_absolute_with_state
+    state = []
+    time  = @start + 2
+    task  = ->(_, s) { s.push 1 }
+    @scheduler.schedule_at_absolute_with_state(state, time, task)
+    @scheduler.start
+
+    assert_equal([1], state)
+    assert_equal(time, @scheduler.now)
+  end
+
+  def test_absolute
+    ran   = false
+    time  = @start + 2
+    task  = ->() { ran = true }
+    @scheduler.schedule_at_absolute(time, task)
+    @scheduler.start
+
+    assert_equal(true, ran)
+    assert_equal(time, @scheduler.now)
+  end
+
+  # Time manipulation
+
+  def test_advance
+    ran     = false
+    task    = ->() { ran = true }
+    failure = ->() { flunk "Should never reach." }
+
+    @scheduler.schedule_at_absolute(@start + 10, task)
+    @scheduler.schedule_at_absolute(@start + 11, failure)
+    @scheduler.advance_to(@start + 10)
+
+    assert_equal(true, ran)
+    assert_equal(@start + 10, @scheduler.now)
+  end
+
+  def test_advance_raises_if_running
+    task = ->() do
+      assert_raises(RuntimeError) { @scheduler.advance_to(@start + 10) }
+    end
+
+    @scheduler.schedule task
+    @scheduler.start
+  end
+
+  def test_advance_by
+    ran     = false
+    task    = ->() { ran = true }
+    failure = ->() { flunk "Should never reach." }
+
+    @scheduler.schedule_at_relative(10, task)
+    @scheduler.schedule_at_relative(11, failure)
+    @scheduler.advance_by(10)
+
+    assert_equal(true, ran)
+    assert_equal(@start + 10, @scheduler.now)
+  end
+
+  def test_advance_raises_if_out_of_range
+    assert_raises(RuntimeError) { @scheduler.advance_by(-10) }
+  end
+
+  def test_sleep
+    failure = ->() { flunk "Should not run." }
+    @scheduler.schedule_at_relative(10, failure)
+    @scheduler.sleep(20)
+
+    assert_equal(@start + 20, @scheduler.now)
+  end
+
+  def test_sleep_raises_if_out_of_range
+    assert_raises(RuntimeError) { @scheduler.sleep(-10) }
+  end
+end

data/test/rx_ruby/concurrency/helpers/immediate_local_scheduler_helper.rb

@@ -0,0 +1,51 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+module ImmediateLocalSchedulerTestHelper
+  def test_now
+    assert_equal(Time.now.to_i, @scheduler.now.to_i)
+  end
+
+  def test_schedule_with_state
+    state = []
+    task  = ->(_, s) { s << 1 }
+    @scheduler.schedule_with_state(state, task)
+
+    assert_equal([1], state)
+  end
+
+  def test_schedule_with_state_simple_absolute
+    state = []
+    task  = ->(_, s) { s << 1 }
+    @scheduler.schedule_absolute_with_state(state, Time.now, task)
+
+    assert_equal([1], state)
+  end
+
+  def test_schedule_recursive_absolute_with_state_simple
+    state = []
+    inner = ->(_, s) { s << 1 }
+    outer = ->(s, x) { s.schedule_absolute_with_state(x, Time.now, inner) }
+    @scheduler.schedule_absolute_with_state(state, Time.now, outer)
+
+    assert_equal([1], state)
+  end
+
+  def test_schedule_with_state_simple_relative
+    state = []
+    task  = ->(_, s) { s << 1 }
+    @scheduler.schedule_relative_with_state(state, 0, task)
+
+    assert_equal([1], state)
+  end 
+
+  def test_schedule_recursive_relative_with_state_simple
+    state = []
+    inner = ->(_, s) { s << 1 }
+    outer = ->(sched, s) { sched.schedule_relative_with_state(s, 1, inner) }
+    @scheduler.schedule_relative_with_state(state, 1, outer)
+
+    assert_equal([1], state)
+  end 
+end

data/test/rx_ruby/concurrency/test_async_lock.rb

@@ -0,0 +1,56 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+class TestAsyncLock < Minitest::Test
+  def setup
+    @lock = RxRuby::AsyncLock.new
+  end
+
+  def test_simple_wait
+    called = false
+    @lock.wait { called = true }
+    assert_equal(true, called)
+  end
+
+  def test_parallel_wait
+    state = [false, false]
+    sync  = [Queue.new, Queue.new]
+
+    thread1 = Thread.new do
+      sync[0].pop
+      @lock.wait do
+        sync[1].push 1
+        sync[0].pop
+        state[0] = true
+      end
+      state.each { |s| assert_equal(true, s) }
+    end
+
+    thread2 = Thread.new do
+      sync[1].pop
+      @lock.wait do
+        assert_equal(thread1, Thread.current)
+        state[1] = true
+      end
+      state.each { |s| assert_equal(false, s) }
+      sync[0].push 1
+    end
+
+    sync[0].push 1
+    [thread1, thread2].each(&:join)
+  end
+
+  def test_clear
+    @lock.clear
+    called = false
+    @lock.wait { called = true }
+    assert_equal(false, called)
+  end
+
+  def test_exceptions_bubble_up_and_fault
+    assert_raises(StandardError) { @lock.wait { raise StandardError } }
+    assert_equal(true, @lock.send(:instance_variable_get, :@has_faulted))
+    assert_equal([], @lock.send(:instance_variable_get, :@queue))
+  end
+end