rx_ruby 0.0.2

data/examples/to_async.rb

@@ -0,0 +1,26 @@
+require 'rx_ruby'
+
+func = RxRuby::Observable.to_async(lambda {|x, y|
+    return x + y
+})
+
+# Execute function with 3 and 4
+source = func.call(3, 4)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 7
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/using.rb

@@ -0,0 +1,52 @@
+require 'rx_ruby'
+
+#  Using an AsyncSubject as a resource which supports the .dispose method
+class DisposableResource
+  def initialize(value, disposed = false)
+    @value = value
+    @disposed = disposed
+  end
+
+  def value
+    if @disposed
+      throw Exception.new('Object is disposed')
+    end
+    @value
+  end
+
+  def unsubscribe
+    unless @disposed
+      @disposed = true
+      @value = nil
+    end
+    puts 'Disposed'
+  end
+end
+
+source = RxRuby::Observable.using(
+  lambda { return DisposableResource.new(42) },
+  lambda {|resource|
+    subject = RxRuby::AsyncSubject.new
+    subject.on_next(resource.value)
+    subject.on_completed
+    return subject
+  }
+)
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Next: 42
+# => Completed
+
+subscription.dispose
+
+# => Disposed

data/examples/when.rb

@@ -0,0 +1,26 @@
+require 'rx_ruby'
+
+# Fire each plan when both are ready
+source = RxRuby::Observable.when(
+  RxRuby::Observable.timer(0.1).and(RxRuby::Observable.timer(0.5)).then_do(lambda {|x, y| return 'first' }),
+  RxRuby::Observable.timer(0.4).and(RxRuby::Observable.timer(0.3)).then_do {|x, y| 'second' }
+)
+
+subscription = source.subscribe(
+  lambda {|x|
+      puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+      puts 'Error: ' + err.to_s
+  },
+  lambda {
+      puts 'Completed'
+  })
+
+# => Next: second
+# => Next: first
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/while.rb

@@ -0,0 +1,25 @@
+require 'rx_ruby'
+
+i = 0
+
+# Repeat until condition no longer holds
+source = RxRuby::Observable.while(
+    lambda { i += 1; i <= 3 },
+    RxRuby::Observable.return(42)
+)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Next: 42
+# => Next: 42
+# => Completed

data/examples/window_with_time.rb

