rx_ruby 0.0.2

data/lib/rx_ruby/subscriptions/single_assignment_subscription.rb

@@ -0,0 +1,64 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+
+module RxRuby
+
+  # Represents a subscription resource which only allows a single assignment of its underlying subscription resource.
+  # If an underlying subscription resource has already been set, future attempts to set the underlying subscription resource will throw an error
+  class SingleAssignmentSubscription
+
+    def initialize
+      @gate = Mutex.new() 
+      @current = nil
+      @unsubscribed = false
+      @set = false
+    end
+
+    # Gets a value that indicates whether the object is unsubscribed.
+    def unsubscribed?
+      @gate.synchronize do
+        return @unsubscribed
+      end
+    end
+
+    # Gets the underlying subscription. After unsubscribing, the result of getting this property is undefined.
+    def subscription
+      @current
+    end
+
+    # Sets the underlying disposable. If this has already been set, then an error is raised.
+    def subscription=(new_subscription)
+      raise 'Subscription already set' if @set
+
+      @set = true
+      should_unsubscribe = false
+      old = nil
+      @gate.synchronize do
+        should_unsubscribe = @unsubscribed
+        unless should_unsubscribe
+          old = @current
+          @current = new_subscription
+        end
+      end
+
+      old.unsubscribe if old
+      new_subscription.unsubscribe if should_unsubscribe && !new_subscription.nil?            
+    end      
+
+    # Unsubscribes the underlying subscription
+    def unsubscribe
+        old = nil
+        @gate.synchronize do
+          unless @unsubscribed
+            @unsubscribed = true
+            old = @current
+            @current = nil
+          end
+        end
+
+        old.unsubscribe if old
+    end
+
+  end
+end

data/lib/rx_ruby/subscriptions/subscription.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 'thread'
+require 'singleton'
+
+module RxRuby
+  module Subscription
+    def dispose
+      unsubscribe
+    end
+  end
+  Disposable = Subscription
+
+  class EmptySubscription
+
+    include Subscription
+    include Singleton
+
+    def unsubscribe
+
+    end
+  end
+
+  class AnonymousSubscription
+    include Subscription
+
+    def initialize(&unsubscribe_action)
+      @unsubscribe_action = unsubscribe_action
+      @gate = Mutex.new
+      @unsubscribed = false
+    end
+
+    def unsubscribe
+      should_unsubscribe = false
+      @gate.synchronize do
+        should_unsubscribe = !@unsubscribed
+      end
+
+      @unsubscribe_action.call if should_unsubscribe
+    end
+  end
+
+  # Provides a set of class methods for creating Disposables.
+  module Subscription
+
+    # Creates a subscription object that invokes the specified action when unsubscribed.
+    def self.create(&unsubscribe_action)
+      AnonymousSubscription.new(&unsubscribe_action)
+    end
+
+    # Gets the subscription that does nothing when unsubscribed.
+    def self.empty
+      EmptySubscription.instance
+    end
+  end
+end

data/lib/rx_ruby/testing/cold_observable.rb

@@ -0,0 +1,45 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/subscriptions/subscription'
+require 'rx_ruby/subscriptions/composite_subscription'
+require 'rx_ruby/testing/test_subscription'
+
+module RxRuby
+
+  class ColdObservable
+
+    attr_reader :messages, :subscriptions
+
+    def initialize(scheduler, *args)
+      raise 'scheduler cannot be nil' unless scheduler
+
+      @scheduler = scheduler
+      @messages = args
+      @subscriptions = []
+    end
+
+    def subscribe(observer)
+      raise 'observer cannot be nil' unless observer
+
+      subscriptions.push(TestSubscription.new @scheduler.clock)
+      index = subscriptions.length - 1
+
+      d = CompositeSubscription.new
+
+      messages.each do |message|
+        notification = message.value
+
+        d.push(@scheduler.schedule_at_relative_with_state(nil, message.time, lambda {|scheduler1, state1|
+          notification.accept observer
+          Subscription.empty
+        }))
+      end
+
+      return Subscription.create do
+        subscriptions[index] = TestSubscription.new(subscriptions[index].subscribe, @scheduler.clock)
+        d.unsubscribe
+      end
+    end
+
+  end
+end

