rx 0.0.2

data/examples/empty.rb

@@ -0,0 +1,16 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable.empty
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Completed

data/examples/for.rb

@@ -0,0 +1,26 @@
+require 'rx_ruby'
+
+#  Using Observables
+array = [1, 2, 3]
+
+source = RxRuby::Observable.for(
+    array,
+    lambda {|x|
+        RxRuby::Observable.return(x)
+    })
+
+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: 3
+# => Completed

data/examples/fork_join.rb

@@ -0,0 +1,23 @@
+require 'rx_ruby'
+
+#  Using observables and Promises
+source = RxRuby::Observable.fork_join(
+    RxRuby::Observable.return(42),
+    RxRuby::Observable.range(0, 10),
+    RxRuby::Observable.from_array([1,2,3]),
+    RxRuby::Observable.return(56)
+)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: [42, 9, 3, 56]
+# => Completed

data/examples/from.rb

@@ -0,0 +1,106 @@
+require 'rx_ruby'
+
+# Array-like object (arguments) to Observable
+def f(*arguments)
+  RxRuby::Observable.from(arguments)
+end
+
+f(1, 2, 3).subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+
+# => Next: 1
+# => Next: 2
+# => Next: 3
+# => Completed
+
+# Any iterable object...
+s = ["foo", :window]
+RxRuby::Observable.from(s).subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+# => Next: foo
+# => Next: window
+# => Completed
+
+# Map
+m = {1 => 2, 2 => 4, 4 => 8}
+RxRuby::Observable.from(m).subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+# => Next: [1, 2]
+# => Next: [2, 4]
+# => Next: [4, 8]
+# => Completed
+
+# String
+RxRuby::Observable.from("foo".to_enum(:each_char)).subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+# => Next: f
+# => Next: o
+# => Next: o
+# => Completed
+
+# Using an arrow function as the map function to
+# manipulate the elements
+RxRuby::Observable.from([1, 2, 3], lambda {|x, i| x + x }).subscribe(
+  lambda {|x|
+    puts 'Next: ' + x.to_s
+  },
+  lambda {|err|
+    puts 'Error: ' + err.to_s
+  },
+  lambda {
+    puts 'Completed'
+  })
+# => Next: 2
+# => Next: 4
+# => Next: 6
+# => Completed
+
+# Generate a sequence of numbers
+RxRuby::Observable.from(5.times, lambda {|v, k| k }).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: 3
+# => Next: 4
+# => Completed

data/examples/from_array.rb

@@ -0,0 +1,21 @@
+require 'rx_ruby'
+
+array = [1,2,3]
+
+source = RxRuby::Observable.from_array(array)
+
+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: 3
+# => Completed

data/examples/from_callback.rb

@@ -0,0 +1,21 @@
+require 'rx_ruby'
+
+# Wrap fs.exists
+exists = RxRuby::Observable.from_callback(File.method(:exist?))
+
+# Check if file.txt exists
+source = exists.call('file.txt')
+
+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/generate.rb

@@ -0,0 +1,24 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable.generate(
+    0,
+    lambda {|x| x < 3 }, # condition
+    lambda {|x| x + 1 }, # iterate
+    lambda {|x| x }  # resultSelector
+)
+
+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

data/examples/group_join.rb

@@ -0,0 +1,39 @@
+require 'rx_ruby'
+
+xs = RxRuby::Observable.interval(0.1)
+    .map {|x| 'first' + x.to_s }
+
+ys = RxRuby::Observable.interval(0.1)
+    .map {|x| 'second' + x.to_s }
+
+source = xs.group_join(
+    ys,
+    lambda {|_| return RxRuby::Observable.timer(0) },
+    lambda {|_| return RxRuby::Observable.timer(0) },
+    lambda {|x, yy|
+        return yy.map {|y|
+            x + y
+        }
+    }).merge_all.take(5)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: first0second0
+# => Next: first1second1
+# => Next: first2second2
+# => Next: first3second3
+# => Next: first4second4
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/if.rb

@@ -0,0 +1,46 @@
+require 'rx_ruby'
+
+# This uses and only then source
+should_run = true
+
+source = RxRuby::Observable.if(
+    lambda { return should_run },
+    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
+
+# The next example uses an elseSource
+should_run = false
+
+source = RxRuby::Observable.if(
+    lambda { return should_run },
+    RxRuby::Observable.return(42),
+    RxRuby::Observable.return(56)
+)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 56
+# => Completed

data/examples/intervals.rb

@@ -0,0 +1,26 @@
+require 'rx_ruby'
+
+source = RxRuby::Observable
+    .interval(0.5) # ms
+    .time_interval
+    .take(3)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: (0)@(0.5120988)
+# => Next: (1)@(0.5000763)
+# => Next: (2)@(0.515575)
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/merge.rb

@@ -0,0 +1,36 @@
+require 'rx_ruby'
+
+source1 = RxRuby::Observable.interval(0.1)
+    .time_interval()
+    .pluck('interval')
+    .take(3)
+source2 = RxRuby::Observable.interval(0.15)
+    .time_interval()
+    .pluck('interval')
+    .take(2)
+
+source = RxRuby::Observable.merge(
+    source1,
+    source2)
+
+subscription = source.subscribe(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    })
+
+# => Next: 100
+# => Next: 150
+# => Next: 100
+# => Next: 150
+# => Next: 100
+# => Completed
+
+while Thread.list.size > 1
+  (Thread.list - [Thread.current]).each &:join
+end

data/examples/merge_all.rb

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

data/examples/multicast.rb

@@ -0,0 +1,32 @@
+require 'rx_ruby'
+
+subject = RxRuby::Subject.new
+source = RxRuby::Observable.range(0, 3)
+    .multicast(subject)
+
+observer = RxRuby::Observer.create(
+    lambda {|x|
+        puts 'Next: ' + x.to_s
+    },
+    lambda {|err|
+        puts 'Error: ' + err.to_s
+    },
+    lambda {
+        puts 'Completed'
+    }
+)
+
+subscription = source.subscribe(observer)
+subject.subscribe(observer)
+
+connected = source.connect
+
+subscription.dispose
+
+# => Next: 0
+# => Next: 0
+# => Next: 1
+# => Next: 1
+# => Next: 2
+# => Next: 2
+# => Completed