rx_ruby 0.0.2

data/examples/buffer_with_time.rb

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

data/examples/case.rb

@@ -0,0 +1,29 @@
+require 'rx_ruby'
+
+sources = {
+    'foo' => RxRuby::Observable.return(42),
+    'bar' => RxRuby::Observable.return(56)
+}
+
+defaultSource = RxRuby::Observable.empty()
+
+source = RxRuby::Observable.case(
+    lambda {
+        'foo'
+    },
+    sources,
+    defaultSource)
+
+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/catch.rb

@@ -0,0 +1,20 @@
+require 'rx_ruby'
+
+obs1 = RxRuby::Observable.raise_error(Exception.new('error'))
+obs2 = RxRuby::Observable.return(42)
+
+source = RxRuby::Observable.rescue_error(obs1, obs2)
+
+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/catchproto.rb

@@ -0,0 +1,39 @@
+require 'rx_ruby'
+
+#  Using a second observable
+source = RxRuby::Observable.raise_error(Exception.new)
+    .rescue_error(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
+
+#  Using a handler function
+source = RxRuby::Observable.raise_error(Exception.new)
+    .rescue_error {|e|
+        RxRuby::Observable.return(e.is_a? Exception)
+    }
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: true
+# => Completed

data/examples/combine_latest.rb

@@ -0,0 +1,35 @@
+require 'rx_ruby'
+
+# Have staggering intervals
+source1 = RxRuby::Observable.interval(0.1)
+    .map {|i| 'First: ' + i.to_s }
+
+source2 = RxRuby::Observable.interval(0.15)
+    .map {|i| 'Second: ' + i.to_s }
+
+# Combine latest of source1 and source2 whenever either gives a value
+source = RxRuby::Observable.combine_latest(
+        source1,
+        source2) {|s1, s2| s1.to_s + ', ' + s2.to_s }
+    .take(4)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: First: 0, Second: 0
+# => Next: First: 1, Second: 0
+# => Next: First: 1, Second: 1
+# => Next: First: 2, Second: 1
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/combine_latestproto.rb

@@ -0,0 +1,33 @@
+require 'rx_ruby'
+
+#  Have staggering intervals
+source1 = RxRuby::Observable.interval(0.1)
+    .map {|i| 'First: ' + i.to_s }
+
+source2 = RxRuby::Observable.interval(0.15)
+    .map {|i| 'Second: ' + i.to_s }
+
+# Combine latest of source1 and source2 whenever either gives a value
+source = source1.combine_latest(source2) {|s1, s2| s1 + ', ' + s2 }
+    .take(4)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: First: 0, Second: 0
+# => Next: First: 1, Second: 0
+# => Next: First: 1, Second: 1
+# => Next: First: 2, Second: 1
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/concat.rb

@@ -0,0 +1,22 @@
+require 'rx_ruby'
+
+#  Using Observable sequences
+source1 = RxRuby::Observable.return(42)
+source2 = RxRuby::Observable.return(56)
+
+source = RxRuby::Observable.concat(source1, source2)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Next: 56
+# => Completed

data/examples/concat_all.rb

@@ -0,0 +1,27 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable.range(0, 3)
+  .map {|x| RxRuby::Observable.range(x, 3) }
+  .concat_all
+
+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
+# => Next: 1
+# => Next: 2
+# => Next: 3
+# => Next: 2
+# => Next: 3
+# => Next: 4
+# => Completed

data/examples/concat_map.rb

@@ -0,0 +1,61 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable.range(0, 5)
+    .concat_map(lambda {|x, i|
+        return RxRuby::Observable
+            .interval(0.1)
+            .take(x).map { i }
+    })
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 1
+# => Next: 2
+# => Next: 2
+# => Next: 3
+# => Next: 3
+# => Next: 3
+# => Next: 4
+# => Next: 4
+# => Next: 4
+# => Next: 4
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end
+
+#  Using an array
+source = RxRuby::Observable.of(1,2,3)
+  .concat_map(
+    lambda {|x, i| return [x,i] },
+    lambda {|x, y, ix, iy| return x + y + ix + iy }
+  )
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 2
+# => Next: 2
+# => Next: 5
+# => Next: 5
+# => Next: 8
+# => Next: 8
+# => Completed

data/examples/concat_map_observer.rb

@@ -0,0 +1,29 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable.range(1, 3)
+    .concat_map_observer(
+        lambda {|x, i|
+            return RxRuby::Observable.repeat(x, i)
+        },
+        lambda {|err|
+            return RxRuby::Observable.return(42)
+        },
+        lambda {
+            return RxRuby::Observable.empty
+        })
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 2
+# => Next: 3
+# => Next: 3
+# => Completed

data/examples/concatproto.rb

@@ -0,0 +1,25 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable
+    .return(42)
+    .concat(RxRuby::Observable.return(56), RxRuby::Observable.return(72))
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 42
+# => Next: 56
+# => Next: 72
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/connect.rb

@@ -0,0 +1,41 @@
+require 'rx_ruby'
+
+interval = RxRuby::Observable.interval(1)
+
+source = interval
+    .take(2)
+    .do {|x| puts 'Side effect' }
+
+def create_observer(tag)
+    return RxRuby::Observer.create(
+        lambda {|x|
+            puts 'Next: ' + tag + x.to_s
+        },
+        lambda {|err|
+            puts 'Error: ' + err.to_s
+        },
+        lambda {
+            puts 'Completed'
+        })
+end
+
+published = source.publish
+
+published.subscribe(create_observer('SourceA'))
+published.subscribe(create_observer('SourceB'))
+
+# Connect the source
+connection = published.connect
+
+# => Side effect
+# => Next: SourceA0
+# => Next: SourceB0
+# => Side effect
+# => Next: SourceA1
+# => Next: SourceB1
+# => Completed
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/contains.rb

@@ -0,0 +1,37 @@
+require 'rx_ruby'
+
+#  Without an index
+source = RxRuby::Observable.of(42)
+  .contains(42)
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+      puts 'Completed'
+  })
+
+# => Next: true
+# => Completed
+
+#  With an index
+source = RxRuby::Observable.of(1,2,3)
+  .contains(2, 1)
+
+subscription = source.subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Next: true
+# => Completed