rx_ruby 0.0.2

data/lib/rx_ruby/operators/synchronization.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/subscriptions/single_assignment_subscription'
+require 'rx_ruby/subscriptions/serial_subscription'
+require 'rx_ruby/subscriptions/scheduled_subscription'
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/observable'
+require 'rx_ruby/core/observe_on_observer'
+
+module RxRuby
+  module Observable
+
+    # Wraps the source sequence in order to run its subscription and unsubscribe logic on the specified scheduler.
+    def subscribe_on(scheduler)
+      raise ArgumentError.new 'Scheduler cannot be nil' unless scheduler
+
+      AnonymousObservable.new do |observer|
+        m = SingleAssignmentSubscription.new
+        d = SerialSubscription.new
+        d.subscription = m
+
+        m.subscription = scheduler.schedule lambda {
+          d.subscription = ScheduledSubscription.new scheduler, (subscribe observer)
+        }
+
+        d
+      end
+    end
+  
+    # Wraps the source sequence in order to run its observer callbacks on the specified scheduler.
+    def observe_on(scheduler)
+      raise ArgumentError.new 'Scheduler cannot be nil' unless scheduler
+
+      AnonymousObservable.new do |observer|
+        subscribe(ObserveOnObserver.new scheduler, observer)
+      end
+    end
+
+    # Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object.
+    def synchronize(gate = Monitor.new)
+      AnonymousObservable.new do |observer|
+        subscribe(Observer.allow_reentrancy observer, gate)
+      end
+    end
+  end
+end

data/lib/rx_ruby/operators/time.rb

@@ -0,0 +1,120 @@
+# 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/default_scheduler'
+require 'rx_ruby/subscriptions/subscription'
+require 'rx_ruby/subscriptions/composite_subscription'
+require 'rx_ruby/subscriptions/ref_count_subscription'
+require 'rx_ruby/subscriptions/serial_subscription'
+require 'rx_ruby/subscriptions/single_assignment_subscription'
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/observable'
+require 'rx_ruby/subjects/subject'
+
+
+module RxRuby
+
+  # Time based operations
+  module Observable
+
+    # Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced
+    # based on timing information.
+    def buffer_with_time(time_span, time_shift = time_span, scheduler = DefaultScheduler.instance)
+      raise ArgumentError.new 'time_span must be greater than zero' if time_span <= 0
+      raise ArgumentError.new 'time_span must be greater than zero' if time_shift <= 0
+      window_with_time(time_span, time_shift, scheduler).flat_map(&:to_a)
+    end
+
+    # Projects each element of an observable sequence into consecutive non-overlapping windows which are produced
+    # based on timing information.
+    def window_with_time(time_span, time_shift = time_span, scheduler = DefaultScheduler.instance)
+      raise ArgumentError.new 'time_span must be greater than zero' if time_span <= 0
+      raise ArgumentError.new 'time_span must be greater than zero' if time_shift <= 0
+
+      AnonymousObservable.new do |observer|
+        total_time = 0
+        next_shift = time_shift
+        next_span = time_span
+
+        gate = Mutex.new
+        q = []
+
+        timer_d = SerialSubscription.new
+        group_subscription = CompositeSubscription.new [timer_d]
+        ref_count_subscription = RefCountSubscription.new(group_subscription)
+
+        create_timer = lambda {
+          m = SingleAssignmentSubscription.new
+          timer_d.subscription = m
+
+          is_span = false
+          is_shift = false
+          if next_span == next_shift
+            is_span = true
+            is_shift = true
+          elsif next_span < next_shift
+            is_span = true
+          else
+            is_shift = true
+          end
+
+          new_total_time = is_span ? next_span : next_shift
+          ts = new_total_time - total_time
+          total_time = new_total_time
+
+          if is_span
+            next_span += time_shift
+          end
+          if is_shift
+            next_shift += time_shift
+          end
+
+          m.subscription = scheduler.schedule_relative(ts, lambda {
+            gate.synchronize do
+              if is_shift
+                s = Subject.new
+                q.push s
+                observer.on_next(s.add_ref(ref_count_subscription))
+              end
+              if is_span
+                s = q.shift
+                s.on_completed
+              end
+              create_timer.call
+            end
+          })
+        }
+
+        q.push(Subject.new)
+        observer.on_next(q[0].add_ref(ref_count_subscription))
+        create_timer.call
+
+        new_obs = Observer.configure do |o|
+          o.on_next do |x|
+            gate.synchronize do
+              q.each {|s| s.on_next x}
+            end
+          end
+
+          o.on_error do |err|
+            gate.synchronize do
+              q.each {|s| s.on_error err}
+              observer.on_error err
+            end
+          end
+
+          o.on_completed do
+            gate.synchronize do
+              q.each {|s| s.on_on_completed}
+              observer.on_completed
+            end
+          end
+        end
+
+        group_subscription.push subscribe(new_obs)
+
+        ref_count_subscription
+      end
+    end
+  end
+end

