bsless

(defn wrap-async
  ([af on-success on-failure]
   (wrap-async af identity on-success on-failure))
  ([af before on-success on-failure]
   (fn -wrap [-next]
     (fn -async [ctx respond raise]
       (let [ctx (before ctx)]
         (letfn [(-on-success [result] (-next (on-success ctx result)) respond raise)
                 (-on-failure [?error] (raise (on-failure ctx ?error)))]
           (af ctx -on-success -on-failure)))))))

bsless

#!/usr/bin/env bash

# Use this to unpack and import an archive

ARCHIVE="$1"
USERNAME="$2"
PASS="$3"

HERE="$PWD"
NOW=$(date +'%s.%N')

bsless

(defn iterduction
  [xf coll]
  (.iterator ^Iterable (->Eduction xf coll)))

bsless

(ns ytdl
  (:require
   [babashka.fs :as fs]
   [babashka.process :refer [process]]
   [cheshire.core :as json]
   [clojure.core.async :as async]
   [clojure.edn :as edn]
   [clojure.java.io :as io]
   [clojure.tools.cli :refer [parse-opts]]
   [clojure.string :as str]))

bsless

;;; As originally seen and improved on https://gist.github.com/holyjak/578571a134ce90526e6907436e91014a

(import '[clojure.lang Box])

(defmacro as
  [tag sym]
  (let [tag (if (class? tag) (.getName ^Class tag) (str tag))]
    `(with-meta ~sym {:tag ~tag})))

(definline box!

bsless

#!/usr/bin/env bash

set -x

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

GROUP=$(cat "${DIR}/GROUP")
PROJECT=$(cat "${DIR}/PROJECT")
SCM=$(cat "${DIR}/SCM")
ver=$("$DIR/current-version")

bsless

#!/usr/bin/env bash

USERNAME="$1"
PASS="$2"

for f in  *.ovpn 
do    
        name=`basename -s .ovpn $f`;
        nmcli connection import type openvpn file $f
        nmcli connection modify "${name}" +vpn.data connection-type=password-tls

bsless

(defn match
  [m]
  (reduce
   (fn [f f']
     (fn [m] (and (f m) (f' m))))
   (map (fn [[k v]] #(= v (get % k))) m)))

(def bands
  [{:genere :rock :name "Deep Purple"}
   {:genere :metal :name "Iron Maiden"}

bsless

  ;;; Based on https://stackoverflow.com/a/38842018/12373587
  
  (defn map-vals
    [m f]
    (persistent!
     (reduce-kv
      (fn [m k v]
        (assoc! m k (f v)))
      (transient {})
      m)))

bsless

(defmacro defnormalizer
  [name m]
  {:pre (map? m)}
  (let [arg 'rec
        body
        (reduce-kv
         (fn [m k v]
           ((if (sequential? v) assoc-in assoc)
            m
            v