rx_ruby 0.0.2

data/lib/rx_ruby/subjects/replay_subject.rb

@@ -0,0 +1,39 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+require 'rx_ruby/concurrency/current_thread_scheduler'
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/observable'
+require 'rx_ruby/core/time_interval'
+
+module RxRuby
+
+  # Represents an object that is both an observable sequence as well as an observer.
+  # Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies.
+  class ReplaySubject
+
+    include Observer
+    include Observable
+
+    INFINITE_BUFFER_SIZE = Float::MAX.to_i
+
+    def initialize(buffer_size = INFINITE_BUFFER_SIZE, window_size = INFINITE_BUFFER_SIZE, scheduler = CurrentThreadScheduler.instance)
+      @buffer_size = buffer_size
+      @window_size = window_size
+      @scheduler = scheduler
+      @queue = []
+      @observers = []
+      @stopped = false
+      @error = nil
+    end
+
+    # Indicates whether the subject has observers subscribed to it.
+    # @return [B]
+    def has_observers?
+      observers = @observers
+      observers && observers.length > 0
+    end
+
+  end
+
+end

data/lib/rx_ruby/subjects/subject.rb

@@ -0,0 +1,131 @@
+# 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'
+require 'rx_ruby/core/observable'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  # Represents an object that is both an observable sequence as well as an observer.
+  # Each notification is broadcasted to all subscribed observers.
+  class Subject
+
+    include Observable
+    include Observer
+
+    def initialize
+      @observers = []
+      @gate = Mutex.new
+      @disposed = false
+      @stopped = false
+      @error = nil
+    end
+
+    # Indicates whether the subject has observers subscribed to it.
+    def has_observers?
+      @observers && @observers.length > 0
+    end
+
+    # Notifies all subscribed observers about the end of the sequence.
+    def on_completed
+      os = nil
+      @gate.synchronize do 
+        check_disposed
+
+        unless @stopped
+          os = @observers.clone
+          @observers = []
+          @stopped = true
+        end 
+      end
+
+      os.each {|o| o.on_completed } if os
+    end
+
+    # Notifies all subscribed observers with the error.
+    def on_error(error)
+      raise 'error cannot be nil' unless error
+
+      os = nil
+      @gate.synchronize do
+        check_disposed
+
+        unless @stopped
+          os = @observers.clone
+          @observers = []
+          @stopped = true
+          @error = error
+        end         
+      end
+
+      os.each {|o| o.on_error error } if os
+    end
+
+    # Notifies all subscribed observers with the value.
+    def on_next(value) 
+      os = nil
+      @gate.synchronize do 
+        check_disposed
+        os = @observers.clone unless @stopped
+      end
+
+      os.each {|o| o.on_next value } if os      
+    end
+
+    # Subscribes an observer to the subject.
+    def subscribe(observer)
+      raise 'observer cannot be nil' unless observer
+
+      @gate.synchronize do
+        check_disposed
+
+        if !@stopped
+          @observers.push(observer)
+          return InnerSubscription.new(self, observer)
+        elsif @error
+          observer.on_error @error
+          return Subscription.empty
+        else
+          observer.on_completed
+          return Subscription.empty
+        end
+      end
+    end
+
+    # Unsubscribe all observers and release resources.
+    def unsubscribe
+      @gate.synchronize do
+        @disposed = true
+        @observers = nil
+      end
+    end
+
+    class InnerSubscription
+      def initialize(subject, observer)
+        @subject = subject
+        @observer = observer
+      end
+
+      def unsubscribe
+        if @observer
+          @subject.send(:unsubscribe_observer, @observer)
+          @subject = nil
+          @observer = nil
+        end
+      end
+    end
+
+    private
+
+    def unsubscribe_observer(observer)
+      @gate.synchronize do
+        @observers.delete(observer) if @observers
+      end
+    end
+
+    def check_disposed
+      raise ArgumentError.new 'Subject disposed' if @disposed
+    end
+  end  
+end

data/lib/rx_ruby/subjects/subject_extensions.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/core/observer'
+require 'rx_ruby/core/observable'
+
+module RxRuby
+
+  # Provides a set of static methods for creating subjects.
+  class Subject
+
+    # Creates a subject from the specified observer and observable.
+    def self.create(observer, observable)
+      AnonymousSubject.new(observer, observable)
+    end
+
+    class AnonymousSubject
+      include Observable
+      include Observer
+
+      def initialize(observer, observable)
+        @observer = observer
+        @observable = observable
+      end
+
+      def on_completed
+        @observer.on_completed
+      end
+
+      def on_error(error)
+        raise 'error cannot be nil' unless error
+        @observer.on_error(error)
+      end
+
+      def on_next(value)
+        @observer.on_next(value)
+      end
+
+      def subscribe(observer)
+        raise 'observer cannot be nil' unless observer
+        @observable.subscribe(observer)
+      end
+    end
+
+  end
+end

data/lib/rx_ruby/subscriptions/composite_subscription.rb

