(ns babashka.fs

(:require [clojure.java.io :as io]

[clojure.string :as str]

[clojure.walk :as walk])

(:import [java.io File InputStream]

[java.net URI]

[java.nio.file StandardOpenOption CopyOption

#?@(:bb [] :clj [DirectoryStream]) #?@(:bb [] :clj [DirectoryStream$Filter])

Files

FileSystems

FileVisitOption

FileVisitResult

StandardCopyOption

LinkOption Path

FileVisitor]

[java.nio.file.attribute BasicFileAttributes FileAttribute FileTime PosixFilePermissions PosixFilePermission]

[java.nio.charset Charset]

[java.util HashSet]

[java.util.zip GZIPInputStream GZIPOutputStream ZipInputStream ZipOutputStream ZipEntry]

[java.io File BufferedInputStream FileInputStream FileOutputStream]))

(set! *warn-on-reflection* true)

(def ^:private fvr-lookup

{:continue FileVisitResult/CONTINUE

:skip-subtree FileVisitResult/SKIP_SUBTREE

:skip-siblings FileVisitResult/SKIP_SIBLINGS

:terminate FileVisitResult/TERMINATE})

(defn- file-visit-result

[x]

(if (instance? FileVisitResult x) x

(or (fvr-lookup x)

(throw (Exception. "Expected: one of :continue, :skip-subtree, :skip-siblings, :terminate.")))))

(defn- as-path

^Path [path]

(if (instance? Path path) path

(if (instance? URI path)

(java.nio.file.Paths/get ^URI path)

(.toPath (io/file path)))))

(defn- as-file

"Coerces a path into a file if it isn't already one."

^java.io.File [path]

(if (instance? Path path) (.toFile ^Path path)

(io/file path)))

(defn- get-env [k]

(System/getenv k))

(defn path

"Coerces f into a Path. Multiple-arg versions treat the first argument as

(^Path [f]

(as-path f))

(^Path [parent child]

(as-path (io/file (as-file parent) (as-file child))))

(^Path [parent child & more]

(reduce path (path parent child) more)))

(defn file

"Coerces f into a File. Multiple-arg versions treat the first argument

(^File [f] (as-file f))

(^File [f & fs]

(apply io/file (map as-file (cons f fs)))))

(defn- ->link-opts ^"[Ljava.nio.file.LinkOption;"

[nofollow-links]

(into-array LinkOption

(cond-> []

nofollow-links

(conj LinkOption/NOFOLLOW_LINKS))))

(defn real-path

"Converts f into real path via Path#toRealPath."

(^Path [f] (real-path f nil))

(^Path [f {:keys [:nofollow-links]}]

(.toRealPath (as-path f) (->link-opts nofollow-links))))

(defn owner

"Returns the owner of a file. Call `str` on it to get the owner name

([f] (owner f nil))

([f {:keys [:nofollow-links]}]

(Files/getOwner (as-path f) (->link-opts nofollow-links))))

(defn regular-file?

"Returns true if f is a regular file, using Files/isRegularFile."

([f] (regular-file? f nil))

([f {:keys [:nofollow-links]}]

(Files/isRegularFile (as-path f)

(->link-opts nofollow-links))))

(defn directory?

"Returns true if f is a directory, using Files/isDirectory."

([f] (directory? f nil))

([f {:keys [:nofollow-links]}]

(Files/isDirectory (as-path f)

(->link-opts nofollow-links))))

(def ^:private simple-link-opts

(into-array LinkOption []))

(defn- directory-simple?

[^Path f] (Files/isDirectory f simple-link-opts))

(defn hidden?

"Returns true if f is hidden."

[f] (Files/isHidden (as-path f)))

(defn absolute?

"Returns true if f represents an absolute path."

[f] (.isAbsolute (as-path f)))

(defn executable?

"Returns true if f is executable."

[f] (Files/isExecutable (as-path f)))

(defn readable?

"Returns true if f is readable"

[f] (Files/isReadable (as-path f)))

