shows all attributes for a given path

(attributes “project.clj”) ;; {:owner “chris”, ;; :group “staff”, ;; :permissions “rw-r–r–”, ;; :file-key “(dev=1000004,ino=2351455)”, ;; :ino 2351455, ;; :is-regular-file true. ;; :is-directory false, :uid 501, ;; :is-other false, :mode 33188, :size 4342, ;; :gid 20, :ctime 1476755481000, ;; :nlink 1, ;; :last-access-time 1476755481000, ;; :is-symbolic-link false, ;; :last-modified-time 1476755481000, ;; :creation-time 1472282953000, ;; :dev 16777220, :rdev 0} => map

copies all specified files from one to another

(copy “src” “.src” {:include “.clj”}) => map?

(delete “.src”)

copies a single file to a destination

(copy-into “src/std/fs.clj” “test-scratch/std.fs”) => vector?

(delete “test-scratch/std.fs”)

copies a single file to a destination

(copy-single “project.clj” “test-scratch/project.clj.bak” {:options #{:replace-existing}}) => (path/path “.” “test-scratch/project.clj.bak”)

(delete “test-scratch/project.clj.bak”)

creates a directory on the filesystem

(do (create-directory “test-scratch/.hello/.world/.foo”) (path/directory? “test-scratch/.hello/.world/.foo”)) => true

(delete “test-scratch/.hello”)

creates a symlink to another file

(do (create-symlink “test-scratch/project.lnk” “project.clj”) (path/link? “test-scratch/project.lnk”)) => true

creates a temp directory on the filesystem

(create-tmpdir) ;;=> #path:“/var/folders/d6/yrjldmsd4jd1h0nm970wmzl40000gn/T/4870108199331749225”

creates a tempory file

(create-tmpfile) ;;#file:“/var/folders/rc/4nxjl26j50gffnkgm65ll8gr0000gp/T/tmp2270822955686495575” => java.io.File

copies all specified files from one to another

(do (copy “src/std/fs.clj” “.src/std/fs.clj”) (delete “.src” {:include “fs.clj”})) => #{(str (path/path “.src/std/fs.clj”))}

(delete “.src”) => set?

checks whether a file is a directory

(directory? “src”) => true

(directory? “project.clj”) => false

checks if a directory is empty, returns true if both are true

(empty-directory? “.”) => false

checks whether a file is executable

(executable? “project.clj”) => boolean?

(executable? “/usr/bin/whoami”) => true

checks whether a file exists

(exists? “project.clj”) => true

(exists? “NON.EXISTENT”) => false

returns the input as a file

(file “project.clj”) => java.io.File

converts a file string to an ns string

(file->ns “std/fs_test”) => “std.fs-test”

returns the last section of the path

(str (file-name “src/hara”)) => “hara”

reads the namespace of the given path

(file-namespace “src/std/fs.clj”) => ’std.fs

encodes the type of file as a keyword

(file-suffix “hello.clj”) => :clj

(file-suffix “hello.java”) => :java

returns the filesystem governing the path

(file-system “.”) ;; #object[sun.nio.fs.MacOSXFileSystem 0x512a9870 “sun.nio.fs.MacOSXFileSystem@512a9870”] => java.nio.file.FileSystem

checks whether a file is not a link or directory

(file? “project.clj”) => true

(file? “src”) => false

gets the namespace given forms

checks whether a file is hidden

(hidden? “.gitignore”) => true

(hidden? “project.clj”) => false

opens a file as an input-stream

(input-stream “project.clj”)

returns the last modified time as a long

(last-modified “project.clj”) => integer?

checks whether a file is a link

(link? “project.clj”) => false

(link? (api/create-symlink “project.lnk” “project.clj”)) => true (api/delete “project.lnk”)

lists the files and attributes for a given directory

(list “src”)

(list “../hara/src/std/fs” {:recursive true})

moves a file or directory

(do (move “shortlist” “.shortlist”) (move “.shortlist” “shortlist”))

(move “.non-existent” “.moved”) => {}

creates a string that takes notice of the user home

(normalise “.”) => (str common/cwd “/” “.”)

(normalise “~/hello/world.txt”) => (str common/home “/hello/world.txt”)

(normalise “/usr/home”) => “/usr/home”

converts an ns string to a file string

(ns->file ’std.fs-test) => “std/fs_test”

returns the nth segment of a given path

(str (nth-segment “/usr/local/bin” 1)) => “local”

shows all options for file operations

(option) => (contains :atomic-move :create-new :skip-siblings :read :continue :create :terminate :copy-attributes :append :truncate-existing :sync :follow-links :delete-on-close :write :dsync :replace-existing :sparse :nofollow-links :skip-subtree)

(option :read) => java.nio.file.StandardOpenOption/READ

opens a file as an output-stream

(output-stream “project.clj”)

returns the parent of the given path

(str (parent “/usr/local/bin”)) => “/usr/local”

creates a `java.nio.file.Path object

checks to see if the object is of type Path

(path? (path “/home”)) => true

returns the permissions for a given file

(permissions “src”) => “rwxr-xr-x”

opens a file and reads the contents as a byte array

(read-all-bytes “project.clj”)

opens a file and reads the contents as an array of lines

(read-all-lines “project.clj”)

takes a file and returns a lazy seq of top-level forms

(->> (read-code “src/std/fs.clj”) first (take 2)) => ’(ns std.fs)

checks whether a file is readable

(readable? “project.clj”) => true

returns one path relative to another

(str (relativize “test” “src/hara”)) => “../src/hara”

returns the root path

(str (root “/usr/local/bin”)) => “/”

path object without normalisation

(str (section “project.clj”)) => “project.clj”

(str (section “src” “hara/time.clj”)) => “src/hara/time.clj”

returns the number of segments of a given path

(segment-count “/usr/local/bin”) => 3

selects all the files in a directory

(->> (select “src/std/fs”) (map #(path/relativize “std/fs” %)) (map str) (sort))

sets all attributes for a given path

(set-attributes “project.clj” {:owner “chris”, :group “staff”, :permissions “rw-rw-rw-”}) ;;=> #path:“/Users/chris/Development/chit/lucidity/project.clj”

sets a file to be executable

returns the subpath of a given path

(str (subpath “/usr/local/bin/hello” 1 3)) => “local/bin”

creates a java.io.File object

(to-file (section “project.clj”)) => (all java.io.File #(-> % str (= “project.clj”)))

returns the shorthand string for a given entry

(typestring “src”) => “d”

(typestring “project.clj”) => “-”

checks whether a file is writable

(writable? “project.clj”) => true

writes a byte-array to file

(write-all-bytes “hello.txt” (.getBytes “Hello World”))

writes a stream to a path

(write-into “project.clj” (java.io.FileInputStream. “project.clj”) {:options #{:replace-existing}})