* add lib test for component

* add example of using GZip

2021-09-26 23:47:39 +02:00

Projects

The following libraries and projects are known to work with babashka.

Projects

Also keep an eye on the news page for new projects, gists and other developments around babashka.

Libraries

clj-http-lite

A fork of a fork of clj-http-lite. Example:

$ export BABASHKA_CLASSPATH="$(clojure -Sdeps '{:deps {clj-http-lite {:git/url "https://github.com/babashka/clj-http-lite" :sha "f44ebe45446f0f44f2b73761d102af3da6d0a13e"}}}' -Spath)"

$ bb "(require '[clj-http.lite.client :as client]) (:status (client/get \"https://www.clojure.org\"))"
200

spartan.spec

An babashka-compatible implementation of clojure.spec.alpha.

missing.test.assertions

This library checks if no assertions have been made in a test:

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {borkdude/missing.test.assertions {:git/url "https://github.com/borkdude/missing.test.assertions" :sha "603cb01bee72fb17addacc53c34c85612684ad70"}}}')

$ lein bb "(require '[missing.test.assertions] '[clojure.test :as t]) (t/deftest foo) (t/run-tests)"

Testing user
WARNING: no assertions made in test foo

Ran 1 tests containing 0 assertions.
0 failures, 0 errors.
{:test 1, :pass 0, :fail 0, :error 0, :type :summary}

medley

Requires bb >= v0.0.71. Latest coordinates checked with with bb:

{:git/url "https://github.com/weavejester/medley" :sha "a4e5fb5383f5c0d83cb2d005181a35b76d8a136d"}

Example:

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {medley {:git/url "https://github.com/weavejester/medley" :sha "a4e5fb5383f5c0d83cb2d005181a35b76d8a136d"}}}')

$ bb -e "(require '[medley.core :as m]) (m/index-by :id [{:id 1} {:id 2}])"
{1 {:id 1}, 2 {:id 2}}

limit-break

A debug REPL library.

Latest coordinates checked with with bb:

{:git/url "https://github.com/technomancy/limit-break" :sha "050fcfa0ea29fe3340927533a6fa6fffe23bfc2f" :deps/manifest :deps}

Example:

$ export BABASHKA_CLASSPATH="$(clojure -Sdeps '{:deps {limit-break {:git/url "https://github.com/technomancy/limit-break" :sha "050fcfa0ea29fe3340927533a6fa6fffe23bfc2f" :deps/manifest :deps}}}' -Spath)"

$ bb "(require '[limit.break :as lb]) (let [x 1] (lb/break))"
Babashka v0.0.49 REPL.
Use :repl/quit or :repl/exit to quit the REPL.
Clojure rocks, Bash reaches.

break> x
1

clojure-csv

A library for reading and writing CSV files. Note that babashka already comes with clojure.data.csv, but in case you need this other library, this is how you can use it:

export BABASHKA_CLASSPATH="$(clojure -Sdeps '{:deps {clojure-csv {:mvn/version "RELEASE"}}}' -Spath)"

./bb -e "
(require '[clojure-csv.core :as csv])
(csv/write-csv (csv/parse-csv \"a,b,c\n1,2,3\"))
"

regal

Requires bb >= v0.0.71. Latest coordinates checked with with bb:

{:git/url "https://github.com/lambdaisland/regal" :sha "d4e25e186f7b9705ebb3df6b21c90714d278efb7"}

Example:

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {regal {:git/url "https://github.com/lambdaisland/regal" :sha "d4e25e186f7b9705ebb3df6b21c90714d278efb7"}}}')

$ bb -e "(require '[lambdaisland.regal :as regal]) (regal/regex [:* \"ab\"])"
#"(?:\Qab\E)*"

cprop

A clojure configuration libary. Latest test version: "0.1.16".

comb

Simple templating system for Clojure. Latest tested version: "0.1.1".

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {comb/comb {:mvn/version "0.1.1"}}})

