feat: Phase 1 — extract the client (web SPA + desktop) to dtoro/oikos-web
Problem: the hexagonal refactor churns the backend tree for nine more phases; the UI delivery stack (web/ SPA, cmd/desktop Wails wrapper, compose/web image) must move to its own repo first so doc/layout rewrites land once on a backend-only tree. Change: - New repo git.hubris.network/dtoro/oikos-web (v0.33.0): web/, desktop/ (updateURL repointed to oikos-web releases), compose/, own CI (web + desktop jobs), own deploy script (CI-green gate, TOCTOU guard, version-tagged images, prune-to-3), own webhook receiver on :9798 + launchd unit, own compose project publishing the same 8091:80. - Cutover executed on mac-mini in order: oikos stack's web service stopped+removed, oikos-web project brought up on 8091; outer Caddy untouched (targets the published port) — serving + Authentik flow + /wails 404 quirk verified post-cutover. - Stripped from oikos: web/, cmd/desktop/, compose/web/, desktop CI workflow, ci.yml web job, Makefile ui/desktop/desktop-package/install targets, the compose web service, oikos-web from deploy.sh's fallback prune list; wails + go-keyring dropped from go.mod, vendor synced. - README / CONTRIBUTING / AGENTS.md / .agents dev+operations docs now point at the new repo; mbse + mascot design docs carry a path note. Risk: production SPA serving depends on the new pipeline now; rollback is versioned-image re-up of the old web service from a pre-split checkout (port 8091). Desktop builds installed before the split still check dtoro/oikos releases — one manual reinstall, noted in the oikos-web release notes. Verification: go vet, make test (race), make generate-check, golangci (no new findings; baseline down 400→365); post-cutover curls — localhost:8091 200, /wails/runtime.js 404, outer Caddy 302 Authentik.
This commit is contained in:
721
web/node_modules/graphology/specs/mutation.js
generated
vendored
Normal file
721
web/node_modules/graphology/specs/mutation.js
generated
vendored
Normal file
@@ -0,0 +1,721 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports["default"] = mutation;
|
||||
var _assert = _interopRequireDefault(require("assert"));
|
||||
var _helpers = require("./helpers");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
|
||||
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
|
||||
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
|
||||
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /**
|
||||
* Graphology Mutation Specs
|
||||
* ==========================
|
||||
*
|
||||
* Testing the mutation methods of the graph.
|
||||
*/
|
||||
function mutation(Graph, checkers) {
|
||||
var invalid = checkers.invalid,
|
||||
notFound = checkers.notFound,
|
||||
usage = checkers.usage;
|
||||
return {
|
||||
'#.addNode': {
|
||||
'it should throw if given attributes is not an object.': function it_should_throw_if_given_attributes_is_not_an_object() {
|
||||
var graph = new Graph();
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addNode('test', true);
|
||||
}, invalid());
|
||||
},
|
||||
'it should throw if the given node already exist.': function it_should_throw_if_the_given_node_already_exist() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addNode('Martha');
|
||||
}, usage());
|
||||
},
|
||||
'it should return the added node.': function it_should_return_the_added_node() {
|
||||
var graph = new Graph();
|
||||
_assert["default"].strictEqual(graph.addNode('John'), 'John');
|
||||
}
|
||||
},
|
||||
'#.mergeNode': {
|
||||
'it should add the node if it does not exist yet.': function it_should_add_the_node_if_it_does_not_exist_yet() {
|
||||
var graph = new Graph();
|
||||
graph.mergeNode('John');
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
},
|
||||
'it should do nothing if the node already exists.': function it_should_do_nothing_if_the_node_already_exists() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('John');
|
||||
graph.mergeNode('John');
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
},
|
||||
'it should merge the attributes.': function it_should_merge_the_attributes() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('John', {
|
||||
eyes: 'blue'
|
||||
});
|
||||
graph.mergeNode('John', {
|
||||
age: 15
|
||||
});
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
_assert["default"].deepStrictEqual(graph.getNodeAttributes('John'), {
|
||||
eyes: 'blue',
|
||||
age: 15
|
||||
});
|
||||
},
|
||||
'it should coerce keys to string.': function it_should_coerce_keys_to_string() {
|
||||
var graph = new Graph();
|
||||
graph.addNode(4);
|
||||
_assert["default"].doesNotThrow(function () {
|
||||
return graph.mergeNode(4);
|
||||
});
|
||||
},
|
||||
'it should return useful information.': function it_should_return_useful_information() {
|
||||
var graph = new Graph();
|
||||
var _graph$mergeNode = graph.mergeNode('Jack'),
|
||||
key = _graph$mergeNode[0],
|
||||
wasAdded = _graph$mergeNode[1];
|
||||
_assert["default"].strictEqual(key, 'Jack');
|
||||
_assert["default"].strictEqual(wasAdded, true);
|
||||
var _graph$mergeNode2 = graph.mergeNode('Jack');
|
||||
key = _graph$mergeNode2[0];
|
||||
wasAdded = _graph$mergeNode2[1];
|
||||
_assert["default"].strictEqual(key, 'Jack');
|
||||
_assert["default"].strictEqual(wasAdded, false);
|
||||
}
|
||||
},
|
||||
'#.updateNode': {
|
||||
'it should add the node if it does not exist yet.': function it_should_add_the_node_if_it_does_not_exist_yet() {
|
||||
var graph = new Graph();
|
||||
graph.updateNode('John');
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
},
|
||||
'it should do nothing if the node already exists.': function it_should_do_nothing_if_the_node_already_exists() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('John');
|
||||
graph.updateNode('John');
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
},
|
||||
'it should update the attributes.': function it_should_update_the_attributes() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('John', {
|
||||
eyes: 'blue',
|
||||
count: 1
|
||||
});
|
||||
graph.updateNode('John', function (attr) {
|
||||
return _objectSpread(_objectSpread({}, attr), {}, {
|
||||
count: attr.count + 1
|
||||
});
|
||||
});
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John']);
|
||||
_assert["default"].deepStrictEqual(graph.getNodeAttributes('John'), {
|
||||
eyes: 'blue',
|
||||
count: 2
|
||||
});
|
||||
},
|
||||
'it should be possible to start from blank attributes.': function it_should_be_possible_to_start_from_blank_attributes() {
|
||||
var graph = new Graph();
|
||||
graph.updateNode('John', function () {
|
||||
return {
|
||||
count: 2
|
||||
};
|
||||
});
|
||||
_assert["default"].deepStrictEqual(graph.getNodeAttributes('John'), {
|
||||
count: 2
|
||||
});
|
||||
},
|
||||
'it should coerce keys to string.': function it_should_coerce_keys_to_string() {
|
||||
var graph = new Graph();
|
||||
graph.addNode(4);
|
||||
_assert["default"].doesNotThrow(function () {
|
||||
return graph.updateNode(4);
|
||||
});
|
||||
},
|
||||
'it should return useful information.': function it_should_return_useful_information() {
|
||||
var graph = new Graph();
|
||||
var _graph$updateNode = graph.updateNode('Jack'),
|
||||
key = _graph$updateNode[0],
|
||||
wasAdded = _graph$updateNode[1];
|
||||
_assert["default"].strictEqual(key, 'Jack');
|
||||
_assert["default"].strictEqual(wasAdded, true);
|
||||
var _graph$updateNode2 = graph.updateNode('Jack');
|
||||
key = _graph$updateNode2[0];
|
||||
wasAdded = _graph$updateNode2[1];
|
||||
_assert["default"].strictEqual(key, 'Jack');
|
||||
_assert["default"].strictEqual(wasAdded, false);
|
||||
}
|
||||
},
|
||||
'#.addDirectedEdge': {
|
||||
'it should throw if given attributes is not an object.': function it_should_throw_if_given_attributes_is_not_an_object() {
|
||||
var graph = new Graph();
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('source', 'target', true);
|
||||
}, invalid());
|
||||
},
|
||||
'it should throw if the graph is undirected.': function it_should_throw_if_the_graph_is_undirected() {
|
||||
var graph = new Graph({
|
||||
type: 'undirected'
|
||||
});
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('source', 'target');
|
||||
}, usage());
|
||||
},
|
||||
'it should throw if either the source or the target does not exist.': function it_should_throw_if_either_the_source_or_the_target_does_not_exist() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('Thomas', 'Eric');
|
||||
}, notFound());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('Martha', 'Eric');
|
||||
}, notFound());
|
||||
},
|
||||
'it should throw if the edge is a loop and the graph does not allow it.': function it_should_throw_if_the_edge_is_a_loop_and_the_graph_does_not_allow_it() {
|
||||
var graph = new Graph({
|
||||
allowSelfLoops: false
|
||||
});
|
||||
graph.addNode('Thomas');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('Thomas', 'Thomas');
|
||||
}, usage());
|
||||
},
|
||||
'it should be possible to add self loops.': function it_should_be_possible_to_add_self_loops() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Thomas');
|
||||
var loop = graph.addDirectedEdge('Thomas', 'Thomas');
|
||||
_assert["default"].deepStrictEqual(graph.extremities(loop), ['Thomas', 'Thomas']);
|
||||
},
|
||||
'it should throw if the graph is not multi & we try to add twice the same edge.': function it_should_throw_if_the_graph_is_not_multi__we_try_to_add_twice_the_same_edge() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Thomas');
|
||||
graph.addNode('Martha');
|
||||
graph.addDirectedEdge('Thomas', 'Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdge('Thomas', 'Martha');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdgeWithKey('T->M', 'Thomas', 'Martha');
|
||||
}, usage());
|
||||
},
|
||||
"it should return the generated edge's key.": function it_should_return_the_generated_edgeS_key() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Thomas');
|
||||
graph.addNode('Martha');
|
||||
var edge = graph.addDirectedEdge('Thomas', 'Martha');
|
||||
(0, _assert["default"])(typeof edge === 'string' || typeof edge === 'number');
|
||||
(0, _assert["default"])(!(edge instanceof Graph));
|
||||
}
|
||||
},
|
||||
'#.addEdge': {
|
||||
'it should add a directed edge if the graph is directed or mixed.': function it_should_add_a_directed_edge_if_the_graph_is_directed_or_mixed() {
|
||||
var graph = new Graph(),
|
||||
directedGraph = new Graph({
|
||||
type: 'directed'
|
||||
});
|
||||
graph.addNode('John');
|
||||
graph.addNode('Martha');
|
||||
var mixedEdge = graph.addEdge('John', 'Martha');
|
||||
directedGraph.addNode('John');
|
||||
directedGraph.addNode('Martha');
|
||||
var directedEdge = directedGraph.addEdge('John', 'Martha');
|
||||
(0, _assert["default"])(graph.isDirected(mixedEdge));
|
||||
(0, _assert["default"])(directedGraph.isDirected(directedEdge));
|
||||
},
|
||||
'it should add an undirected edge if the graph is undirected.': function it_should_add_an_undirected_edge_if_the_graph_is_undirected() {
|
||||
var graph = new Graph({
|
||||
type: 'undirected'
|
||||
});
|
||||
graph.addNode('John');
|
||||
graph.addNode('Martha');
|
||||
var edge = graph.addEdge('John', 'Martha');
|
||||
(0, _assert["default"])(graph.isUndirected(edge));
|
||||
}
|
||||
},
|
||||
'#.addDirectedEdgeWithKey': {
|
||||
'it should throw if an edge with the same key already exists.': function it_should_throw_if_an_edge_with_the_same_key_already_exists() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Thomas');
|
||||
graph.addNode('Martha');
|
||||
graph.addDirectedEdgeWithKey('T->M', 'Thomas', 'Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdgeWithKey('T->M', 'Thomas', 'Martha');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addUndirectedEdgeWithKey('T->M', 'Thomas', 'Martha');
|
||||
}, usage());
|
||||
}
|
||||
},
|
||||
'#.addUndirectedEdgeWithKey': {
|
||||
'it should throw if an edge with the same key already exists.': function it_should_throw_if_an_edge_with_the_same_key_already_exists() {
|
||||
var graph = new Graph();
|
||||
graph.addNode('Thomas');
|
||||
graph.addNode('Martha');
|
||||
graph.addUndirectedEdgeWithKey('T<->M', 'Thomas', 'Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addUndirectedEdgeWithKey('T<->M', 'Thomas', 'Martha');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.addDirectedEdgeWithKey('T<->M', 'Thomas', 'Martha');
|
||||
}, usage());
|
||||
}
|
||||
},
|
||||
'#.addEdgeWithKey': {
|
||||
'it should add a directed edge if the graph is directed or mixed.': function it_should_add_a_directed_edge_if_the_graph_is_directed_or_mixed() {
|
||||
var graph = new Graph(),
|
||||
directedGraph = new Graph({
|
||||
type: 'directed'
|
||||
});
|
||||
graph.addNode('John');
|
||||
graph.addNode('Martha');
|
||||
var mixedEdge = graph.addEdgeWithKey('J->M', 'John', 'Martha');
|
||||
directedGraph.addNode('John');
|
||||
directedGraph.addNode('Martha');
|
||||
var directedEdge = directedGraph.addEdgeWithKey('J->M', 'John', 'Martha');
|
||||
(0, _assert["default"])(graph.isDirected(mixedEdge));
|
||||
(0, _assert["default"])(directedGraph.isDirected(directedEdge));
|
||||
},
|
||||
'it should add an undirected edge if the graph is undirected.': function it_should_add_an_undirected_edge_if_the_graph_is_undirected() {
|
||||
var graph = new Graph({
|
||||
type: 'undirected'
|
||||
});
|
||||
graph.addNode('John');
|
||||
graph.addNode('Martha');
|
||||
var edge = graph.addEdgeWithKey('J<->M', 'John', 'Martha');
|
||||
(0, _assert["default"])(graph.isUndirected(edge));
|
||||
}
|
||||
},
|
||||
'#.mergeEdge': {
|
||||
'it should add the edge if it does not yet exist.': function it_should_add_the_edge_if_it_does_not_yet_exist() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.mergeEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
},
|
||||
'it should do nothing if the edge already exists.': function it_should_do_nothing_if_the_edge_already_exists() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.addEdge('John', 'Martha');
|
||||
graph.mergeEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
},
|
||||
'it should merge existing attributes if any.': function it_should_merge_existing_attributes_if_any() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.addEdge('John', 'Martha', {
|
||||
type: 'KNOWS'
|
||||
});
|
||||
graph.mergeEdge('John', 'Martha', {
|
||||
weight: 2
|
||||
});
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
_assert["default"].deepStrictEqual(graph.getEdgeAttributes('John', 'Martha'), {
|
||||
type: 'KNOWS',
|
||||
weight: 2
|
||||
});
|
||||
},
|
||||
'it should add missing nodes in the path.': function it_should_add_missing_nodes_in_the_path() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John', 'Martha']);
|
||||
},
|
||||
'it should throw in case of inconsistencies.': function it_should_throw_in_case_of_inconsistencies() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdgeWithKey('J->M', 'John', 'Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.mergeEdgeWithKey('J->M', 'John', 'Thomas');
|
||||
}, usage());
|
||||
},
|
||||
'it should be able to merge undirected edges in both directions.': function it_should_be_able_to_merge_undirected_edges_in_both_directions() {
|
||||
_assert["default"].doesNotThrow(function () {
|
||||
var graph = new Graph();
|
||||
graph.mergeUndirectedEdgeWithKey('J<->M', 'John', 'Martha');
|
||||
graph.mergeUndirectedEdgeWithKey('J<->M', 'John', 'Martha');
|
||||
graph.mergeUndirectedEdgeWithKey('J<->M', 'Martha', 'John');
|
||||
}, usage());
|
||||
},
|
||||
'it should distinguish between typed edges.': function it_should_distinguish_between_typed_edges() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge('John', 'Martha', {
|
||||
type: 'LIKES'
|
||||
});
|
||||
graph.mergeUndirectedEdge('John', 'Martha', {
|
||||
weight: 34
|
||||
});
|
||||
_assert["default"].strictEqual(graph.size, 2);
|
||||
},
|
||||
'it should be possible to merge a self loop.': function it_should_be_possible_to_merge_a_self_loop() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge('John', 'John', {
|
||||
type: 'IS'
|
||||
});
|
||||
_assert["default"].strictEqual(graph.order, 1);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
},
|
||||
'it should return useful information.': function it_should_return_useful_information() {
|
||||
var graph = new Graph();
|
||||
var info = graph.mergeEdge('John', 'Jack');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('John', 'Jack'), true, true, true]);
|
||||
info = graph.mergeEdge('John', 'Jack');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('John', 'Jack'), false, false, false]);
|
||||
graph.addNode('Mary');
|
||||
info = graph.mergeEdge('Mary', 'Sue');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Mary', 'Sue'), true, false, true]);
|
||||
info = graph.mergeEdge('Gwladys', 'Mary');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Gwladys', 'Mary'), true, true, false]);
|
||||
graph.addNode('Quintin');
|
||||
info = graph.mergeEdge('Quintin', 'Mary');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Quintin', 'Mary'), true, false, false]);
|
||||
}
|
||||
},
|
||||
'#.updateEdge': {
|
||||
'it should add the edge if it does not yet exist.': function it_should_add_the_edge_if_it_does_not_yet_exist() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.updateEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
},
|
||||
'it should do nothing if the edge already exists.': function it_should_do_nothing_if_the_edge_already_exists() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.addEdge('John', 'Martha');
|
||||
graph.updateEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
},
|
||||
'it should be possible to start from blank attributes.': function it_should_be_possible_to_start_from_blank_attributes() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.updateEdge('John', 'Martha', function (attr) {
|
||||
return _objectSpread(_objectSpread({}, attr), {}, {
|
||||
weight: 3
|
||||
});
|
||||
});
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
_assert["default"].deepStrictEqual(graph.getEdgeAttributes('John', 'Martha'), {
|
||||
weight: 3
|
||||
});
|
||||
},
|
||||
'it should update existing attributes if any.': function it_should_update_existing_attributes_if_any() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
graph.addEdge('John', 'Martha', {
|
||||
type: 'KNOWS'
|
||||
});
|
||||
graph.updateEdge('John', 'Martha', function (attr) {
|
||||
return _objectSpread(_objectSpread({}, attr), {}, {
|
||||
weight: 2
|
||||
});
|
||||
});
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Martha'), true);
|
||||
_assert["default"].deepStrictEqual(graph.getEdgeAttributes('John', 'Martha'), {
|
||||
type: 'KNOWS',
|
||||
weight: 2
|
||||
});
|
||||
},
|
||||
'it should add missing nodes in the path.': function it_should_add_missing_nodes_in_the_path() {
|
||||
var graph = new Graph();
|
||||
graph.updateEdge('John', 'Martha');
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].deepStrictEqual(graph.nodes(), ['John', 'Martha']);
|
||||
},
|
||||
'it should throw in case of inconsistencies.': function it_should_throw_in_case_of_inconsistencies() {
|
||||
var graph = new Graph();
|
||||
graph.updateEdgeWithKey('J->M', 'John', 'Martha');
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.updateEdgeWithKey('J->M', 'John', 'Thomas');
|
||||
}, usage());
|
||||
},
|
||||
'it should distinguish between typed edges.': function it_should_distinguish_between_typed_edges() {
|
||||
var graph = new Graph();
|
||||
graph.updateEdge('John', 'Martha', function () {
|
||||
return {
|
||||
type: 'LIKES'
|
||||
};
|
||||
});
|
||||
graph.updateUndirectedEdge('John', 'Martha', function () {
|
||||
return {
|
||||
weight: 34
|
||||
};
|
||||
});
|
||||
_assert["default"].strictEqual(graph.size, 2);
|
||||
},
|
||||
'it should be possible to merge a self loop.': function it_should_be_possible_to_merge_a_self_loop() {
|
||||
var graph = new Graph();
|
||||
graph.updateEdge('John', 'John', function () {
|
||||
return {
|
||||
type: 'IS'
|
||||
};
|
||||
});
|
||||
_assert["default"].strictEqual(graph.order, 1);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
},
|
||||
'it should return useful information.': function it_should_return_useful_information() {
|
||||
var graph = new Graph();
|
||||
var info = graph.updateEdge('John', 'Jack');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('John', 'Jack'), true, true, true]);
|
||||
info = graph.updateEdge('John', 'Jack');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('John', 'Jack'), false, false, false]);
|
||||
graph.addNode('Mary');
|
||||
info = graph.updateEdge('Mary', 'Sue');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Mary', 'Sue'), true, false, true]);
|
||||
info = graph.updateEdge('Gwladys', 'Mary');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Gwladys', 'Mary'), true, true, false]);
|
||||
graph.addNode('Quintin');
|
||||
info = graph.updateEdge('Quintin', 'Mary');
|
||||
_assert["default"].deepStrictEqual(info, [graph.edge('Quintin', 'Mary'), true, false, false]);
|
||||
}
|
||||
},
|
||||
'#.dropEdge': {
|
||||
'it should throw if the edge or nodes in the path are not found in the graph.': function it_should_throw_if_the_edge_or_nodes_in_the_path_are_not_found_in_the_graph() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Martha']);
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.dropEdge('Test');
|
||||
}, notFound());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.dropEdge('Forever', 'Alone');
|
||||
}, notFound());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.dropEdge('John', 'Test');
|
||||
}, notFound());
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.dropEdge('John', 'Martha');
|
||||
}, notFound());
|
||||
},
|
||||
'it should correctly remove the given edge from the graph.': function it_should_correctly_remove_the_given_edge_from_the_graph() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Margaret']);
|
||||
var edge = graph.addEdge('John', 'Margaret');
|
||||
graph.dropEdge(edge);
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 0);
|
||||
_assert["default"].strictEqual(graph.degree('John'), 0);
|
||||
_assert["default"].strictEqual(graph.degree('Margaret'), 0);
|
||||
_assert["default"].strictEqual(graph.hasEdge(edge), false);
|
||||
_assert["default"].strictEqual(graph.hasDirectedEdge('John', 'Margaret'), false);
|
||||
},
|
||||
'it should be possible to remove an edge using source & target.': function it_should_be_possible_to_remove_an_edge_using_source__target() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Margaret']);
|
||||
graph.addEdge('John', 'Margaret');
|
||||
graph.dropEdge('John', 'Margaret');
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 0);
|
||||
_assert["default"].strictEqual(graph.degree('John'), 0);
|
||||
_assert["default"].strictEqual(graph.degree('Margaret'), 0);
|
||||
_assert["default"].strictEqual(graph.hasEdge('John', 'Margaret'), false);
|
||||
_assert["default"].strictEqual(graph.hasDirectedEdge('John', 'Margaret'), false);
|
||||
},
|
||||
'it should work with self loops.': function it_should_work_with_self_loops() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge('John', 'John');
|
||||
graph.dropEdge('John', 'John');
|
||||
_assert["default"].deepStrictEqual(graph.edges(), []);
|
||||
_assert["default"].deepStrictEqual(graph.edges('John'), []);
|
||||
_assert["default"].strictEqual(graph.size, 0);
|
||||
var multiGraph = new Graph({
|
||||
multi: true
|
||||
});
|
||||
multiGraph.mergeEdgeWithKey('j', 'John', 'John');
|
||||
multiGraph.mergeEdgeWithKey('k', 'John', 'John');
|
||||
multiGraph.dropEdge('j');
|
||||
_assert["default"].deepStrictEqual(multiGraph.edges(), ['k']);
|
||||
_assert["default"].deepStrictEqual(multiGraph.edges('John'), ['k']);
|
||||
_assert["default"].strictEqual(multiGraph.size, 1);
|
||||
}
|
||||
},
|
||||
'#.dropNode': {
|
||||
'it should throw if the edge is not found in the graph.': function it_should_throw_if_the_edge_is_not_found_in_the_graph() {
|
||||
var graph = new Graph();
|
||||
_assert["default"]["throws"](function () {
|
||||
graph.dropNode('Test');
|
||||
}, notFound());
|
||||
},
|
||||
'it should correctly remove the given node from the graph.': function it_should_correctly_remove_the_given_node_from_the_graph() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['John', 'Margaret']);
|
||||
var edge = graph.addEdge('John', 'Margaret');
|
||||
graph.mergeEdge('Jack', 'Trudy');
|
||||
graph.dropNode('Margaret');
|
||||
_assert["default"].strictEqual(graph.order, 3);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasNode('Margaret'), false);
|
||||
_assert["default"].strictEqual(graph.hasEdge(edge), false);
|
||||
_assert["default"].strictEqual(graph.degree('John'), 0);
|
||||
_assert["default"].strictEqual(graph.hasDirectedEdge('John', 'Margaret'), false);
|
||||
},
|
||||
'it should also work with mixed, multi graphs and self loops.': function it_should_also_work_with_mixed_multi_graphs_and_self_loops() {
|
||||
var graph = new Graph({
|
||||
multi: true
|
||||
});
|
||||
graph.mergeEdge('A', 'B');
|
||||
graph.mergeEdge('A', 'B');
|
||||
graph.mergeEdge('B', 'A');
|
||||
graph.mergeEdge('A', 'B');
|
||||
graph.mergeEdge('A', 'A');
|
||||
graph.mergeUndirectedEdge('A', 'B');
|
||||
graph.mergeUndirectedEdge('A', 'B');
|
||||
graph.mergeUndirectedEdge('A', 'A');
|
||||
var copy = graph.copy();
|
||||
graph.dropNode('B');
|
||||
_assert["default"].strictEqual(graph.size, 2);
|
||||
_assert["default"].strictEqual(graph.directedSelfLoopCount, 1);
|
||||
_assert["default"].strictEqual(graph.undirectedSelfLoopCount, 1);
|
||||
copy.dropNode('A');
|
||||
_assert["default"].strictEqual(copy.size, 0);
|
||||
_assert["default"].strictEqual(copy.directedSelfLoopCount, 0);
|
||||
_assert["default"].strictEqual(copy.undirectedSelfLoopCount, 0);
|
||||
},
|
||||
'it should also coerce keys as strings.': function it_should_also_coerce_keys_as_strings() {
|
||||
function Key(name) {
|
||||
this.name = name;
|
||||
}
|
||||
Key.prototype.toString = function () {
|
||||
return this.name;
|
||||
};
|
||||
var graph = new Graph();
|
||||
var key = new Key('test');
|
||||
graph.addNode(key);
|
||||
graph.dropNode(key);
|
||||
_assert["default"].strictEqual(graph.order, 0);
|
||||
_assert["default"].strictEqual(graph.hasNode(key), false);
|
||||
}
|
||||
},
|
||||
'#.dropDirectedEdge': {
|
||||
'it should throw if given incorrect arguments.': function it_should_throw_if_given_incorrect_arguments() {
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph({
|
||||
multi: true
|
||||
});
|
||||
graph.mergeEdge('a', 'b');
|
||||
graph.dropDirectedEdge('a', 'b');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph({
|
||||
multi: true
|
||||
});
|
||||
graph.mergeEdgeWithKey('1', 'a', 'b');
|
||||
graph.dropDirectedEdge('1');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph();
|
||||
graph.dropDirectedEdge('a', 'b');
|
||||
}, notFound());
|
||||
},
|
||||
'it should correctly drop the relevant edge.': function it_should_correctly_drop_the_relevant_edge() {
|
||||
var graph = new Graph();
|
||||
graph.mergeUndirectedEdge('a', 'b');
|
||||
graph.mergeDirectedEdge('a', 'b');
|
||||
graph.dropDirectedEdge('a', 'b');
|
||||
_assert["default"].strictEqual(graph.directedSize, 0);
|
||||
_assert["default"].strictEqual(graph.hasDirectedEdge('a', 'b'), false);
|
||||
_assert["default"].strictEqual(graph.hasUndirectedEdge('a', 'b'), true);
|
||||
}
|
||||
},
|
||||
'#.dropUndirectedEdge': {
|
||||
'it should throw if given incorrect arguments.': function it_should_throw_if_given_incorrect_arguments() {
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph({
|
||||
multi: true,
|
||||
type: 'undirected'
|
||||
});
|
||||
graph.mergeEdge('a', 'b');
|
||||
graph.dropUndirectedEdge('a', 'b');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph({
|
||||
multi: true,
|
||||
type: 'undirected'
|
||||
});
|
||||
graph.mergeEdgeWithKey('1', 'a', 'b');
|
||||
graph.dropUndirectedEdge('1');
|
||||
}, usage());
|
||||
_assert["default"]["throws"](function () {
|
||||
var graph = new Graph({
|
||||
type: 'undirected'
|
||||
});
|
||||
graph.dropUndirectedEdge('a', 'b');
|
||||
}, notFound());
|
||||
},
|
||||
'it should correctly drop the relevant edge.': function it_should_correctly_drop_the_relevant_edge() {
|
||||
var graph = new Graph();
|
||||
graph.mergeUndirectedEdge('a', 'b');
|
||||
graph.mergeDirectedEdge('a', 'b');
|
||||
graph.dropUndirectedEdge('a', 'b');
|
||||
_assert["default"].strictEqual(graph.undirectedSize, 0);
|
||||
_assert["default"].strictEqual(graph.hasUndirectedEdge('a', 'b'), false);
|
||||
_assert["default"].strictEqual(graph.hasDirectedEdge('a', 'b'), true);
|
||||
}
|
||||
},
|
||||
'#.clear': {
|
||||
'it should empty the graph.': function it_should_empty_the_graph() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['Lindsay', 'Martha']);
|
||||
var edge = graph.addEdge('Lindsay', 'Martha');
|
||||
graph.clear();
|
||||
_assert["default"].strictEqual(graph.order, 0);
|
||||
_assert["default"].strictEqual(graph.size, 0);
|
||||
_assert["default"].strictEqual(graph.hasNode('Lindsay'), false);
|
||||
_assert["default"].strictEqual(graph.hasNode('Martha'), false);
|
||||
_assert["default"].strictEqual(graph.hasEdge(edge), false);
|
||||
},
|
||||
'it should be possible to use the graph normally afterwards.': function it_should_be_possible_to_use_the_graph_normally_afterwards() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['Lindsay', 'Martha']);
|
||||
graph.addEdge('Lindsay', 'Martha');
|
||||
graph.clear();
|
||||
(0, _helpers.addNodesFrom)(graph, ['Lindsay', 'Martha']);
|
||||
var edge = graph.addEdge('Lindsay', 'Martha');
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 1);
|
||||
_assert["default"].strictEqual(graph.hasNode('Lindsay'), true);
|
||||
_assert["default"].strictEqual(graph.hasNode('Martha'), true);
|
||||
_assert["default"].strictEqual(graph.hasEdge(edge), true);
|
||||
}
|
||||
},
|
||||
'#.clearEdges': {
|
||||
'it should drop every edge from the graph.': function it_should_drop_every_edge_from_the_graph() {
|
||||
var graph = new Graph();
|
||||
(0, _helpers.addNodesFrom)(graph, ['Lindsay', 'Martha']);
|
||||
var edge = graph.addEdge('Lindsay', 'Martha');
|
||||
graph.clearEdges();
|
||||
_assert["default"].strictEqual(graph.order, 2);
|
||||
_assert["default"].strictEqual(graph.size, 0);
|
||||
_assert["default"].strictEqual(graph.hasNode('Lindsay'), true);
|
||||
_assert["default"].strictEqual(graph.hasNode('Martha'), true);
|
||||
_assert["default"].strictEqual(graph.hasEdge(edge), false);
|
||||
},
|
||||
'it should properly reset instance counters.': function it_should_properly_reset_instance_counters() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge(0, 1);
|
||||
_assert["default"].strictEqual(graph.directedSize, 1);
|
||||
graph.clearEdges();
|
||||
_assert["default"].strictEqual(graph.directedSize, 0);
|
||||
graph.mergeEdge(0, 1);
|
||||
graph.clear();
|
||||
_assert["default"].strictEqual(graph.directedSize, 0);
|
||||
},
|
||||
'it should properly clear node indices, regarding self loops notably.': function it_should_properly_clear_node_indices_regarding_self_loops_notably() {
|
||||
var graph = new Graph();
|
||||
graph.mergeEdge(1, 1);
|
||||
_assert["default"].strictEqual(graph.degree(1), 2);
|
||||
graph.clearEdges();
|
||||
_assert["default"].strictEqual(graph.degree(1), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user