@atomist/clj-editors/target/cljsbuild-compiler-1/atomist/encrypt.js

editor functions that use rewrite-clj and other important things from the clojurescript ecosystem

// Compiled by ClojureScript 1.10.238 {:target :nodejs}
goog.provide('atomist.encrypt');
goog.require('cljs.core');
goog.require('cljs_node_io.core');
goog.require('cljs_node_io.fs');
goog.require('cljs.reader');
goog.require('goog.json');
goog.require('cljs.core');
goog.require('clojure.string');
goog.require('cljs.pprint');
goog.require('goog.crypt.base64');
goog.require('goog.string');
goog.require('goog.string.format');
goog.require('goog.crypt');
goog.require('goog.crypt.Aes');
/**
 * generate a new key and write to key.txt
 */
atomist.encrypt.generate_key = (function atomist$encrypt$generate_key(){
var t = cljs.core.take.call(null,(16),cljs.core.repeatedly.call(null,(function (){
return cljs.core.rand_int.call(null,(20));
})));
return cljs_node_io.core.spit.call(null,"key.txt",cljs.core.print_str.call(null,t));
});
atomist.encrypt.read_key = (function atomist$encrypt$read_key(var_args){
var G__21726 = arguments.length;
switch (G__21726) {
case 1:
return atomist.encrypt.read_key.cljs$core$IFn$_invoke$arity$1((arguments[(0)]));

break;
case 0:
return atomist.encrypt.read_key.cljs$core$IFn$_invoke$arity$0();

break;
default:
throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));

}
});

atomist.encrypt.read_key.cljs$core$IFn$_invoke$arity$1 = (function (s){
return (new goog.crypt.Aes(cljs.core.clj__GT_js.call(null,cljs.core.into.call(null,cljs.core.PersistentVector.EMPTY,cljs.reader.read_string.call(null,s)))));
});

atomist.encrypt.read_key.cljs$core$IFn$_invoke$arity$0 = (function (){
return atomist.encrypt.read_key.call(null,cljs_node_io.core.slurp.call(null,"key.txt"));
});

atomist.encrypt.read_key.cljs$lang$maxFixedArity = 1;

atomist.encrypt.block_size = (function atomist$encrypt$block_size(k){
return k.BLOCK_SIZE;
});
atomist.encrypt.s__GT_blocks = (function atomist$encrypt$s__GT_blocks(n,s){
return cljs.core.partition.call(null,(16),(16),cljs.core.take.call(null,(16),cljs.core.repeat.call(null," ".charCodeAt((0)))),cljs.core.map.call(null,(function (p1__21728_SHARP_){
return p1__21728_SHARP_.charCodeAt((0));
}),cljs.core.seq.call(null,s)));
});
atomist.encrypt.encrypt = (function atomist$encrypt$encrypt(k,s){
return cljs.core.flatten.call(null,cljs.core.map.call(null,(function (p1__21729_SHARP_){
return cljs.core.js__GT_clj.call(null,k.encrypt(cljs.core.clj__GT_js.call(null,p1__21729_SHARP_)));
}),atomist.encrypt.s__GT_blocks.call(null,atomist.encrypt.block_size.call(null,k),s)));
});
atomist.encrypt.decrypt = (function atomist$encrypt$decrypt(k,cypher){
return goog.string.trim(cljs.core.apply.call(null,cljs.core.str,cljs.core.map.call(null,(function (p1__21731_SHARP_){
return cljs.core.char$.call(null,p1__21731_SHARP_);
}),cljs.core.flatten.call(null,cljs.core.map.call(null,(function (p1__21730_SHARP_){
return cljs.core.js__GT_clj.call(null,k.decrypt(cljs.core.clj__GT_js.call(null,p1__21730_SHARP_)));
}),cljs.core.partition.call(null,(16),cypher))))));
});
atomist.encrypt.encrypt_vault = (function atomist$encrypt$encrypt_vault(m){
return cljs_node_io.core.spit.call(null,"vault.txt",cljs.core.pr_str.call(null,atomist.encrypt.encrypt.call(null,atomist.encrypt.read_key.call(null),cljs.core.pr_str.call(null,m))));
});
atomist.encrypt.decrypt_vault = (function atomist$encrypt$decrypt_vault(){
return cljs.reader.read_string.call(null,atomist.encrypt.decrypt.call(null,atomist.encrypt.read_key.call(null),cljs.reader.read_string.call(null,cljs_node_io.core.slurp.call(null,"vault.txt"))));
});
atomist.encrypt.__GT_env = (function atomist$encrypt$__GT_env(k){
return clojure.string.upper_case.call(null,clojure.string.replace_all.call(null,cljs.core.name.call(null,k),/-/,"_"));
});
atomist.encrypt.__GT_env_form = (function atomist$encrypt$__GT_env_form(m){
return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__21732){
var vec__21733 = p__21732;
var k = cljs.core.nth.call(null,vec__21733,(0),null);
var v = cljs.core.nth.call(null,vec__21733,(1),null);
return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [atomist.encrypt.__GT_env.call(null,k),v], null);
}),m));
});
atomist.encrypt.encrypted__GT_clj = (function atomist$encrypt$encrypted__GT_clj(key,s){
return cljs.reader.read_string.call(null,atomist.encrypt.decrypt.call(null,atomist.encrypt.read_key.call(null,key),cljs.reader.read_string.call(null,s)));
});
/**
 *   params
 *     key - string key
 *     vault - vault file
 */
