rx 0.0.2

data/lib/rx_ruby/core/observable.rb

@@ -0,0 +1,104 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'rx_ruby/concurrency/current_thread_scheduler'
+require 'rx_ruby/concurrency/immediate_scheduler'
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/auto_detach_observer'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  module Observable
+
+    def subscribe(*args)
+      case args.size
+      when 0
+        if block_given?
+          _subscribe Observer.configure {|o| o.on_next(&Proc.new) }
+        else
+          _subscribe Observer.configure
+        end
+      when 1
+        _subscribe args[0]
+      when 3
+        _subscribe Observer.configure {|o|
+          o.on_next(&args[0])
+          o.on_error(&args[1])
+          o.on_completed(&args[2])
+        }
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0..1 or 3)"
+      end
+    end
+
+    # Subscribes the given observer to the observable sequence.
+    # @param [Observer] observer
+    # @return [Subscription]
+    def _subscribe(observer)
+
+      auto_detach_observer = AutoDetachObserver.new observer
+
+      if CurrentThreadScheduler.schedule_required?
+        CurrentThreadScheduler.instance.schedule_with_state auto_detach_observer, method(:schedule_subscribe)
+      else
+        begin
+          auto_detach_observer.subscription = subscribe_core auto_detach_observer
+        rescue => e
+          raise e unless auto_detach_observer.fail e
+        end
+      end
+
+      auto_detach_observer
+    end
+
+    # Subscribes the given block to the on_next action of the observable sequence.
+    # @param [Object] block
+    # @return [Subscription]
+    def subscribe_on_next(&block)
+      raise ArgumentError.new 'Block is required' unless block_given?
+      subscribe(Observer.configure {|o| o.on_next(&block) })
+    end
+
+    # Subscribes the given block to the on_error action of the observable sequence.
+    def subscribe_on_error(&block)
+      raise ArgumentError.new 'Block is required' unless block_given?
+      subscribe(Observer.configure {|o| o.on_error(&block) })
+    end
+
+    # Subscribes the given block to the on_completed action of the observable sequence.
+    def subscribe_on_completed(&block)
+      raise ArgumentError.new 'Block is required' unless block_given?
+      subscribe(Observer.configure {|o| o.on_completed(&block) })
+    end
+
+    private
+
+    def schedule_subscribe(_, auto_detach_observer)
+      begin
+        auto_detach_observer.subscription = subscribe_core auto_detach_observer
+      rescue => e
+        raise e unless auto_detach_observer.fail e
+      end
+
+      Subscription.empty
+    end
+
+  end
+
+  class AnonymousObservable
+
+    include Observable
+
+    def initialize(&subscribe)
+      @subscribe = subscribe
+    end
+
+    protected
+
+    def subscribe_core(obs)
+      @subscribe.call(obs) || Subscription.empty
+    end
+
+  end
+
+end

data/lib/rx_ruby/core/observe_on_observer.rb

@@ -0,0 +1,50 @@
+# 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/scheduled_observer'
+
+module RxRuby
+
+  module Observer
+    # Schedules the invocation of observer methods on the given scheduler.
+    def notify_on(scheduler)
+      ObserveOnObserver.new(scheduler, self, nil)
+    end
+  end
+
+  class ObserveOnObserver < ScheduledObserver
+
+    def initialize(scheduler, observer, cancel = nil)
+      @cancel = cancel
+
+      super(scheduler, observer)      
+    end
+
+    def on_next_core(value)
+      ensure_active
+      super(value)
+    end
+
+    def on_error_core(error)
+      ensure_active
+      super(error)
+    end
+
+    def on_completed_core
+      ensure_active
+      super
+    end
+
+    def unsubscribe
+      super
+
+      cancel = nil
+      Mutex.new.synchronize do
+        cancel = @cancel
+        @cancel = nil
+      end
+
+      canel.unsubscribe if cancel
+    end
+  end
+end

data/lib/rx_ruby/core/observer.rb

