travisshears/time_guesser
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

init repo

Browse source
This commit is contained in:
Travis Shears 2026-05-27 15:41:03 +01:00
commit 174258c611
Signed by: travisshears
GPG key ID: CB9BF1910F3F7469
11 changed files with 11589 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

184
minify.bb Executable file
View file

@ -0,0 +1,184 @@
#!/usr/bin/env bb
(ns minify
(:require
[babashka.fs :as fs]
[clojure.pprint :refer [pprint]]
[clojure.string :as str])
(:import
'java.io.StringReader))
;; TOKENIZE
(defn is-whitespace [c] (contains? #{\ \tab \newline \return} c))
(defn tokenize [source]
(let [chars (vec source) total-chars (count chars)]
(loop [cursor 0 tokens []]
; (when (< cursor 100) (pprint {:tokens tokens}))
(if (>= cursor total-chars)
tokens
(let [c (chars cursor) nxt (get chars (inc cursor))]
(cond
;; comment — inner loop scans to end of line
(= c \;)
(let [end (loop [j cursor]
(if (or (>= j total-chars) (= (chars j) \newline))
j
(recur (inc j))))]
(recur end (conj tokens {:type :comment :value (apply str (subvec chars cursor end))})))
;; whitespace — consume the whole run as one :space token
(is-whitespace c)
(let [end (loop [j cursor]
(if (or (>= j total-chars) (not (is-whitespace (chars j))))
j
(recur (inc j))))]
(recur end (conj tokens {:type :space :value nil})))
(contains? #{\( \[ \{} c)
(recur (inc cursor) (conj tokens {:type :open-paren :value (str c)}))
(contains? #{\) \] \}} c)
(recur (inc cursor) (conj tokens {:type :close-paren :value (str c)}))
;; strings
(= c \")
(let [end (loop [j (inc cursor)]
(if (or (>= j total-chars) (= (chars j) \"))
(inc j)
(recur (inc j))))]
(recur end (conj tokens {:type :string :value (apply str (subvec chars cursor end))})))
(and nxt (= c \#) (= nxt \())
(recur (+ cursor 2) (conj tokens {:type :open-annon-fn :value "#("}))
:else
; (let [delimiters #{\( \) \[ \] \{ \} \; \" \, \@ \` \'}
(let [delimiters #{\( \) \[ \] \{ \} \; \" \, \@ \` \'}
cursor2 (loop [j cursor]
(if (or (>= j total-chars) (is-whitespace (chars j)) (contains? delimiters (chars j))) j
(recur (inc j))))]
(if (= cursor2 cursor)
(recur (inc cursor) (conj tokens {:type :unknown :value (str c)}))
(recur cursor2 (conj tokens {:type :symbol :value (apply str (subvec chars cursor cursor2))}))))))))))
; COLLECT BINDING
(def built-ins #{"fn" "local" "λ" "lambda" "require" "let" "+" "-" "/" "*" "<" ">" "<=" ">=" "not=" ".."
"var" "if" "when" "and" "or" "not" "do" "set" "each" "for" "while"
"true" "$1" "math.floor" "floor" "false" "nil" "size" "textSize" "background" "text" "random" "key"
":setup" ":draw" ":key-pressed" ":L5"})
(defn collect-bindings [tokens]
(reduce (fn [acc token]
(let [val (:value token)]
(cond
(nil? val) acc
; handle table access create bindings for each element tools.wrench -> tools wrench
(re-matches #"^[a-z]+\..*" val) ; table access
(apply conj acc (str/split val #"\."))
(and
(> (count val) 1)
(not (re-matches #"^:.*" val)) ; exclude keywords
;; (not (re-matches #"^[a-z]+\..*" val)) ; table access
(not (re-matches #"\d+" val))
(not (get built-ins val))
(= (:type token) :symbol))
(conj acc val)
:else
acc))) #{} tokens))
;; BUILD RENAME MAP
(defn short-name-seq
"Lazy infinite seq of short names. like a,b,c..aa,bb,cc..zzzzz"
[]
(let [letters (map str "abcdefghijklmnopqrstuvwxyz")]
(mapcat (fn [length]
(map (fn [letter] (apply str (repeat length letter))) letters))
(range 1 Long/MAX_VALUE))))
(defn build-rename-map [names]
(zipmap names (short-name-seq)))
;; EMIT
(def simple-replace-map {"lambda" "λ" "local" "var"})
(def drop-tokens #{:space :comment})
(defn needs-space?
"does this token need space before it?"
[prev current nxt]
(when (= (current :type) :string) (pprint {:current current}))
(or
(= (current :type) :open-annon-fn)
(and
prev
(= (prev :type) :string)
(contains? #{:symbol :open-paren} (current :type)))
(= (current :type) :string)
; space needed: prev is :symbol or :close-paren, AND current is :symbol or :open-paren
(and
prev
(or (= (prev :type) :symbol) (= (prev :type) :close-paren))
(or (= (current :type) :symbol) (= (current :type) :open-paren)))))
(defn add-space [tokens]
(loop [cursor 0 result []]
(if (>= cursor (count tokens))
result
(let [prev (when (pos? cursor) (get tokens (dec (count result))))
curr (tokens cursor)
nxt (when (< (inc cursor) (count tokens)) (tokens (inc cursor)))]
(recur (inc cursor)
(if (needs-space? prev curr nxt)
(conj result (assoc curr :value (str " " (curr :value))))
(conj result curr)))))))
(defn transform-tokens
"get tokens ready to emit"
[tokens re-map]
(->>
tokens
; drop whitespace and comments
(remove (fn [token] (drop-tokens (token :type))))
; make simple replaces
(map (fn [token] (if (simple-replace-map (token :value))
(assoc token :value (simple-replace-map (token :value)))
token)))
;; apply rename map
(map (fn [token]
(let [val (token :value)]
(cond
(nil? val) token
; keywords
(and (re-matches #"^:.*" val) (not (built-ins val)))
(assoc token :value (str ":" (re-map (subs val 1))))
; table access
(re-matches #"^[a-z]+\..*" val)
(assoc token :value (->> (str/split val #"\.")
(map #(re-map %))
(str/join ".")))
; keywords
:else
(if-let [new-value (re-map (token :value))]
(assoc token :value new-value)
token)))))
(vec)
; add needed space before ( { [
; space needed: prev is :symbol or :close-paren, AND current is :symbol or :open-paren
(add-space)))
(defn emit [tokens re-map]
(->>
(transform-tokens tokens re-map)
(reduce (fn [acc token] (conj acc (:value token))) [])
(str/join "")))
(defn write-file
"Write a file to the file system"
[file-name content]
(fs/write-lines file-name [content]))
(defn gen-output-file-name [file-name] (str/replace file-name #"\.fnl$" ".min.fnl"))
(when (first *command-line-args*)
(let [file-name (first *command-line-args*)
source (slurp file-name)
tokens (tokenize source)
re-map (build-rename-map (collect-bindings tokens))
output (emit tokens re-map)
output-file-name (gen-output-file-name file-name)]
(pprint {:output output :token-sample (take 15 tokens) :bindings (build-rename-map (collect-bindings tokens))})
(write-file "tokens.clj" (with-out-str (pprint (transform-tokens tokens re-map))))
(write-file output-file-name output)
(println (str "Wrote file " output-file-name))))