data/lib/rx_ruby/testing/hot_observable.rb

@@ -0,0 +1,47 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/core/observable'
+require 'rx_ruby/subscriptions/subscription'
+require 'rx_ruby/testing/test_subscription'
+
+module RxRuby
+
+  class HotObservable 
+    include Observable
+
+    attr_reader :messages, :subscriptions
+
+    def initialize(scheduler, *args)
+      raise 'scheduler cannot be nil' unless scheduler
+
+      @scheduler = scheduler
+      @messages = args
+      @subscriptions = []
+      @observers = []
+
+      @messages.each do |message|
+        notification = message.value
+        @scheduler.schedule_at_relative_with_state(nil, message.time, lambda {|scheduler1, state1|
+
+          @observers.clone.each {|observer| notification.accept observer }
+
+          Subscription.empty
+        })
+      end
+    end
+
+    def subscribe(observer)
+      raise 'observer cannot be nil' unless observer
+
+      @observers.push observer
+      subscriptions.push (TestSubscription.new @scheduler.clock)
+
+      index = subscriptions.length - 1
+
+      Subscription.create do 
+        @observers.delete observer
+        subscriptions[index] = TestSubscription.new(subscriptions[index].subscribe, @scheduler.clock)
+      end
+    end
+  end
+end

data/lib/rx_ruby/testing/mock_observer.rb

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/notification'
+require 'rx_ruby/testing/recorded'
+
+module RxRuby
+
+  class MockObserver
+    include Observer
+
+    attr_reader :messages
+
+    def initialize(scheduler)
+      raise 'scheduler cannot be nil' unless scheduler
+
+      @scheduler = scheduler
+      @messages = []
+    end
+
+    def on_next(value)
+      messages.push(Recorded.new(@scheduler.clock, Notification.create_on_next(value)))
+    end
+
+    def on_error(error)
+      messages.push(Recorded.new(@scheduler.clock, Notification.create_on_error(error)))
+    end
+
+    def on_completed
+      messages.push(Recorded.new(@scheduler.clock, Notification.create_on_completed))
+    end
+  end
+end

data/lib/rx_ruby/testing/reactive_test.rb

@@ -0,0 +1,94 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/core/notification'
+require 'rx_ruby/testing/recorded'
+
+module RxRuby
+
+  # Module to write unit tests for applications and libraries built using Reactive Extensions.
+  module ReactiveTest
+
+    # Default virtual time used for creation of observable sequences in ReactiveTest-based unit tests.
+    CREATED = 100
+
+    # Default virtual time used to subscribe to observable sequences in ReactiveTest-based unit tests.
+    SUBSCRIBED = 200
+
+    # Default virtual time used to dispose subscriptions in ReactiveTest-based unit tests.
+    DISPOSED = 1000
+
+    # Factory method for an on_next notification record at a given time with a given value.
+    def on_next(ticks, value)
+      Recorded.new(ticks, Notification.create_on_next(value))
+    end
+
+    # Factory method for writing an assert that checks for an on_next notification record at a given time, using the specified predicate to check the value.
+    def on_next_predicate(ticks, &block)
+      n = OnNextPredicate.new(&block)
+      Recorded.new(ticks, n)
+    end
+
+    # Factory method for an on_error notification record at a given time with a given error.
+    def on_error(ticks, error)
+      Recorded.new(ticks, Notification.create_on_error(error))
+    end
+
+    # Factory method for writing an assert that checks for an on_error notification record at a given time, using the specified predicate to check the exception.
+    def on_error_predicate(ticks, &block)
+      n = OnErrorPredicate.new(&block)
+      Recorded.new(ticks, n)
+    end
+
+    # Factory method for an OnCompleted notification record at a given time.
+    def on_completed(ticks)
+      Recorded.new(ticks, Notification.create_on_completed)
+    end
+
+    # Factory method for a subscription record based on a given subscription and unsubscribe time.
+    def subscribe(subscribe, unsubscribe)
+      TestSubscription.new(subscribe, unsubscribe)
+    end
+
+    def assert_messages(expected, actual)
+      assert_equal expected.length, actual.length, "The size of messages differ"
+
+      for i in 0..expected.length - 1
+        assert_equal expected[i].time, actual[i].time, "The messages[#{i}].time differ"
+        assert_equal expected[i].value, actual[i].value, "The messages[#{i}].value differ"
+      end
+    end
+
+    def assert_subscriptions(expected, actual)
+      assert_equal expected.length, actual.length
+
+      for i in 0..expected.length - 1
+        assert (expected[i] == actual[i])
+      end      
+    end
+
+    class OnNextPredicate
+
+      def initialize(&action)
+        @action = action
+      end
+
+      def ==(other)
+        other && other.on_next? && @action.call(other.value)
+      end
+      alias_method :eql?, :==
+    end
+
+    class OnErrorPredicate
+
+      def initialize(&action)
+        @action = action
+      end
+
+      def ==(other)
+        other && other.on_error? && @action.call(other.error)
+      end
+      alias_method :eql?, :==
+    end    
+
+  end
+end