@@ -0,0 +1,78 @@
+require 'rx_ruby'
+
+#  Without a skip
+source = RxRuby::Observable.interval(0.1)
+    .window_with_time(0.5)
+    .take(3)
+
+subscription = source.subscribe(
+    lambda {|child|
+        child.to_a.subscribe(
+            lambda {|x|
+                puts 'Child Next: ' + x.to_s
+            },
+            lambda {|err|
+                puts 'Child Error: ' + err.to_s
+            },
+            lambda {
+                puts 'Child Completed'
+            }
+        )
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Child Next: [0, 1, 2, 3]
+# => Child Completed
+# => Completed
+# => Child Next: [4, 5, 6, 7, 8]
+# => Child Completed
+# => Child Next:  [9, 10, 11, 12, 13]
+# => Child Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end
+
+#  Using a skip
+source = RxRuby::Observable.interval(0.1)
+    .window_with_time(0.5, 0.1)
+    .take(3)
+
+subscription = source.subscribe(
+    lambda {|child|
+
+        child.to_a.subscribe(
+            lambda {|x|
+                puts 'Child Next: ' + x.to_s
+            },
+            lambda {|err|
+                puts 'Child Error: ' + err.to_s
+            },
+            lambda {
+                puts 'Child Completed'
+            }
+        )
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Completed
+# => Child Next: [0, 1, 2, 3, 4]
+# => Child Completed
+# => Child Next: [1, 2, 3, 4, 5]
+# => Child Completed
+# => Child Next: [2, 3, 4, 5, 6]
+# => Child Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/zip.rb

@@ -0,0 +1,27 @@
+require 'rx_ruby'
+
+# Using arguments
+range = RxRuby::Observable.range(0, 5)
+
+source = RxRuby::Observable.zip(
+    range,
+    range.skip(1),
+    range.skip(2)) {|s1, s2, s3|
+        s1.to_s + ':' + s2.to_s + ':' + s3.to_s
+    }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 0:1:2
+# => Next: 1:2:3
+# => Next: 2:3:4
+# => Completed

data/examples/zip_array.rb

@@ -0,0 +1,25 @@
+require 'rx_ruby'
+
+range = RxRuby::Observable.range(0, 5)
+
+source = RxRuby::Observable.zip(
+    range,
+    range.skip(1),
+    range.skip(2)
+)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: [0, 1, 2]
+# => Next: [1, 2, 3]
+# => Next: [2, 3, 4]
+# => Completed

data/lib/core_ext/enumerable.rb

@@ -0,0 +1,22 @@
+module Enumerable
+  def subscribe(observer, scheduler = RxRuby::ImmediateScheduler.instance)
+    begin
+      self.each do |e|
+        scheduler.schedule lambda {
+          observer.on_next(e)
+        }
+      end
+    rescue => ex
+      observer.on_error(ex)
+      return
+    end
+    
+    observer.on_completed
+  end
+  
+  def to_observable(scheduler = RxRuby::ImmediateScheduler.instance)
+    RxRuby::AnonymousObservable.new do |observer|
+      self.subscribe(observer, scheduler)
+    end
+  end
+end

data/lib/rx_ruby.rb

@@ -0,0 +1,27 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+$:.unshift File.dirname(__FILE__) # For use/testing when no gem is installed
+
+# Require all of the Ruby files in the given directory.
+#
+# path - The String relative path from here to the directory.
+#
+# Returns nothing.
+def require_all(path)
+  glob = File.join(File.dirname(__FILE__), path, '*.rb')
+  Dir[glob].sort.each do |f|
+    require f
+  end
+end
+
+require_all 'rx_ruby/internal/'
+require_all 'rx_ruby/concurrency/'
+require_all 'rx_ruby/subscriptions/'
+require_all 'rx_ruby/core/'
+require_all 'rx_ruby/linq/'
+require_all 'rx_ruby/linq/observable/'
+require_all 'rx_ruby/operators/'
+require_all 'rx_ruby/subjects/'
+require_all 'rx_ruby/testing/'
+require_all 'rx_ruby/joins/'
+require_all 'rx_ruby/'

data/lib/rx_ruby/concurrency/async_lock.rb

@@ -0,0 +1,57 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+
+module RxRuby
+  # Asynchronous lock.
+  class AsyncLock
+
+    def initialize
+      @queue = []
+      @is_acquired = false
+      @has_faulted = false
+      @gate = Mutex.new
+    end
+
+    def wait(&action)
+      @gate.synchronize do
+        @queue.push action unless @has_faulted
+
+        if @is_acquired or @has_faulted
+          return
+        else
+          @is_acquired = true
+        end
+      end
+
+      loop do
+        work = nil
+
+        @gate.synchronize do
+          work = @queue.shift
+
+          unless work
+            @is_acquired = false
+            return
+          end
+        end
+
+        begin
+          work.call
+        rescue
+          clear
+          raise
+        end
+      end
+    end
+
+    # Clears the work items in the queue and drops further work being queued.
+    def clear
+      @gate.synchronize do
+        @queue = []
+        @has_faulted = true
+      end
+    end
+
+  end
+end

data/lib/rx_ruby/concurrency/current_thread_scheduler.rb

@@ -0,0 +1,75 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'singleton'
+require 'thread'
+require 'rx_ruby/internal/priority_queue'
+require 'rx_ruby/concurrency/local_scheduler'
+require 'rx_ruby/concurrency/scheduled_item'
+require 'rx_ruby/subscriptions/subscription'
+
+module RxRuby
+
+  # Represents an object that schedules units of work on the platform's default scheduler.
+  class CurrentThreadScheduler < RxRuby::LocalScheduler
+
+    include Singleton
+
+    @@thread_local_queue = nil
+
+    # Gets a value that indicates whether the caller must call a Schedule method.
+    def self.schedule_required?
+      @@thread_local_queue.nil?
+    end
+
+    # Schedules an action to be executed after dueTime.
+    def schedule_relative_with_state(state, due_time, action)
+      raise 'action cannot be nil' unless action
+
+      dt = self.now.to_i + Scheduler.normalize(due_time)
+      si = ScheduledItem.new self, state, dt, &action
+
+      local_queue = self.class.queue
+
+      unless local_queue
+        local_queue = PriorityQueue.new
+        local_queue.push si
+
+        self.class.queue = local_queue
+
+        begin
+          self.class.run_trampoline local_queue
+        ensure
+          self.class.queue = nil
+        end
+      else
+        local_queue.push si
+      end
+
+      Subscription.create { si.cancel }
+    end
+
+    private
+
+    class << self
+      def queue
+        @@thread_local_queue
+      end
+
+      def queue=(new_queue)
+        @@thread_local_queue = new_queue
+      end
+
+      def run_trampoline(queue)
+        while item = queue.shift
+          unless item.cancelled?
+            wait = item.due_time - Scheduler.now.to_i
+            sleep wait if wait > 0
+            item.invoke unless item.cancelled?
+          end
+        end
+      end
+
+    end
+
+  end
+end