Initial commit

skills/babashka.fs/examples.clj

@@ -0,0 +1,172 @@
+#!/usr/bin/env bb
+;; Comprehensive babashka.fs examples
+;; Run with: bb examples.clj
+
+(ns fs-examples
+  (:require [babashka.fs :as fs]
+            [clojure.string :as str]))
+
+(println "\n=== BABASHKA.FS EXAMPLES ===\n")
+
+;; Example 1: Basic file operations
+(println "1. Basic File Operations")
+(fs/with-temp-dir [tmp {}]
+  (let [test-file (fs/path tmp "test.txt")]
+    (spit test-file "Hello, babashka.fs!")
+    (println "  Created:" test-file)
+    (println "  Exists?" (fs/exists? test-file))
+    (println "  Is file?" (fs/regular-file? test-file))
+    (println "  Size:" (fs/size test-file) "bytes")
+    (println "  Content:" (slurp test-file))))
+
+;; Example 2: Directory listing and filtering
+(println "\n2. Finding Clojure Source Files")
+(let [clj-files (->> (fs/glob "." "*.{clj,md}")
+                     (map str)
+                     (take 5))]
+  (println "  Found files:")
+  (doseq [f clj-files]
+    (println "   -" f)))
+
+;; Example 3: Creating directory structure
+(println "\n3. Creating Directory Structure")
+(fs/with-temp-dir [tmp {}]
+  (let [nested-dir (fs/path tmp "a" "b" "c")]
+    (fs/create-dirs nested-dir)
+    (println "  Created nested directories:" nested-dir)
+    (println "  Directory exists?" (fs/directory? nested-dir))))
+
+;; Example 4: Copying and moving files
+(println "\n4. Copy and Move Operations")
+(fs/with-temp-dir [tmp {}]
+  (let [src (fs/path tmp "source.txt")
+        dest (fs/path tmp "destination.txt")
+        moved (fs/path tmp "moved.txt")]
+    (spit src "Original content")
+    (fs/copy src dest)
+    (println "  Copied:" src "→" dest)
+    (println "  Both exist?" (and (fs/exists? src) (fs/exists? dest)))
+    (fs/move dest moved)
+    (println "  Moved:" dest "→" moved)
+    (println "  Dest exists?" (fs/exists? dest))
+    (println "  Moved exists?" (fs/exists? moved))))
+
+;; Example 5: Working with paths
+(println "\n5. Path Manipulation")
+(let [path "src/project/core.clj"]
+  (println "  Original path:" path)
+  (println "  File name:" (fs/file-name path))
+  (println "  Extension:" (fs/extension path))
+  (println "  Parent:" (fs/parent path))
+  (println "  Without ext:" (fs/strip-ext path))
+  (println "  Absolute:" (str (fs/absolutize path))))
+
+;; Example 6: File metadata
+(println "\n6. File Metadata")
+(let [this-file *file*]
+  (when (and this-file (fs/exists? this-file))
+    (println "  This script:" this-file)
+    (println "  Size:" (fs/size this-file) "bytes")
+    (println "  Modified:" (fs/last-modified-time this-file))
+    (println "  Readable?" (fs/readable? this-file))
+    (println "  Writable?" (fs/writable? this-file))
+    (println "  Executable?" (fs/executable? this-file))))
+
+;; Example 7: Finding executable in PATH
+(println "\n7. Finding Executables")
+(when-let [bb-path (fs/which "bb")]
+  (println "  Found bb at:" bb-path))
+(when-let [git-path (fs/which "git")]
+  (println "  Found git at:" git-path))
+
+;; Example 8: Glob patterns
+(println "\n8. Glob Pattern Matching")
+(fs/with-temp-dir [tmp {}]
+  ;; Create some test files
+  (doseq [file ["data.json" "config.edn" "test.clj" 
+                "README.md" "nested/deep.txt"]]
+    (let [path (fs/path tmp file)]
+      (fs/create-dirs (fs/parent path))
+      (spit path "test")))
+  
+  (println "  All files:")
+  (doseq [f (fs/glob tmp "**/*")]
+    (when (fs/regular-file? f)
+      (println "   -" (fs/relativize tmp f))))
+  
+  (println "  Just .clj and .edn files:")
+  (doseq [f (fs/glob tmp "**/*.{clj,edn}")]
+    (println "   -" (fs/relativize tmp f))))
+
+;; Example 9: Recursive directory walking
+(println "\n9. Walking Directory Tree")
+(fs/with-temp-dir [tmp {}]
+  ;; Create structure
+  (doseq [dir ["a" "a/b" "a/b/c"]]
+    (fs/create-dirs (fs/path tmp dir))
+    (spit (fs/path tmp dir "file.txt") "test"))
+  
+  (println "  Directory structure:")
+  (fs/walk-file-tree tmp
+    {:pre-visit-dir (fn [path _]
+                      (let [depth (count (fs/components 
+                                          (fs/relativize tmp path)))]
+                        (println (str (apply str (repeat depth "  "))
+                                     "📁 " (fs/file-name path))))
+                      :continue)
+     :visit-file (fn [path _]
+                   (let [depth (count (fs/components 
+                                       (fs/relativize tmp path)))]
+                     (println (str (apply str (repeat depth "  "))
+                                  "📄 " (fs/file-name path))))
+                   :continue)}))
+
+;; Example 10: File filtering pipeline
+(println "\n10. File Filtering Pipeline")
+(fs/with-temp-dir [tmp {}]
+  ;; Create test files with different sizes
+  (doseq [[name content] [["small.txt" "x"]
+                          ["medium.txt" (apply str (repeat 100 "x"))]
+                          ["large.txt" (apply str (repeat 1000 "x"))]]]
+    (spit (fs/path tmp name) content))
+  
+  (let [files (->> (fs/list-dir tmp)
+                   (filter fs/regular-file?)
+                   (map (fn [path]
+                          {:name (fs/file-name path)
+                           :size (fs/size path)}))
+                   (sort-by :size))]
+    (println "  Files by size:")
+    (doseq [{:keys [name size]} files]
+      (println (format "   - %s: %d bytes" name size)))))
+
+;; Example 11: XDG directories (Unix/Linux)
+(println "\n11. XDG Base Directories")
+(try
+  (println "  Config home:" (fs/xdg-config-home))
+  (println "  Data home:" (fs/xdg-data-home))
+  (println "  Cache home:" (fs/xdg-cache-home))
+  (println "  App config:" (fs/xdg-config-home "myapp"))
+  (catch Exception _
+    (println "  (XDG directories not available on this platform)")))
+
+;; Example 12: Temporary files and cleanup
+(println "\n12. Temporary File Management")
+(let [temp-file (fs/create-temp-file {:prefix "demo-" 
+                                        :suffix ".txt"})]
+  (println "  Created temp file:" temp-file)
+  (spit temp-file "Temporary data")
+  (println "  Content:" (slurp temp-file))
+  (fs/delete temp-file)
+  (println "  Deleted:" (not (fs/exists? temp-file))))
+
+(println "\n13. Working with temp directory context")
+(fs/with-temp-dir [tmp-dir {:prefix "work-"}]
+  (println "  Working in:" tmp-dir)
+  (let [work-file (fs/path tmp-dir "work.txt")]
+    (spit work-file "work data")
+    (println "  Created file:" work-file)
+    (println "  File exists:" (fs/exists? work-file)))
+  (println "  (Directory will be deleted after this block)"))
+
+(println "\n=== All examples completed! ===\n")