@@ -0,0 +1,119 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+
+  # Configuration class for storing Observer actions
+  class ObserverConfiguration
+
+    DEFAULT_ON_NEXT = lambda {|x| }
+    DEFAULT_ON_ERROR = lambda {|error| raise error }
+    DEFAULT_ON_COMPLETED = lambda { }
+
+    attr_reader :on_next_action, :on_error_action, :on_completed_action
+
+    def initialize
+      @on_next_action = DEFAULT_ON_NEXT
+      @on_error_action = DEFAULT_ON_ERROR
+      @on_completed_action = DEFAULT_ON_COMPLETED
+    end
+
+    def on_next(&on_next_action)
+      @on_next_action = on_next_action
+    end
+
+    def on_error(&on_error_action)
+      @on_error_action = on_error_action
+    end
+
+    def on_completed(&on_completed_action)
+      @on_completed_action = on_completed_action
+    end    
+  end
+
+  # Module for all Observers
+  module Observer
+
+    # Hides the identity of an observer.
+    def as_observer
+      Observer.configure do |o|
+        o.on_next(&method(:on_next))
+        o.on_error(&method(:on_error))
+        o.on_completed(&method(:on_completed))
+      end      
+    end
+
+    # Creates a notification callback from an observer.
+    def to_notifier
+      lambda {|n| n.accept self}
+    end
+
+    class << self
+
+      # Configures a new instance of an Observer
+      def configure
+        config = ObserverConfiguration.new
+        yield config if block_given?
+        ObserverBase.new config
+      end
+
+      def create(on_next = nil, on_error = nil, on_completed = nil)
+        configure do |o|
+          o.on_next(&on_next) if on_next
+          o.on_error(&on_error) if on_error
+          o.on_completed(&on_completed) if on_completed
+        end
+      end
+    end
+
+  end
+
+  # Base class for all Observer implementations
+  class ObserverBase
+    include Observer
+
+    def initialize(config)
+      @config = config
+      @stopped = false
+    end
+
+    # Unsubscribes from the current observer causing it to transition to the stopped state.
+    def unsubscribe
+      @stopped = true
+    end
+
+    def dispose
+      unsubscribe
+    end
+
+    # Notifies the observer of a new element in the sequence.
+    def on_next(value)
+      @config.on_next_action.call value unless @stopped
+    end
+    
+    # Notifies the observer that an exception has occurred.
+    def on_error(error)
+      raise 'Error cannot be nil' unless error
+      unless @stopped
+        @stopped = true
+        @config.on_error_action.call error
+      end
+    end
+    
+    # Notifies the observer of the end of the sequence.
+    def on_completed
+      unless @stopped
+        @stopped = true
+        @config.on_completed_action.call
+      end
+    end
+
+    def fail(error) 
+      unless @stopped
+        @stopped = true
+        @config.on_error_action.call error
+        return true
+      end
+      return false
+    end    
+  end
+end

data/lib/rx_ruby/core/scheduled_observer.rb

@@ -0,0 +1,83 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'monitor'
+require 'rx_ruby/subscriptions/serial_subscription'
+require 'rx_ruby/core/observer'
+
+module RxRuby
+
+  class ScheduledObserver < ObserverBase
+
+    def initialize(scheduler, observer)
+      @scheduler = scheduler
+      @observer = observer
+      @gate = Monitor.new
+      @queue = []
+      @subscriber = SerialSubscription.new
+      @acquired = false
+      @faulted = false
+
+      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 on_next_core(value)
+      @gate.synchronize { @queue.push(lambda { @observer.on_next value }) }
+    end
+
+    def on_error_core(error)
+       @gate.synchronize { @queue.push(lambda { @observer.on_error error }) }
+    end
+
+    def on_completed_core
+       @gate.synchronize { @queue.push(lambda { @observer.on_completed }) }
+    end
+
+    def ensure_active(n=0)
+      owner = false
+
+      @gate.synchronize do
+        if !@faulted && @queue.length > 0
+          owner = !@acquired
+          @acquired = true
+        end
+      end
+
+      @subscriber.subscription = @scheduler.schedule_recursive_with_state(nil, method(:run)) if owner
+    end
+
+    def run(state, recurse)
+      work = nil
+      @gate.synchronize do
+        if @queue.length > 0
+          work = @queue.shift
+        else
+          @acquired = false
+          return
+        end
+      end
+
+      begin
+        work.call
+      rescue => e
+        @queue = []
+        @faulted = true
+
+        raise e
+      end
+
+      recurse.call state
+    end
+
+    def unsubscribe
+      super
+      @subscriber.unsubscribe
+    end
+
+  end
+
+end