(require '[comb.template :as template])

(template/eval "<% (dotimes [x 3] %>foo<% ) %>") ;;=> "foofoofoo"

nubank/docopt

Docopt implementation in Clojure, compatible with babashka.

arrangement

A micro-library which provides a total-ordering comparator for Clojure values. Tested with version 1.2.0.

clojure.math.combinatorics

$ bb --classpath "$(clojure -Spath -Sdeps '{:deps {org.clojure/math.combinatorics {:mvn/version "0.1.6"}}}')" \
     -e "(use 'clojure.math.combinatorics) (permutations [:a :b])"
((:a :b) (:b :a))

testdoc

Yet another doctest implementation in Clojure.

$ export BABASHKA_CLASSPATH=$(clojure -Sdeps '{:deps {testdoc {:mvn/version "1.2.0"}}}' -Spath)

$ bb '(ns foo (:use clojure.test testdoc.core))
(defn foo "
  => (foo)
  :foox"
  [] :foo)

(deftest footest
  (is (testdoc (var foo))))

(test-var (var footest))'

FAIL in (footest) (:1)
(= (foo) :foox)
expected: :foox
  actual: :foo

doric

Library for printing tables.

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {doric {:mvn/version "0.9.0"}}}')
$ bb "(use 'doric.core) (println (table [:a :b :c] [{:a 1 :b 2 :c 3} {:a 4 :b 5 :c 6}]))"
|---+---+---|
| A | B | C |
|---+---+---|
| 1 | 2 | 3 |
| 4 | 5 | 6 |
|---+---+---|

clojure.data.zip

Utilities for clojure.zip, among other things a more fluent way to work with xml.

Small sample:

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {org.clojure/data.zip {:mvn/version "1.0.0"}}}')

