Added QR code manager app

chandanankush · chandanankush · commit 6bbcea4a4bba · 2025-09-16T23:49:10.000+05:30
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3,10 +3,11 @@
 All notable changes to this project will be documented here.
 
 ## [Unreleased]
+- Folder-aware library management with CSV export/import preserving subfolders
+- File menu option to clear all saved QR files/folders with confirmation
 - Export/copy QR image
 - Adjustable size and correction level
 
 ## [0.1.0] - 2025-09-12
 - Initial public structure and docs
 - Basic SwiftUI app to generate QR from text
-
diff --git a/QRCodeGenerator/QRCodeGenerator/ContentView.swift b/QRCodeGenerator/QRCodeGenerator/ContentView.swift
diff --git a/QRCodeGenerator/QRCodeGenerator/FileManagement.swift b/QRCodeGenerator/QRCodeGenerator/FileManagement.swift
@@ -24,6 +24,8 @@ struct FileNode: Identifiable, Hashable {
 enum FileScanner {
     static let allowedExtensions: Set<String> = ["txt", "qr", "qrtext"]
 
+    // MARK: - Directory tree helpers
+
     static func buildTree(at root: URL) -> FileNode? {
         let fm = FileManager.default
         var isDir: ObjCBool = false
@@ -66,5 +68,44 @@ enum FileScanner {
         try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
         try text.data(using: .utf8)?.write(to: url)
     }
-}
 
+    // MARK: - Name sanitization
+
+    static func sanitizeFileComponent(_ name: String) -> String {
+        var base = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        base = base.replacingOccurrences(of: "\\s+", with: "_", options: .regularExpression)
+            .replacingOccurrences(of: "[\\\\/:*?\"<>|]", with: "-", options: .regularExpression)
+        return base
+    }
+
+    static func ensureAllowedExtension(for filename: String) -> String {
+        let url = URL(fileURLWithPath: filename)
+        let ext = url.pathExtension.lowercased()
+        if allowedExtensions.contains(ext) {
+            return url.lastPathComponent
+        }
+        let base = url.deletingPathExtension().lastPathComponent
+        return (base.isEmpty ? "QRText" : base) + ".txt"
+    }
+
+    static func sanitizedFileName(_ raw: String, fallback: String) -> String {
+        var candidate = sanitizeFileComponent(raw)
+        if candidate.isEmpty {
+            candidate = sanitizeFileComponent(fallback)
+        }
+        return ensureAllowedExtension(for: candidate)
+    }
+
+    static func sanitizeFolderComponent(_ name: String) -> String {
+        var base = name.trimmingCharacters(in: .whitespacesAndNewlines)
+        if base == "." || base == ".." { return "" }
+        base = base.replacingOccurrences(of: "\\s+", with: "_", options: .regularExpression)
+            .replacingOccurrences(of: "[\\\\/:*?\"<>|]", with: "-", options: .regularExpression)
+        return base
+    }
+
+    static func sanitizedFolderPath(_ rawPath: String) -> String {
+        let components = rawPath.split(separator: "/").map { sanitizeFolderComponent(String($0)) }.filter { !$0.isEmpty }
+        return components.joined(separator: "/")
+    }
+}
diff --git a/QRCodeGenerator/QRCodeGenerator/LibraryTransfer.swift b/QRCodeGenerator/QRCodeGenerator/LibraryTransfer.swift
@@ -9,12 +9,13 @@ import Foundation
 import AppKit
 
 struct QRItem {
-    let path: String // relative path within library (we use just filename for CSV schema)
+    let relativePath: String // relative file path within the library
     let text: String
 }
 
 extension Notification.Name {
     static let LibraryDidChange = Notification.Name("LibraryDidChange")
+    static let LibraryDidClear = Notification.Name("LibraryDidClear")
 }
 
 enum LibraryTransfer {
@@ -45,22 +46,24 @@ enum LibraryTransfer {
             if values?.isDirectory == true { continue }
             if FileScanner.allowedExtensions.contains(item.pathExtension.lowercased()),
                let text = try? String(contentsOf: item, encoding: .utf8) {
-                // Export using only filename for simplicity
-                let filename = item.lastPathComponent
-                results.append(QRItem(path: filename, text: text))
+                let relative = relativePath(for: item, root: root)
+                results.append(QRItem(relativePath: relative, text: text))
             }
         }
-        return results.sorted { $0.path.localizedCaseInsensitiveCompare($1.path) == .orderedAscending }
+        return results.sorted { $0.relativePath.localizedCaseInsensitiveCompare($1.relativePath) == .orderedAscending }
     }
 
     // Apply snapshot into library (overwrite existing files)
     static func applySnapshot(_ items: [QRItem]) throws {
         guard let root = appLibraryRoot() else { return }
         let fm = FileManager.default
         for item in items {
-            let dest = uniqueFileURL(root: root, preferredFilename: ensureAllowedExtensionForFilename(item.path))
+            let relativePath = sanitizedRelativePath(item.relativePath)
+            guard !relativePath.isEmpty else { continue }
+            let dest = uniqueFileURL(root: root, preferredRelativePath: relativePath)
             try fm.createDirectory(at: dest.deletingLastPathComponent(), withIntermediateDirectories: true)
-            try item.text.data(using: .utf8)?.write(to: dest)
+            guard let data = item.text.data(using: .utf8) else { continue }
+            try data.write(to: dest)
         }
         NotificationCenter.default.post(name: .LibraryDidChange, object: nil)
     }
@@ -97,6 +100,30 @@ enum LibraryTransfer {
         }
     }
 