@@ -0,0 +1,91 @@
+# 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 group of subscription resources that are unsubscribed together.
+  class CompositeSubscription
+  
+    include Enumerable
+
+    attr_reader :length
+
+    def initialize(subscriptions = [])
+      @subscriptions = subscriptions
+      @length = subscriptions.length
+      @unsubscribed = false
+      @gate = Mutex.new
+    end
+
+    # Gets a value that indicates whether the object is unsubscribed.
+    def unsubscribed?
+      @unsubscribed
+    end
+
+    def each(&block)
+      @subscriptions.each(&block)
+    end
+
+    # Unsubscribes all subscriptions in the group and removes them from the group.
+    def unsubscribe
+      currentSubscriptions = nil
+
+      @gate.synchronize do
+        unless @unsubscribed
+          @unsubscribed = true
+          currentSubscriptions = @subscriptions
+          @subscriptions = []
+          @length = 0
+        end
+      end
+
+      currentSubscriptions.each {|subscription| subscription.unsubscribe} if currentSubscriptions
+    end
+
+    # Adds a subscription to the CompositeSubscription or unsubscribes the subscription if the CompositeSubscription is unsubscribed.
+    def push(subscription)
+      should_unsubscribe = false
+    
+      @gate.synchronize do
+        should_unsubscribe = @unsubscribed
+  
+        unless @unsubscribed
+          @subscriptions.push(subscription)
+          @length += 1
+        end
+      end
+    
+      subscription.unsubscribe if should_unsubscribe
+
+      return self
+    end
+    alias_method :<<, :push
+    
+    # Removes and unsubscribes all subscriptions from the CompositeSubscription, but does not dispose the CompositeSubscription.
+    def clear
+      currentSubscriptions = nil
+    
+      @gate.synchronize do
+        currentSubscriptions = @subscriptions
+        @subscriptions = []
+        @length = 0
+      end
+      currentSubscriptions.each {|subscription| subscription.unsubscribe}
+    end
+    
+    # Removes and unsubscribes the first occurrence of a subscription from the CompositeSubscription.
+    def delete(subscription)
+      should_unsubscribe = nil
+    
+      @gate.synchronize do
+        should_unsubscribe = @subscriptions.delete(subscription)
+        @length -= 1 if should_unsubscribe
+      end
+    
+      subscription.unsubscribe if should_unsubscribe
+
+      should_unsubscribe
+    end
+  end
+end

data/lib/rx_ruby/subscriptions/ref_count_subscription.rb

@@ -0,0 +1,88 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  # Represents a subscription resource that only disposes its underlying subscription resource when all dependent subscription objects have been unsubscribed.
+  class RefCountSubscription
+
+    def initialize(subscription)
+      raise ArgumentError.new 'Subscription cannot be nil' unless subscription
+
+      @subscription = subscription
+      @primary_unsubscribed = false
+      @gate = Mutex.new
+      @count = 0
+    end
+
+    # Gets a value that indicates whether the object is disposed.
+    def unsubscribed?
+      @subscription.nil?
+    end
+
+    # Returns a dependent subscription that when disposed decreases the refcount on the underlying subscription.
+    def subscription
+      @gate.synchronize do 
+        if @subscription
+          @count += 1
+          return InnerSubscription.new self
+        else
+          return Subscription.empty
+        end
+      end
+    end
+
+    # Unsubscribes the underlying subscription only when all dependent subscriptions have been unsubscribed.
+    def unsubscribe
+      subscription = nil
+      @gate.synchronize do
+        if @subscription
+          unless @primary_unsubscribed
+            @primary_unsubscribed = true
+
+            if @count == 0
+              subscription = @subscription
+              @subscription = nil
+            end
+          end
+        end
+      end
+
+      subscription.unsubscribe if subscription
+    end
+
+    def release
+      subscription = nil
+      @gate.synchronize do
+        if @subscription
+          @count -= 1
+
+          if @primary_unsubscribed && @count == 0
+            subscription = @subscription
+            @subscription = nil
+          end
+        end
+      end
+
+      subscription.unsubscribe if subscription
+    end
+
+    class InnerSubscription
+      def initialize(parent)
+        @parent = parent
+      end
+
+      def unsubscribe
+        parent = nil
+        Mutex.new.synchronize do
+          parent = @parent
+          @parent = nil
+        end
+        parent.release if parent
+      end
+    end
+
+  end
+end

data/lib/rx_ruby/subscriptions/scheduled_subscription.rb

@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+module RxRuby
+  # Represents a disposable resource whose disposal invocation will be scheduled on the specified scheduler
+  class ScheduledDisposable
+
+    attr_reader :scheduler, :subscription
+
+    def initialize(scheduler, subscription)
+      raise 'disposable cannot be nil' unless subscription
+      raise 'scheduler cannot be nil' unless scheduler
+
+      @scheduler = scheduler
+      @subscription = subscription
+    end
+
+    # Gets a value that indicates whether the object is unsubscribed.
+    def unsubscribed?
+      @subscription.nil?
+    end
+
+    # Unsubscribes the wrapped subscription on the provided scheduler.
+    def unsubscribe
+      @scheduler.schedule lambda do
+        unless @subscription.nil?
+          @subscription.unsubscribe
+          @subscription = nil
+        end
+      end
+    end
+  end
+end

data/lib/rx_ruby/subscriptions/serial_subscription.rb

@@ -0,0 +1,60 @@
+# 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 whose underlying subscription resource can be replaced by another subscription resource, causing automatic disposal of the previous underlying subscription resource.
+  class SerialSubscription
+    include Subscription
+
+    def initialize
+      @gate = Mutex.new
+      @current = nil
+      @unsubscribed = 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.
+    def subscription
+      @current
+    end
+
+    # Sets the underlying subscription.
+    def subscription=(new_subscription)
+      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 current underlying subscription and all future subscriptions.
+    def unsubscribe
+      old = nil
+      @gate.synchronize do
+        unless @unsubscribed
+          @unsubscribed = true
+          old = @current
+          @current = nil
+        end
+      end
+
+      old.unsubscribe if old
+    end
+
+  end
+end