(defn writable?

"Returns true if f is writable"

[f] (Files/isWritable (as-path f)))

(defn relative?

"Returns true if f represents a relative path."

[f] (not (absolute? f)))

(defn exists?

"Returns true if f exists."

([f] (exists? f nil))

([f {:keys [:nofollow-links]}]

(try

(Files/exists

(as-path f)

(->link-opts nofollow-links))

(catch Exception _e

false))))

(defn components

"Returns a seq of all components of f as paths, i.e. split on the file

[f]

(seq (as-path f)))

(defn absolutize

"Converts f into an absolute path via Path#toAbsolutePath."

[f] (.toAbsolutePath (as-path f)))

(defn relativize

"Returns relative path by comparing this with other."

^Path [this other]

(.relativize (as-path this) (as-path other)))

(defn normalize

"Normalizes f via Path#normalize."

[f]

(.normalize (as-path f)))

(defn canonicalize

"Returns the canonical path via

(^Path [f] (canonicalize f nil))

(^Path [f {:keys [:nofollow-links]}]

(if nofollow-links

(-> f absolutize normalize)

(as-path (.getCanonicalPath (as-file f))))))

(defn file-name

"Returns the name of the file or directory. E.g. (file-name \"foo/bar/baz\") returns \"baz\"."

[x]

(.getName (as-file x)))

(def ^:private continue (constantly :continue))

(defn walk-file-tree

"Walks f using Files/walkFileTree. Visitor functions: :pre-visit-dir,

[f

{:keys [:pre-visit-dir :post-visit-dir

:visit-file :visit-file-failed

:follow-links :max-depth]}]

(let [pre-visit-dir (or pre-visit-dir continue)

post-visit-dir (or post-visit-dir continue)

visit-file (or visit-file continue)

max-depth (or max-depth Integer/MAX_VALUE)

visit-opts (set (cond-> []

follow-links (conj FileVisitOption/FOLLOW_LINKS)))

visit-file-failed (or visit-file-failed

(fn [_path _attrs]

:continue))]

(Files/walkFileTree (as-path f)

visit-opts

max-depth

(reify FileVisitor

(preVisitDirectory [_ dir attrs]

(-> (pre-visit-dir dir attrs)

file-visit-result))

(postVisitDirectory [_ dir ex]

(-> (post-visit-dir dir ex)

file-visit-result))

(visitFile [_ path attrs]

(-> (visit-file path attrs)

file-visit-result))

(visitFileFailed [_ path ex]

(-> (visit-file-failed path ex)

file-visit-result))))))

#?(:bb nil :clj

(defn- directory-stream

"Returns a stream of all files in dir. The caller of this function is

(^DirectoryStream [dir]

(Files/newDirectoryStream (as-path dir)))

(^DirectoryStream [dir glob-or-accept]

(if (string? glob-or-accept)

(Files/newDirectoryStream (as-path dir) (str glob-or-accept))

(let [accept* glob-or-accept]

(Files/newDirectoryStream (as-path dir)

(reify DirectoryStream$Filter

(accept [_ entry]

(boolean (accept* entry))))))))))

#?(:bb nil :clj

(defn list-dir

"Returns all paths in dir as vector. For descending into subdirectories use `glob.`

([dir]

(with-open [stream (directory-stream dir)]

(vec stream)))

([dir glob-or-accept]

(with-open [stream (directory-stream dir glob-or-accept)]

(vec stream)))))

(def file-separator File/separator)

(def path-separator File/pathSeparator)

(def ^:private win?

(-> (System/getProperty "os.name")

(str/lower-case)

(str/includes? "win")))

