293 lines
12 KiB
JavaScript
293 lines
12 KiB
JavaScript
goog.provide('clojure.data');
|
|
/**
|
|
* Internal helper for diff.
|
|
*/
|
|
clojure.data.atom_diff = (function clojure$data$atom_diff(a,b){
|
|
if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){
|
|
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
|
|
} else {
|
|
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [a,b,null], null);
|
|
}
|
|
});
|
|
/**
|
|
* Convert an associative-by-numeric-index collection into
|
|
* an equivalent vector, with nil for any missing keys
|
|
*/
|
|
clojure.data.vectorize = (function clojure$data$vectorize(m){
|
|
if(cljs.core.seq(m)){
|
|
return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (result,p__14553){
|
|
var vec__14555 = p__14553;
|
|
var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14555,(0),null);
|
|
var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14555,(1),null);
|
|
return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(result,k,v);
|
|
}),cljs.core.vec(cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.max,cljs.core.keys(m)),null)),m);
|
|
} else {
|
|
return null;
|
|
}
|
|
});
|
|
/**
|
|
* Diff associative things a and b, comparing only the key k.
|
|
*/
|
|
clojure.data.diff_associative_key = (function clojure$data$diff_associative_key(a,b,k){
|
|
var va = cljs.core.get.cljs$core$IFn$_invoke$arity$2(a,k);
|
|
var vb = cljs.core.get.cljs$core$IFn$_invoke$arity$2(b,k);
|
|
var vec__14559 = clojure.data.diff(va,vb);
|
|
var a_STAR_ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14559,(0),null);
|
|
var b_STAR_ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14559,(1),null);
|
|
var ab = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__14559,(2),null);
|
|
var in_a = cljs.core.contains_QMARK_(a,k);
|
|
var in_b = cljs.core.contains_QMARK_(b,k);
|
|
var same = ((in_a) && (((in_b) && ((((!((ab == null)))) || ((((va == null)) && ((vb == null)))))))));
|
|
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [((((in_a) && ((((!((a_STAR_ == null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,a_STAR_]):null),((((in_b) && ((((!((b_STAR_ == null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,b_STAR_]):null),((same)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ab]):null)], null);
|
|
});
|
|
/**
|
|
* Diff associative things a and b, comparing only keys in ks (if supplied).
|
|
*/
|
|
clojure.data.diff_associative = (function clojure$data$diff_associative(var_args){
|
|
var G__14581 = arguments.length;
|
|
switch (G__14581) {
|
|
case 2:
|
|
return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
|
|
|
|
break;
|
|
case 3:
|
|
return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
|
|
|
|
break;
|
|
default:
|
|
throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
|
|
|
|
}
|
|
});
|
|
|
|
(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
|
|
return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(a,b,clojure.set.union.cljs$core$IFn$_invoke$arity$2(cljs.core.keys(a),cljs.core.keys(b)));
|
|
}));
|
|
|
|
(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3 = (function (a,b,ks){
|
|
return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (diff1,diff2){
|
|
return cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$3(cljs.core.merge,diff1,diff2));
|
|
}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,null], null),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$3(clojure.data.diff_associative_key,a,b),ks));
|
|
}));
|
|
|
|
(clojure.data.diff_associative.cljs$lang$maxFixedArity = 3);
|
|
|
|
clojure.data.diff_sequential = (function clojure$data$diff_sequential(a,b){
|
|
return cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.data.vectorize,clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(((cljs.core.vector_QMARK_(a))?a:cljs.core.vec(a)),((cljs.core.vector_QMARK_(b))?b:cljs.core.vec(b)),cljs.core.range.cljs$core$IFn$_invoke$arity$1((function (){var x__5130__auto__ = cljs.core.count(a);
|
|
var y__5131__auto__ = cljs.core.count(b);
|
|
return ((x__5130__auto__ > y__5131__auto__) ? x__5130__auto__ : y__5131__auto__);
|
|
})()))));
|
|
});
|
|
clojure.data.diff_set = (function clojure$data$diff_set(a,b){
|
|
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(a,b)),cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(b,a)),cljs.core.not_empty(clojure.set.intersection.cljs$core$IFn$_invoke$arity$2(a,b))], null);
|
|
});
|
|
|
|
/**
|
|
* Implementation detail. Subject to change.
|
|
* @interface
|
|
*/
|
|
clojure.data.EqualityPartition = function(){};
|
|
|
|
var clojure$data$EqualityPartition$equality_partition$dyn_14650 = (function (x){
|
|
var x__5393__auto__ = (((x == null))?null:x);
|
|
var m__5394__auto__ = (clojure.data.equality_partition[goog.typeOf(x__5393__auto__)]);
|
|
if((!((m__5394__auto__ == null)))){
|
|
return (m__5394__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5394__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5394__auto__.call(null,x));
|
|
} else {
|
|
var m__5392__auto__ = (clojure.data.equality_partition["_"]);
|
|
if((!((m__5392__auto__ == null)))){
|
|
return (m__5392__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5392__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5392__auto__.call(null,x));
|
|
} else {
|
|
throw cljs.core.missing_protocol("EqualityPartition.equality-partition",x);
|
|
}
|
|
}
|
|
});
|
|
/**
|
|
* Implementation detail. Subject to change.
|
|
*/
|
|
clojure.data.equality_partition = (function clojure$data$equality_partition(x){
|
|
if((((!((x == null)))) && ((!((x.clojure$data$EqualityPartition$equality_partition$arity$1 == null)))))){
|
|
return x.clojure$data$EqualityPartition$equality_partition$arity$1(x);
|
|
} else {
|
|
return clojure$data$EqualityPartition$equality_partition$dyn_14650(x);
|
|
}
|
|
});
|
|
|
|
|
|
/**
|
|
* Implementation detail. Subject to change.
|
|
* @interface
|
|
*/
|
|
clojure.data.Diff = function(){};
|
|
|
|
var clojure$data$Diff$diff_similar$dyn_14652 = (function (a,b){
|
|
var x__5393__auto__ = (((a == null))?null:a);
|
|
var m__5394__auto__ = (clojure.data.diff_similar[goog.typeOf(x__5393__auto__)]);
|
|
if((!((m__5394__auto__ == null)))){
|
|
return (m__5394__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5394__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5394__auto__.call(null,a,b));
|
|
} else {
|
|
var m__5392__auto__ = (clojure.data.diff_similar["_"]);
|
|
if((!((m__5392__auto__ == null)))){
|
|
return (m__5392__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5392__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5392__auto__.call(null,a,b));
|
|
} else {
|
|
throw cljs.core.missing_protocol("Diff.diff-similar",a);
|
|
}
|
|
}
|
|
});
|
|
/**
|
|
* Implementation detail. Subject to change.
|
|
*/
|
|
clojure.data.diff_similar = (function clojure$data$diff_similar(a,b){
|
|
if((((!((a == null)))) && ((!((a.clojure$data$Diff$diff_similar$arity$2 == null)))))){
|
|
return a.clojure$data$Diff$diff_similar$arity$2(a,b);
|
|
} else {
|
|
return clojure$data$Diff$diff_similar$dyn_14652(a,b);
|
|
}
|
|
});
|
|
|
|
(clojure.data.EqualityPartition["null"] = true);
|
|
|
|
(clojure.data.equality_partition["null"] = (function (x){
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["string"] = true);
|
|
|
|
(clojure.data.equality_partition["string"] = (function (x){
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["number"] = true);
|
|
|
|
(clojure.data.equality_partition["number"] = (function (x){
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["array"] = true);
|
|
|
|
(clojure.data.equality_partition["array"] = (function (x){
|
|
return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["function"] = true);
|
|
|
|
(clojure.data.equality_partition["function"] = (function (x){
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["boolean"] = true);
|
|
|
|
(clojure.data.equality_partition["boolean"] = (function (x){
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
}));
|
|
|
|
(clojure.data.EqualityPartition["_"] = true);
|
|
|
|
(clojure.data.equality_partition["_"] = (function (x){
|
|
if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (1024))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IMap$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x))){
|
|
return new cljs.core.Keyword(null,"map","map",1371690461);
|
|
} else {
|
|
if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISet$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x))){
|
|
return new cljs.core.Keyword(null,"set","set",304602554);
|
|
} else {
|
|
if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISequential$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x))){
|
|
return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
|
|
} else {
|
|
return new cljs.core.Keyword(null,"atom","atom",-397043653);
|
|
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
(clojure.data.Diff["null"] = true);
|
|
|
|
(clojure.data.diff_similar["null"] = (function (a,b){
|
|
return clojure.data.atom_diff(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["string"] = true);
|
|
|
|
(clojure.data.diff_similar["string"] = (function (a,b){
|
|
return clojure.data.atom_diff(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["number"] = true);
|
|
|
|
(clojure.data.diff_similar["number"] = (function (a,b){
|
|
return clojure.data.atom_diff(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["array"] = true);
|
|
|
|
(clojure.data.diff_similar["array"] = (function (a,b){
|
|
return clojure.data.diff_sequential(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["function"] = true);
|
|
|
|
(clojure.data.diff_similar["function"] = (function (a,b){
|
|
return clojure.data.atom_diff(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["boolean"] = true);
|
|
|
|
(clojure.data.diff_similar["boolean"] = (function (a,b){
|
|
return clojure.data.atom_diff(a,b);
|
|
}));
|
|
|
|
(clojure.data.Diff["_"] = true);
|
|
|
|
(clojure.data.diff_similar["_"] = (function (a,b){
|
|
var fexpr__14623 = (function (){var G__14624 = clojure.data.equality_partition(a);
|
|
var G__14624__$1 = (((G__14624 instanceof cljs.core.Keyword))?G__14624.fqn:null);
|
|
switch (G__14624__$1) {
|
|
case "atom":
|
|
return clojure.data.atom_diff;
|
|
|
|
break;
|
|
case "set":
|
|
return clojure.data.diff_set;
|
|
|
|
break;
|
|
case "sequential":
|
|
return clojure.data.diff_sequential;
|
|
|
|
break;
|
|
case "map":
|
|
return clojure.data.diff_associative;
|
|
|
|
break;
|
|
default:
|
|
throw (new Error(["No matching clause: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__14624__$1)].join('')));
|
|
|
|
}
|
|
})();
|
|
return (fexpr__14623.cljs$core$IFn$_invoke$arity$2 ? fexpr__14623.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__14623.call(null,a,b));
|
|
}));
|
|
/**
|
|
* Recursively compares a and b, returning a tuple of
|
|
* [things-only-in-a things-only-in-b things-in-both].
|
|
* Comparison rules:
|
|
*
|
|
* * For equal a and b, return [nil nil a].
|
|
* * Maps are subdiffed where keys match and values differ.
|
|
* * Sets are never subdiffed.
|
|
* * All sequential things are treated as associative collections
|
|
* by their indexes, with results returned as vectors.
|
|
* * Everything else (including strings!) is treated as
|
|
* an atom and compared for equality.
|
|
*/
|
|
clojure.data.diff = (function clojure$data$diff(a,b){
|
|
if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){
|
|
return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
|
|
} else {
|
|
if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(clojure.data.equality_partition(a),clojure.data.equality_partition(b))){
|
|
return clojure.data.diff_similar(a,b);
|
|
} else {
|
|
return clojure.data.atom_diff(a,b);
|
|
}
|
|
}
|
|
});
|
|
|
|
//# sourceMappingURL=clojure.data.js.map
|