atomist.encrypt.vault_contents = (function atomist$encrypt$vault_contents(key,vault){
if(cljs_node_io.fs.fexists_QMARK_.call(null,vault)){
} else {
throw (new Error("Assert failed: (fs/fexists? vault)"));
}

return atomist.encrypt.__GT_env_form.call(null,atomist.encrypt.encrypted__GT_clj.call(null,key,cljs_node_io.core.slurp.call(null,vault)));
});
/**
 * 
 *  returns unencrypted cljs map
 *  params
 *    f1 - key file
 *    f2 - vault file
 */
atomist.encrypt.read_vault = (function atomist$encrypt$read_vault(f1,f2){
if(((cljs_node_io.fs.fexists_QMARK_.call(null,f2)) && (cljs_node_io.fs.fexists_QMARK_.call(null,f1)))){
} else {
throw (new Error("Assert failed: (and (fs/fexists? f2) (fs/fexists? f1))"));
}

return atomist.encrypt.vault_contents.call(null,cljs_node_io.core.slurp.call(null,f1),f2);
});
atomist.encrypt.or_empty_map = (function atomist$encrypt$or_empty_map(f,k,cipher){
try{return f.call(null,k,cipher);
}catch (e21736){var t = e21736;
return cljs.core.PersistentArrayMap.EMPTY;
}});
atomist.encrypt.or_empty_string = (function atomist$encrypt$or_empty_string(f,f1){
try{return f.call(null,f1);
}catch (e21737){var t = e21737;
return "";
}});
/**
 * run an edit function f on encrypted vault
 *  returns nil if successful
 *  params
 *    f1 - key file
 *    f2 - original vault file
 *    f3 - new vault file
 *    f - one-arg function to edit current vault
 */
atomist.encrypt.edit_vault = (function atomist$encrypt$edit_vault(f1,f2,f){
if(cljs_node_io.fs.fexists_QMARK_.call(null,f1)){
} else {
throw (new Error("Assert failed: (fs/fexists? f1)"));
}

var k = cljs_node_io.core.slurp.call(null,f1);
return cljs.core.pr_str.call(null,atomist.encrypt.encrypt.call(null,atomist.encrypt.read_key.call(null,k),cljs.core.pr_str.call(null,f.call(null,atomist.encrypt.or_empty_map.call(null,atomist.encrypt.encrypted__GT_clj,k,atomist.encrypt.or_empty_string.call(null,cljs_node_io.core.slurp,f2))))));
});
/**
 * 
 *  returns nil if successful
 *  params
 *    f1 - key file
 *    f2 - original vault file
 *    f3 - new vault file
 *    m - map to merge into vault
 */
atomist.encrypt.merge_vault = (function atomist$encrypt$merge_vault(f1,f2,m){
if(cljs.core.map_QMARK_.call(null,m)){
} else {
throw (new Error("Assert failed: (map? m)"));
}

return atomist.encrypt.edit_vault.call(null,f1,f2,(function (v){
return cljs.core.merge.call(null,v,m);
}));
});

//# sourceMappingURL=encrypt.js.map