(defn match

"Given a file and match pattern, returns matches as vector of

([root pattern] (match root pattern nil))

([root pattern {:keys [hidden follow-links max-depth recursive]}]

(let [base-path (-> root absolutize normalize)

base-path (if win?

(str/replace base-path file-separator (str "\\" file-separator))

(str base-path))

skip-hidden? (not hidden)

results (atom (transient []))

past-root? (volatile! nil)

[prefix pattern] (str/split pattern #":")

pattern (let [separator (when-not (str/ends-with? base-path file-separator)

;; we need to escape the file separator on Windows

(str (when win? "\\")

file-separator))]

(str base-path

separator

(if win?

(str/replace pattern "/" "\\\\")

pattern)))

pattern (str prefix ":" pattern)

matcher (.getPathMatcher

(FileSystems/getDefault)

pattern)

match (fn [^Path path]

(when (.matches matcher path)

(swap! results conj! path))

nil)]

(walk-file-tree

base-path

{:max-depth max-depth

:follow-links follow-links

:pre-visit-dir (fn [dir _attrs]

(if (and @past-root?

(or (not recursive)

(and skip-hidden?

(hidden? dir))))

:skip-subtree

(do

(if @past-root? (match dir)

(vreset! past-root? true))

:continue)))

:visit-file (fn [path _attrs]

(when-not (and skip-hidden?

(hidden? path))

(match path))

:continue)})

(let [results (persistent! @results)

absolute-cwd (absolutize "")]

(if (relative? root)

(mapv #(relativize absolute-cwd %)

results)

results)))))

(defn glob

"Given a file and glob pattern, returns matches as vector of

([root pattern] (glob root pattern nil))

([root pattern opts]

(let [recursive (:recursive opts

(or (str/includes? pattern "**")

(str/includes? pattern file-separator)

(when win?

(str/includes? pattern "/"))))

hidden (:hidden opts (str/starts-with? pattern "."))]

(match root (str "glob:" pattern) (assoc opts :recursive recursive :hidden hidden)))))

(defn- ->copy-opts ^"[Ljava.nio.file.CopyOption;"

[replace-existing copy-attributes atomic-move nofollow-links]

(into-array CopyOption

(cond-> []

replace-existing (conj StandardCopyOption/REPLACE_EXISTING)

copy-attributes (conj StandardCopyOption/COPY_ATTRIBUTES)

atomic-move (conj StandardCopyOption/ATOMIC_MOVE)

nofollow-links (conj LinkOption/NOFOLLOW_LINKS))))

(defn copy

"Copies src file to dest dir or file.

([src dest] (copy src dest nil))

([src dest {:keys [replace-existing

copy-attributes

nofollow-links]}]

(let [copy-options (->copy-opts replace-existing copy-attributes false nofollow-links)

dest (as-path dest)

dest (if (directory-simple? dest)

(path dest (file-name src))

dest)

input-stream? (instance? java.io.InputStream src)]

(if input-stream?

(Files/copy ^java.io.InputStream src dest copy-options)

(Files/copy (as-path src) dest copy-options)))))

(defn posix->str

"Converts a set of PosixFilePermission to a string."

[p]

(PosixFilePermissions/toString p))

(defn str->posix

"Converts a string to a set of PosixFilePermission.

[s]

(PosixFilePermissions/fromString s))

(defn- ->posix-file-permissions [s]

(cond (string? s)

(str->posix s)

;; (set? s)

;; (into #{} (map keyword->posix-file-permission) s)

:else

s))

(defn- posix->file-attribute [x]

(PosixFilePermissions/asFileAttribute x))

(defn- posix->attrs

^"[Ljava.nio.file.attribute.FileAttribute;" [posix-file-permissions]

(let [attrs (if posix-file-permissions

(-> posix-file-permissions

(->posix-file-permissions)

(posix->file-attribute)

vector)

[])]

(into-array FileAttribute attrs)))

(defn create-dir

"Creates dir using `Files#createDirectory`. Does not create parents."

([path]

(create-dir path nil))

([path {:keys [:posix-file-permissions]}]

(let [attrs (posix->attrs posix-file-permissions)]

(Files/createDirectory (as-path path) attrs))))

(defn create-dirs

"Creates directories using `Files#createDirectories`. Also creates parents if needed.

([path] (create-dirs path nil))

([path {:keys [:posix-file-permissions]}]

(Files/createDirectories (as-path path) (posix->attrs posix-file-permissions))))

(defn set-posix-file-permissions

"Sets posix file permissions on f. Accepts a string like `\"rwx------\"` or a set of PosixFilePermission."

[f posix-file-permissions]

(Files/setPosixFilePermissions (as-path f) (->posix-file-permissions posix-file-permissions)))

(defn posix-file-permissions

"Gets f's posix file permissions. Use posix->str to view as a string."

([f] (posix-file-permissions f nil))

([f {:keys [:nofollow-links]}]

(Files/getPosixFilePermissions (as-path f) (->link-opts nofollow-links))))

(defn- u+wx

[f]

(if win?

(.setWritable (file f) true)

(let [^HashSet perms (posix-file-permissions f)

p1 (.add perms PosixFilePermission/OWNER_WRITE)

p2 (.add perms PosixFilePermission/OWNER_EXECUTE)]

(when (or p1 p2)

(set-posix-file-permissions f perms)))))

(defn copy-tree

"Copies entire file tree from src to dest. Creates dest if needed

([src dest] (copy-tree src dest nil))

([src dest {:keys [:replace-existing

:copy-attributes

:nofollow-links]

:as opts}]

;; cf. Python

(when-not (directory? src)

(throw (IllegalArgumentException. (str "Not a directory: " src))))

;; cf. Python

(when (and (exists? dest)

(not (directory? dest)))

(throw (IllegalArgumentException. (str "Not a directory: " dest))))

;; cf. Python

(create-dirs dest opts)

(let [copy-options (->copy-opts replace-existing copy-attributes false nofollow-links)

link-options (->link-opts nofollow-links)

from (real-path src {:nofollow-links nofollow-links})

;; using canonicalize here because real-path requires the path to exist

to (canonicalize dest {:nofollow-links nofollow-links})]

(walk-file-tree from {:pre-visit-dir (fn [dir _attrs]

(let [rel (relativize from dir)

to-dir (path to rel)]

(when-not (Files/exists to-dir link-options)

(Files/copy ^Path dir to-dir

^"[Ljava.nio.file.CopyOption;"

copy-options)

(when-not win?

(u+wx to-dir))))

:continue)

:visit-file (fn [from-path _attrs]

(let [rel (relativize from from-path)

to-file (path to rel)]

(Files/copy ^Path from-path to-file

^"[Ljava.nio.file.CopyOption;"

copy-options)

:continue)

:continue)

:post-visit-dir (fn [dir _ex]

(let [rel (relativize from dir)

to-dir (path to rel)]

(when-not win?

(let [perms (posix-file-permissions (file dir))]

(Files/setPosixFilePermissions to-dir perms)))

:continue))}))))

(declare posix-file-permissions)

(declare set-posix-file-permissions)

(defn temp-dir

"Returns `java.io.tmpdir` property as path."

[]

(as-path (System/getProperty "java.io.tmpdir")))

(defn create-temp-dir

"Creates a temporary directory using Files#createDirectories.

([]

(Files/createTempDirectory

(str (java.util.UUID/randomUUID))

(make-array FileAttribute 0)))

([{:keys [:dir :prefix :posix-file-permissions] :as opts}]

(let [attrs (posix->attrs posix-file-permissions)

prefix (or prefix (str (java.util.UUID/randomUUID)))

dir (or dir (:path opts))]

(if dir

(Files/createTempDirectory

(as-path dir)

prefix

attrs)

(Files/createTempDirectory

prefix

attrs)))))

(defn create-temp-file

"Creates an empty temporary file using Files#createTempFile.

([]

(Files/createTempFile

(str (java.util.UUID/randomUUID))

(str (java.util.UUID/randomUUID))

(make-array FileAttribute 0)))

([{:keys [:dir :prefix :suffix :posix-file-permissions] :as opts}]

(let [attrs (posix->attrs posix-file-permissions)

prefix (or prefix (str (java.util.UUID/randomUUID)))

suffix (or suffix (str (java.util.UUID/randomUUID)))

dir (or dir

;; backwards compat

(:path opts))]

(if dir

(Files/createTempFile

(as-path dir)

prefix

suffix

attrs)

(Files/createTempFile

prefix

suffix

attrs)))))

(defn create-sym-link

"Create a soft link from path to target."

[path target]

(Files/createSymbolicLink

(as-path path)

(as-path target)

(make-array FileAttribute 0)))

(defn create-link

"Create a hard link from path to target."

[path target]

(Files/createLink

(as-path path)

(as-path target)))

(defn read-link

"Reads the target of a symbolic link. The target need not exist."

[path]

(java.nio.file.Files/readSymbolicLink (as-path path)))

(defn delete

"Deletes f. Returns nil if the delete was successful,

;; We don't follow symlinks, since the link can target a dir and you should be

;; using delete-tree to delete that.

[f]

(Files/delete (as-path f)))

(defn delete-if-exists

"Deletes f if it exists. Returns true if the delete was successful,

[f]

(Files/deleteIfExists (as-path f)))

(defn sym-link?

"Determines if `f` is a symbolic link via `java.nio.file.Files/isSymbolicLink`."

[f]

(Files/isSymbolicLink (as-path f)))

(defn delete-tree

"Deletes a file tree using `walk-file-tree`. Similar to `rm -rf`. Does not follow symlinks.

;; See delete-permission-assumptions-test

;; Implementation with the force flag is based on those assumptions

([root] (delete-tree root nil))

([root {:keys [force]}]

(when (exists? root)

(walk-file-tree root

{:visit-file (fn [path _]

(when (and win? force)

(.setWritable (file path) true))

(delete path)

:continue)

:pre-visit-dir (fn [path _]

(when force

(u+wx path))

:continue)

:post-visit-dir (fn [path _]

(delete path)

:continue)}))))

(defn create-file

"Creates empty file using `Files#createFile`.

([path]

(create-file path nil))

([path {:keys [:posix-file-permissions]}]

(let [attrs (posix->attrs posix-file-permissions)]

(Files/createFile (as-path path) attrs))))

(defn move

"Move or rename a file to a target dir or file via `Files/move`."

([source target] (move source target nil))

([source target {:keys [:replace-existing

:atomic-move

:nofollow-links]}]

(let [target (as-path target)]

(if (directory-simple? target)

(Files/move (as-path source)

(path target (file-name source))

(->copy-opts replace-existing false atomic-move nofollow-links))

(Files/move (as-path source)

target

(->copy-opts replace-existing false atomic-move nofollow-links))))))

(defn parent

"Returns parent of f. Akin to `dirname` in bash."

[f]

(.getParent (as-path f)))

(defn size

"Returns the size of a file (in bytes)."

[f]

(Files/size (as-path f)))

(defn delete-on-exit

"Requests delete on exit via `File#deleteOnExit`. Returns f."

[f]

(.deleteOnExit (as-file f))

f)

(defn same-file?

"Returns true if this is the same file as other."

[this other]

(Files/isSameFile (as-path this) (as-path other)))

(defn read-all-bytes

"Returns contents of file as byte array."

[f]

(Files/readAllBytes (as-path f)))

(defn- ->charset ^Charset [charset]

(if (string? charset)

(Charset/forName charset)

charset))

(defn read-all-lines

"Read all lines from a file."

([f]

(vec (Files/readAllLines (as-path f))))

([f {:keys [charset]

:or {charset "utf-8"}}]

(vec (Files/readAllLines

(as-path f)

(->charset charset)))))

(defn get-attribute

([path attribute]

(get-attribute path attribute nil))

([path attribute {:keys [:nofollow-links]}]

(Files/getAttribute (as-path path)

attribute

(->link-opts {:nofollow-links nofollow-links}))))

(defn- keyize

[key-fn m]

(let [f (fn [[k v]] (if (string? k) [(key-fn k) v] [k v]))]

(walk/postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))

(defn read-attributes*

"Reads attributes via Files/readAttributes."

([path attributes]

(read-attributes* path attributes nil))

([path attributes {:keys [:nofollow-links]}]

(let [p (as-path path)

link-opts (->link-opts {:nofollow-links nofollow-links})

attrs

;; prevent reflection warning

(if (instance? String attributes)

(Files/readAttributes p

^String attributes

link-opts)

(Files/readAttributes p

^Class attributes

link-opts))]

attrs)))

(defn read-attributes

"Same as `read-attributes*` but turns attributes into a map and keywordizes keys.

([path attributes]

(read-attributes path attributes nil))

([path attributes {:keys [:nofollow-links :key-fn] :as opts}]

(->> (read-attributes* path attributes opts)

(into {})

(keyize (or key-fn keyword)))))

(defn set-attribute

([path attribute value]

(set-attribute path attribute value nil))

([path attribute value {:keys [:nofollow-links]}]

(Files/setAttribute (as-path path)

attribute

value

(->link-opts {:nofollow-links nofollow-links}))))

(defn file-time->instant

"Converts a java.nio.file.attribute.FileTime to a java.time.Instant."

[^FileTime ft]

(.toInstant ft))

(defn instant->file-time

"Converts a java.time.Instant to a java.nio.file.attribute.FileTime."

[instant]

(FileTime/from instant))

(defn file-time->millis

"Converts a java.nio.file.attribute.FileTime to epoch millis (long)."

[^FileTime ft]

(.toMillis ft))

(defn millis->file-time

"Converts epoch millis (long) to a java.nio.file.attribute.FileTime."

[millis]

(FileTime/fromMillis millis))

(defn- ->file-time [x]

(cond (int? x) (millis->file-time x)

(instance? java.time.Instant x) (instant->file-time x)

:else x))

(defn last-modified-time

"Returns last modified time as a java.nio.file.attribute.FileTime."

([f]

(last-modified-time f nil))

([f {:keys [nofollow-links] :as opts}]

(get-attribute f "basic:lastModifiedTime" opts)))

(defn set-last-modified-time

"Sets last modified time of f to time (millis, java.time.Instant or java.nio.file.attribute.FileTime)."

([f time]

(set-last-modified-time f time nil))

([f time {:keys [nofollow-links] :as opts}]

(set-attribute f "basic:lastModifiedTime" (->file-time time) opts)))

(defn creation-time

"Returns creation time as FileTime."

([f]

(creation-time f nil))

([f {:keys [nofollow-links] :as opts}]

(get-attribute f "basic:creationTime" opts)))

(defn set-creation-time

"Sets creation time of f to time (millis, java.time.Instant or java.nio.file.attribute.FileTime)."

([f time]

(set-creation-time f time nil))

([f time {:keys [nofollow-links] :as opts}]

(set-attribute f "basic:creationTime" (->file-time time) opts)))

(defn list-dirs

"Similar to list-dir but accepts multiple roots and returns the concatenated results.

[dirs glob-or-accept]

(mapcat #(list-dir % glob-or-accept) dirs))

(defn split-ext

"Splits path on extension If provided, a specific extension `ext`, the

([path] (split-ext path nil))

([path {:keys [ext]}]

(let [path-str (str path)

file-name (file-name path)]

(let [ext (if ext

(str "." ext)

(when-let [last-dot (str/last-index-of file-name ".")]

(subs file-name last-dot)))]

(if (and ext

(str/ends-with? path-str ext)

(not= path-str ext))

(let [loc (str/last-index-of path-str ext)]

[(subs path-str 0 loc)

(subs path-str (inc loc))])

[path-str nil])))))

(defn strip-ext

"Strips extension via `split-ext`."

([path]

(strip-ext path nil))

([path {:keys [ext] :as opts}]

(first (split-ext path opts))))

(defn extension

"Returns the extension of a file via `split-ext`."

[path]

(-> path split-ext last))

(defn split-paths

"Splits a path list given as a string joined by the OS-specific path-separator into a vec of paths.

[^String joined-paths]

(mapv path (.split joined-paths path-separator)))

(defn exec-paths

"Returns executable paths (using the PATH environment variable). Same

[]

(split-paths (System/getenv "PATH")))

(defn- filename-only?

"Returns true if `f` is exactly a file name (i.e. with no absolute or

[f]

(let [f-as-path (as-path f)]

(= f-as-path (.getFileName f-as-path))))

(defn which

"Returns Path to first executable `program` found in `:paths` `opt`, similar to the which Unix command.

([program] (which program nil))

([program opts]

(let [exts (if win?

(let [exts (or (:win-exts opts)

["com" "exe" "bat" "cmd"])

ext (extension program)]

(if (and ext (contains? (set exts) ext))

;; this program name already contains the expected extension so we

;; first search with that and then try the others to find e.g. foo.bat.cmd

(into [nil] exts)

exts))

[nil])

paths (or (:paths opts) (babashka.fs/exec-paths))

;; if program is exactly a file name, then search all the path entries

;; otherwise, only search relative to current directory (absolute paths will throw)

candidate-paths (if (filename-only? program)

paths

[nil])]

(loop [paths candidate-paths

results []]

(if (seq paths)

(let [p (first paths)

fs (loop [exts exts

candidates []]

(if (seq exts)

(let [ext (first exts)

program (str program (when ext (str "." ext)))

f (if (babashka.fs/relative? program)

(babashka.fs/path p program)

(babashka.fs/path program))]

(if (and (executable? f) (not (directory? f)))

(recur (rest exts)

(conj candidates f))

(recur (rest exts)

candidates)))

candidates))]

(if (seq fs)

(if (:all opts)

(recur (rest paths) (into results fs))

(first fs))

(recur (rest paths) results)))

(if (:all opts) results (first results)))))))

(defn which-all

"Returns every Path to `program` found in (`exec-paths`). See `which`."

([program] (which-all program nil))

([program opts]

(which program (assoc opts :all true))))

(defn starts-with?

"Returns true if path this starts with path other."

[this other]

(.startsWith (as-path this) (as-path other)))

(defn ends-with?

"Returns true if path this ends with path other."

[this other]

(.endsWith (as-path this) (as-path other)))

(defn- last-modified-1

"Returns max last-modified of regular file f. Returns 0 if file does not exist."

[f]

(if (exists? f)

(file-time->millis

(last-modified-time f))

0))

(defn- last-modified

"Returns max last-modified of f or of all files within f"

[f]

(if (exists? f)

(if (regular-file? f)

(last-modified-1 f)

(apply max 0

(map last-modified-1

(filter regular-file? (file-seq (file f))))))

0))

(defn- expand-file-set

[file-set]

(if (coll? file-set)

(mapcat expand-file-set file-set)

(filter regular-file? (file-seq (file file-set)))))

(defn modified-since

"Returns seq of regular files (non-directories, non-symlinks) from file-set that were modified since the anchor path.

[anchor file-set]

(let [lm (last-modified anchor)]

(map path (filter #(> (last-modified-1 %) lm) (expand-file-set file-set)))))

(defn unzip

"Unzips `zip-file` to `dest` directory (default `\".\"`).

([zip-file] (unzip zip-file "."))

([zip-file dest] (unzip zip-file dest nil))

([zip-file dest {:keys [replace-existing]}]

(let [output-path (as-path dest)

_ (create-dirs dest)

cp-opts (->copy-opts replace-existing nil nil nil)]

(with-open

[^InputStream fis

(if (instance? InputStream zip-file) zip-file

(Files/newInputStream (as-path zip-file) (into-array java.nio.file.OpenOption [])))

zis (ZipInputStream. fis)]

(loop []

(let [entry (.getNextEntry zis)]

(when entry

(let [entry-name (.getName entry)

new-path (.resolve output-path entry-name)]

(if (.isDirectory entry)

(create-dirs new-path)

(do

(create-dirs (parent new-path))

(Files/copy ^java.io.InputStream zis