rx 0.0.2

data/lib/rx_ruby/internal/util.rb

@@ -0,0 +1,9 @@
+module RxRuby
+  module Observable
+    def add_ref(r)
+      AnonymousObservable.new do |observer|
+        CompositeSubscription.new [r.subscription, self.subscribe(observer)]
+      end
+    end
+  end
+end

data/lib/rx_ruby/joins/active_plan.rb

@@ -0,0 +1,45 @@
+module RxRuby
+  class ActivePlan
+    def initialize(join_observer_array, on_next, on_completed)
+      @join_observer_array = join_observer_array
+      @on_next = on_next
+      @on_completed = on_completed
+      @join_observers = {}
+      @join_observer_array.each {|x|
+        @join_observers[x] = x
+      }
+    end
+
+    def dequeue
+      @join_observers.each {|_, v| v.queue.shift }
+    end
+
+    def match
+      has_values = true
+      @join_observer_array.each {|v|
+        if v.queue.length == 0
+          has_values = false
+          break
+        end
+      }
+      if has_values
+        first_values = []
+        is_completed = false
+        @join_observer_array.each {|v|
+          first_values.push v.queue[0]
+          is_completed = true if v.queue[0].on_completed?
+        }
+        if is_completed
+          @on_completed.call
+        else
+          dequeue
+          values = []
+          first_values.each {|v|
+            values.push v.value
+          }
+          @on_next.call(*values)
+        end
+      end
+    end
+  end
+end

data/lib/rx_ruby/joins/join_observer.rb

@@ -0,0 +1,51 @@
+module RxRuby
+  class JoinObserver < ObserverBase
+
+    attr_reader :queue
+    def initialize(source, on_error)
+      super Observer.configure {|o|
+        o.on_next {|notification|
+          if !@is_disposed
+            if notification.on_error?
+              @on_error.call(notification.exception)
+              next
+            end
+            @queue.push notification
+            @active_plans.dup.each {|v|
+              v.match
+            }
+          end
+        }
+      }
+      @source = source
+      @on_error = on_error
+      @queue = []
+      @active_plans = []
+      @subscription = SingleAssignmentSubscription.new
+      @is_disposed = false
+    end
+
+    def add_active_plan(active_plan)
+      @active_plans.push active_plan
+    end
+
+    def subscribe
+      @subscription.subscription = @source.materialize.subscribe(@config)
+    end
+
+    def remove_active_plan(active_plan)
+      if idx = @active_plans.index(active_plan)
+        @active_plans.delete_at idx
+      end
+      self.unsubscribe if @active_plans.length == 0
+    end
+
+    def unsubscribe
+      super
+      if !@is_disposed
+        @is_disposed = true
+        @subscription.unsubscribe
+      end
+    end
+  end
+end

data/lib/rx_ruby/joins/pattern.rb

@@ -0,0 +1,14 @@
+module RxRuby
+  class Pattern
+    attr_reader :patterns
+    def initialize(patterns)
+      @patterns = patterns
+    end
+    def and(other)
+      Pattern.new(@patterns.concat(other))
+    end
+    def then_do(selector = Proc.new)
+      Plan.new(self, selector)
+    end
+  end
+end

data/lib/rx_ruby/joins/plan.rb

@@ -0,0 +1,44 @@
+module RxRuby
+  class Plan
+    def initialize(expression, selector)
+      @expression = expression
+      @selector = selector
+    end
+
+    def activate(external_subscriptions, observer, deactivate)
+      join_observers = []
+      @expression.patterns.each {|pat|
+        join_observers.push plan_create_observer(external_subscriptions, pat, observer.method(:on_error))
+      }
+
+      active_plan = ActivePlan.new(join_observers, lambda {|*args|
+        begin
+          result = @selector.call(*args)
+        rescue => e
+          observer.on_error e
+        end
+        observer.on_next result
+      },
+      lambda {
+        join_observers.each {|v|
+          v.remove_active_plan(active_plan)
+        }
+        deactivate.call(active_plan)
+      })
+      join_observers.each {|v|
+        v.add_active_plan(active_plan)
+      }
+      return active_plan
+    end
+
+    def plan_create_observer(external_subscriptions, observable, on_error)
+      entry = external_subscriptions[observable]
+      if !entry
+        observer = JoinObserver.new(observable, on_error)
+        external_subscriptions[observable] = observer
+        return observer
+      end
+      entry
+    end
+  end
+end

data/lib/rx_ruby/linq/connectable_observable.rb

