rx_ruby 0.0.2

data/lib/rx_ruby/linq/observable/delay.rb

@@ -0,0 +1,81 @@
+module RxRuby
+  module Observable
+    def delay(due_time, scheduler = DefaultScheduler.instance)
+      if Time === due_time
+        delay_date(due_time, scheduler)
+      else
+        delay_time_span(due_time, scheduler)
+      end
+    end
+
+    private
+
+    def delay_time_span(due_time, scheduler)
+      AnonymousObservable.new do |observer|
+        active = false
+        cancelable = SerialSubscription.new
+        exception = nil
+        q = []
+        running = false
+        subscription = materialize.timestamp(scheduler).subscribe do |notification|
+          if notification[:value].on_error?
+            q = []
+            q.push notification
+            exception = notification[:value].error
+            should_run = !running
+          else
+            q.push({ value: notification[:value], timestamp: notification[:timestamp] + due_time })
+            should_run = !active
+            active = true
+          end
+
+          if should_run
+            if exception != nil
+              observer.on_error exception
+            else
+              d = SingleAssignmentSubscription.new
+              cancelable.subscription = d
+
+              d.subscription = scheduler.schedule_recursive_relative(due_time, lambda {|this|
+                return if exception != nil
+
+                running = true
+                begin
+                  result = nil
+                  if q.length > 0 && q[0][:timestamp] - scheduler.now <= 0
+                    result = q.shift[:value]
+                  end
+                  if result != nil
+                    result.accept observer
+                  end
+                end while result != nil
+
+                should_recurse = false
+                recurse_due_time = 0
+                if q.length > 0
+                  should_recurse = true
+                  recurse_due_time = [0, q[0][:timestamp] - scheduler.now].max
+                else
+                  active = false
+                end
+                e = exception
+                running = false
+                if e != nil
+                  observer.on_error e
+                elsif should_recurse
+                  this.call recurse_due_time
+                end
+              })
+            end
+          end
+        end
+
+        CompositeSubscription.new [subscription, cancelable]
+      end
+    end
+
+    def delay_date(due_time, scheduler)
+      delay_time_span(due_time - scheduler.now, scheduler)
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/delay_with_selector.rb

@@ -0,0 +1,64 @@
+module RxRuby
+  module Observable
+    def delay_with_selector(subscription_delay, delay_duration_selector = nil)
+      if Proc === subscription_delay
+        selector = subscription_delay
+      else
+        sub_delay = subscription_delay
+        selector = delay_duration_selector
+      end
+
+      AnonymousObservable.new do |observer|
+        delays = CompositeSubscription.new
+        at_end = false
+        done = lambda {
+          if at_end && delays.length == 0
+            observer.on_completed
+          end
+        }
+        subscription = SerialSubscription.new
+        start = lambda {|*_|
+          subscription.subscription = subscribe(
+            lambda {|x|
+              begin
+                delay = selector.call(x)
+              rescue => error
+                observer.on_error error
+                return
+              end
+              d = SingleAssignmentSubscription.new
+              delays.push(d)
+              d.subscription = delay.subscribe(
+                lambda {|_|
+                  observer.on_next x
+                  delays.delete(d)
+                  done.call
+                },
+                observer.method(:on_error),
+                lambda {
+                  observer.on_next x
+                  delays.delete(d)
+                  done.call
+                })
+            },
+            observer.method(:on_error),
+            lambda {
+              at_end = true
+              subscription.dispose
+              done.call
+            })
+        }
+        
+        if !sub_delay
+          start.call
+        else
+          subscription.subscription = sub_delay.subscribe(
+            start,
+            observer.method(:on_error),
+            start)
+        end
+        CompositeSubscription.new [subscription, delays]
+      end
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/do.rb

@@ -0,0 +1,42 @@
+module RxRuby
+  module Observable
+    def do(observer_or_on_next = nil, on_error_func = nil, on_completed_func = nil)
+      if block_given?
+        on_next_func = Proc.new
+      elsif Proc === observer_or_on_next
+        on_next_func = observer_or_on_next
+      else
+        on_next_func = observer_or_on_next.method(:on_next)
+        on_error_func = observer_or_on_next.method(:on_error)
+        on_completed_func = observer_or_on_next.method(:on_completed)
+      end
+      AnonymousObservable.new do |observer|
+        subscribe(
+          lambda {|x|
+            begin
+              on_next_func.call x
+            rescue => e
+              observer.on_error e
+            end
+            observer.on_next x
+          },
+          lambda {|err|
+            begin
+              on_error_func && on_error_func.call(x)
+            rescue => e
+              observer.on_error e
+            end
+            observer.on_error err
+          },
+          lambda {
+            begin
+              on_completed_func && on_completed_func.call
+            rescue => e
+              observer.on_error e
+            end
+            observer.on_completed
+          })
+      end
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/for.rb

@@ -0,0 +1,13 @@
+module RxRuby
+  class << Observable
+    def for(sources, result_selector = nil)
+      result_selector ||= lambda {|*args| args}
+      enum = Enumerator.new {|y|
+        sources.each {|v|
+          y << result_selector.call(v)
+        }
+      }
+      Observable.concat(enum)
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/fork_join.rb