data/lib/rx_ruby/testing/recorded.rb

@@ -0,0 +1,17 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+
+  # Record of a value including the virtual time it was produced on.
+  class Recorded < Struct.new(:time, :value)
+
+    def initialize(time, value)
+      super
+    end    
+
+    def to_s
+      "#{value} @ #{time}"
+    end
+
+  end
+end

data/lib/rx_ruby/testing/test_scheduler.rb

@@ -0,0 +1,96 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/virtual_time_scheduler'
+require 'rx_ruby/subscriptions/subscription'
+require 'rx_ruby/testing/cold_observable'
+require 'rx_ruby/testing/hot_observable'
+require 'rx_ruby/testing/mock_observer'
+require 'rx_ruby/testing/reactive_test'
+
+module RxRuby
+
+  # Virtual time scheduler used for testing applications and libraries built using Reactive Extensions.
+  class TestScheduler < VirtualTimeScheduler
+
+    def initialize
+      super(0)
+    end
+
+    # Schedules an action to be executed at due_time.
+    def schedule_at_absolute_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+      
+      due_time = clock + 1 if due_time <= clock
+
+      super(state, due_time, action)
+    end
+
+    # Adds a relative virtual time to an absolute virtual time value.
+    def add(absolute, relative)
+      absolute + relative
+    end
+
+    # Converts the absolute time value to a Time value.
+    def to_time(absolute)
+      Time.at absolute
+    end
+
+    # Converts the time span value to a relative time value.
+    def to_relative(time_span)
+      time_span
+    end    
+
+    # Starts the test scheduler and uses the specified virtual times to invoke the factory function, subscribe to the resulting sequence, and unsubscribe the subscription.
+    def configure(options = {})
+      options.each {|key,_|
+        unless [:created, :subscribed, :disposed].include? key
+          raise ArgumentError, "Should be spcified whether :created, :subscribed or :disposed, but the #{key.inspect}"
+        end
+      }
+      o = {
+        :created    => ReactiveTest::CREATED,
+        :subscribed => ReactiveTest::SUBSCRIBED,
+        :disposed   => ReactiveTest::DISPOSED
+      }.merge(options)
+
+      source = nil
+      subscription = nil
+      observer = create_observer
+
+      schedule_at_absolute_with_state(nil, o[:created], lambda {|scheduler, state|
+        source = yield
+        Subscription.empty
+      })
+
+      schedule_at_absolute_with_state(nil, o[:subscribed], lambda {|scheduler, state|
+        subscription = source.subscribe observer
+        Subscription.empty
+      })
+
+       schedule_at_absolute_with_state(nil, o[:disposed], lambda {|scheduler, state|
+        subscription.unsubscribe
+        Subscription.empty
+      })
+
+      start
+      
+      observer           
+    end
+
+    # Creates a hot observable using the specified timestamped notification messages.
+    def create_hot_observable(*args)
+      HotObservable.new(self, *args)
+    end
+
+    # Creates a cold observable using the specified timestamped notification messages.
+    def create_cold_observable(*args)
+      ColdObservable.new(self, *args)
+    end
+
+    # Creates an observer that records received notification messages and timestamps those.
+    def create_observer
+      MockObserver.new self
+    end
+
+  end
+end