litre.combine = function (first, second) {
if (teishi.stop ([{
compare: arguments,
to: ['array', 'object'],
test: teishi.test.type,
multi: 'each_of',
label: 'Argument passed to litre.combine'
}, {
compare: teishi.type (second),
to: teishi.type (first),
label: 'Type of arguments is inconsistent.'
}])) return false;
if (dale.stop_on (second, false, function (v, k) {
if (teishi.type (v) !== 'array' && teishi.type (v) !== 'object') {
// We don't override null or undefined values.
if (v === null || v === undefined) return true;
first [k] = v;
}
else {
if (teishi.type (first [k]) !== 'array' && teishi.type (first [k]) !== 'object') {
// If first [k] is a simple value, we override it.
first [k] = v;
}
else {
// If it's a complex value, we combine it recursively!
var recursive_result = litre.combine (first [k], v);
if (recursive_result === false) return false;
first [k] = recursive_result;
}
}
}) === false) return false;
else return first;
}
litre.unroot = function (tree) {
if (litre.v.tree (tree) === false) return false;
if (tree.length === 0) return [];
if (tree.length === 1) return tree;
if (litre.v.branch (tree [0]) === false) return false;
// In this function we are going to use destructive operations on the tree argument, so we need to copy it. Did you know that when you pass an array or an object to a javascript function, you pass a reference to that array or object (and not a copy)? I didn't!
var tree = teishi.p (teishi.s (tree));
var root = tree [0] [0];
dale.stop_on (tree, 0, function (v) {
dale.stop_on (v [0], false, function (v2, k2) {
if (root [k2] !== v2) {
root = root.slice (0, k2);
return false;
}
});
return root.length;
});
return dale.do (tree, function (v) {
v [0] = v [0].slice (0 + root.length, v [0].length);
return v;
});
}
if (dale.stop_on (tree, false, function (v) {
if (v [0].length < path.length) return;
if (litre.v.branch (v) === false) return false;
if (dale.stop_on (path, false, function (v2, k2) {
if (path [k2] !== v [0] [k2]) return false;
else return true;
}) === true) output.push (v);
}) === false) return false;
dale.stop_on (tree, 0, function (v) {
dale.stop_on (v [0], false, function (v2, k2) {
if (root [k2] !== v2) {
root = root.slice (0, k2);
return false;
}
});
return root.length;
});
litre.consistent_tree = function (tree) {
var consistent_branches = [];
return dale.stop_on (tree, false, function (v) {
if (litre.branch_consistent_in_tree (v, consistent_branches)) {
consistent_branches.push (v);
return true;
}
else return false;
});
}
litre.prepend = function (tree, path) {
if (litre.v.tree (tree) === false) return false;
if (dale.stop_on (tree, false, function (v) {
return litre.v.branch (v);
}) === false) return false;
if (litre.v.path (path) === false) return false;
var output = [];
dale.do (tree, function (v) {
v [0] = path.concat (v [0]);
output.push (v);
});
return output;
}
[function (aStack) {
var output_tree = [];
if (dale.stop_on (aStack.last, false, function (v, k) {
// We return false if any of the values is false.
if (v === false) {
a.aReturn (aStack, false);
return false;
}
if (v !== null) output_tree.push ([aStack.paths [k], v]);
return true;
})) {
delete aStack.paths;
a.aReturn (aStack, output_tree);
}
}]
litre.pick = function (tree, path) {
if (litre.v.tree (tree) === false) return false;
if (litre.v.path (path) === false) return false;
var output = [];
if (dale.stop_on (tree, false, function (v) {
if (v [0].length < path.length) return;
if (litre.v.branch (v) === false) return false;
if (dale.stop_on (path, false, function (v2, k2) {
if (path [k2] !== v [0] [k2]) return false;
else return true;
}) === true) output.push (v);
}) === false) return false;
return output;
}
[function (aStack) {
var output_tree = [];
if (dale.stop_on (aStack.last, false, function (v, k) {
// We return false if any of the values is false.
if (v === false) {
a.aReturn (aStack, false);
return false;
}
dale.do (v, function (v2) {
output_tree.push (v2);
});
return true;
})) {
a.aReturn (aStack, output_tree);
}
}]
litre.v.path = function (path) {
if (teishi.stop ([{
compare: path,
to: 'array',
test: teishi.test.type,
label: 'litre path',
}, {
// This is hackish, but I don't want to write teishi.test.greater
compare: path.length < 1,
to: false,
label: 'Path length cannot be empty!'
}, {
compare: path,
to: 'string',
multi: 'each',
test: teishi.test.type,
label: 'litre path step'
}])) return false;
return dale.stop_on (path, false, function (v) {
if (v.length === 0) return false;
else return true;
});
}
litre.branch_consistent_in_tree = function (tree, branch) {
if (litre.v.branch (branch) === false) return false;
if (litre.v.branch (tree) === false) return false;
if (tree.length === 0) return true;
return dale.stop_on (tree, false, function (v) {
var left;
var right;
if (v [0].length > branch [0].length) {
left = v [0].slice (0, branch [0].length);
right = branch [0].length;
}
else {
left = v [0];
right = branch [0].slice (0, v [0].length);
}
if (teishi.s (left) === teishi.s (right)) {
log ('Inconsistent branch!', branch [0], 'clashes with', v [0]);
return false;
}
else return true;
});
}
[function (aStack) {
a.aReturn (aStack, dale.stop_on (aStack.last, false, function (v, k) {
if (v === false) return false;
else return true;
}));
}]
litre.toJSON = function (tree, absolute) {
if (litre.v.tree (tree) === false) return false;
if (tree.length === 0) return {};
var output;
if (dale.stop_on (absolute ? tree : litre.unroot (tree), false, function (v, k) {
var branch_output;
// Since a branch can't be inconsistent with itself, we use dale.do instead of dale.stop_on.
dale.do (v [0], function (v2, k2) {
// We reverse the loop.
k2 = (v [0].length - 1 - k2);
v2 = v [0] [k2];
// If the step is a number, we convert it into a number and zeroindex it.
if (litre.isInteger (v2)) v2 = parseInt (v2) - 1;
if (k2 === v [0].length - 1) {
// We are at the last step of the path.
if (litre.isInteger (v2) === false) {
branch_output = {};
}
else {
branch_output = [];
}
branch_output [v2] = v [1];
}
else {
var temp = litre.isInteger (v2) ? [] : {};
temp [v2] = branch_output;
branch_output = temp;
}
});
if (k === 0) output = branch_output;
else {
if (litre.combine (output, branch_output) === false) return false;
else output = litre.combine (output, branch_output);
}
}) === false) return false;
else return output;
}