+    static func clearLibrary() {
+        guard let root = appLibraryRoot() else { return }
+        let alert = NSAlert()
+        alert.messageText = "Delete all saved QR entries?"
+        alert.informativeText = "This removes every file and folder in the app library. This action cannot be undone."
+        alert.alertStyle = .warning
+        alert.addButton(withTitle: "Delete All")
+        alert.addButton(withTitle: "Cancel")
+        let response = alert.runModal()
+        if response == .alertFirstButtonReturn {
+            let fm = FileManager.default
+            do {
+                let contents = try fm.contentsOfDirectory(at: root, includingPropertiesForKeys: nil, options: [])
+                for item in contents {
+                    try fm.removeItem(at: item)
+                }
+                NotificationCenter.default.post(name: .LibraryDidClear, object: nil)
+                NotificationCenter.default.post(name: .LibraryDidChange, object: nil)
+            } catch {
+                NSSound.beep()
+            }
+        }
+    }
+
     private static func defaultExportName() -> String {
         let f = DateFormatter()
         f.locale = Locale(identifier: "en_US_POSIX")
@@ -114,23 +141,22 @@ enum LibraryTransfer {
     }
 
     private static func buildCSV(from items: [QRItem]) -> String {
-        // Simple, hand-editable schema: filename,text,order
-        // - No quoting required
-        // - Replace newlines in text with literal \n
-        var out = "filename,text,order\n"
+        var lines: [String] = []
+        lines.append(["folder", "filename", "text", "order"].map(csvEscape).joined(separator: ","))
         var order = 1
         for item in items {
-            var filename = URL(fileURLWithPath: item.path).lastPathComponent
-            // Avoid commas in filename to keep CSV very simple
-            filename = filename.replacingOccurrences(of: ",", with: "-")
-            let textEscaped = item.text
-                .replacingOccurrences(of: "\r\n", with: "\n")
-                .replacingOccurrences(of: "\r", with: "\n")
-                .replacingOccurrences(of: "\n", with: "\\n")
-            out += filename + "," + textEscaped + "," + String(order) + "\n"
+            let parts = splitRelativePath(item.relativePath)
+            let normalizedText = normalizeNewlines(item.text).replacingOccurrences(of: "\n", with: "\\n")
+            let fields = [
+                csvEscape(parts.folder),
+                csvEscape(parts.filename),
+                csvEscape(normalizedText),
+                csvEscape(String(order))
+            ]
+            lines.append(fields.joined(separator: ","))
             order += 1
         }
-        return out
+        return lines.joined(separator: "\n") + "\n"
     }
 
     private static func normalizeNewlines(_ s: String) -> String { s.replacingOccurrences(of: "\r\n", with: "\n").replacingOccurrences(of: "\r", with: "\n") }
@@ -193,61 +219,130 @@ enum LibraryTransfer {
 
     private static func parseCSVToItems(_ csv: String) -> [QRItem] {
         var rows = parseCSVRows(csv)
-        if let first = rows.first, first.count >= 2 {
-            let h0 = first[0].trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-            let h1 = first[1].trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-            if (h0 == "filename" && h1 == "text") { rows.removeFirst() }
+        guard !rows.isEmpty else { return [] }
+
+        var folderIndex: Int? = nil
+        var filenameIndex: Int = 0
+        var textStartIndex: Int = 1
+        var orderIndex: Int? = nil
+
+        if let first = rows.first {
+            let normalized = first.map { $0.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
+            if normalized.contains("filename") {
+                if let idx = normalized.firstIndex(of: "folder") { folderIndex = idx }
+                if let idx = normalized.firstIndex(of: "filename") { filenameIndex = idx }
+                if let idx = normalized.firstIndex(of: "text") {
+                    textStartIndex = idx
+                } else {
+                    textStartIndex = max(filenameIndex, folderIndex ?? filenameIndex) + 1
+                }
+                if let idx = normalized.firstIndex(of: "order") { orderIndex = idx }
+                rows.removeFirst()
+            }
         }
+
         var items: [QRItem] = []
         for row in rows {
             if row.isEmpty { continue }
-            let filenameRaw = row.first ?? ""
-            // Join the middle columns as text to support unquoted commas in text
-            var textRaw = ""
-            if row.count >= 3, Int(row.last!.trimmingCharacters(in: .whitespaces)) != nil {
-                textRaw = row[1..<(row.count-1)].joined(separator: ",")
-            } else if row.count >= 2 {
-                textRaw = row[1...].joined(separator: ",")
+
+            let filenameRaw: String
+            if filenameIndex < row.count {
+                filenameRaw = row[filenameIndex]
+            } else {
+                filenameRaw = row.first ?? ""
+            }
+
+            let folderRaw: String
+            if let folderIdx = folderIndex, folderIdx < row.count {
+                folderRaw = row[folderIdx]
+            } else {
+                folderRaw = ""
+            }
+
+            var orderColumn: Int? = nil
+            if let idx = orderIndex, idx < row.count,
+               Int(row[idx].trimmingCharacters(in: .whitespaces)) != nil {
+                orderColumn = idx
+            } else if let last = row.last,
+                      Int(last.trimmingCharacters(in: .whitespaces)) != nil,
+                      row.count > max(filenameIndex, (folderIndex ?? -1)) + 1 {
+                orderColumn = row.count - 1
+            }
+
+            let textStartCandidate = max(textStartIndex, max(filenameIndex + 1, (folderIndex ?? -1) + 1))
+            let startIndex = min(textStartCandidate, row.count)
+            var endIndex = row.count
+            if let orderIdx = orderColumn {
+                endIndex = min(orderIdx, row.count)
+            }
+            if startIndex >= endIndex { continue }
+            let textFields = row[startIndex..<endIndex]
+            let textRaw = textFields.joined(separator: ",")
+
+            let sanitizedFolder = FileScanner.sanitizedFolderPath(folderRaw)
+            let fallbackName = filenameRaw.isEmpty ? "Imported" : filenameRaw
+            let sanitizedFile = FileScanner.sanitizedFileName(filenameRaw, fallback: fallbackName)
+            let relativePath: String
+            if sanitizedFolder.isEmpty {
+                relativePath = sanitizedFile
             } else {
-                continue
+                relativePath = sanitizedFolder + "/" + sanitizedFile
             }
-            let filename = sanitizeFilename(ensureAllowedExtensionForFilename(filenameRaw))
-            guard !filename.isEmpty else { continue }
             let text = textRaw.replacingOccurrences(of: "\\n", with: "\n")
-            items.append(QRItem(path: filename, text: text))
+            items.append(QRItem(relativePath: relativePath, text: text))
         }
         return items
     }
 
-    private static func sanitizeFilename(_ name: String) -> String {
-        var base = name.trimmingCharacters(in: .whitespacesAndNewlines)
-        // remove any path components
-        base = URL(fileURLWithPath: base).lastPathComponent
-        if base.isEmpty { return "" }
-        // replace illegal filename characters and commas
-        base = base.replacingOccurrences(of: "[\\\\/:*?\"<>|,]", with: "-", options: .regularExpression)
-        return base
-    }
-
-    private static func ensureAllowedExtensionForFilename(_ name: String) -> String {
-        let url = URL(fileURLWithPath: name)
-        let ext = url.pathExtension.lowercased()
-        if FileScanner.allowedExtensions.contains(ext) { return url.lastPathComponent }
-        if ext.isEmpty { return url.lastPathComponent + ".txt" }
-        return url.deletingPathExtension().lastPathComponent + ".txt"
-    }
-
-    private static func uniqueFileURL(root: URL, preferredFilename: String) -> URL {
-        var url = root.appendingPathComponent(preferredFilename)
+    private static func uniqueFileURL(root: URL, preferredRelativePath: String) -> URL {
+        let initial = URL(fileURLWithPath: preferredRelativePath, relativeTo: root).standardizedFileURL
         let fm = FileManager.default
-        if !fm.fileExists(atPath: url.path) { return url }
-        let base = url.deletingPathExtension().lastPathComponent
-        let ext = url.pathExtension
+        if !fm.fileExists(atPath: initial.path) { return initial }
+        let directory = initial.deletingLastPathComponent()
+        let ext = initial.pathExtension
+        let base = initial.deletingPathExtension().lastPathComponent
         var i = 1
         while true {
-            let candidate = root.appendingPathComponent("\(base)-\(i).\(ext)")
+            let candidateName = ext.isEmpty ? "\(base)-\(i)" : "\(base)-\(i).\(ext)"
+            let candidate = directory.appendingPathComponent(candidateName)
             if !fm.fileExists(atPath: candidate.path) { return candidate }
             i += 1
         }
     }
+
+    private static func relativePath(for url: URL, root: URL) -> String {
+        let absolute = url.standardizedFileURL.path
+        let rootPath = root.standardizedFileURL.path
+        if absolute.hasPrefix(rootPath) {
+            var relative = String(absolute.dropFirst(rootPath.count))
+            if relative.hasPrefix("/") { relative.removeFirst() }
+            return relative
+        }
+        return url.lastPathComponent
+    }
+
+    private static func splitRelativePath(_ relativePath: String) -> (folder: String, filename: String) {
+        if let range = relativePath.range(of: "/", options: .backwards) {
+            let folder = String(relativePath[..<range.lowerBound])
+            let filename = String(relativePath[range.upperBound...])
+            return (folder, filename)
+        }
+        return ("", relativePath)
+    }
+
+    private static func sanitizedRelativePath(_ raw: String) -> String {
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.isEmpty {
+            return FileScanner.sanitizedFileName("Imported", fallback: "Imported")
+        }
+        let components = trimmed.split(separator: "/").map(String.init)
+        guard let fileComponent = components.last else {
+            return FileScanner.sanitizedFileName("Imported", fallback: "Imported")
+        }
+        let folderComponents = components.dropLast().map { FileScanner.sanitizeFolderComponent($0) }.filter { !$0.isEmpty }
+        let sanitizedFile = FileScanner.sanitizedFileName(fileComponent, fallback: fileComponent.isEmpty ? "Imported" : fileComponent)
+        var parts = folderComponents
+        parts.append(sanitizedFile)
+        return parts.joined(separator: "/")
+    }
 }
diff --git a/QRCodeGenerator/QRCodeGenerator/QRCodeGeneratorApp.swift b/QRCodeGenerator/QRCodeGenerator/QRCodeGeneratorApp.swift
@@ -18,6 +18,8 @@ struct QRCodeGeneratorApp: App {
             CommandGroup(after: .importExport) {
                 Button("Import Library…") { LibraryTransfer.importLibrary() }
                 Button("Export Library…") { LibraryTransfer.exportLibrary() }
+                Divider()
+                Button("Clear Library…", role: .destructive) { LibraryTransfer.clearLibrary() }
             }
         }
     }
diff --git a/README.md b/README.md
@@ -16,9 +16,9 @@ TextToQR renders a QR code for any text you type. It uses the `CIQRCodeGenerator
 ## Features
 
 - App-managed storage: files saved under Application Support in the app container (no folder selection)
-- Folder-based management within the app’s library; browse subfolders/files
+- Folder-based management within the app’s library; create subfolders, browse, and save into them
 - Load/save QR texts as files (`.txt`, `.qr`, `.qrtext`)
-- Export/Import the entire library as a single `.csv` file (File menu)
+- Export/Import the entire library as a single `.csv` file and clear the saved library from the File menu
 - Edit and generate QR without saving; choose to Save or Save As later
 - Live preview as you type (no Render button)
 - Core Image–based QR generation with error correction
@@ -32,7 +32,7 @@ TextToQR renders a QR code for any text you type. It uses the `CIQRCodeGenerator
 - Start typing to generate a QR without saving; click Save or Save As to persist within the app library.
 - Or select a file to load and regenerate its QR; edit and Save to update that file.
 - Use File → Export Library… to save a snapshot (`.csv`), and File → Import Library… to merge from a snapshot.
-  - CSV schema (simple): header `filename,text,order`. Each row has the filename only (no folders), the QR text, and a serial number for readability. Fields are quoted and quotes inside a field are doubled.
+  - CSV schema: header `folder,filename,text,order`. `folder` is a relative path inside the library (blank for the root). Text is stored with literal `\n`, and `order` preserves the display ordering.
 
 See `docs/DEVELOPMENT.md` for detailed setup instructions.
 
diff --git a/docs/PROJECT_CONTEXT.md b/docs/PROJECT_CONTEXT.md

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,8 @@ struct QRCodeGeneratorApp: App {`
`18`	`18`	`CommandGroup(after: .importExport) {`
`19`	`19`	`Button("Import Library…") { LibraryTransfer.importLibrary() }`
`20`	`20`	`Button("Export Library…") { LibraryTransfer.exportLibrary() }`
	`21`	`+ Divider()`
	`22`	`+ Button("Clear Library…", role: .destructive) { LibraryTransfer.clearLibrary() }`
`21`	`23`	`}`
`22`	`24`	`}`
`23`	`25`	`}`