Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Operation "ludicrous speed". Part 2.

  • Loading branch information...
commit cfcfe17c0b32bbfc28bc7f911201054151b84696 1 parent eeda47b
Michael Aufreiter authored
View
11 README
@@ -4,11 +4,7 @@ Data.js
Data.js is a data manipulation and persistence framework for Javascript. It's being developed in the context of Substance, a data-driven document authoring engine.
For documentation, usage, and examples, see:
- http://substance.io/#michael/data-js
-
-For the annotated source code, see:
- http://quasipartikel.at/data-js
-
+ http://substance.io/michael/data-js
Features
------------------
@@ -26,4 +22,7 @@ Substance (http://substance.io)
A web-based document authoring and publication platform that relies on Data.js for object persistence.
Déjàvis (http://beta.dejavis.org)
- A tool for analyzing and visualizing data. It uses Data.js for filtering and aggregating data
+ A tool for analyzing and visualizing data. It uses Data.js for filtering and aggregating data
+
+Dance.js (http://github.com/michael/dance)
+ A data-driven visualization library.
View
8 adapters/ajax_adapter.js
@@ -67,14 +67,6 @@ Data.Adapters["ajax"] = function(graph, config) {
});
};
- self.watch = function() {
- // no-op
- };
-
- self.unwatch = function() {
- // no-op
- };
-
// Expose Public API
return self;
};
View
1  adapters/couch_adapter.js
@@ -373,7 +373,6 @@ var CouchAdapter = function(graph, config, callback) {
// Execute query either typed (by id) or untyped (using a CouchDB View)
qry._id ? executeUntypedQuery(function() { resolveReferences(result, callback); })
: executeTypedQuery(function() { resolveReferences(result, callback); });
-
}
// Perform queries
View
69 adapters/nowjs_adapter.js
@@ -1,69 +0,0 @@
-Data.Adapters["nowjs"] = function(graph, options) {
- var self = {realtime: true};
-
- // write
- // --------------
-
- // Takes a Data.Graph and calls the server to persist it
-
- self.write = function(graph, callback) {
- now.write(graph, function(err, graph) {
- callback(err, graph);
- });
- };
-
- // read
- // --------------
-
- // Takes a query object and reads all matching nodes
- // If you'd like to make a deep fetch, you just need to specify
- // expand: true in the options hash
-
- self.read = function(qry, options, callback) {
- now.read(qry, options, function(err, graph) {
- callback(err, graph);
- });
- };
-
- // watch
- // --------------
-
- self.watch = function(name, query, callback) {
- now.watch(name, query, function(err) {
- callback(err);
- });
- };
-
- // unwatch
- // --------------
-
- self.unwatch = function(name, callback) {
- now.unwatch(name, function(err) {
- callback(err);
- });
- };
-
- // update
- // --------------
-
- // Gets called by the server when updates arrive.
- // It applies them and calls the corresponding watcher callback
-
- now.update = function(channel, rawNodes) {
- var nodes = new Data.Hash();
- graph.merge(rawNodes, false);
- _.each(rawNodes, function(node, key) {
- nodes.set(key, graph.get(key));
- });
- graph.watchers[channel](null, nodes);
- };
-
- // Delegate ready callback
-
- now.ready(function() {
- graph.connectedCallback();
- });
-
- // Expose Public API
- return self;
-};
View
964 data.js
@@ -36,57 +36,10 @@
'boolean',
'date'
];
-
+
+
Data.isValueType = function (type) {
- return _.include(Data.VALUE_TYPES, type);
- };
-
- // Returns true if a certain object matches a particular query object
- // TODO: optimize!
- Data.matches = function(node, queries) {
- queries = _.isArray(queries) ? queries : [queries];
- var matched = false;
- // Matches at least one query
- _.each(queries, function(query) {
- if (matched) return;
- var rejected = false;
- _.each(query, function(value, key) {
- if (rejected) return;
- var condition;
- // Extract operator
- var matches = key.match(/^([a-z_]{1,30})(=|==|!=|>|>=|<|<=|\|=|&=)?$/),
- property = matches[1],
- operator = matches[2] || (property == "type" || _.isArray(value) ? "|=" : "=");
-
- if (operator === "|=") { // one of operator
- var values = _.isArray(value) ? value : [value];
- var objectValues = _.isArray(node[property]) ? node[property] : [node[property]];
- condition = false;
- _.each(values, function(val) {
- if (_.include(objectValues, val)) {
- condition = true;
- }
- });
- } else if (operator === "&=") {
- var values = _.isArray(value) ? value : [value];
- var objectValues = _.isArray(node[property]) ? node[property] : [node[property]];
- condition = _.intersect(objectValues, values).length === values.length;
- } else { // regular operators
- switch (operator) {
- case "!=": condition = !_.isEqual(node[property], value); break;
- case ">": condition = node[property] > value; break;
- case ">=": condition = node[property] >= value; break;
- case "<": condition = node[property] < value; break;
- case "<=": condition = node[property] <= value; break;
- default : condition = _.isEqual(node[property], value); break;
- }
- }
- // TODO: Make sure we exit the loop and return immediately when a condition is not met
- if (!condition) return rejected = true;
- });
- if (!rejected) return matched = true;
- });
- return matched;
+ return _.include(Data.VALUE_TYPES, _.last(type));
};
@@ -240,419 +193,6 @@
};
- // Data.Hash
- // --------------
-
- // A Hash data structure that provides a simple layer of abstraction for
- // managing a sortable data-structure with hash semantics. It's heavily
- // used throughout Data.js.
-
- Data.Hash = function(data) {
- var that = this;
- this.data = {};
- this.keyOrder = [];
- this.length = 0;
-
- if (data instanceof Array) {
- _.each(data, function(datum, index) {
- that.set(index, datum);
- });
- } else if (data instanceof Object) {
- _.each(data, function(datum, key) {
- that.set(key, datum);
- });
- }
-
- if (this.initialize) this.initialize(attributes, options);
- };
-
- _.extend(Data.Hash.prototype, _.Events, {
-
- // Returns a copy of the Hash
- // Used by transformation methods
- clone: function () {
- var copy = new Data.Hash();
- copy.length = this.length;
- _.each(this.data, function(value, key) {
- copy.data[key] = value;
- });
- copy.keyOrder = this.keyOrder.slice(0, this.keyOrder.length);
- return copy;
- },
-
- // Set a value at a given *key*
- set: function (key, value, targetIndex) {
- var index;
- if (key === undefined)
- return this;
-
- if (!this.data[key]) {
- if (targetIndex !== undefined) { // insert at a given index
- var front = this.select(function(item, key, i) {
- return i < targetIndex;
- });
-
- var back = this.select(function(item, key, i) {
- return i >= targetIndex;
- });
-
- this.keyOrder = [].concat(front.keyOrder);
- this.keyOrder.push(key);
- this.keyOrder = this.keyOrder.concat(back.keyOrder);
- } else {
- this.keyOrder.push(key);
- }
- index = this.length;
- this.length += 1;
- } else {
- index = this.index(key);
- }
- this.data[key] = value;
-
- this.trigger('set', key);
- return this;
- },
-
- // Delete entry at given *key*
- del: function (key) {
- if (this.data.hasOwnProperty(key)) {
- var l = this.length;
- var index = this.index(key);
- delete this.data[key];
- this.keyOrder.splice(index, 1);
- Array.prototype.splice.call(this, index, 1);
- this.length = l-1;
- this.trigger('del', key);
- }
- return this;
- },
-
- // Get value at given *key*
- get: function (key) {
- return this.data.hasOwnProperty(key) ? this.data[key] : undefined;
- },
-
- // Get value at given *index*
- at: function (index) {
- var key = this.keyOrder[index];
- return this.data[key];
- },
-
- // Get first item
- first: function () {
- return this.at(0);
- },
-
- // Returns a sub-range of the current *hash*
- range: function(start, end) {
- var result = new Data.Hash();
- for(var i=start; i<=end; i++) {
- result.set(this.key(i), this.at(i));
- }
- return result;
- },
-
- // Returns the rest of the elements.
- // Pass an index to return the items from that index onward.
- rest: function(index) {
- return this.range(index, this.length-1);
- },
-
- // Get last item
- last: function () {
- return this.at(this.length-1);
- },
-
- // Returns for an index the corresponding *key*
- key: function (index) {
- return this.keyOrder[index];
- },
-
- // Returns for a given *key* the corresponding *index*
- index: function(key) {
- return this.keyOrder.indexOf(key);
- },
-
- // Iterate over values contained in the `Data.Hash`
- each: function (fn) {
- var that = this;
- _.each(this.keyOrder, function(key, index) {
- fn.call(that, that.data[key], key, index);
- });
- return this;
- },
-
- // Convert to an ordinary JavaScript Array containing just the values
- values: function () {
- var result = [];
- this.each(function(value, key, index) {
- result.push(value);
- });
- return result;
- },
-
- // Returns all keys in current order
- keys: function () {
- return _.clone(this.keyOrder);
- },
-
- // Convert to an ordinary JavaScript Array containing
- // key value pairs. Used by `sort`.
- toArray: function () {
- var result = [];
-
- this.each(function(value, key) {
- result.push({key: key, value: value});
- });
-
- return result;
- },
-
- // Serialize
- toJSON: function() {
- var result = {};
-
- this.each(function(value, key) {
- result[key] = value.toJSON ? value.toJSON() : value;
- });
- return result;
- },
-
- // Map the `Data.Hash` to your needs
- map: function (fn) {
- var result = this.clone(),
- that = this;
- result.each(function(item, key, index) {
- result.data[that.key(index)] = fn.call(result, item);
- });
- return result;
- },
-
- // Select items that match some conditions expressed by a matcher function
- select: function (fn) {
- var result = new Data.Hash(),
- that = this;
-
- this.each(function(value, key, index) {
- if (fn.call(that, value, key, index)) {
- result.set(key, value);
- }
- });
- return result;
- },
-
- // Performs a sort
- sort: function (comparator) {
- var result = this.clone(),
- sortedKeys = result.toArray().sort(comparator);
-
- // update keyOrder
- result.keyOrder = _.map(sortedKeys, function(k) {
- return k.key;
- });
- return result;
- },
-
- // Performs an intersection with the given *hash*
- intersect: function(hash) {
- var that = this,
- result = new Data.Hash();
-
- // Find out which hash is smaller
- var smaller, other;
- if (hash.length < that.length) {
- smaller = hash;
- other = that;
- } else {
- smaller = that;
- other = hash;
- }
- _.each(smaller.keyOrder, function (key) {
- // TODO: Test for existence of a key with Object.prototype.hasOwnProperty
- if (other.get(key)) {
- result.set(key, hash.get(key));
- }
- });
- return result;
- },
-
- // Performs an union with the given *hash*
- union: function(hash) {
- var that = this,
- result = new Data.Hash();
-
- this.each(function(value, key) {
- result.set(key, value);
- });
- hash.each(function(value, key) {
- if (!result.get(key)) result.set(key, value);
- });
- return result;
- },
-
- // Computes the difference between the current *hash* and a given *hash*
- difference: function(hash) {
- var that = this;
- result = new Data.Hash();
- this.each(function(value, key) {
- if (!hash.get(key)) result.set(key, value);
- });
- return result;
- }
- });
-
-
- // Data.Comparators
- // --------------
-
- Data.Comparators = {};
-
- Data.Comparators.ASC = function(item1, item2) {
- return item1.value === item2.value ? 0 : (item1.value < item2.value ? -1 : 1);
- };
-
- Data.Comparators.DESC = function(item1, item2) {
- return item1.value === item2.value ? 0 : (item1.value > item2.value ? -1 : 1);
- };
-
-
- // Data.Aggregators
- // --------------
-
- Data.Aggregators = {};
-
- Data.Aggregators.SUM = function (values) {
- var result = 0;
- values.each(function(value, key, index) {
- if (_.isNumber(value)) result += value;
- });
- return result;
- };
-
- Data.Aggregators.MIN = function (values) {
- var result = Infinity;
- values.each(function(value, key, index) {
- if (_.isNumber(value) && value < result) result = value;
- });
- return result;
- };
-
- Data.Aggregators.MAX = function (values) {
- var result = -Infinity;
- values.each(function(value, key, index) {
- if (_.isNumber(value) && value > result) result = value;
- });
- return result;
- };
-
- Data.Aggregators.AVG = function (values) {
- var sum = 0,
- count = 0;
- values.each(function(value, key, index) {
- if (_.isNumber(value)) {
- sum += value;
- count += 1;
- }
- });
- return count === 0 ? 0 : (sum / count);
- };
-
- Data.Aggregators.COUNT = function (values) {
- return values.length;
- };
-
-
- // Data.Modifiers
- // --------------
-
- Data.Modifiers = {};
-
- // The default modifier simply does nothing
- Data.Modifiers.DEFAULT = function (attribute) {
- return attribute;
- };
-
- Data.Modifiers.MONTH = function (attribute) {
- return attribute.getMonth();
- };
-
- Data.Modifiers.QUARTER = function (attribute) {
- return Math.floor(attribute.getMonth() / 3) + 1;
- };
-
- // Data.Transformers
- // --------------
-
- Data.Transformers = {
- group: function(g, type, keys, properties) {
- var gspec = {},
- type = g.get(type),
- groups = {},
- count = 0;
-
- gspec[type._id] = {"type": "/type/type", "properties": {}, indexes: type.indexes};
-
- // Include group keys to the output graph
- _.each(keys, function(key) {
- gspec[type._id].properties[key] = type.properties().get(key).toJSON();
- });
-
- // Include additional properties
- _.each(properties, function(options, key) {
- var p = type.properties().get(options.property || key).toJSON();
- if (options.name) p.name = options.name;
- gspec[type._id].properties[key] = p;
- });
-
- var groupedGraph = new Data.Graph(gspec);
-
- _.each(keys, function(key) {
- groups[key] = type.properties().get(key).all('values');
- });
-
- function aggregate(key) {
- var members = new Data.Hash();
-
- _.each(keys, function(k, index) {
- var objects = groups[keys[index]].get(key[index]).referencedObjects;
- members = index === 0 ? members.union(objects) : members.intersect(objects);
- });
-
- // Empty group key
- if (key.length === 0) members = g.objects();
- if (members.length === 0) return null;
-
- var res = {type: type._id};
- _.each(gspec[type._id].properties, function(p, pk) {
- if (_.include(keys, pk)) {
- res[pk] = key[_.indexOf(keys, pk)];
- } else {
- var numbers = members.map(function(obj) {
- return obj.get(properties[pk].property || pk);
- });
- var aggregator = properties[pk].aggregator || Data.Aggregators.SUM;
- res[pk] = aggregator(numbers);
- }
- });
- return res;
- }
-
- function extractGroups(keyIndex, key) {
- if (keyIndex === keys.length-1) {
- var aggregatedItem = aggregate(key);
- if (aggregatedItem) groupedGraph.set(key.join('::'), aggregatedItem);
- } else {
- keyIndex += 1;
- groups[keys[keyIndex]].each(function(grp, grpkey) {
- extractGroups(keyIndex, key.concat([grpkey]));
- });
- }
- }
- extractGroups(-1, []);
- return groupedGraph;
- }
- };
-
// Data.Adapter
// --------------
@@ -667,57 +207,6 @@
// Namespace where Data.Adapters can register
Data.Adapters = {};
- // Data.Property
- // --------------
-
- // Meta-data (data about data) is represented as a set of properties that
- // belongs to a certain `Data.Type`. A `Data.Property` holds a key, a name
- // and an expected type, telling whether the data is numeric or textual, etc.
-
- Data.Property = function(type, key, options) {
- this.key = key;
- this.type = type;
- this.unique = options.unique !== undefined ? options.unique : true;
- this.name = options.name;
- this.meta = options.meta || {};
- this.validator = options.validator;
- this.required = options["required"];
- this["default"] = options["default"];
-
- // TODO: ensure that object and value types are not mixed
- this.expectedTypes = _.isArray(options['type']) ? options['type'] : [ options['type'] ];
- };
-
- _.extend(Data.Property.prototype, _.Events, {
-
- isValueType: function() {
- return Data.isValueType(this.expectedTypes[0]);
- },
-
- isObjectType: function() {
- return !this.isValueType();
- },
-
- // Aggregates the property's values
- aggregate: function (fn) {
- return fn(this.values("values"));
- },
-
- // Serialize a propery definition
- toJSON: function() {
- return {
- name: this.name,
- type: this.expectedTypes,
- unique: this.unique,
- meta: this.meta,
- sync: this.sync,
- validator: this.validator,
- required: this.required,
- "default": this["default"]
- }
- }
- });
-
// Data.Type
// --------------
@@ -732,31 +221,20 @@
this.g = g;
this._id = id;
if (type._rev) this._rev = type._rev;
- if (type._conflicted) this._conflicted = type._conflicted;
this.type = type.type;
this.name = type.name;
this.meta = type.meta || {};
if (type.indexes) this.indexes = type.indexes;
- this.properties = new Data.Hash();
+ this.properties = type.properties;
- _.each(type.properties, _.bind(function(property, key) {
- this.properties.set(key, new Data.Property(this, key, property));
+ _.each(this.properties, _.bind(function(property, key) {
+ property.type = _.isArray(property.type) ? property.type : [ property.type ];
}, this));
};
_.extend(Data.Type.prototype, _.Events, {
- // Convenience function for accessing properties
- properties: function() {
- return this.all('properties');
- },
-
- // Objects of this type
- objects: function() {
- return this.all('nodes');
- },
-
// Serialize a single type node
toJSON: function() {
var result = {
@@ -791,51 +269,27 @@
// Represents a typed data object within a `Data.Graph`.
// Provides access to properties, defined on the corresponding `Data.Type`.
-
- Data.wrapInHash = function(graph, values) {
- var hash = new Data.Hash();
- _.each(values, function(v) {
- if (!graph.get(v)) {
- console.log(graph);
- console.log('not found: '+v);
- }
- hash.set(v, graph.get(v));
- });
- return hash;
- };
-
- Data.resolve = function(graph, values) {
- var hash = new Data.Hash();
- _.each(values, function(v) {
- if (!graph.get(v)) {
- console.log(graph);
- console.log('not found: '+v);
- }
- hash.set(v, graph.get(v));
- });
- return hash;
- };
Data.Object = function(g, id, data) {
this.g = g;
- this._id = id; delete data._id;
- this.data = data;
-
- this._types = _.isArray(data.type) ? data.type : [data.type];
- if (this.data._dirty) this._dirty = true;
- if (this.data.meta) this.meta = this.data.meta;
- // delete this.data.type; Why this isn't working?
+ this._id = id; delete data._id;
+ this.update(data);
};
_.extend(Data.Object.prototype, _.Events, {
-
- // Convenience function for accessing all related types
- types: function() {
- return Data.wrapInHash(this.g, this._types);
+
+ // Update node based on the serialized data
+ update: function(data) {
+ this.data = data;
+
+ this.types = _.isArray(data.type) ? data.type : [data.type];
+ if (this.data._dirty) this._dirty = true;
+ if (this.data.meta) this.meta = this.data.meta;
+ // delete this.data.type; // Why this isn't working?
},
type: function() {
- return this.g.get(_.last(this._types));
+ return this.g.get(_.last(this.types));
},
toString: function() {
@@ -844,16 +298,12 @@
// Properties from all associated types
properties: function() {
- var properties = new Data.Hash();
- // Prototypal inheritance in action: overriden properties belong to the last type specified
- this.types().each(function(type) {
- type.properties.each(function(property) {
- properties.set(property.key, property);
- });
- });
+ var properties = {};
+ _.each(this.types, _.bind(function(type) {
+ _.extend(properties, this.g.get(type).properties);
+ }, this));
return properties;
},
-
// Validates an object against its type (=schema)
validate: function() {
@@ -920,19 +370,16 @@
// two arguments are provided `get` delegates to `Data.Node#get`.
get: function(property, key) {
- // TODO: optimize and skip that check?
- var p = this.properties().get(property);
+ var p = this.properties()[property];
var value = this.data[property];
- if (!p) return null;
- if (p.isObjectType()) {
- return p.unique ? this.g.get(value) : Data.wrapInHash(this.g, value);
+
+ if (!p || !value) return null;
+
+ if (Data.isValueType(p.type)) {
+ return value;
} else {
- if (p.unique) return value;
- var res = new Data.Hash();
- _.each(value, function(v) {
- res.set(v, v);
- });
- return res;
+ return p.unique ? this.g.get(value)
+ : _.map(value, _.bind(function(v) { return this.g.get(v); }, this));
}
},
@@ -944,51 +391,26 @@
if (p.isObjectType()) {
return p.unique ? this.g.get(value) : resolve(this.g, value);
} else {
- // if (p.unique) return value;
return value;
-
- // var res = new Data.Hash();
- // _.each(value, function(v) {
- // res.set(v, v);
- // });
- return res;
}
},
-
+
// Sets properties on the object
// Existing properties are overridden / replaced
set: function(properties) {
var that = this;
- _.each(properties, function(value, key) {
- var p = that.properties().get(key);
- if (!p) return; // Property not found on type
-
- // Setup values
- // that.replace(p.key, p.registerValues(_.isArray(value) ? value : [value], that));
-
+ _.each(properties, _.bind(function(value, key) {
+ if (!that.properties()[key]) return; // Property not found on type
+ that.data[key] = value;
that._dirty = true;
that.g.trigger('dirty', that);
- });
+ }, this));
},
// Serialize an `Data.Object`'s properties
toJSON: function() {
- var that = this,
- result = {};
- _.each(this._properties, function(value, key) {
- var p = that.properties().get(key);
- if (p.isObjectType()) {
- result[key] = p.unique ? that.all(key).keys()[0] : that.all(key).keys()
- } else {
- result[key] = p.unique ? that.value(key) : that.values(key).values();
- }
- });
- result['type'] = this.types().keys();
- result['_id'] = this._id;
- if (this._rev !== undefined) result['_rev'] = this._rev;
- if (this._deleted) result['_deleted'] = this._deleted;
- return result;
+ return _.extend(this.data, {_id: this._id, type: this.types})
}
});
@@ -1002,9 +424,10 @@
// See the testsuite for usage.
Data.Graph = function(g, options) {
- this.nodes = new Data.Hash();
+ this.nodes = [];
+ // Lookup objects by key
+ this.keys = {};
if (!g) return;
-
this.merge(g, options && options.dirty);
this.syncMode = options && options.syncMode ? options.syncMode : 'push';
};
@@ -1036,18 +459,6 @@
require(__dirname + '/server').initialize(server, this);
},
- // Watch for graph updates
- watch: function(channel, query, callback) {
- this.watchers[channel] = callback;
- this.adapter.watch(channel, query, function(err) {});
- },
-
- // Stop watching that channel
- unwatch: function(channel, callback) {
- delete this.watchers[channel];
- this.adapter.unwatch(channel, function() {});
- },
-
// Empty graph
empty: function() {
var that = this;
@@ -1055,60 +466,38 @@
that.del(id);
that.all('nodes').del(id);
});
+ return this;
},
// Merges in another Graph
- merge: function(g, dirty) {
- var that = this;
-
- // Process schema nodes
- _.each(g, function(node, key) {
- if (node.type === '/type/type' || node.type === 'type') {
- if (!that.get(key)) {
- var obj = new Data.Type(that, key, node);
- if (node._dirty || dirty) obj._dirty = true;
- that.nodes.set(key, obj);
- }
- } else {
- var obj = that.get(key);
- // var types = _.isArray(node.type) ? node.type : [node.type];
- if (!obj) {
- obj = new Data.Object(that, key, node);
- that.nodes.set(key, obj);
- } else if (obj.data._dirty) {
- res._conflicted = true;
- res._conflicted_rev = node;
- } else {
- res.data = node;
- }
-
- if (node._dirty || dirty) obj._dirty = true;
- if (!node._id) node._id = key;
- }
- });
-
- if (this.conflictedNodes().length > 0) this.trigger('conflicted');
-
+ merge: function(nodes, dirty) {
+ _.each(nodes, _.bind(function(n, key) { this.set(_.extend(n, {_id: key})); }, this));
return this;
},
- set: function(node) {
- var id, that = this;
-
+ set: function(node, dirty) {
+ if (dirty === undefined) dirty = true;
var types = _.isArray(node.type) ? node.type : [node.type];
node._id = node._id ? node._id : Data.uuid('/' + _.last(_.last(types).split('/')) + '/');
- // Recycle existing object if there is one
- var res = that.get(node._id) ? that.get(node._id) : new Data.Object(that, node._id, _.clone(node), true);
- res.data = node;
- res._dirty = true;
- this.nodes.set(node._id, res);
- return res;
+ function createNode() {
+ return _.last(types) === "/type/type" ? new Data.Type(this, node._id, _.clone(node))
+ : new Data.Object(this, node._id, _.clone(node))
+ }
+ var n = this.get(node._id);
+ if (!n) {
+ n = createNode.apply(this);
+ this.keys[node._id] = this.nodes.length;
+ this.nodes.push(n);
+ } else {
+ n.update(node);
+ }
+ return n;
},
// API method for accessing objects in the graph space
get: function(id) {
- return this.nodes.get(id);
+ return this.nodes[this.keys[id]];
},
// Delete node by id, referenced nodes remain untouched
@@ -1120,13 +509,6 @@
this.trigger('dirty', node);
},
- // Find objects that match a particular query
- find: function(query) {
- return this.objects().select(function(o) {
- return Data.matches(o.data, query);
- });
- },
-
// Fetches a new subgraph from the adapter and either merges the new nodes
// into the current set of nodes
fetch: function(query, options, callback) {
@@ -1150,250 +532,38 @@
});
},
- // Pull in remote updates and push local changes to the server
- sync: function(callback, resolveConflicts) {
- callback = callback || function() {};
- resolveConflicts = resolveConflicts || function(cb) { cb(); };
- var that = this;
-
- if (this.syncMode === 'full') {
- this.pull(function() {
- if (that.conflictedNodes().length > 0) {
- resolveConflicts(function() { that.push(callback); });
- } else {
- that.push(callback);
- }
- });
- } else if (this.syncMode === 'pull') {
- this.pull(function() {
- if (that.conflictedNodes().length > 0) {
- resolveConflicts(function() {});
- }
- });
- } else { // Push sync -> default
- this.push(callback);
- }
- },
-
- // Push local updates to the server
- push: function(callback) {
- var that = this,
- nodes = this.dirtyNodes();
-
- var validNodes = new Data.Hash();
- nodes.select(function(node, key) {
- if (!node.validate || (node.validate && node.validate())) {
- validNodes.set(key, node);
- }
- });
-
- this.adapter.write(validNodes.toJSON(), function(err, g) {
- if (err) return callback(err);
-
- // Check for rejectedNodes / conflictedNodes
- validNodes.each(function(n, key) {
- if (g[key]) {
- n._dirty = false;
- n._rejected = false;
- } else {
- n._rejected = true;
- }
- });
-
- // Update local nodes with new revision
- that.merge(g, false);
-
- // Update localStorage
- if (this.persistent) that.snapshot();
-
- if (that.invalidNodes().length > 0) that.trigger('invalid');
- if (that.conflictedNodes().length > 0) that.trigger('conflicted');
- if (that.rejectedNodes().length > 0) that.trigger('rejected');
-
- var unsavedNodes = that.invalidNodes().union(that.conflictedNodes())
- .union(that.rejectedNodes()).length;
-
- callback(unsavedNodes > 0 ? unsavedNodes+' unsaved nodes' : null);
- });
- },
-
- pull: function(callback) {
- var that = this;
- var nodes = {};
- this.objects().each(function(o) {
- nodes[o._id] = o._rev || null;
- });
-
- this.adapter.pull(nodes, function(err, g) {
- that.merge(g, false);
- callback();
- });
- },
-
- // Perform a group operation on a Data.Graph
- group: function(type, keys, properties) {
- var res = new Data.Collection();
- res.g = Data.Transformers.group(this, type, keys, properties);
- return res;
- },
-
// Type nodes
types: function() {
// TODO: not efficient
- return this.nodes.select(function(node, key) {
- return node.type === '/type/type' || node.type === 'type';
+ return _.select(this.nodes, function(node, index) {
+ return node instanceof Data.Type;
});
},
// Object nodes
objects: function() {
// TODO: not efficient
- return this.nodes.select(function(node, key) {
- return node.type !== '/type/type' && node.type !== 'type' && node.data && !node._deleted;
- });
- },
-
- // Get dirty nodes
- // Used by Data.Graph#sync
- dirtyNodes: function() {
- // TODO: not efficient, keep track of dirty nodes seperately
- return this.nodes.select(function(obj, key) {
- return (obj._dirty && (obj.data || obj instanceof Data.Type));
+ return _.select(this.nodes, function(node, index) {
+ return node instanceof Data.Type;
});
},
// Get invalid nodes
invalidNodes: function() {
// TODO: not efficient, keep track of invalid nodes seperately
- return this.nodes.select(function(obj, key) {
- return (obj.errors && obj.errors.length > 0);
- });
- },
-
- // Get conflicting nodes
- conflictedNodes: function() {
- // TODO: not efficient, keep track of conflicted nodes seperately
- return this.nodes.select(function(obj, key) {
- return obj._conflicted;
- });
- },
-
- // Nodes that got rejected during sync
- rejectedNodes: function() {
- // TODO: not efficient, keep track of rejected nodes seperately
- return this.nodes.select(function(obj, key) {
- return obj._rejected;
+ return _.select(this.nodes, function(node, index) {
+ return (node.errors && node.errors.length > 0);
});
},
-
+
// Serializes the graph to the JSON-based exchange format
toJSON: function(extended) {
var result = {};
-
- // Serialize object nodes
- this.all('nodes').each(function(obj, key) {
- // Only serialize fetched nodes
- if (obj.data || obj instanceof Data.Type) {
- result[key] = obj.toJSON();
- if (extended) {
- // include special properties
- if (obj._dirty) result[key]._dirty = true;
- if (obj._deleted) result[key]._deleted = true;
- if (obj._conflicted) result[key]._conflicted = true;
- if (obj._rejected) result[key]._rejected = true;
- }
- }
+ _.each(this.nodes, function(n) {
+ result[n._id] = n.toJSON()
});
return result;
}
});
-
- // Data.Collection
- // --------------
-
- // A Collection is a simple data abstraction format where a dataset under
- // investigation conforms to a collection of data items that describes all
- // facets of the underlying data in a simple and universal way. You can
- // think of a Collection as a table of data, except it provides precise
- // information about the data contained (meta-data). A Data.Collection
- // just wraps a `Data.Graph` internally, in order to simplify the interface,
- // for cases where you do not have to deal with linked data.
-
- Data.Collection = function(spec) {
- var that = this,
- gspec = { "/type/item": { "type": "/type/type", "properties": {}} };
-
- if (spec) gspec["/type/item"]["indexes"] = spec.indexes || {};
-
- // Convert to Data.Graph serialization format
- if (spec) {
- _.each(spec.properties, function(property, key) {
- gspec["/type/item"].properties[key] = property;
- });
- this.g = new Data.Graph(gspec);
- _.each(spec.items, function(item, key) {
- that.set(key, item);
- });
- } else {
- this.g = new Data.Graph();
- }
- };
-
- _.extend(Data.Collection.prototype, {
-
- // Get an object (item) from the collection
- get: function(key) {
- return this.g.get.apply(this.g, arguments);
- },
-
- // Set (add) a new object to the collection
- set: function(id, properties) {
- this.g.set(id, _.extend(properties, {type: "/type/item"}));
- },
-
- // Find objects that match a particular query
- find: function(query) {
- query["type|="] = "/type/item";
- return this.g.find(query);
- },
-
- // Returns a filtered collection containing only items that match a certain query
- filter: function(query) {
- return new Data.Collection({
- properties: this.properties().toJSON(),
- items: this.find(query).toJSON()
- });
- },
-
- // Perform a group operation on the collection
- group: function(keys, properties) {
- var res = new Data.Collection();
- res.g = Data.Transformers.group(this.g, "/type/item", keys, properties);
- return res;
- },
-
- // Convenience function for accessing properties
- properties: function() {
- return this.g.get('nodes', '/type/item').all('properties');
- },
-
- // Convenience function for accessing items
- items: function() {
- return this.g.objects();
- },
-
- // Convenience function for accessing indexes defined on the collection
- indexes: function() {
- return this.g.get('/type/item').indexes;
- },
-
- // Serialize
- toJSON: function() {
- return {
- properties: this.g.toJSON()["/type/item"].properties,
- items: this.g.objects().toJSON()
- }
- }
- });
})();
View
82,900 fixtures/policies.js
82,900 additions, 0 deletions not shown
View
1,177 lib/crossfilter.js
@@ -0,0 +1,1177 @@
+(function(exports){
+crossfilter.version = "1.0.2";
+function crossfilter_identity(d) {
+ return d;
+}
+crossfilter.permute = permute;
+
+function permute(array, index) {
+ for (var i = 0, n = index.length, copy = new Array(n); i < n; ++i) {
+ copy[i] = array[index[i]];
+ }
+ return copy;
+}
+var bisect = crossfilter.bisect = bisect_by(crossfilter_identity);
+
+bisect.by = bisect_by;
+
+function bisect_by(f) {
+
+ // Locate the insertion point for x in a to maintain sorted order. The
+ // arguments lo and hi may be used to specify a subset of the array which
+ // should be considered; by default the entire array is used. If x is already
+ // present in a, the insertion point will be before (to the left of) any
+ // existing entries. The return value is suitable for use as the first
+ // argument to `array.splice` assuming that a is already sorted.
+ //
+ // The returned insertion point i partitions the array a into two halves so
+ // that all v < x for v in a[lo:i] for the left side and all v >= x for v in
+ // a[i:hi] for the right side.
+ function bisectLeft(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (f(a[mid]) < x) lo = mid + 1;
+ else hi = mid;
+ }
+ return lo;
+ }
+
+ // Similar to bisectLeft, but returns an insertion point which comes after (to
+ // the right of) any existing entries of x in a.
+ //
+ // The returned insertion point i partitions the array into two halves so that
+ // all v <= x for v in a[lo:i] for the left side and all v > x for v in
+ // a[i:hi] for the right side.
+ function bisectRight(a, x, lo, hi) {
+ while (lo < hi) {
+ var mid = lo + hi >> 1;
+ if (x < f(a[mid])) hi = mid;
+ else lo = mid + 1;
+ }
+ return lo;
+ }
+
+ bisectRight.right = bisectRight;
+ bisectRight.left = bisectLeft;
+ return bisectRight;
+}
+var heap = crossfilter.heap = heap_by(crossfilter_identity);
+
+heap.by = heap_by;
+
+function heap_by(f) {
+
+ // Builds a binary heap within the specified array a[lo:hi]. The heap has the
+ // property such that the parent a[lo+i] is always less than or equal to its
+ // two children: a[lo+2*i+1] and a[lo+2*i+2].
+ function heap(a, lo, hi) {
+ var n = hi - lo,
+ i = (n >>> 1) + 1;
+ while (--i > 0) sift(a, i, n, lo);
+ return a;
+ }
+
+ // Sorts the specified array a[lo:hi] in descending order, assuming it is
+ // already a heap.
+ function sort(a, lo, hi) {
+ var n = hi - lo,
+ t;
+ while (--n > 0) t = a[lo], a[lo] = a[lo + n], a[lo + n] = t, sift(a, 1, n, lo);
+ return a;
+ }
+
+ // Sifts the element a[lo+i-1] down the heap, where the heap is the contiguous
+ // slice of array a[lo:lo+n]. This method can also be used to update the heap
+ // incrementally, without incurring the full cost of reconstructing the heap.
+ function sift(a, i, n, lo) {
+ var d = a[--lo + i],
+ x = f(d),
+ child;
+ while ((child = i << 1) <= n) {
+ if (child < n && f(a[lo + child]) > f(a[lo + child + 1])) child++;
+ if (x <= f(a[lo + child])) break;
+ a[lo + i] = a[lo + child];
+ i = child;
+ }
+ a[lo + i] = d;
+ }
+
+ heap.sort = sort;
+ return heap;
+}
+var heapselect = crossfilter.heapselect = heapselect_by(crossfilter_identity);
+
+heapselect.by = heapselect_by;
+
+function heapselect_by(f) {
+ var heap = heap_by(f);
+
+ // Returns a new array containing the top k elements in the array a[lo:hi].
+ // The returned array is not sorted, but maintains the heap property. If k is
+ // greater than hi - lo, then fewer than k elements will be returned. The
+ // order of elements in a is unchanged by this operation.
+ function heapselect(a, lo, hi, k) {
+ var queue = new Array(k = Math.min(hi - lo, k)),
+ min,
+ i,
+ x,
+ d;
+
+ for (i = 0; i < k; ++i) queue[i] = a[lo++];
+ heap(queue, 0, k);
+
+ if (lo < hi) {
+ min = f(queue[0]);
+ do {
+ if (x = f(d = a[lo]) > min) {
+ queue[0] = d;
+ min = f(heap(queue, 0, k)[0]);
+ }
+ } while (++lo < hi);
+ }
+
+ return queue;
+ }
+
+ return heapselect;
+}
+var insertionsort = crossfilter.insertionsort = insertionsort_by(crossfilter_identity);
+
+insertionsort.by = insertionsort_by;
+
+function insertionsort_by(f) {
+
+ function insertionsort(a, lo, hi) {
+ for (var i = lo + 1; i < hi; ++i) {
+ for (var j = i, t = a[i], x = f(t); j > lo && f(a[j - 1]) > x; --j) {
+ a[j] = a[j - 1];
+ }
+ a[j] = t;
+ }
+ return a;
+ }
+
+ return insertionsort;
+}
+// Algorithm designed by Vladimir Yaroslavskiy.
+// Implementation based on the Dart project; see lib/dart/LICENSE for details.
+
+var quicksort = crossfilter.quicksort = quicksort_by(crossfilter_identity);
+
+quicksort.by = quicksort_by;
+
+function quicksort_by(f) {
+ var insertionsort = insertionsort_by(f);
+
+ function sort(a, lo, hi) {
+ return (hi - lo < quicksort_sizeThreshold
+ ? insertionsort
+ : quicksort)(a, lo, hi);
+ }
+
+ function quicksort(a, lo, hi) {
+
+ // Compute the two pivots by looking at 5 elements.
+ var sixth = (hi - lo) / 6 | 0,
+ i1 = lo + sixth,
+ i5 = hi - 1 - sixth,
+ i3 = lo + hi - 1 >> 1, // The midpoint.
+ i2 = i3 - sixth,
+ i4 = i3 + sixth;
+
+ var e1 = a[i1], x1 = f(e1),
+ e2 = a[i2], x2 = f(e2),
+ e3 = a[i3], x3 = f(e3),
+ e4 = a[i4], x4 = f(e4),
+ e5 = a[i5], x5 = f(e5);
+
+ // Sort the selected 5 elements using a sorting network.
+ if (x1 > x2) t = e1, e1 = e2, e2 = t, t = x1, x1 = x2, x2 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+ if (x1 > x3) t = e1, e1 = e3, e3 = t, t = x1, x1 = x3, x3 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x1 > x4) t = e1, e1 = e4, e4 = t, t = x1, x1 = x4, x4 = t;
+ if (x3 > x4) t = e3, e3 = e4, e4 = t, t = x3, x3 = x4, x4 = t;
+ if (x2 > x5) t = e2, e2 = e5, e5 = t, t = x2, x2 = x5, x5 = t;
+ if (x2 > x3) t = e2, e2 = e3, e3 = t, t = x2, x2 = x3, x3 = t;
+ if (x4 > x5) t = e4, e4 = e5, e5 = t, t = x4, x4 = x5, x5 = t;
+
+ var pivot1 = e2, pivotValue1 = x2,
+ pivot2 = e4, pivotValue2 = x4;
+
+ // e2 and e4 have been saved in the pivot variables. They will be written
+ // back, once the partitioning is finished.
+ a[i1] = e1;
+ a[i2] = a[lo];
+ a[i3] = e3;
+ a[i4] = a[hi - 1];
+ a[i5] = e5;
+
+ var less = lo + 1, // First element in the middle partition.
+ great = hi - 2; // Last element in the middle partition.
+
+ // Note that for value comparison, <, <=, >= and > coerce to a primitive via
+ // Object.prototype.valueOf; == and === do not, so in order to be consistent
+ // with natural order (such as for Date objects), we must do two compares.
+ var pivotsEqual = pivotValue1 <= pivotValue2 && pivotValue1 >= pivotValue2;
+ if (pivotsEqual) {
+
+ // Degenerated case where the partitioning becomes a dutch national flag
+ // problem.
+ //
+ // [ | < pivot | == pivot | unpartitioned | > pivot | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1) for x in ]left, less[ : x < pivot.
+ // 2) for x in [less, k[ : x == pivot.
+ // 3) for x in ]great, right[ : x > pivot.
+ for (var k = less; k <= great; ++k) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else if (xk > pivotValue1) {
+
+ // Find the first element <= pivot in the range [k - 1, great] and
+ // put [:ek:] there. We know that such an element must exist:
+ // When k == less, then el3 (which is equal to pivot) lies in the
+ // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
+ // Note that in the latter case invariant 2 will be violated for a
+ // short amount of time. The invariant will be restored when the
+ // pivots are put into their final positions.
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue1) {
+ great--;
+ // This is the only location in the while-loop where a new
+ // iteration is started.
+ continue;
+ } else if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ break;
+ } else {
+ a[k] = a[great];
+ a[great--] = ek;
+ // Note: if great < k then we will exit the outer loop and fix
+ // invariant 2 (which we just violated).
+ break;
+ }
+ }
+ }
+ }
+ } else {
+
+ // We partition the list into three parts:
+ // 1. < pivot1
+ // 2. >= pivot1 && <= pivot2
+ // 3. > pivot2
+ //
+ // During the loop we have:
+ // [ | < pivot1 | >= pivot1 && <= pivot2 | unpartitioned | > pivot2 | ]
+ // ^ ^ ^ ^ ^
+ // left less k great right
+ //
+ // a[left] and a[right] are undefined and are filled after the
+ // partitioning.
+ //
+ // Invariants:
+ // 1. for x in ]left, less[ : x < pivot1
+ // 2. for x in [less, k[ : pivot1 <= x && x <= pivot2
+ // 3. for x in ]great, right[ : x > pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk < pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ ++less;
+ } else {
+ if (xk > pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue > pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] <= pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] >= pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Move pivots into their final positions.
+ // We shrunk the list from both sides (a[left] and a[right] have
+ // meaningless values in them) and now we move elements from the first
+ // and third partition into these locations so that we can store the
+ // pivots.
+ a[lo] = a[less - 1];
+ a[less - 1] = pivot1;
+ a[hi - 1] = a[great + 1];
+ a[great + 1] = pivot2;
+
+ // The list is now partitioned into three partitions:
+ // [ < pivot1 | >= pivot1 && <= pivot2 | > pivot2 ]
+ // ^ ^ ^ ^
+ // left less great right
+
+ // Recursive descent. (Don't include the pivot values.)
+ sort(a, lo, less - 1);
+ sort(a, great + 2, hi);
+
+ if (pivotsEqual) {
+ // All elements in the second partition are equal to the pivot. No
+ // need to sort them.
+ return a;
+ }
+
+ // In theory it should be enough to call _doSort recursively on the second
+ // partition.
+ // The Android source however removes the pivot elements from the recursive
+ // call if the second partition is too large (more than 2/3 of the list).
+ if (less < i1 && great > i5) {
+ var lessValue, greatValue;
+ while ((lessValue = f(a[less])) <= pivotValue1 && lessValue >= pivotValue1) ++less;
+ while ((greatValue = f(a[great])) <= pivotValue2 && greatValue >= pivotValue2) --great;
+
+ // Copy paste of the previous 3-way partitioning with adaptions.
+ //
+ // We partition the list into three parts:
+ // 1. == pivot1
+ // 2. > pivot1 && < pivot2
+ // 3. == pivot2
+ //
+ // During the loop we have:
+ // [ == pivot1 | > pivot1 && < pivot2 | unpartitioned | == pivot2 ]
+ // ^ ^ ^
+ // less k great
+ //
+ // Invariants:
+ // 1. for x in [ *, less[ : x == pivot1
+ // 2. for x in [less, k[ : pivot1 < x && x < pivot2
+ // 3. for x in ]great, * ] : x == pivot2
+ for (var k = less; k <= great; k++) {
+ var ek = a[k], xk = f(ek);
+ if (xk <= pivotValue1 && xk >= pivotValue1) {
+ if (k !== less) {
+ a[k] = a[less];
+ a[less] = ek;
+ }
+ less++;
+ } else {
+ if (xk <= pivotValue2 && xk >= pivotValue2) {
+ while (true) {
+ var greatValue = f(a[great]);
+ if (greatValue <= pivotValue2 && greatValue >= pivotValue2) {
+ great--;
+ if (great < k) break;
+ // This is the only location inside the loop where a new
+ // iteration is started.
+ continue;
+ } else {
+ // a[great] < pivot2.
+ if (greatValue < pivotValue1) {
+ // Triple exchange.
+ a[k] = a[less];
+ a[less++] = a[great];
+ a[great--] = ek;
+ } else {
+ // a[great] == pivot1.
+ a[k] = a[great];
+ a[great--] = ek;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // The second partition has now been cleared of pivot elements and looks
+ // as follows:
+ // [ * | > pivot1 && < pivot2 | * ]
+ // ^ ^
+ // less great
+ // Sort the second partition using recursive descent.
+
+ // The second partition looks as follows:
+ // [ * | >= pivot1 && <= pivot2 | * ]
+ // ^ ^
+ // less great
+ // Simply sort it by recursive descent.
+
+ return sort(a, less, great + 1);
+ }
+
+ return sort;
+}
+
+var quicksort_sizeThreshold = 32;
+var crossfilter_array8 = crossfilter_arrayUntyped,
+ crossfilter_array16 = crossfilter_arrayUntyped,
+ crossfilter_array32 = crossfilter_arrayUntyped,
+ crossfilter_arrayLengthen = crossfilter_identity,
+ crossfilter_arrayWiden = crossfilter_identity;
+
+if (typeof Uint8Array !== "undefined") {
+ crossfilter_array8 = function(n) { return new Uint8Array(n); };
+ crossfilter_array16 = function(n) { return new Uint16Array(n); };
+ crossfilter_array32 = function(n) { return new Uint32Array(n); };
+
+ crossfilter_arrayLengthen = function(array, length) {
+ var copy = new array.constructor(length);
+ copy.set(array);
+ return copy;
+ };
+
+ crossfilter_arrayWiden = function(array, width) {
+ var copy;
+ switch (width) {
+ case 16: copy = crossfilter_array16(array.length); break;
+ case 32: copy = crossfilter_array32(array.length); break;
+ default: throw new Error("invalid array width!");
+ }
+ copy.set(array);
+ return copy;
+ };
+}
+
+function crossfilter_arrayUntyped(n) {
+ return new Array(n);
+}
+function crossfilter_filterExact(bisect, value) {
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, value, 0, n), bisect.right(values, value, 0, n)];
+ };
+}
+
+function crossfilter_filterRange(bisect, range) {
+ var min = range[0],
+ max = range[1];
+ return function(values) {
+ var n = values.length;
+ return [bisect.left(values, min, 0, n), bisect.left(values, max, 0, n)];
+ };
+}
+
+function crossfilter_filterAll(values) {
+ return [0, values.length];
+}
+function crossfilter_null() {
+ return null;
+}
+function crossfilter_zero() {
+ return 0;
+}
+function crossfilter_reduceIncrement(p) {
+ return p + 1;
+}
+
+function crossfilter_reduceDecrement(p) {
+ return p - 1;
+}
+
+function crossfilter_reduceAdd(f) {
+ return function(p, v) {
+ return p + +f(v);
+ };
+}
+
+function crossfilter_reduceSubtract(f) {
+ return function(p, v) {
+ return p - f(v);
+ };
+}
+exports.crossfilter = crossfilter;
+
+function crossfilter() {
+ var crossfilter = {
+ add: add,
+ dimension: dimension,
+ groupAll: groupAll,
+ size: size
+ };
+
+ var data = [], // the records
+ n = 0, // the number of records; data.length
+ m = 0, // number of dimensions in use
+ M = 8, // number of dimensions that can fit in `filters`
+ filters = crossfilter_array8(0), // M bits per record; 1 is filtered out
+ filterListeners = [], // when the filters change
+ dataListeners = []; // when data is added
+
+ // Adds the specified new records to this crossfilter.
+ function add(newData) {
+ var n0 = n,
+ n1 = newData.length;
+
+ // If there's actually new data to add…
+ // Merge the new data into the existing data.
+ // Lengthen the filter bitset to handle the new records.
+ // Notify listeners (dimensions and groups) that new data is available.
+ if (n1) {
+ data = data.concat(newData);
+ filters = crossfilter_arrayLengthen(filters, n += n1);
+ dataListeners.forEach(function(l) { l(newData, n0, n1); });
+ }
+
+ return crossfilter;
+ }
+
+ // Adds a new dimension with the specified value accessor function.
+ function dimension(value) {
+ var dimension = {
+ filter: filter,
+ filterExact: filterExact,
+ filterRange: filterRange,
+ filterAll: filterAll,
+ top: top,
+ group: group,
+ groupAll: groupAll
+ };
+
+ var one = 1 << m++, // bit mask, e.g., 00001000
+ zero = ~one, // inverted one, e.g., 11110111
+ values, // sorted, cached array
+ index, // value rank ↦ object id
+ newValues, // temporary array storing newly-added values
+ newIndex, // temporary array storing newly-added index
+ sort = quicksort_by(function(i) { return newValues[i]; }),
+ refilter = crossfilter_filterAll, // for recomputing filter
+ indexListeners = [], // when data is added
+ lo0 = 0,
+ hi0 = 0;
+
+ // Updating a dimension is a two-stage process. First, we must update the
+ // associated filters for the newly-added records. Once all dimensions have
+ // updated their filters, the groups are notified to update.
+ dataListeners.unshift(preAdd);
+ dataListeners.push(postAdd);
+
+ // Incorporate any existing data into this dimension, and make sure that the
+ // filter bitset is wide enough to handle the new dimension.
+ if (m > M) filters = crossfilter_arrayWiden(filters, M <<= 1);
+ preAdd(data, 0, n);
+ postAdd(data, 0, n);
+
+ // Incorporates the specified new records into this dimension.
+ // This function is responsible for updating filters, values, and index.
+ function preAdd(newData, n0, n1) {
+
+ // Permute new values into natural order using a sorted index.
+ newValues = newData.map(value);
+ newIndex = sort(crossfilter_range(n1), 0, n1);
+ newValues = permute(newValues, newIndex);
+
+ // Bisect newValues to determine which new records are selected.
+ var bounds = refilter(newValues), lo1 = bounds[0], hi1 = bounds[1], i;
+ for (i = 0; i < lo1; ++i) filters[newIndex[i] + n0] |= one;
+ for (i = hi1; i < n1; ++i) filters[newIndex[i] + n0] |= one;
+
+ // If this dimension previously had no data, then we don't need to do the
+ // more expensive merge operation; use the new values and index as-is.
+ if (!n0) {
+ values = newValues;
+ index = newIndex;
+ lo0 = lo1;
+ hi0 = hi1;
+ return;
+ }
+
+ var oldValues = values,
+ oldIndex = index,
+ i0 = 0,
+ i1 = 0;
+
+ // Otherwise, create new arrays into which to merge new and old.
+ values = new Array(n);
+ index = crossfilter_index(n, n);
+
+ // Merge the old and new sorted values, and old and new index.
+ for (i = 0; i0 < n0 && i1 < n1; ++i) {
+ if (oldValues[i0] < newValues[i1]) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0++];
+ } else {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1++] + n0;
+ }
+ }
+
+ // Add any remaining old values.
+ for (; i0 < n0; ++i0, ++i) {
+ values[i] = oldValues[i0];
+ index[i] = oldIndex[i0];
+ }
+
+ // Add any remaining new values.
+ for (; i1 < n1; ++i1, ++i) {
+ values[i] = newValues[i1];
+ index[i] = newIndex[i1] + n0;
+ }
+
+ // Bisect again to recompute lo0 and hi0.
+ bounds = refilter(values), lo0 = bounds[0], hi0 = bounds[1];
+ }
+
+ // When all filters have updated, notify index listeners of the new values.
+ function postAdd(newData, n0, n1) {
+ indexListeners.forEach(function(l) { l(newValues, newIndex, n0, n1); });
+ newValues = newIndex = null;
+ }
+
+ // Updates the selected values based on the specified bounds [lo, hi].
+ // This implementation is used by all the public filter methods.
+ function filterIndex(bounds) {
+ var i,
+ j,
+ k,
+ lo1 = bounds[0],
+ hi1 = bounds[1],
+ added = [],
+ removed = [];
+
+ // Fast incremental update based on previous lo index.
+ if (lo1 < lo0) {
+ for (i = lo1, j = Math.min(lo0, hi1); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (lo1 > lo0) {
+ for (i = lo0, j = Math.min(lo1, hi0); i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ // Fast incremental update based on previous hi index.
+ if (hi1 > hi0) {
+ for (i = Math.max(lo1, hi0), j = hi1; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ added.push(k);
+ }
+ } else if (hi1 < hi0) {
+ for (i = Math.max(lo0, hi1), j = hi0; i < j; ++i) {
+ filters[k = index[i]] ^= one;
+ removed.push(k);
+ }
+ }
+
+ lo0 = lo1;
+ hi0 = hi1;
+ filterListeners.forEach(function(l) { l(one, added, removed); });
+ return dimension;
+ }
+
+ // Filters this dimension using the specified range, value, or null.
+ // If the range is null, this is equivalent to filterAll.
+ // If the range is an array, this is equivalent to filterRange.
+ // Otherwise, this is equivalent to filterExact.
+ function filter(range) {
+ return range == null
+ ? filterAll() : Array.isArray(range)
+ ? filterRange(range)
+ : filterExact(range);
+ }
+
+ // Filters this dimension to select the exact value.
+ function filterExact(value) {
+ return filterIndex((refilter = crossfilter_filterExact(bisect, value))(values));
+ }
+
+ // Filters this dimension to select the specified range [lo, hi].
+ // The lower bound is inclusive, and the upper bound is exclusive.
+ function filterRange(range) {
+ return filterIndex((refilter = crossfilter_filterRange(bisect, range))(values));
+ }
+
+ // Clears any filters on this dimension.
+ function filterAll() {
+ return filterIndex((refilter = crossfilter_filterAll)(values));
+ }
+
+ // Returns the top K selected records, based on this dimension's order.
+ // Note: observes this dimension's filter, unlike group and groupAll.
+ function top(k) {
+ var array = [],
+ i = hi0,
+ j;
+
+ while (--i >= lo0 && k > 0) {
+ if (!filters[j = index[i]]) {
+ array.push(data[j]);
+ --k;
+ }
+ }
+
+ return array;
+ }
+
+ // Adds a new group to this dimension, using the specified key function.
+ function group(key) {
+ var group = {
+ top: top,
+ all: all,
+ reduce: reduce,
+ reduceCount: reduceCount,
+ reduceSum: reduceSum,
+ order: order,
+ orderNatural: orderNatural,
+ size: size
+ };
+
+ var groups, // array of {key, value}
+ groupIndex, // object id ↦ group id
+ groupWidth = 8,
+ groupCapacity = crossfilter_capacity(groupWidth),
+ k = 0, // cardinality
+ select,
+ heap,
+ reduceAdd,
+ reduceRemove,
+ reduceInitial,
+ update = crossfilter_null,
+ reset = crossfilter_null,
+ resetNeeded = true;
+
+ if (arguments.length < 1) key = crossfilter_identity;
+
+ // The group listens to the crossfilter for when any dimension changes, so
+ // that it can update the associated reduce values. It must also listen to
+ // the parent dimension for when data is added, and compute new keys.
+ filterListeners.push(update);
+ indexListeners.push(add);
+
+ // Incorporate any existing data into the grouping.
+ add(values, index, 0, n);
+
+ // Incorporates the specified new values into this group.
+ // This function is responsible for updating groups and groupIndex.
+ function add(newValues, newIndex, n0, n1) {
+ var oldGroups = groups,
+ reIndex = crossfilter_index(k, groupCapacity),
+ add = reduceAdd,
+ initial = reduceInitial,
+ k0 = k, // old cardinality
+ i0 = 0, // index of old group
+ i1 = 0, // index of new record
+ j, // object id
+ g0, // old group
+ x0, // old key
+ x1, // new key
+ g, // group to add
+ x; // key of group to add
+
+ // If a reset is needed, we don't need to update the reduce values.
+ if (resetNeeded) add = initial = crossfilter_null;
+
+ // Reset the new groups (k is a lower bound).
+ // Also, make sure that groupIndex exists and is long enough.
+ groups = new Array(k), k = 0;
+ groupIndex = k0 > 1 ? crossfilter_arrayLengthen(groupIndex, n) : crossfilter_index(n, groupCapacity);
+
+ // Get the first old key (x0 of g0), if it exists.
+ if (k0) x0 = (g0 = oldGroups[0]).key;
+
+ // Find the first new key (x1), skipping NaN keys.
+ while (i1 < n1 && !((x1 = key(newValues[i1])) >= x1)) ++i1;
+
+ // While new keys remain…
+ while (i1 < n1) {
+
+ // Determine the lesser of the two current keys; new and old.
+ // If there are no old keys remaining, then always add the new key.
+ if (g0 && x0 <= x1) {
+ g = g0, x = x0;
+
+ // Record the new index of the old group.
+ reIndex[i0] = k;
+
+ // Retrieve the next old key.
+ if (g0 = oldGroups[++i0]) x0 = g0.key;
+ } else {
+ g = {key: x1, value: initial()}, x = x1;
+ }
+
+ // Add the lesser group.
+ groups[k] = g;
+
+ // Add any selected records belonging to the added group, while
+ // advancing the new key and populating the associated group index.
+ while (!(x1 > x)) {
+ groupIndex[j = newIndex[i1] + n0] = k;
+ if (!(filters[j] & zero)) g.value = add(g.value, data[j]);
+ if (++i1 >= n1) break;
+ x1 = key(newValues[i1]);
+ }
+
+ groupIncrement();
+ }
+
+ // Add any remaining old groups that were greater than all new keys.
+ // No incremental reduce is needed; these groups have no new records.
+ // Also record the new index of the old group.
+ while (i0 < k0) {
+ groups[reIndex[i0] = k] = oldGroups[i0++];
+ groupIncrement();
+ }
+
+ // If we added any new groups before any old groups,
+ // update the group index of all the old records.
+ if (k > i0) for (i0 = 0; i0 < n0; ++i0) {
+ groupIndex[i0] = reIndex[groupIndex[i0]];
+ }
+
+ // Modify the update and reset behavior based on the cardinality.
+ // If the cardinality is less than or equal to one, then the groupIndex
+ // is not needed. If the cardinality is zero, then there are no records
+ // and therefore no groups to update or reset. Note that we also must
+ // change the registered listener to point to the new method.
+ j = filterListeners.indexOf(update);
+ if (k > 1) {
+ update = updateMany;
+ reset = resetMany;
+ } else {
+ if (k === 1) {
+ update = updateOne;
+ reset = resetOne;
+ } else {
+ update = crossfilter_null;
+ reset = crossfilter_null;
+ }
+ groupIndex = null;
+ }
+ filterListeners[j] = update;
+
+ // Count the number of added groups,
+ // and widen the group index as needed.
+ function groupIncrement() {
+ if (++k === groupCapacity) {
+ reIndex = crossfilter_arrayWiden(reIndex, groupWidth <<= 1);
+ groupIndex = crossfilter_arrayWiden(groupIndex, groupWidth);
+ groupCapacity = crossfilter_capacity(groupWidth);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is greater than 1.
+ function updateMany(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n;
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g = groups[groupIndex[k]];
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g = groups[groupIndex[k]];
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ // This function is only used when the cardinality is 1.
+ function updateOne(filterOne, added, removed) {
+ if (filterOne === one || resetNeeded) return;
+
+ var i,
+ k,
+ n,
+ g = groups[0];
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!(filters[k = added[i]] & zero)) {
+ g.value = reduceAdd(g.value, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if ((filters[k = removed[i]] & zero) === filterOne) {
+ g.value = reduceRemove(g.value, data[k]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is greater than 1.
+ function resetMany() {
+ var i,
+ g;
+
+ // Reset all group values.
+ for (i = 0; i < k; ++i) {
+ groups[i].value = reduceInitial();
+ }
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g = groups[groupIndex[i]];
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce values from scratch.
+ // This function is only used when the cardinality is 1.
+ function resetOne() {
+ var i,
+ g = groups[0];
+
+ // Reset the singleton group values.
+ g.value = reduceInitial();
+
+ // Add any selected records.
+ for (i = 0; i < n; ++i) {
+ if (!(filters[i] & zero)) {
+ g.value = reduceAdd(g.value, data[i]);
+ }
+ }
+ }
+
+ // Returns the array of group values, in the dimension's natural order.
+ function all() {
+ if (resetNeeded) reset(), resetNeeded = false;
+ return groups;
+ }
+
+ // Returns a new array containing the top K group values, in reduce order.
+ function top(k) {
+ var top = select(all(), 0, groups.length, k);
+ return heap.sort(top, 0, top.length);
+ }
+
+ // Sets the reduce behavior for this group to use the specified functions.
+ // This method lazily recomputes the reduce values, waiting until needed.
+ function reduce(add, remove, initial) {
+ reduceAdd = add;
+ reduceRemove = remove;
+ reduceInitial = initial;
+ resetNeeded = true;
+ return group;
+ }
+
+ // A convenience method for reducing by count.
+ function reduceCount() {
+ return reduce(crossfilter_reduceIncrement, crossfilter_reduceDecrement, crossfilter_zero);
+ }
+
+ // A convenience method for reducing by sum(value).
+ function reduceSum(value) {
+ return reduce(crossfilter_reduceAdd(value), crossfilter_reduceSubtract(value), crossfilter_zero);
+ }
+
+ // Sets the reduce order, using the specified accessor.
+ function order(value) {
+ select = heapselect_by(valueOf);
+ heap = heap_by(valueOf);
+ function valueOf(d) { return value(d.value); }
+ return group;
+ }
+
+ // A convenience method for natural ordering by reduce value.
+ function orderNatural() {
+ return order(crossfilter_identity);
+ }
+
+ // Returns the cardinality of this group, irrespective of any filters.
+ function size() {
+ return k;
+ }
+
+ return reduceCount().orderNatural();
+ }
+
+ // A convenience function for generating a singleton group.
+ function groupAll() {
+ var g = group(crossfilter_null), all = g.all;
+ delete g.all;
+ delete g.top;
+ delete g.order;
+ delete g.orderNatural;
+ delete g.size;
+ g.value = function() { return all()[0].value; };
+ return g;
+ }
+
+ return dimension;
+ }
+
+ // A convenience method for groupAll on a dummy dimension.
+ // This implementation can be optimized since it is always cardinality 1.
+ function groupAll() {
+ var group = {
+ reduce: reduce,
+ reduceCount: reduceCount,
+ reduceSum: reduceSum,
+ value: value
+ };
+
+ var reduceValue,
+ reduceAdd,
+ reduceRemove,
+ reduceInitial,
+ resetNeeded = true;
+
+ // The group listens to the crossfilter for when any dimension changes, so
+ // that it can update the reduce value. It must also listen to the parent
+ // dimension for when data is added.
+ filterListeners.push(update);
+ dataListeners.push(add);
+
+ // For consistency; actually a no-op since resetNeeded is true.
+ add(data, 0, n);
+
+ // Incorporates the specified new values into this group.
+ function add(newData, n0, n1) {
+ var i;
+
+ if (resetNeeded) return;
+
+ // Add the added values.
+ for (i = n0; i < n; ++i) {
+ if (!filters[i]) {
+ reduceValue = reduceAdd(reduceValue, data[i]);
+ }
+ }
+ }
+
+ // Reduces the specified selected or deselected records.
+ function update(filterOne, added, removed) {
+ var i,
+ k,
+ n;
+
+ if (resetNeeded) return;
+
+ // Add the added values.
+ for (i = 0, n = added.length; i < n; ++i) {
+ if (!filters[k = added[i]]) {
+ reduceValue = reduceAdd(reduceValue, data[k]);
+ }
+ }
+
+ // Remove the removed values.
+ for (i = 0, n = removed.length; i < n; ++i) {
+ if (filters[k = removed[i]] === filterOne) {
+ reduceValue = reduceRemove(reduceValue, data[k]);
+ }
+ }
+ }
+
+ // Recomputes the group reduce value from scratch.
+ function reset() {
+ var i;
+
+ reduceValue = reduceInitial();
+
+ for (i = 0; i < n; ++i) {
+ if (!filters[i]) {
+ reduceValue = reduceAdd(reduceValue, data[i]);
+ }
+ }
+ }
+
+ // Sets the reduce behavior for this group to use the specified functions.
+ // This method lazily recomputes the reduce value, waiting until needed.
+ function reduce(add, remove, initial) {
+ reduceAdd = add;
+ reduceRemove = remove;
+ reduceInitial = initial;
+ resetNeeded = true;
+ return group;
+ }
+
+ // A convenience method for reducing by count.
+ function reduceCount() {
+ return reduce(crossfilter_reduceIncrement, crossfilter_reduceDecrement, crossfilter_zero);
+ }
+
+ // A convenience method for reducing by sum(value).
+ function reduceSum(value) {
+ return reduce(crossfilter_reduceAdd(value), crossfilter_reduceSubtract(value), crossfilter_zero);
+ }
+
+ // Returns the computed reduce value.
+ function value() {
+ if (resetNeeded) reset(), resetNeeded = false;
+ return reduceValue;
+ }
+
+ return reduceCount();
+ }
+
+ // Returns the number of records in this crossfilter, irrespective of any filters.
+ function size() {
+ return n;
+ }
+
+ return arguments.length
+ ? add(arguments[0])
+ : crossfilter;
+}
+
+// Returns an array of size n, big enough to store ids up to m.
+function crossfilter_index(n, m) {
+ return (m < 0x101
+ ? crossfilter_array8 : m < 0x10001
+ ? crossfilter_array16
+ : crossfilter_array32)(n);
+}
+
+// Constructs a new array of size n, with sequential values from 0 to n - 1.
+function crossfilter_range(n) {
+ var range = crossfilter_index(n, n);
+ for (var i = -1; ++i < n;) range[i] = i;
+ return range;
+}
+
+function crossfilter_capacity(w) {
+ return w === 8