$ cat data_zip_xml.clj
(require '[clojure.data.xml :as xml])
(require '[clojure.zip :as zip])
(require '[clojure.data.zip.xml :refer [text attr attr= xml-> xml1-> text=]])

(def data (str "<root>"
               "  <character type=\"person\" name=\"alice\" />"
               "  <character type=\"animal\" name=\"march hare\" />"
               "</root>"))

(let [xml  (-> data java.io.StringReader. xml/parse zip/xml-zip)]
  (prn :alice-is-a (xml1-> xml :character [(attr= :name "alice")] (attr :type)))
  (prn :animal-is-called (xml1-> xml :character [(attr= :type "animal")] (attr :name))))

$ bb data_zip_xml.clj
:alice-is-a "person"
:animal-is-called "march hare"

(see for exaple this article for more on clojure.data.zip).

clj-psql

A small Clojure wrapper for interacting with psql.

user> (psql/query conn "select name, subject from grades where grade = 100")
   => ({:name "Bobby Tables", :subject "Math"}
       {:name "Suzy Butterbean", :subject "Math"})

camel-snake-kebab

A library for word case conversions.

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {camel-snake-kebab/camel-snake-kebab {:mvn/version "0.4.2"}}})

(require '[camel-snake-kebab.core :as csk])

(csk/->camelCase 'flux-capacitor) ;;=> 'fluxCapacitor

aero

A small library for explicit, intentful configuration.

bond

Spying and stubbing library, primarily intended for tests.

version-clj

Analysis and comparison of artifact version numbers.

> export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {version-clj/version-clj {:mvn/version "0.1.2"}}}')
> bb --repl
...
user=> (require '[version-clj.core :as ver])
nil
user=> (ver/version->seq "1.0.0-SNAPSHOT")
[(1 0 0) ["snapshot"]]
user=> (ver/version-compare "1.2.3" "1.0.0")
1
user=> (ver/version-compare "1.0.0-SNAPSHOT" "1.0.0")
-1
user=> (ver/version-compare "1.0" "1.0.0")
0

matchete

Pattern matching library:

$ rlwrap bb -cp "$(clojure -Spath -Sdeps '{:deps {io.xapix/matchete {:mvn/version "1.2.0"}}}')"
user=> (require '[matchete.core :as mc])
nil
user=> (mc/matches '{?k 1} {:x 1 :y 1})"
({?k :y} {?k :x})

progrock

A functional Clojure progress bar for the command line.

Tested version: 0.1.2.

clj-commons/fs

File system utilities for Clojure.

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {clj-commons/fs {:mvn/version "1.5.2"}}})

(require '[me.raynes.fs :as fs])

(fs/link? "/tmp") ;; true

cljc.java-time

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {cljc.java-time/cljc.java-time {:mvn/version "0.1.12"}}})

(require  '[cljc.java-time.local-date :as ld])

(def a-date (ld/parse "2019-01-01"))

(ld/plus-days a-date 99)

environ

Library for managing environment variables in Clojure.

(require '[babashka.deps :as deps])

(babashka.deps/add-deps '{:deps {environ/environ {:mvn/version "1.2.0"}}})

(require '[environ.core :refer [env]])

(prn (:path env))

gaka

(ns script
  (:require [babashka.deps :as deps]))

(deps/add-deps '{:deps {gaka/gaka {:mvn/version "0.3.0"}}})

(require '[gaka.core :as gaka])

(def rules [:div#foo
            :margin "0px"
            [:span.bar
             :color "black"
             :font-weight "bold"
             [:a:hover
              :text-decoration "none"]]])

(println (gaka/css rules))

Output:

div#foo {
  margin: 0px;}

  div#foo span.bar {
    color: black;
    font-weight: bold;}

    div#foo span.bar a:hover {
      text-decoration: none;}

failjure

Working with failed computations in Clojure.

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {failjure/failjure {:mvn/version "2.1.1"}}})

(require '[failjure.core :as f])

(f/fail "foo")

pretty

The io.aviso.ansi namespace provides ANSI font and background color support.

(require '[babashka.deps :as deps])

(deps/add-deps
 '{:deps {io.aviso/pretty {:mvn/version "0.1.36"}}})

(require '[io.aviso.ansi :as ansi])

(println
 (str "The following text will be "
      ansi/bold-red-font "bold and red "
      ansi/reset-font "but this text will not."))

clojure-term-colors

Clojure ASCII color formatting for terminal output.

(require '[babashka.deps :as deps])

(deps/add-deps
 '{:deps {clojure-term-colors/clojure-term-colors {:mvn/version "0.1.0"}}})

(require '[clojure.term.colors :as c])

(println
 (c/yellow "Yellow")
 (c/red "Red")
 "No color")

binf

Handling binary formats in all shapes and forms.

rewrite-edn

Rewrite EDN with preservation of whitespace, based on rewrite-clj.

Example:

#!/usr/bin/env bb

(require '[babashka.deps :as deps])
(deps/add-deps '{:deps {borkdude/rewrite-edn {:mvn/version "0.0.2"}}})
(require '[borkdude.rewrite-edn :as r])

(def edn-string (slurp "deps.edn"))
(def nodes (r/parse-string edn-string))

(println (str (r/assoc-in nodes [:deps 'my-other-dep] {:mvn/version "0.1.2"})))

expound

Formats spartan.spec error messages in a way that is optimized for humans to read.

Example:

#!/usr/bin/env bb

(ns expound
  (:require [babashka.deps :as deps]))

(deps/add-deps
 '{:deps {borkdude/spartan.spec {:git/url "https://github.com/borkdude/spartan.spec"
                                 :sha "bf4ace4a857c29cbcbb934f6a4035cfabe173ff1"}
          expound/expound {:mvn/version "0.8.9"}}})

;; Loading spartan.spec will create a namespace clojure.spec.alpha for compatibility:
(require 'spartan.spec)
(alias 's 'clojure.spec.alpha)

;; Expound expects some vars to be there, like `fdef`. Spartan prints warnings that these are used, but doesn't implement them yet.
(require '[expound.alpha :as expound])

(s/def ::a (s/cat :i int? :j string?))

(expound/expound ::a [1 2])

omniconf

script.clj:

#!/usr/bin/env bb

(ns script
  (:require [babashka.deps :as deps]))

(deps/add-deps
 '{:deps {com.grammarly/omniconf {:mvn/version "0.4.3"}}})

(require '[omniconf.core :as cfg])
(cfg/define {:foo {}})
(cfg/populate-from-env)
(cfg/get :foo)

FOO=1 script.clj
Populating Omniconf from env: 1 value(s)
"1"

slingshot

Enhanced try and throw for Clojure leveraging Clojure's capabilities.

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {slingshot/slingshot {:mvn/version "0.12.2"}}}')
$ bb -e "(require '[slingshot.slingshot :as s]) (s/try+ (s/throw+ {:type ::foo}) (catch [:type ::foo] [] 1))"
1

NOTE: slingshot's tests pass with babashka except one: catching a record types by name. This is due to a difference in how records are implemented in babashka. This may be fixed later if this turns out to be really useful.

hasch

Cross-platform (JVM and JS atm.) edn data structure hashing for Clojure.

$ export BABASHKA_CLASSPATH=$(clojure -Spath -Sdeps '{:deps {io.replikativ/hasch {:mvn/version "0.3.7"}}}')
$ bb -e "(use 'hasch.core) (edn-hash (range 100))"
(168 252 48 247 180 148 51 182 108 76 20 251 155 187 66 8 124 123 103 28 250 151 26 139 10 216 119 168 101 123 130 225 66 168 48 63 53 99 25 117 173 29 198 229 101 196 162 30 23 145 7 166 232 193 57 239 226 238 240 41 254 78 135 122)

NOTE: hasch's tests pass with babashka except the test around hashing records. This is due to a difference in how records are implemented in babashka. This may be fixed later if this turns out to be really useful.

crispin

Populate a configuration map from multiple sources (environment variables, system variables, config files, etc.)

Example:

script.clj

#!/usr/bin/env bb

(ns script
  (:require [babashka.deps :as deps]))

(deps/add-deps
 '{:deps {crispin/crispin {:mvn/version "0.3.8"}}})

(require '[crispin.core :as crispin])
(def app-cfg (crispin/cfg))
(app-cfg :foo)

FOO=1 script.clj
"1"

ffclj

A wrapper around executing ffmpeg and ffprobe. Supports progress reporting via core.async channels.

multigrep

Regex-based file grepping and/or text substitution.

Example:

find the words that are exactly four letters long in some strings:

(ns multigrep-demo
  (:require [babashka.deps :as deps]
            [clojure.pprint :refer [pprint]])
  (:import (java.io StringReader)))

(deps/add-deps '{:deps {clj-commons/multigrep {:mvn/version "0.5.0"}}})

(require '[multigrep.core :as grep])

; the StringReaders could be anything that clojure.java.io/reader will accept (files, URLs, etc.)
(let [sentence1 (StringReader. "the quick brown fox jumps over the lazy dog")
      sentence2 (StringReader. "Lorem ipsum dolor sit amet")]
  (pprint (grep/grep #"\b[a-z]{4}\b" [sentence1 sentence2])))

outputs:

({:file
  #object[java.io.StringReader...],
  :line "the quick brown fox jumps over the lazy dog",
  :line-number 1,
  :regex #"\b[a-z]{4}\b",
  :re-seq ("over" "lazy")}
 {:file
  #object[java.io.StringReader...],
  :line "Lorem ipsum dolor sit amet",
  :line-number 1,
  :regex #"\b[a-z]{4}\b",
  :re-seq ("amet")})

java-http-clj

Http client based on java.net.http.

component

A tiny Clojure framework for managing the lifecycle and dependencies of software components which have runtime state.

Pods

Babashka pods are programs that can be used as Clojure libraries by babashka. See pod-registry for an overview of available pods.

Pods not available in the pod registry:

pod-janet-peg: a pod for calling Janet's PEG functionality.
pod-jaydeesimon-jsoup: a pod for parsing HTML using CSS queries backed by Jsoup.
pod.xledger.sql-server: pod for interacting with SQL Server.

24 KiB Raw Blame History

Projects

Libraries

Pods

Projects

24 KiB

Raw Blame History