@@ -0,0 +1,55 @@
+module RxRuby
+  class << Observable
+    def fork_join(*all_sources)
+      AnonymousObservable.new {|subscriber|
+        count = all_sources.length
+        if count == 0
+          subscriber.on_completed
+          Subscription.empty
+        end
+        group = CompositeSubscription.new
+        finished = false
+        has_results = Array.new(count)
+        has_completed  = Array.new(count)
+        results  = Array.new(count)
+
+        count.times {|i|
+          source = all_sources[i]
+          group.push(
+            source.subscribe(
+              lambda {|value|
+                if !finished
+                  has_results[i] = true
+                  results[i] = value
+                end
+              },
+              lambda {|e|
+                finished = true
+                subscriber.on_error e
+                group.dispose
+              },
+              lambda {
+                if !finished
+                  if !has_results[i]
+                      subscriber.on_completed
+                      return
+                  end
+                  has_completed[i] = true
+                  count.times {|ix|
+                    if !has_completed[ix]
+                      return
+                    end
+                  }
+                  finished = true
+                  subscriber.on_next results
+                  subscriber.on_completed
+                end
+              }
+            )
+          )
+        }
+        group
+      }
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/from.rb

@@ -0,0 +1,34 @@
+module RxRuby
+  class << Observable
+    def from(iterable, map_fn = nil, scheduler = CurrentThreadScheduler.instance)
+      it = iterable.to_enum
+      AnonymousObservable.new {|observer|
+        i = 0
+        scheduler.schedule_recursive lambda {|this|
+          begin
+            result = it.next
+          rescue StopIteration => e
+            observer.on_completed
+            return
+          rescue => e
+            observer.on_error e
+            return
+          end
+
+          if Proc === map_fn
+            begin
+              result = map_fn.call(result, i)
+            rescue => e
+              observer.on_error e
+              return
+            end
+          end
+
+          observer.on_next result
+          i += 1
+          this.call
+        }
+      }
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/group_join.rb

@@ -0,0 +1,108 @@
+module RxRuby
+  module Observable
+    def group_join(right, left_duration_selector, right_duration_selector, result_selector)
+      AnonymousObservable.new do |observer|
+        group = CompositeSubscription.new
+        r = RefCountSubscription.new(group)
+        left_map = {}
+        right_map = {}
+        left_id = 0
+        right_id = 0
+
+        left_obs = Observer.configure do |o|
+          o.on_next {|value|
+            s = Subject.new
+            id = left_id
+            left_id += 1
+            left_map[id] = s
+
+            begin
+              result = result_selector.call(value, s.add_ref(r))
+            rescue => err
+              left_map.values.each {|v| v.on_error(err) }
+              observer.on_error(err)
+              next
+            end
+            observer.on_next(result)
+
+            right_map.values.each {|v| s.on_next(v) }
+
+            md = SingleAssignmentSubscription.new
+            group.push md
+
+            expire = lambda {
+              if left_map.delete(id)
+                s.on_completed
+              end
+              group.delete(md)
+            }
+
+            begin
+              duration = left_duration_selector.call(value)
+            rescue => err
+              left_map.values.each {|v| v.on_error(err) }
+              observer.on_error(err)
+              next
+            end
+
+            md.subscription = duration.take(1).subscribe(
+              lambda {|_| },
+              lambda {|e|
+                left_map.values.each {|v| v.on_error(e) }
+                observer.on_error(e)
+              },
+              expire)
+          }
+
+          o.on_error {|e|
+            left_map.values.each {|v| v.on_error(e) }
+            observer.on_error(e)
+          }
+
+          o.on_completed(&observer.method(:on_completed))
+        end
+        group.push self.subscribe(left_obs)
+
+        right_obs = Observer.configure do |o|
+          o.on_next {|value|
+            id = right_id
+            right_id += 1
+            right_map[id] = value
+
+            md = SingleAssignmentSubscription.new
+            group.push md
+
+            expire = lambda {
+              right_map.delete(id)
+              group.delete(md)
+            }
+
+            begin
+              duration = right_duration_selector.call(value)
+            rescue => err
+              right_map.values.each {|v| v.on_error(err) }
+              observer.on_error(err)
+              next
+            end
+
+            md.subscription = duration.take(1).subscribe(
+              lambda {|_| },
+              lambda {|e|
+                left_map.values.each {|v| v.on_error(e) }
+                observer.on_error(e)
+              },
+              expire)
+          }
+
+          o.on_error {|e|
+            left_map.values.each {|v| v.on_error(e) }
+            observer.on_error(e)
+          }
+        end
+        group.push right.subscribe(right_obs)
+
+        r
+      end
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/if.rb

@@ -0,0 +1,17 @@
+module RxRuby
+  class << Observable
+    def if(condition, then_source, else_source_or_scheduler = nil)
+      case else_source_or_scheduler
+      when Scheduler
+        scheduler = else_source_or_scheduler
+        else_source = Observable.empty(scheduler)
+      when Observable
+        else_source = else_source_or_scheduler
+      when nil
+        else_source = Observable.empty
+      end
+
+      return condition.call ? then_source : else_source
+    end
+  end
+end

data/lib/rx_ruby/linq/observable/interval.rb

@@ -0,0 +1,5 @@
+module RxRuby::Observable
+  def self.interval(period, scheduler = RxRuby::DefaultScheduler.instance)
+    observable_timer_time_span_and_period(period, period, scheduler)
+  end
+end

data/lib/rx_ruby/linq/observable/multicast.rb

@@ -0,0 +1,14 @@
+module RxRuby
+  module Observable
+    def multicast(subject_or_subject_selector, selector = nil)
+      if Proc === subject_or_subject_selector
+        AnonymousObservable.new do |observer|
+          connectable = self.multicast(subject_or_subject_selector.call)
+          CompositeSubscription.new [selector.call(connectable).subscribe(observer), self]
+        end
+      else
+        ConnectableObservable.new(self, subject_or_subject_selector)
+      end
+    end
+  end
+end