rx 0.0.2

data/examples/count.rb

@@ -0,0 +1,36 @@
+require 'rx_ruby'
+
+#  Without a predicate
+source = RxRuby::Observable.range(0, 10).count
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 10
+# => Completed
+
+#  With a predicate
+source = RxRuby::Observable.range(0, 10)
+    .count {|x| x % 2 === 0 }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 5
+# => Completed

data/examples/create.rb

@@ -0,0 +1,55 @@
+require 'rx_ruby'
+
+#  Using a function
+source = RxRuby::Observable.create {|observer|
+    observer.on_next(42)
+    observer.on_completed
+
+    # Note that this is optional, you do not have to return this if you require no cleanup
+    lambda {
+        puts 'disposed'
+    }
+}
+
+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
+
+#  Using a disposable
+source = RxRuby::Observable.create {|observer|
+    observer.on_next(42)
+    observer.on_completed
+
+    # Note that this is optional, you do not have to return this if you require no cleanup
+    RxRuby::Disposable.create {
+        puts 'disposed'
+    }
+}
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Completed

data/examples/debounce.rb

@@ -0,0 +1,35 @@
+require 'rx_ruby'
+
+times = [
+    { value: 0, time: 0.1 },
+    { value: 1, time: 0.6 },
+    { value: 2, time: 0.4 },
+    { value: 3, time: 0.7 },
+    { value: 4, time: 0.2 }
+]
+
+# Delay each item by time and project value
+source = RxRuby::Observable.from(times)
+  .flat_map {|item|
+    RxRuby::Observable.of(item[:value])
+      .delay(item[:time])
+  }
+  .debounce 0.5 # ms
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Next: 3
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/default_if_empty.rb

@@ -0,0 +1,35 @@
+require 'rx_ruby'
+
+#  Without a default value
+source = RxRuby::Observable.empty.default_if_empty
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.inspect
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: nil
+# => Completed
+
+#  With a default_value
+source = RxRuby::Observable.empty.default_if_empty(false)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: false
+# => Completed

data/examples/defer.rb

@@ -0,0 +1,20 @@
+require 'rx_ruby'
+
+#  Using an observable sequence
+source = RxRuby::Observable.defer {
+    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
+# => Completed

data/examples/delay.rb

@@ -0,0 +1,49 @@
+require 'rx_ruby'
+
+#  Using an absolute time to delay by a second
+source = RxRuby::Observable.range(0, 3)
+    .delay(Time.now + 1)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 0
+# => Next: 1
+# => Next: 2
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end
+
+#  Using an relatove time to delay by a second
+source = RxRuby::Observable.range(0, 3)
+    .delay(1)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 0
+# => Next: 1
+# => Next: 2
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/delay_with_selector.rb

@@ -0,0 +1,63 @@
+require 'rx_ruby'
+
+#  With subscription_delay
+source = RxRuby::Observable
+    .range(0, 3)
+    .delay_with_selector(
+        RxRuby::Observable.timer(0.3),
+        lambda {|x|
+            return RxRuby::Observable.timer(x * 0.4)
+        }
+    )
+    .time_interval
+    .map {|x| x.value.to_s + ':' + x.interval.to_s }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 0:0.3
+# => Next: 1:0.4
+# => Next: 2:0.4
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end
+
+#  Without subscription_delay
+source = RxRuby::Observable
+    .range(0, 3)
+    .delay_with_selector(
+        lambda {|x|
+            return RxRuby::Observable.timer(x * 0.4)
+        })
+    .time_interval
+    .map {|x| x.value.to_s + ':' + x.interval.to_s }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 0:0
+# => Next: 1:0.4
+# => Next: 2:0.4
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/dematerialize.rb

@@ -0,0 +1,22 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable
+    .from_array([
+        RxRuby::Notification.create_on_next(42),
+        RxRuby::Notification.create_on_error(Exception.new('woops'))
+    ])
+    .dematerialize
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Error: woops

data/examples/disposable.rb

@@ -0,0 +1,12 @@
+require 'rx_ruby'
+
+disposable = RxRuby::Disposable.create {
+    puts 'disposed'
+}
+
+disposable.dispose
+# => disposed
+
+disposable = RxRuby::Disposable.empty
+
+disposable.dispose # Does nothing

data/examples/distinct.rb

@@ -0,0 +1,43 @@
+require 'rx_ruby'
+
+#  Without key selector
+source = RxRuby::Observable.from_array([
+        42, 24, 42, 24
+    ])
+    .distinct
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Next: 24
+# => Completed
+
+#  With key selector
+source = RxRuby::Observable.from_array([
+        {value: 42}, {value: 24}, {value: 42}, {value: 24}
+    ])
+    .distinct {|x| x[:value] }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: {:value=>42}
+# => Next: {:value=>24}
+# => Completed

data/examples/distinct_until_changed.rb

@@ -0,0 +1,43 @@
+require 'rx_ruby'
+
+#  Without key selector
+source = RxRuby::Observable.from_array([
+        42, 42, 24, 24
+    ])
+    .distinct_until_changed
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Next: 24
+# => Completed
+
+#  With key selector
+source = RxRuby::Observable.from_array([
+        {value: 42}, {value: 42}, {value: 24}, {value: 24}
+    ])
+    .distinct_until_changed {|x| x[:value] }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: {:value=>42}
+# => Next: {:value=>24}
+# => Completed

data/examples/do.rb

@@ -0,0 +1,59 @@
+require 'rx_ruby'
+
+#  Using a function
+source = RxRuby::Observable.range(0, 3)
+  .do(
+    lambda {|x|   puts 'Do Next:' + x.to_s },
+    lambda {|err| puts 'Do Error:' + err.to_s },
+    lambda {      puts 'Do Completed' }
+  )
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Do Next: 0
+# => Next: 0
+# => Do Next: 1
+# => Next: 1
+# => Do Next: 2
+# => Next: 2
+# => Do Completed
+# => Completed
+
+#  Using an observer
+observer = RxRuby::Observer.create(
+  lambda {|x|   puts 'Do Next: ' + x.to_s },
+  lambda {|err| puts 'Do Error: ' + err.to_s },
+  lambda {      puts 'Do Completed' }
+)
+
+source = RxRuby::Observable.range(0, 3)
+    .do(observer)
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Do Next: 0
+# => Next: 0
+# => Do Next: 1
+# => Next: 1
+# => Do Next: 2
+# => Next: 2
+# => Do Completed
+# => Completed