exports.observerFromTopic = function (sns, params) {
return Rx.Observer.create(function (messageParams) {
sns.publish(_.defaults(messageParams, params), function (err, data) {
});
});
};
function clientStream(socket) {
const outgoing = Observer.create(
function onNext(msg) {
socket.emit('toserver', msg);
}
);
const incoming = Observable.create(observer => {
observer.onNext(connectionStatus(WAITING));
socket.on('connect', function onConnect() {
observer.onNext(connectionStatus(CONNECTED));
});
socket.on('fromserver', function onOpen(msg) {
observer.onNext(msg);
});
socket.on('disconnect', function onDisconnect() {
observer.onNext(connectionStatus(DISCONNECTED));
});
});
return Subject.create(outgoing, incoming);
}
function fromFtpSocket(host, port) {
var ftpSocket = Net.createConnection(port, host);
var observable = RxNode.fromStream(ftpSocket);
var observer = Rx.Observer.create(ftpSocket.send);
return Rx.Subject.create(observer, observable);
}
function createObserver(tag) {
return Rx.Observer.create(
x => console.log(tag + ' : ' + x),
err => console.error(err),
_ => console.log('DONE')
)
}
exports.observerFromQueue = function (sqs, params) {
return Rx.Observer.create(function (messageParams) {
sqs.sendMessage(_.defaults(messageParams, params), function (err, data) {
});
});
};
it("returns an array of primes", function (done) {
console.time("Primes test");
//var primesObservable = require('./primes.model').fromJsonFileStream(path.resolve(__dirname, 'data/1000.primes.json'));
var primesObservable = require('./primes.model').fromJsonFile(path.resolve(__dirname, 'data/1000.primes.json'));
var primesCounter = 0;
var observer = Rx.Observer.create(
function(next){
logger.debug("Value obtained: " + next);
primesCounter++;
},
function(error){
logger.error("Error obtained: " + error);
expect(true).to.equal(false);
},
function(){
expect(primesCounter).to.equal(1000);
logger.info("Completed");
console.timeEnd("Primes test");
done();
}
);
primesObservable.subscribe(observer);
})
const tap = (name = '?') => Observer.create(
x =>
log.trace(`[${name}] next:`, x),
e =>
log.warn(`[${name}] error:`, e),
() =>
log.trace(`[${name}] completed.`)
);
function ObservableScanner(observable) {
var _this = this;
_super.call(this);
this.buffer = new Buffer();
this.output = this.buffer.output;
observable.subscribe(Rx.Observer.create(function (x) {
return _this.buffer.input.onNext(x);
}));
}
function fromFtpSocket(host, port) {
let ftpSocket = Net.createConnection(port, host);
let source$ = RxNode.fromStream(ftpSocket);
//let cmd$ = new Rx.Subject();
let observer = Rx.Observer.create(cmd => {
//cmd$.onNext(cmd);
ftpSocket.send(cmd + '\r\n');
});
return Rx.Subject.create(observer, source$);
}
function createObserver(tag) {
return Rx.Observer.create(
function (x) {
console.log('Next: ' + tag + ': ' + x.toString());
},
function (err) {
console.log('Error: ' + err);
},
function () {
console.log('Completed');
});
}
env.response.on(ev, function(arg0) {
var pipeline = env.pipeline('websocket:' + ev);
if (pipeline) {
if (ev === 'message') {
env.response.message = arg0;
} else if (ev === 'error') {
env.response.error = arg0;
}
pipeline.observe(env).subscribe(Rx.Observer.create());
}
});
function(observer) {
var perDeviceFlow = {};
function buildNewFlow(deviceName) {
deviceFlow = new rx.Subject();
deviceFlow
.selfJoin(makeFirstCompleteScheduleHandler())
.apply(marrySettings(configFn))
.subscribe(function (e){
observer.onNext(e);
},
function(err) {
retVal.onError(err);
},
function(){
delete perDeviceFlow[deviceName];
if (_.isEmpty(perDeviceFlow)) {
observer.onCompleted();
}
});
return deviceFlow;
}
var retVal = rx.Observer.create(
function(e) {
if (e.type !== 'settingsPart') {
return observer.onNext(e);
}
var deviceFlow = perDeviceFlow[e.deviceId];
if (deviceFlow == null) {
deviceFlow = buildNewFlow(e.deviceId);
perDeviceFlow[e.deviceId] = deviceFlow;
}
deviceFlow.onNext(e);
},
function(err) {
observer.onError(err);
},
function() {
Object.keys(perDeviceFlow).forEach(function(device){
perDeviceFlow[device].onCompleted();
});
}
);
return retVal;
});
handleMouseDown(event: Event): void {
const evt: MouseEvent = (event: any);
this._dragOrigin = {
x: evt.clientX - this._offset.x,
y: evt.clientY - this._offset.y,
};
this._ensureMouseSubscriptionDisposed();
this._mouseDisposable =
documentMouseMove$().takeUntil(documentMouseUp$()).subscribe(Rx.Observer.create(
(e: MouseEvent) => {this.handleGlobalMouseMove(e);},
(error: any) => {},
() => {this.handleGlobalMouseUp();},
));
}
export default function createObserver(socket) {
return Observer
.create(next => {
if (next instanceof Buffer) {
socket.write(next)
} else if (Array.isArray(next)) {
socket.write(generateCommandBuffer(...next))
}
}, err => {
socket.on('error', err)
}, done => {
socket.destroy()
})
}
it('should filter out actions without `type` property', () => {
let spy = sinon.spy();
let observer = Rx.Observer.create(
() => { spy(); },
() => { spy(); },
() => { spy(); }
);
dispatcher.stream.subscribe(observer);
dispatcher.dispatch({});
spy.called.should.be.false;
});
function printComponent(eventStream) {
var printObserver = rx.Observer.create(
function (message) {
console.log(message);
},
function (err) {
debug(err);
},
function () {
debug('completed');
}
);
var subscription = eventStream.subscribe(printObserver);
}
return function () {
var subject = createSubject(null, true);
var observer = Rx.Observer.create(function (x) {
subject.onNext(x, true);
});
var observable = Rx.Observable.create(function (obs) {
subject.subscribe(function (data, cb) {
process.nextTick(function () {
obs.onNext(data);
});
cb();
});
});
return Rx.Subject.create(observer, observable);
}
return this.link(function (outputObs) {
return rx.Observer.create(
function (e) {
bufferedString += e;
var splits = bufferedString.split('\n');
for (var i = 0; i < splits.length - 1; ++i) {
outputObs.onNext(splits[i] + '\n');
}
bufferedString = splits[splits.length - 1];
},
function (err) {
outputObs.onError(err);
},
function () {
outputObs.onNext(bufferedString);
outputObs.onCompleted();
}
)
});
function RxWebSocket(url) {
var WebSocket = require('ws');
var Rx = require('rx');
var socket = new WebSocket(url);
this.socket = socket; // FIXME: duplicated, for public
var observer = Rx.Observer.create(function (data) {
if (socket.readyState === WebSocket.OPEN) { socket.send(data); }
});
this.open = function () {
var observable = Rx.Observable.create(function (sub) {
socket.onopen = function (e) {
sub.onNext(socket);
sub.onCompleted();
};
});
return Rx.Subject.create(observer, observable);
//return observable;
};
this.message = function () {
var observable = Rx.Observable.create(function (sub) {
socket.onmessage = sub.onNext.bind(sub);
socket.onerror = sub.onError.bind(sub);
socket.onclose = sub.onCompleted.bind(sub);
return socket.close.bind(socket);
});
return Rx.Subject.create(observer, observable);
//return observable;
};
// Please use rxSocket.next(msg) instead
this.send = function (msg) {
if (socket.readyState === WebSocket.OPEN) { socket.send(data); }
};
// Or wait for auto closing when message() subscriptoin unsubscribed or onCompleted
this.close = function () {
socket.close();
}
}
import $ from 'jquery';
const toBtc = function(satoshi) {
return satoshi / 100000000;
}
/*
Defining the next and error callbacks of our Observable
*/
const openObs = Rx.Observer.create(e => {
console.info('socket open');
socket.onNext('{"op":"unconfirmed_sub"}');
});
const closeObs = Rx.Observer.create(() => {
console.log('socket is about to close');
});
/*
fromWebSocket takes two callbacks:
1. WS Open
2. WS Close
*/
const socket = Rx.DOM.fromWebSocket('wss://ws.blockchain.info/inv', null, openObs, closeObs);
return observable.link(function(observer) {
var currSettings = null;
var emittedSomething = false;
function err() {
retVal.onError(new Error(util.format.apply(util, Array.prototype.slice.call(arguments, 0))));
return false;
}
var settingsHandlers = {
activeSchedule: {
onLifecycleEnd: function(e) {
if (currSettings.activeBasalSchedule == null) {
currSettings.activeBasalSchedule = e.scheduleName;
} else if (currSettings.activeBasalSchedule !== e.scheduleName) {
return err(
'basalSchedules don\'t match, [%s] !== [%s], ts[%s]',
currSettings.activeBasalSchedule, e.scheduleName, e.deviceTime
);
}
},
onLifecycleStart: function(e) {
if (currSettings.activeBasalSchedule !== e.scheduleName) {
currSettings.activeBasalSchedule = null;
this.onLifecycleEnd(e);
misc.annotateEvent(currSettings, 'settings-mismatch/activeSchedule');
}
currSettings.deviceTime = e.deviceTime;
var retVal = currSettings;
currSettings = _.clone(retVal);
currSettings.activeBasalSchedule = e.previousSchedule;
return retVal;
}
},
bolusWizard: {
onLifecycleEnd: function(e) {
currSettings.carbRatio = e.payload.carbRatio;
currSettings.insulinSensitivity = e.payload.insulinSensitivity;
currSettings.bgTarget = e.payload.bgTarget;
currSettings.units = e.units;
},
onLifecycleStart: function(e) {
if (! this.isUpToDate(e)) {
this.onLifecycleEnd(e);
misc.annotateEvent(currSettings, 'settings-mismatch/wizard');
}
currSettings.deviceTime = e.deviceTime;
return currSettings;
},
isUpToDate: function(e) {
return _.isEqual(currSettings.carbRatio, e.payload.carbRatio)
&& _.isEqual(currSettings.insulinSensitivity, e.payload.insulinSensitivity)
&& _.isEqual(currSettings.bgTarget, e.payload.bgTarget)
&& _.isEqual(currSettings.units, e.units);
}
},
basalSchedule: {
onLifecycleEnd: function(e) {
currSettings.basalSchedules[e.scheduleName] = e.payload;
},
onLifecycleStart: function(e) {
if (! _.isEqual(currSettings.basalSchedules[e.scheduleName], e.payload)) {
this.onLifecycleEnd(e);
misc.annotateEvent(currSettings, 'settings-mismatch/basal');
}
currSettings.deviceTime = e.deviceTime;
var retVal = currSettings;
currSettings = _.cloneDeep(retVal);
currSettings.basalSchedules[e.scheduleName] = [];
return retVal;
}
}
};
var retVal = rx.Observer.create(
function(e){
if (! (e.type === 'settings' || e.type === 'settingsPart') ) {
observer.onNext(e);
return;
}
if (e.type === 'settings') {
if (currSettings == null && e.lifecycle === 'end') {
currSettings = e;
return;
} else {
err('Unexpected \'settings\' events in stream, ts[%s], lifecycle[%s]', e.deviceTime, e.lifecycle);
return;
}
}
if (! (e.lifecycle === 'start' || e.lifecycle === 'end') ) {
err('Unexpected lifecycle[%s], type[%s], subType[%s], ts[%s]', e.lifecycle, e.type, e.subType, e.deviceTime);
return;
}
var handler = settingsHandlers[e.subType];
if (handler == null) {
err('Unknown subType[%s] in stream, type[%s], ts[%s]', e.subType, e.type, e.deviceTime);
return;
}
if (e.lifecycle === 'end') {
handler.onLifecycleEnd(e);
} else {
var toEmit = handler.onLifecycleStart(e);
if (toEmit != null) {
emittedSomething = true;
observer.onNext(_.omit(toEmit, 'lifecycle'));
}
}
},
function(error) {
observer.onError(error);
},
function() {
var config = configFn();
if (! emittedSomething) {
// If we have gone through all of the data and we never emitted something, that means that the
// settings never changed throughout the entire data stream. In this case, we need to take the
// currSettings, which are derived from the settings at the time of upload, attach a timestamp
// of the earliest message we have seen and call that our settings.
//
// If, on the other hand, we did emit an event while processing, then it is actually impossible
// for us to know with 100% accuracy what the schedule was before that event, so we do not
// attempt to even guess.
observer.onNext(_.assign({}, _.omit(currSettings, 'lifecycle'), {deviceTime: config.startTime}));
}
observer.completed();
}
);
return retVal;
});
import Rx from 'rx';
import RxNode from 'rx-node';
import request from 'request';
var fetchContent = url => {
return Rx.Observable.create(observer => {
request(url, (error, response, body => {
if (error) {
observer.onError();
} else {
observer.onNext({
response,
body
});
observer.onCompleted();
}
}));
});
};
var observer = Rx.Observer.create(function (x) {
console.log('Next: %s', x);
}, function (err) {
console.log('Error: %s', err);
}, function () {
console.log('Completed');
});
var subscription = fetchContent('http://thewatchseries.to/serie/the_flash_2014_').subscribe(observer);
//# sourceMappingURL=rx.js.map
let observable = rx.Observable.create(function(observer) {
setTimeout(function() {
observer.onNext(1)
}, 1000)
setTimeout(function() {
observer.onCompleted()
}, 2000)
return function() {
// do cleanup if needed
console.log('cleanup observable')
}
})
let observer = rx.Observer.create(
function(x) {
console.log('onNext', x)
},
function(err) {
console.log('onError', err)
},
function() {
console.log('onCompleted')
}
)
observable.subscribe(observer)
// rewrite observer to be inline on subscribe
// stop observing
#!/usr/bin/env node
var Rx = require( 'rx' );
var symlinkDedupe = require( '../build/index' ).default;
var logObserver = Rx.Observer.create(
function( el ) {
console.log( el );
},
function( el ) {
console.error( el );
},
function( ) {
console.log( 'completed' );
}
);
symlinkDedupe( process.cwd() ).subscribe( logObserver );