exports.createTestTable = function createTestTable () {
const subject$ = new Rx.ReplaySubject()
subject$.onNext(define(
'testset',
{ a: { type: Sequelize.STRING } },
{ freezeTableName: true }
))
return subject$
}
const createInitialTree = ({
initialState,
pauser,
hookMap,
createNode,
provisional,
provisionalNode
}) => {
if (!pauser) {
pauser = new Rx.BehaviorSubject(true);
}
if (!hookMap) {
hookMap = new WeakMap();
}
const addChildrenSubject = new Rx.Subject();
const getChildrenSubject = new Rx.BehaviorSubject({});
const childrenObservable = createChildrenObservable({
addChildrenSubject,
getChildrenSubject,
pauser,
hookMap,
createNode
});
const valueSubject = new Rx.ReplaySubject(1);
childrenObservable.subscribe(getChildrenSubject)
childrenObservable.subscribeOnError(err => { throw err });
if (!provisional) {
updateAddChildrenSubject(initialState, addChildrenSubject, pauser);
}
const valueObservable = createTreeObservable(childrenObservable)
.pausable(pauser);
const setNextState = createTreeSetNextState(childrenObservable, pauser);
valueObservable.subscribe(valueSubject);
const node = createNode({
addChildrenSubject,
getChildrenSubject,
pauser,
observable: valueSubject.asObservable(),
hookMap,
setNextState,
provisional,
provisionalNode
});
return node;
};
}).on("complete", function () {
var fastest = this.filter("fastest");
var fastestName = String(fastest.pluck("name"));
var fastestTime = parseFloat(this.filter("fastest").pluck("hz"));
var slowestTime = parseFloat(this.filter("slowest").pluck("hz"));
// percent change formula: ((V2 - V1) / |V1|) * 100
if(fastestName.substr(0, 3) === "new") {
complete.onNext("\t" + (Math.round((fastestTime - slowestTime) / slowestTime * 10000) / 100) + "% " + "faster".green +" than Rx\n");
} else {
complete.onNext("\t" + (Math.round((slowestTime - fastestTime) / fastestTime * 10000) / 100) + "% " + "slower".red + " than Rx\n");
}
}).run({ "async": true });
const createRouterObservable = (history, prefix='') => {
const historySubject = new Rx.BehaviorSubject(history.getCurrentLocation());
const routeSubject = new Rx.ReplaySubject();
let subRouters = [];
history.listen((location) => historySubject.onNext(location));
const route = (pattern, opts, cb) => {
const finalOpts = typeof opts === 'function' ? { stream: opts } : opts;
const joinedPattern = joinPattern(prefix, pattern);
const subRouter = typeof cb === 'function' && cb (
createRouterObservable(history, joinedPattern)
);
if (subRouter) {
const subRouterObservable = subRouter.asObservable();
subRouters = [subRouter, ...subRouters];
}
const routeObservable = createRouteObservable(
joinedPattern,
finalOpts,
history,
historySubject.asObservable(),
subRouter
);
routeSubject.onNext(routeObservable);
return api;
};
const allRoutesObservable = routeSubject
.flatMap(obs => obs)
.replay();
const asObservable = () => allRoutesObservable;
const start = () => {
const allDisposable = new Rx.CompositeDisposable();
allDisposable.add(allRoutesObservable.connect());
subRouters.forEach(router => {
allDisposable.add(router.start());
})
return allDisposable;
};
const api = { route, asObservable, start };
return api;
}
function lazyLoad (moduleNamePath) {
let obs = new Rx.ReplaySubject(1)
// let waitForChunk = require('dynamic?' + moduleNamePath)
// require("bundle?lazy!usco-ctm-parser")(function(module) {
// const requireStr = `bundle?lazy!./node_modules/${moduleNamePath}`
// const requireStr = `bundle?lazy!./`
// let req = require.context("./node-modules", true, /^\.\/.*\.jade$/)
// const requireStr = `bundle?lazy!./node_modules/${moduleNamePath}/lib/ctm-parser.js`
// var req = require.context('../../node_modules', true, /^\.\/.*\.js$/)
/* require.ensure(['usco-ctm-parser'], function(require) {
//require('usco-ctm-parser')
let module = require(moduleNamePath)
console.log("dynamic load of module",module)
//obs.onNext(module)
})*/
/* require(requireStr)(function(module) {
// now you can use the b-module
console.log("dynamic load of module",module)
obs.onNext(module)
})*/
// System.import('usco-ctm-parser').then(module=>console.log("module",module))
// FIXME: awfull, horrible horrrible horrible
// NOTE : chunk names can be specified like this : &name=stl-parser
switch (moduleNamePath) {
case 'stl':
require('bundle?lazy!usco-stl-parser')(module => obs.onNext(module))
break
case 'ctm':
require('bundle?lazy!usco-ctm-parser')(module => obs.onNext(module))
break
case 'obj':
require('bundle?lazy!usco-obj-parser')(module => obs.onNext(module))
break
case '3mf':
require('bundle?lazy!usco-3mf-parser')(module => obs.onNext(module))
break
case 'gcode':
require('bundle?lazy!usco-gcode-parser')(module => obs.onNext(module))
//obs.onNext({default:gcodeParser})
break
default:
obs.onError(`No parser for "${moduleNamePath}" format`)
}
return obs
}
beforeEach(() => {
fakeAsyncSource = new ReplaySubject(1);
fakeAsyncSource.onNext([
{value: 'PvuaP6YALSA', label: 'Community'},
{value: 'cNzfcPWEGSH', label: 'Country'},
{value: 'POHZmzofoVx', label: 'Facility'},
{value: 'NUPoPEBGCq9', label: 'OUs and Countries'},
]);
listSelectAsyncComponent = shallow(
<ListSelectAsync onItemDoubleClick={onItemDoubleClickSpy} source={fakeAsyncSource} />
);
listSelectAsyncComponent.update();
});
const setNodeCompleted = () => {
setCompleted();
observableSubject.onCompleted();
// Dispose on next tick so onComplete handlers
// will be invoked.
setTimeout(() => connectDisposable.dispose());
};
IntentCounter.subjects.decreaseCounterSubject.subscribe(function () {
state = update(state, {
$merge: {
counter: state.counter - 1
}
});
subject.onNext(state);
});
IntentJSON.jsonSubjects.goGetJSON.subscribe(data => {
state = update(state, {
$merge: {
results: data
}
});
subject.onNext(state);
});
IntentJSON.jsonSubjects.goPostJSON.subscribe(data => {
state = update(state, {
$merge: {
postResult: data
}
});
subject.onNext(state);
});
IntentPolo.poloSubjects.getFeed.subscribe(data => {
state = update(state, {
$merge: {
data: data,
lastUpdated : new Date()
}
});
subject.onNext(state)
});
search(
directories: Array<RemoteDirectory>,
regex: RegExp,
options: Object,
): RemoteDirectorySearch {
// Track the files that we have seen updates for.
const seenFiles = new Set();
// Get the remote service that corresponds to each remote directory.
const services = directories.map(dir => this._serviceProvider(dir));
// Start the search in each directory, and merge the resulting streams.
const searchStream = Observable.merge(directories.map((dir, index) =>
services[index].findInProjectSearch(dir.getPath(), regex, options.inclusions)));
// Create a subject that we can use to track search completion.
const searchCompletion = new ReplaySubject();
searchCompletion.onNext();
const subscription = searchStream.subscribe(next => {
options.didMatch(next);
// Call didSearchPaths with the number of unique files we have seen matches in. This is
// not technically correct, as didSearchPaths is also supposed to count files for which
// no matches were found. However, we currently have no way of obtaining this information.
seenFiles.add(next.filePath);
options.didSearchPaths(seenFiles.size);
}, error => {
searchCompletion.onError(error);
}, () => {
searchCompletion.onCompleted();
});
// Return a promise that resolves on search completion.
const completionPromise = searchCompletion.toPromise();
return {
then: completionPromise.then.bind(completionPromise),
cancel() {
// Cancel the subscription, which should also kill the grep process.
subscription.dispose();
},
};
}
var editorCode$ = editor$.map(function (editor) {
var subject = new _rx.ReplaySubject(1);
editor.on('change', function (e) {
var value = editor.getValue();
subject.onNext(value);
});
return subject;
}).switch();
return function on({event}) {
if (!event || typeof event !== `string`) {
throw new TypeError(`event should be in this format ` +
` {event: 'eventName'}`)
}
const stream = new Rx.ReplaySubject(1)
client.on(event, message => {
stream.onNext(message)
})
return stream
}
constructor(view, rx, aTransform, renderCycle) {
let transform = aTransform || (a=>a),
replay = new Rx.ReplaySubject(1),
subj = new Rx.BehaviorSubject();
let disposable = new Rx.CompositeDisposable(
rx
.distinctUntilChanged(x=>x, (x, y) => x === y)
.map(transform)
.subscribe(replay),
replay
.subscribe(subj),
replay
.skip(1)
.subscribe(() => {
needUpdate(view);
}));
this.disposable = disposable;
this.subject = subj;
this.renderCycle = null;
}
return Observable.defer(function () {
var cycles = new Rx.ReplaySubject();
var complete = new Rx.ReplaySubject();
tests.on("cycle", function (e) {
cycles.onNext(String(e.target));
}).on("complete", function () {
var fastest = this.filter("fastest");
var fastestName = String(fastest.pluck("name"));
var fastestTime = parseFloat(this.filter("fastest").pluck("hz"));
var slowestTime = parseFloat(this.filter("slowest").pluck("hz"));
// percent change formula: ((V2 - V1) / |V1|) * 100
if(fastestName.substr(0, 3) === "new") {
complete.onNext("\t" + (Math.round((fastestTime - slowestTime) / slowestTime * 10000) / 100) + "% " + "faster".green +" than Rx\n");
} else {
complete.onNext("\t" + (Math.round((slowestTime - fastestTime) / fastestTime * 10000) / 100) + "% " + "slower".red + " than Rx\n");
}
}).run({ "async": true });
return cycles.merge(complete).take(tests.length + 1);
});
return function fetchDriver (request$) {
const response$$ = new Rx.ReplaySubject(1)
request$
.map(normalizeRequest)
.subscribe(
request => {
const { input, url, init } = request
const response$ = Rx.Observable.fromPromise(global.fetch(input || url, init), scheduler)
response$.request = request
response$$.onNext(response$)
},
response$$.onError.bind(response$$),
response$$.onCompleted.bind(response$$)
)
response$$.byKey = byKey.bind(null, response$$)
response$$.byUrl = byUrl.bind(null, response$$)
return response$$
}
const route = (pattern, opts, cb) => {
const finalOpts = typeof opts === 'function' ? { stream: opts } : opts;
const joinedPattern = joinPattern(prefix, pattern);
const subRouter = typeof cb === 'function' && cb (
createRouterObservable(history, joinedPattern)
);
if (subRouter) {
const subRouterObservable = subRouter.asObservable();
subRouters = [subRouter, ...subRouters];
}
const routeObservable = createRouteObservable(
joinedPattern,
finalOpts,
history,
historySubject.asObservable(),
subRouter
);
routeSubject.onNext(routeObservable);
return api;
};
export const setVisibilityFilter = (filter) => subject.onNext({type:Keys.SET_VISIBILITY_FILTER,filter})
tests.on("cycle", function (e) {
cycles.onNext(String(e.target));
}).on("complete", function () {
var Rx = require('rx');
var React = require('react');
var getYOffset = function () {
return window.pageYOffset;
};
var initialScrollSubject = (new Rx.ReplaySubject(1));
initialScrollSubject.onNext(getYOffset());
var yOffsetStream = initialScrollSubject.merge(
Rx.Observable.fromEvent(window, 'scroll').map(getYOffset)
);
var getWindowHeight = function () {
return window.innerHeight;
};
var initialHeightSubject = (new Rx.ReplaySubject(1));
initialHeightSubject.onNext(getWindowHeight());
var windowHeightStream = initialHeightSubject.merge(
Rx.Observable.fromEvent(window, 'resize').map(getWindowHeight)
);
var Phonebook = React.createClass({
getInitialState: function () {
return {
visibleIndices: []
};
},
export const createInitialNode = ({
addChildrenSubject,
getChildrenSubject,
pauser,
observable,
hookMap,
setNextState,
provisional
}) => {
const observableSubject = new Rx.ReplaySubject(1);
// Great name right?
const combinedObservable = observableSubject
.flatMapLatest(obs => obs);
const externalObservable = combinedObservable
.replay();
const child = createChildAccessor(addChildrenSubject, getChildrenSubject);
const nodeSubject = new Rx.BehaviorSubject();
const asObservable = () => externalObservable;
const reduce = createReduce(
combinedObservable,
nodeSubject.asObservable(),
hookMap,
pauser
);
const connect = () => {
const allDisposable = new Rx.CompositeDisposable();
const children = getChildrenSubject && getChildrenSubject.getValue();
if (children) {
const keys = Object.keys(children);
keys.forEach(key => allDisposable.add(
children[key].getValue().connect()
));
}
allDisposable.add(
asObservable().connect()
);
return allDisposable;
};
const setInitialState = (initialState) => {
const currentNode = nodeSubject.getValue()
if (!currentNode.provisional) {
throwFinalizedError();
} else {
createTree({
initialState,
createNode,
pauser,
hookMap,
provisional: false,
provisionalNode: node
});
return publishNode(nodeSubject.getValue());
}
};
if (observable) {
observableSubject.onNext(observable);
}
const nodeProps = {
addChildrenSubject,
getChildrenSubject,
reduce,
child,
setNextState,
nodeSubject,
provisional: !!provisional,
provisionalNode: !!provisional && node,
pauser,
combinedObservable,
observableSubject,
asObservable,
connect,
setInitialState
};
const node = Object.assign(
createNodeAccessor(nodeProps),
nodeProps
);
nodeSubject.onNext(node);
return node;
};
function runGame (mount, gameId) {
/// States ///
var speed, refreshRate;
var playing = false;
var game = null;
var buffered = 0;
/// Streams ///
// The game stream is cached once forever
var gameStream = new Rx.ReplaySubject();
GameStream(gameId).subscribe(gameStream);
var gameInterruptions = new Rx.Subject();
var refreshRateStream = Rx.Observable.generateWithRelativeTime(0, alwaysTrue, increment, identity, function () { return refreshRate; });
// Functions
function render () {
if (!game) return; // Nothing to render yet
React.renderComponent(Game({
game: game,
refreshRate: refreshRate,
increaseSpeed: increaseSpeed,
decreaseSpeed: decreaseSpeed,
play: play,
pause: pause,
jump: jump,
playing: playing,
buffered: buffered,
map: url.query.map,
debug: debug,
quality: quality,
}), mount);
}
function restart (startAtTurn) {
playing = true;
gameStream
.skip(startAtTurn-1) // Jump at startAtTurn
.zip(refreshRateStream, identity) // Schedule the game stream to the dynamic refreshRate
.bufferWithTime(1000 / 60) // Throttle the game states to allow very fast play
.takeUntil(gameInterruptions) // Stop once there is a game interruption (pause / jump)
.filter(isNotEmptyArray) // Filter empty buffers
.subscribe(function (g) {
game = g[g.length-1]; // The most recent game in the buffer
render();
}, function (err) {
console.error(err);
playing = false;
render();
}, function () {
playing = false;
render();
});
}
function setSpeed (s) {
speed = s === "max" ? s : isNaN(s) ? DEFAULT_SPEED : parseInt(s, 10);
refreshRate = speed==="max" ? 0 : 1000 / speed;
}
function increaseSpeed () {
if (speed!=="max") {
var i;
for (i=0; i<SPEEDS.length && speed > SPEEDS[i]; ++i);
setSpeed(i >= SPEEDS.length-1 ? "max" : SPEEDS[i+1]);
render();
}
}
function decreaseSpeed () {
if (speed === "max") {
setSpeed(SPEEDS[SPEEDS.length-1]);
}
else {
var i;
for (i=SPEEDS.length-1; i >= 0 && speed < SPEEDS[i]; --i);
setSpeed(i<=0 ? SPEEDS[0] : SPEEDS[i-1]);
}
render();
}
function pause () {
if (!playing) return;
gameInterruptions.onNext("paused");
render();
}
function play () {
if (playing) return;
restart(!game || game.turn === game.maxTurns ? 1 : game.turn);
render();
}
function jump (turn) {
turn -= 1;
if (turn < 0 || game && turn >= game.maxTurns) return;
gameInterruptions.onNext("jumped");
gameStream
.skip(turn)
.first()
.subscribe(function (g) {
game = g;
render();
});
}
// Start the game
setSpeed(url.query.speed);
gameStream
.subscribe(function (game) {
buffered = game.turn;
});
play();
}
[publishError](error) {
return this[observableSymbol].onError(error);
}
[publishState]() {
return this[observableSymbol].onNext(this.state);
}
_subscribe(observer) {
return this[observableSymbol].subscribe(observer);
}
request => {
const { input, url, init } = request
const response$ = Rx.Observable.fromPromise(global.fetch(input || url, init), scheduler)
response$.request = request
response$$.onNext(response$)
},
const createComposedNode = ({
nodeMap,
accessor,
pauser,
hookMap
}) => {
const nodeSubject = new Rx.ReplaySubject(1);
const keys = Object.keys(nodeMap);
const compositeAccessor = (key) => {
const path = nodeMap[key];
if (typeof path === 'undefined') {
throw new Error(`Key ${key} not found on composite node`);
}
return accessor(nodeMap[key]).nodeSubject.getValue();
};
const combinedObservable = Rx.Observable
.combineLatest(
...keys.map(key => {
const path = nodeMap[key];
const node = accessor(path);
if (!node) {
throw new Error(
`Bad path to node: ${path}
Cannot compose nodes that have not been previously defined.`
);
}
return node.nodeSubject;
})
)
.flatMapLatest(nodes => {
return Rx.Observable
.combineLatest(
...nodes.map(node => {
return node.combinedObservable
})
)
.map(values => {
return values.reduce((acc, val, i) => {
return Object.assign({}, acc, {
[keys[i]]: val
});
}, {})
}
)
})
.pausable(pauser);
const externalObservable = combinedObservable.shareReplay(1);
const reduce = createReduce(
combinedObservable,
nodeSubject.asObservable(),
hookMap,
pauser
);
const setNextState = (state) => {
const newKeys = Object.keys(state);
newKeys.forEach(key => {
accessor(nodeMap[key]).nodeSubject
.getValue()
.setNextState(state[key]);
});
};
const asObservable = () => externalObservable;
// Non implemented functions
const compose = () => {
throw new Error('Composite nodes cannot be further composed');
}
const connect = () => {
throw new Error(
`Composite nodes cannot be connected.
Connect from the original state tree`
);
};
const setInitialState = () => {
throw new Error(
`Cannot set initial state on a composite node
Set initial state from the original state tree`
)
}
const node = Object.assign(
wrapInPublish(compositeAccessor),
{
nodeSubject,
reduce,
setNextState,
compose,
connect,
asObservable,
setInitialState
}
);
nodeSubject.onNext(node);
return node;
};
export const createInitialNode = ({
addChildrenSubject,
getChildrenSubject,
pauser,
observable,
hookMap,
setNextState,
setCompleted,
provisional
}) => {
const observableSubject = new Rx.ReplaySubject(1);
// Great name right?
const combinedObservable = observableSubject
.flatMapLatest(obs => obs);
const externalObservable = combinedObservable
.replay();
const child = createChildAccessor(addChildrenSubject, getChildrenSubject);
const nodeSubject = new Rx.BehaviorSubject();
const asObservable = () => externalObservable;
const reduce = createReduce(
combinedObservable,
nodeSubject.asObservable(),
hookMap,
pauser
);
const connectDisposable = new Rx.CompositeDisposable();
const connect = () => {
const children = getChildrenSubject && getChildrenSubject.getValue();
if (children) {
const keys = Object.keys(children);
keys.forEach(key => connectDisposable.add(
children[key].getValue().connect()
));
}
connectDisposable.add(
asObservable().connect()
);
return connectDisposable;
};
const setInitialState = (initialState) => {
const currentNode = nodeSubject.getValue()
if (!currentNode.provisional) {
throwFinalizedError();
} else {
createTree({
initialState,
createNode,
pauser,
hookMap,
provisional: false,
provisionalNode: node
});
return publishNode(nodeSubject.getValue());
}
};
const setNodeCompleted = () => {
setCompleted();
observableSubject.onCompleted();
// Dispose on next tick so onComplete handlers
// will be invoked.
setTimeout(() => connectDisposable.dispose());
};
if (observable) {
observableSubject.onNext(observable);
}
const nodeProps = {
addChildrenSubject,
getChildrenSubject,
reduce,
child,
setNextState,
setCompleted: setNodeCompleted,
nodeSubject,
provisional: !!provisional,
provisionalNode: !!provisional && node,
pauser,
combinedObservable,
observableSubject,
asObservable,
connect,
setInitialState
};
const accessor = createNodeAccessor(nodeProps);
const compose = nodeProps.compose = wrapInPublish((nodeMap) => createComposedNode({
nodeMap,
accessor,
pauser,
hookMap
}));
const node = Object.assign(
wrapInPublish(accessor),
nodeProps
);
nodeSubject.onNext(node);
return node;
};
import Rx from 'rx';
import update from 'react/lib/update';
import IntentCounter from '../intent/Counter-intent';
import IntentJSON from '../intent/json-intent';
var subject = new Rx.ReplaySubject(1);
var state = {
postResult: [],
results: [],
counter: 0
};
IntentCounter.subjects.incrementCounterSubject.subscribe(function () {
state = update(state, {
$merge: {
counter: state.counter + 1
}
});
subject.onNext(state);
});
IntentCounter.subjects.decreaseCounterSubject.subscribe(function () {
state = update(state, {
$merge: {
counter: state.counter - 1
}
});
subject.onNext(state);
});