rx_ruby 0.0.2

data/lib/rx_ruby/concurrency/virtual_time_scheduler.rb

@@ -0,0 +1,170 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/scheduler'
+require 'rx_ruby/internal/priority_queue'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  # Base class for virtual time schedulers using a priority queue for scheduled items.
+  class VirtualTimeScheduler
+
+    include Scheduler
+
+    attr_reader :clock
+
+    def initialize(initial_clock)
+      @clock = initial_clock.to_i
+      @queue = PriorityQueue.new
+      @enabled = false
+    end
+
+    # Gets the scheduler's notion of current time.
+    def now
+      clock
+    end
+
+    # Gets whether the scheduler is enabled to run work.
+    def enabled?
+      @enabled
+    end
+
+    # Starts the virtual time scheduler.
+    def start
+      unless @enabled
+        @enabled = true
+
+        begin
+          next_item = self.get_next
+
+          unless next_item.nil?
+            @clock = next_item.due_time if next_item.due_time > @clock
+            next_item.invoke
+          else
+            @enabled = false
+          end
+
+        end while @enabled
+      end
+    end  
+
+    # Stops the virtual time scheduler.
+    def stop
+      @enabled = false
+    end
+
+    # Schedules an action to be executed.
+    def schedule_with_state(state, action)
+      raise 'action cannot be nil' unless action
+      schedule_at_absolute_with_state(state, clock, action)
+    end
+
+    # Schedules an action to be executed at due_time.
+    def schedule_at_relative(due_time, action)
+      raise 'action cannot be nil' unless action
+
+      schedule_at_relative_with_state(action, due_time, method(:invoke))
+    end
+
+    # Schedules an action to be executed at due_time.
+    def schedule_at_relative_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+
+      schedule_at_absolute_with_state(state, @clock + due_time, action)
+    end
+    alias_method :schedule_relative_with_state, :schedule_at_relative_with_state
+
+    # Schedules an action to be executed at due_time.
+    def schedule_at_absolute(due_time, action)
+      raise 'action cannot be nil' unless action
+
+      schedule_at_absolute_with_state(action, due_time, method(:invoke))      
+    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
+
+      si = nil
+      run = lambda {|scheduler, state1|
+        @queue.delete si
+        action.call(scheduler, state1)
+      }
+
+      si = ScheduledItem.new(self, state, due_time, &run)
+      @queue.push si
+
+      Subscription.create { si.cancel }
+    end
+    alias_method :schedule_absolute_with_state, :schedule_at_absolute_with_state
+
+    # Advances the scheduler's clock to the specified time, running all work till that point.
+    def advance_to(time)
+      due_to_clock = time<=>clock
+      raise 'Time is out of range' if due_to_clock < 0 
+
+      return if due_to_clock == 0
+
+      unless @enabled
+        @enabled = true
+
+        begin
+          next_item = self.get_next
+          if !next_item.nil? && next_item.due_time <= time
+            @clock = next_item.due_time if next_item.due_time > @clock
+            next_item.invoke
+          else
+            @enabled = false
+          end
+
+        end while @enabled
+
+        @clock = time
+      else
+        raise 'Cannot advance while running'
+      end
+
+    end
+
+    # Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan.
+    def advance_by(time)
+      dt = @clock + time
+
+      due_to_clock = dt<=>clock
+      raise 'Time is out of range' if due_to_clock < 0
+
+      return if due_to_clock == 0
+      raise 'Cannot advance while running' if @enabled
+
+      self.advance_to dt
+    end  
+
+    # Advances the scheduler's clock by the specified relative time.
+    def sleep(time)
+      dt = @clock + time
+
+      due_to_clock = dt<=>@clock
+      raise 'Time is out of range' if due_to_clock < 0
+
+      @clock = dt
+    end
+
+    # Gets the next scheduled item to be executed
+    def get_next
+      while next_item = @queue.peek
+        if next_item.cancelled?
+          @queue.shift
+        else
+          return next_item
+        end
+      end
+
+      return nil
+    end
+
+    def invoke(scheduler, action)
+      action.call
+      Subscription.empty
+    end
+  end
+end

data/lib/rx_ruby/core/async_lock_observer.rb

@@ -0,0 +1,46 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/async_lock'
+require 'rx_ruby/core/observer'
+
+module RxRuby
+
+  module Observer
+
+    class << self
+      # Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access.
+      # This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock.
+      def prevent_reentrancy(observer, gate = AsyncLock.new)
+        AsyncLockObserver.new(observer, gate)
+      end
+    end
+  end
+
+  class AsyncLockObserver < RxRuby::ObserverBase
+
+    def on_next_core(value)
+      @gate.wait { @observer.on_next value }
+    end
+
+    def on_error_core(error)
+      @gate.wait { @observer.on_error error }
+    end
+
+    def on_completed_core
+      @gate.wait { @observer.on_completed }
+    end
+
+    def initialize(observer, gate)
+      @observer = observer
+      @gate = gate
+
+      config = ObserverConfiguration.new
+      config.on_next(&method(:on_next_core))
+      config.on_error(&method(:on_error_core))
+      config.on_completed(&method(:on_completed_core))
+
+      super(config)
+    end
+
+  end
+end

data/lib/rx_ruby/core/auto_detach_observer.rb