@@ -0,0 +1,34 @@
+module RxRuby
+  class ConnectableObservable < AnonymousObservable
+    def initialize(source, subject)
+      @has_subscription = false
+      @subscription = nil
+      @source_observable = source.as_observable
+      @subject = subject
+
+      super(&subject.method(:subscribe))
+    end
+
+    def connect
+      unless @has_subscription
+        @has_subscription = true
+        @subscription = CompositeSubscription.new [@source_observable.subscribe(@subject), Subscription.create { @has_subscription = false }]
+      end
+      @subscription
+    end
+
+    def ref_count
+      count = 0
+      AnonymousObservable.new do |observer|
+        count += 1
+        should_connect = true if count == 1
+        connectable_subscription = self.connect if should_connect
+        Subscription.create {
+          @subscription.unsubscribe
+          count -= 1
+          connectable_subscription.unsubscribe if count == 0
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module RxRuby
+  class << Observable
+    private
+    def observable_timer_date_and_period(due_time, period, scheduler)
+      AnonymousObservable.new do |observer|
+        count = 0
+        d = due_time
+        p = Scheduler.normalize(period)
+        scheduler.schedule_recursive_absolute(d, lambda {|this|
+          if p > 0
+            now = scheduler.now()
+            d = d + p
+            d <= now && (d = now + p)
+          end
+          observer.on_next(count)
+          count += 1
+          this.call(d)
+        })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module RxRuby
+  class << Observable
+    private
+    def observable_timer_time_span(due_time, scheduler)
+      AnonymousObservable.new do |observer|
+        scheduler.schedule_relative(Scheduler.normalize(due_time),
+          lambda {
+            observer.on_next(0)
+            observer.on_completed
+          })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module RxRuby
+  class << Observable
+    private
+    def observable_timer_time_span_and_period(due_time, period, scheduler)
+      if due_time == period
+        AnonymousObservable.new do |observer|
+          scheduler.schedule_periodic_with_state(0, period,
+            lambda {|count|
+              observer.on_next(count)
+              count + 1
+            })
+        end
+      else
+        Observable.defer {
+          observable_timer_date_and_period(scheduler.now() + due_time, period, scheduler)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'rx_ruby/operators/aggregates.rb'
+
+module RxRuby
+  module Observable
+    alias :aggregate :reduce
+  end
+end

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

@@ -0,0 +1,7 @@
+module RxRuby
+  module Observable
+    def and(right)
+      Pattern.new([self, right]);
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module RxRuby
+  class << Observable
+    def case(selector, sources, defaultSourceOrScheduler = Observable.empty)
+      defer {
+        if Scheduler === defaultSourceOrScheduler
+          defaultSourceOrScheduler = Observable.empty(defaultSourceOrScheduler)
+        end
+
+        result = sources[selector.call]
+        result || defaultSourceOrScheduler
+      }
+    end
+    alias :switchCase :case
+  end
+end

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

@@ -0,0 +1,7 @@
+module RxRuby
+  module Observable
+    def concat_all
+      merge_concurrent(1)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module RxRuby
+  module Observable
+    def concat_map(selector, result_selector = nil)
+      if Proc === result_selector
+        return concat_map(lambda {|x, i|
+          selector_result = selector.call(x, i)
+          if selector_result.respond_to?(:each)
+            selector_result = Observable.from(selector_result)
+          end
+          selector_result.map_with_index {|y, i2|
+            result_selector.call(x, y, i, i2)
+          }
+        })
+      end
+
+      if Proc === selector
+        _concat_map(selector)
+      else
+        _concat_map(lambda {|*_| selector })
+      end
+    end
+
+    private
+
+    def _concat_map(selector)
+      map_with_index {|x, i|
+        result = selector.call(x, i)
+        if result.respond_to?(:each)
+          result = Observable.from(result)
+        end
+        result
+      }.concat_all
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module RxRuby
+  module Observable
+    def concat_map_observer(on_next, on_error, on_completed)
+      AnonymousObservable.new do |observer|
+        index = 0
+
+        subscribe(
+          lambda {|x|
+            begin
+              result = on_next.call(x, index)
+              index += 1
+            rescue => e
+              observer.on_error e
+              return
+            end
+            observer.on_next result
+          },
+          lambda {|err|
+            begin
+              result = on_error.call(err)
+            rescue => e
+              observer.on_error e
+              return
+            end
+
+            observer.on_next result
+            observer.on_completed
+          },
+          lambda {
+            begin
+              result = on_completed.call
+            rescue => e
+              observer.on_error e
+              return
+            end
+
+            observer.on_next result
+            observer.on_completed
+          })
+      end.concat_all
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module RxRuby
+  module Observable
+    def contains(search_element, from_index = 0)
+      AnonymousObservable.new do |observer|
+        i = 0
+        n = from_index
+        if n < 0
+          observer.on_next false
+          observer.on_completed
+          return Subscription.empty
+        end
+
+        subscribe(
+          lambda {|x|
+            if i.tap { i += 1 } >= n && x == search_element
+              observer.on_next true
+              observer.on_completed
+            end
+          },
+          observer.method(:on_error),
+          lambda {
+            observer.on_next false
+            observer.on_completed
+          })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module RxRuby
+  module Observable
+    def debounce(due_time, scheduler = DefaultScheduler.instance)
+      AnonymousObservable.new do |observer|
+        cancelable = SerialSubscription.new
+        hasvalue = false
+        value = nil
+        id = 0
+
+        subscription = subscribe(
+          lambda {|x|
+            hasvalue = true
+            value = x
+            id += 1
+            current_id = id
+            d = SingleAssignmentSubscription.new
+            cancelable.subscription = d
+            d.subscription = scheduler.schedule_relative(due_time, lambda {
+              observer.on_next value if hasvalue && id == current_id
+              hasvalue = false
+            })
+          },
+          lambda {|e|
+            cancelable.dispose
+            observer.on_error e
+            hasvalue = false
+            id += 1
+          },
+          lambda {
+            cancelable.dispose
+            observer.on_next value if hasvalue
+            observer.on_completed
+            hasvalue = false
+            id += 1
+          })
+
+        CompositeSubscription.new [subscription, cancelable]
+      end
+    end
+  end
+end