data/lib/rx_ruby/core/synchronized_observer.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 'monitor'
+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 by multiple threads, using the specified gate object for use by a Monitor based lock.
+      # This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object if given.
+      # Notice reentrant observer callbacks on the same thread are still possible.
+      def allow_reentrancy(observer, gate = Monitor.new)
+        SynchronizedObserver.new(observer, gate)
+      end
+    end
+  end
+
+  class SynchronizedObserver < RxRuby::ObserverBase
+
+    def on_next_core(value)
+      @gate.synchronize { @observer.on_next value }
+    end
+
+    def on_error_core(error)
+      @gate.synchronize { @observer.on_error error }
+    end
+
+    def on_completed_core
+      @gate.synchronize { @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/time_interval.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 TimeInterval < Struct.new(:interval, :value)
+
+    def initialize(interval, value)
+      super
+    end
+
+    def to_s
+      "(#{value})@(#{interval})"
+    end
+
+  end
+end

data/lib/rx_ruby/internal/priority_queue.rb

@@ -0,0 +1,122 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+
+  # Priority Queue implemented as a binary heap.
+  class PriorityQueue
+    def initialize
+      @items = []
+      @mutex = Mutex.new
+    end
+
+    def peek
+      @mutex.synchronize do
+        unsafe_peek
+      end
+    end
+
+    def shift
+      @mutex.synchronize do
+        result = unsafe_peek
+        delete_at 0
+        result
+      end
+    end
+
+    def push(item)
+      @mutex.synchronize do
+        @items.push IndexedItem.new(item)
+        percolate length - 1
+      end
+    end
+
+    def delete(item)
+      @mutex.synchronize do
+        index = @items.index {|it| it.value == item }
+        if index
+          delete_at index
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def length
+      @items.length
+    end
+
+    private
+
+    def unsafe_peek
+      @items.first.value unless @items.empty?
+    end
+
+    def delete_at(index)
+      substitute = @items.pop
+      if substitute and index < @items.length
+        @items[index] = substitute
+        heapify index
+      end
+    end
+
+    # bubble up an item while it's smaller than parents
+    def percolate(index)
+      parent = (index - 1) / 2
+      return if parent < 0
+
+      current_value = @items[index]
+      parent_value  = @items[parent]
+
+      if current_value < parent_value
+        @items[index]  = parent_value
+        @items[parent] = current_value
+        percolate parent
+      end
+    end
+
+    # bubble down an item while it's bigger than children
+    def heapify(index)
+      current_index = index
+      left_index    = 2 * index + 1
+      right_index   = 2 * index + 2
+
+      current_value = @items[index]
+      left_value    = @items[left_index]
+      right_value   = @items[right_index]
+
+      if right_value && right_value < current_value && right_value < left_value
+        current_index = right_index
+      elsif left_value && left_value < current_value
+        current_index = left_index
+      end
+
+      if current_index != index
+        @items[index] = @items[current_index]
+        @items[current_index] = current_value
+        heapify current_index
+      end
+    end
+
+    class IndexedItem
+      include Comparable
+      attr_reader :id , :value
+
+      @@length = 0
+
+      def initialize(value)
+        @id = @@length += 1
+        @value = value
+      end
+
+      def <=>(other)
+        if @value == other.value
+          @id <=> other.id
+        else
+          @value <=> other.value
+        end
+      end
+    end
+
+  end
+end