@@ -0,0 +1,59 @@
+# 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/subscriptions/single_assignment_subscription'
+
+module RxRuby
+
+  class AutoDetachObserver < RxRuby::ObserverBase
+
+    def on_next_core(value) 
+      no_error = false
+      begin
+        @observer.on_next(value)
+        no_error = true
+      ensure
+        unsubscribe unless no_error
+      end
+    end
+
+    def on_error_core(error)
+      begin
+        @observer.on_error(error)
+      ensure
+        unsubscribe
+      end
+    end
+
+    def on_completed_core
+      begin
+        @observer.on_completed
+      ensure
+        unsubscribe
+      end
+    end
+
+    def initialize(observer)
+      @observer = observer
+      @m = SingleAssignmentSubscription.new
+
+      config = ObserverConfiguration.new
+      config.on_next(&method(:on_next_core))
+      config.on_error(&method(:on_error_core))
+      config.on_completed(&method(:on_completed_core))
+
+      super(config)
+    end
+
+    def subscription=(new_subscription)
+      @m.subscription = new_subscription
+    end
+
+    def unsubscribe
+      super
+      @m.unsubscribe
+    end
+
+  end
+end
+

data/lib/rx_ruby/core/checked_observer.rb

@@ -0,0 +1,66 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+require 'rx_ruby/core/observer'
+
+module RxRuby
+
+  module Observer
+    # Checks access to the observer for grammar violations. This includes checking for multiple on_error or on_completed calls, as well as reentrancy in any of the observer methods.
+    # If a violation is detected, an error is thrown from the offending observer method call.
+    def checked
+      CheckedObserver.new(self)
+    end
+  end
+
+  class CheckedObserver
+    include Observer
+
+    def initialize(observer)
+      @observer = observer
+      @state = :idle
+    end
+
+    def on_next(value)
+      check_access
+      begin
+        @observer.on_next value
+      ensure
+        Mutex.new.synchronize { @state = :idle }
+      end
+    end
+
+    def on_error(error)
+      check_access
+      begin
+        @observer.on_error error
+      ensure
+        Mutex.new.synchronize { @state = :done }
+      end
+    end
+
+    def on_completed
+      check_access
+      begin
+        @observer.on_completed
+      ensure
+        Mutex.new.synchronize { @state = :done }
+      end
+    end
+
+    private
+
+    def check_access
+      Mutex.new.synchronize do 
+        old = @state
+        @state = :busy if @state == :idle
+        case old
+        when :busy
+          raise 'Re-entrancy detected'
+        when :done
+          raise 'Observer terminated'
+        end
+      end
+    end
+  end
+end

data/lib/rx_ruby/core/notification.rb

@@ -0,0 +1,161 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/immediate_scheduler'
+require 'rx_ruby/core/observable'
+
+module RxRuby
+
+  module Observer
+
+    class << self
+    # Creates an observer from a notification callback.
+      def from_notifier
+        raise ArgumentError.new 'Block required' unless block_given?
+
+        configure do |o|
+          o.on_next      {|x| yield Notification.create_on_next(x) }
+          o.on_error     {|err| yield Notification.create_on_error(err) }
+          o.on_completed { yield Notification.create_on_completed }
+        end
+      end
+    end
+  end
+
+  # Represents a notification to an observer.
+  module Notification
+
+    class << self
+
+      # Creates an object that represents an on_next notification to an observer.
+      def create_on_next(value)
+        OnNextNotification.new value
+      end
+
+      # Creates an object that represents an on_error notification to an observer.
+      def create_on_error(error)
+        OnErrorNotification.new error
+      end
+
+      # Creates an object that represents an on_completed notification to an observer.
+      def create_on_completed
+        OnCompletedNotification.new
+      end
+
+    end
+
+    # Determines whether this is an on_next notification.
+    def on_next?
+      @kind == :on_next
+    end
+
+    # Determines whether this is an on_error notification.
+    def on_error?
+      @kind == :on_error
+    end
+
+    # Determines whether this is an on_completed notification.
+    def on_completed?
+      @kind == :on_completed
+    end
+
+    # Determines whether this notification has a value.
+    def has_value?
+      false
+    end
+
+    # Returns an observable sequence with a single notification.
+    def to_observable(scheduler = ImmediateScheduler.instance)
+      AnonymousObservable.new do |observer|
+        scheduler.schedule lambda {
+          accept observer
+          observer.on_completed if on_next?
+        }
+      end
+    end
+
+  end
+
+  # Represents an on_next notification to an observer.
+  class OnNextNotification
+    include Notification
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+      @kind = :on_next
+    end
+
+    # Determines whether this notification has a value.
+    def has_value?
+      true
+    end
+
+    def ==(other)
+      other.class == self.class && other.on_next? && value == other.value
+    end
+    alias_method :eql?, :==
+
+    def to_s
+      "on_next(#{value})"
+    end
+
+    # Invokes the observer's method corresponding to the notification.
+    def accept(observer)
+      observer.on_next value
+    end
+
+  end
+
+  # Represents an on_error notification to an observer.
+  class OnErrorNotification
+    include Notification
+
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+      @kind = :on_error
+    end
+
+    def ==(other)
+      other.class == self.class && other.on_error? && error == other.error
+    end
+    alias_method :eql?, :==
+
+    def to_s
+      "on_error(#{error})"
+    end
+
+    # Invokes the observer's method corresponding to the notification.
+    def accept(observer)
+      observer.on_error error
+    end
+
+  end
+
+  # Represents an on_completed notification to an observer.
+  class OnCompletedNotification
+    include Notification
+
+    def initialize
+      @kind = :on_completed
+    end
+
+    def ==(other)
+      other.class == self.class && other.on_completed?
+    end
+    alias_method :eql?, :==
+
+    def to_s
+      "on_completed()"
+    end
+
+    # Invokes the observer's method corresponding to the notification.
+    def accept(observer)
+      observer.on_completed
+    end    
+
+  end
+
+end