Observable.combine -> Observable.combineLatest;

doc/README.md

@@ -18,7 +18,7 @@ RxLua
   - [fromCoroutine](#fromcoroutinecoroutine)
   - [dump](#dumpname-formatter)
   - [distinctUntilChanged](#distinctuntilchangedcomparator)
-  - [combine](#combineobservables-combinator)
+  - [combineLatest](#combinelatestobservables-combinator)
   - [compact](#compact)
   - [concat](#concatsources)
   - [distinct](#distinct)
@@ -223,7 +223,7 @@ Returns an Observable that only produces values from the original if they are di
 
 ---
 
-#### `:combine(observables, combinator)`
+#### `:combineLatest(observables, combinator)`
 
 Returns a new Observable that runs a combinator function on the most recent values from a set of Observables whenever any of them produce a new value. The results of the combinator function are produced by the new Observable.
 

src/observable.lua

@@ -155,7 +155,7 @@ end
 -- @arg {function} combinator - A function that combines the latest result from each Observable and
 --                              returns a single value.
 -- @returns {Observable}
-function Observable:combine(...)
+function Observable:combineLatest(...)
   local sources = {...}
   local combinator = table.remove(sources)
   if type(combinator) ~= 'function' then

tests/combine.lua → tests/combineLatest.lua

@@ -1,6 +1,6 @@
-describe('combine', function()
+describe('combineLatest', function()
   it('returns the observable it is called on if only the identity function is passed as an argument', function()
-    local observable = Rx.Observable.fromRange(1, 5):combine(function(x) return x end)
+    local observable = Rx.Observable.fromRange(1, 5):combineLatest(function(x) return x end)
     expect(observable).to.produce(1, 2, 3, 4, 5)
   end)
 
@@ -9,7 +9,7 @@ describe('combine', function()
     local observableB = Rx.Observable.fromValue('b')
     local observableC = Rx.Observable.fromValue('c')
     local combinator = spy()
-    Rx.Observable.combine(observableA, observableB, observableC, function(...) combinator(...) end):subscribe()
+    Rx.Observable.combineLatest(observableA, observableB, observableC, function(...) combinator(...) end):subscribe()
     expect(combinator).to.equal({{'a', 'b', 'c'}})
   end)
 
@@ -17,7 +17,7 @@ describe('combine', function()
     local observableA = Rx.Subject.create()
     local observableB = Rx.Subject.create()
     local onNext = spy()
-    Rx.Observable.combine(observableA, observableB, function(a, b) return a + b end):subscribe(Rx.Observer.create(onNext))
+    Rx.Observable.combineLatest(observableA, observableB, function(a, b) return a + b end):subscribe(Rx.Observer.create(onNext))
     expect(#onNext).to.equal(0)
     observableA:onNext(1)
     observableB:onNext(2)
@@ -30,7 +30,7 @@ describe('combine', function()
     local observableA = Rx.Subject.create()
     local observableB = Rx.Subject.create()
     local complete = spy()
-    Rx.Observable.combine(observableA, observableB, function() end):subscribe(nil, nil, complete)
+    Rx.Observable.combineLatest(observableA, observableB, function() end):subscribe(nil, nil, complete)
 
     expect(#complete).to.equal(0)
     observableA:onNext(1)
@@ -47,13 +47,13 @@ describe('combine', function()
     local observableA = Rx.Subject.create()
     local observableB = Rx.Subject.create()
     local errored = spy()
-    Rx.Observable.combine(observableA, observableB, function() end):subscribe(nil, errored)
+    Rx.Observable.combineLatest(observableA, observableB, function() end):subscribe(nil, errored)
     expect(#errored).to.equal(0)
     observableB:onError()
     expect(#errored).to.equal(1)
   end)
 
   it('should error if the combinator is absent', function()
-    expect(Rx.Observable.combine(Rx.Observable.fromRange(1, 3)).subscribe).to.fail()
+    expect(Rx.Observable.combineLatest(Rx.Observable.fromRange(1, 3)).subscribe).to.fail()
   end)
 end)