data/lib/rx_ruby/subjects/async_subject.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 'thread'
+require 'rx_ruby/core/observer'
+require 'rx_ruby/core/observable'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  # Represents the result of an asynchronous operation.
+  # Each notification is broadcasted to all subscribed observers.
+  class AsyncSubject
+
+    include Observable
+    include Observer
+
+    attr_reader :gate, :observers, :unsubscribed
+
+    def initialize
+      @observers = []
+      @gate = Mutex.new
+      @unsubscribed = false
+      @stopped = false
+      @error = nil
+      @value = nil
+      @has_value = false
+    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
+      v = nil
+      hv = false
+
+      gate.synchronize do
+        check_unsubscribed
+
+        unless @stopped
+          os = @observers.clone
+          @observers = []
+          @stopped = true
+          v = @value
+          hv = @has_value
+        end
+      end
+
+      if os
+        if hv
+          os.each do |o|
+            o.on_next @value
+            o.on_completed
+          end
+        else
+          os.each {|o| o.on_completed }
+        end
+      end
+    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_unsubscribed
+
+        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)
+      gate.synchronize do
+        check_unsubscribed
+        unless @stopped
+          @value = value
+          @has_value = true
+        end
+      end
+    end
+
+    # Subscribes an observer to the subject.
+    def subscribe(observer)
+      raise 'observer cannot be nil' unless observer
+
+      err = nil
+      v = nil
+      hv = false
+
+      gate.synchronize do
+        check_unsubscribed
+
+        if !@stopped
+          observers.push(observer)
+          return InnerSubscription.new(self, observer)
+        end
+
+        err = @error
+        v = @value
+        hv = @has_value
+      end
+
+      if err
+        observer.on_next err
+      elsif hv
+        observer.on_next v
+        observer.on_completed
+      else
+        observer.on_completed
+      end
+
+      Subscription.empty
+    end
+
+    # Unsubscribe all observers and release resources.
+    def unsubscribe
+      gate.synchronize do
+        @unsubscribed = true
+        @observers = nil
+        @error = nil
+        @value = nil
+      end
+    end    
+
+    class InnerSubscription
+      def initialize(subject, observer)
+        @subject = subject
+        @observer = observer
+      end
+
+      def unsubscribe
+        if @observer
+          @subject.gate.synchronize do
+            if !@subject.unsubscribed && @observer
+              @subject.observers.delete @observer
+              @observer = nil
+            end
+          end
+        end
+      end
+    end
+
+    private 
+
+    def check_unsubscribed
+      raise ArgumentError.new 'Subject unsubscribed' if unsubscribed
+    end
+  end
+end  

data/lib/rx_ruby/subjects/behavior_subject.rb

@@ -0,0 +1,149 @@
+# 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'
+
+module RxRuby
+
+  # Represents a value that changes over time.
+  # Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications.
+  class BehaviorSubject
+
+    include Observable
+    include Observer
+
+    attr_reader :gate, :observers, :unsubscribed
+
+    def initialize(value)
+      @value = value
+      @observers = []
+      @gate = Mutex.new
+      @unsubscribed = false
+      @stopped = false
+      @error = nil
+    end
+
+    # Indicates whether the subject has observers subscribed to it.
+    def has_observers?
+      observers && observers.length > 0
+    end
+
+    # Gets the current value or throws an exception.
+    def value
+      gate.synchronize do 
+        self.check_unsubscribed
+        raise @error if @error
+        @value
+      end
+    end
+
+    # Notifies all subscribed observers about the end of the sequence.
+    def on_completed
+      os = nil
+      @gate.synchronize do 
+        self.check_unsubscribed
+
+        unless @stopped
+          os = @observers.clone
+          @observers = []
+          @stopped = true
+        end 
+      end
+
+      os.each {|o| observer.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
+        self.check_unsubscribed
+
+        unless @stopped
+          os = @observers.clone
+          @observers = []
+          @stopped = true
+          @error = error
+        end         
+      end
+
+      os.each {|o| observer.on_error error } if os
+    end    
+
+    # Notifies all subscribed observers with the value.
+    def on_next(value) 
+      os = nil
+      @gate.synchronize do
+        self.check_unsubscribed
+        @value = value
+        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
+
+      err = nil
+      gate.synchronize do
+        self.check_unsubscribed
+
+        unless @stopped
+          observers.push(observer)
+          observer.on_next(@value)
+          return InnerSubscription.new(self, observer)
+        end
+
+        err = @error
+      end
+
+      if err
+        observer.on_next err
+      else
+        observer.on_completed
+      end
+
+      Subscription.empty
+    end
+
+    # Unsubscribe all observers and release resources.
+    def unsubscribe
+      gate.synchronize do
+        @unsubscribed = true
+        @observers = nil
+        @error = nil
+        @value = nil
+      end
+    end
+
+    class InnerSubscription
+      def initialize(subject, observer)
+        @subject = subject
+        @observer = observer
+      end
+
+      def unsubscribe
+        if @observer
+          @subject.gate.synchronize do
+            if !@subject.unsubscribed && @observer
+              @subject.observers.delete @observer
+              @observer = nil
+            end
+          end
+        end
+      end
+    end 
+
+    private
+
+    def check_unsubscribed
+      raise 'Subject unsubscribed' if unsubscribed
+    end
+
+  end
+end