re-add old logic and update readme

README.md

···
 # StorageKit
 
-### WARNING
-This package is subject to change a lot. If you want to use this it probably makes sense to copy and paste the code (it is only 1 file with 82 lines of code).   
+# StorageKit
 
-Sometimes Core Data or SQLite are overkill for your app. In those situations, StorageKit is a great solution to save `Codable` objects to disk.
+Sometimes Core Data or SQLite are overkill for your app. StorageKit saves `Codable` objects or raw `Data` to disk in the app sandbox.
 
 ## Install StorageKit
 
-StorageKit currently only supports installation via Swift Package Manager. 
-
-### Add Package Dependency
-In Xcode, select `File` > `Add Packages...`.
+StorageKit currently only supports installation via Swift Package Manager.
 
-### Specify the Repository
-Copy and paste the following into the search/input box.
-`https://github.com/SparrowTek/StorageKit.git`
-
-### Specify Options
-In the options for the StorageKit package, we recommend setting the Dependency Rule to Up to Next Major Version, and enter the 
-current StorageKit version. Then, click `Add Package`.
-
-### Select the Package Products
-Select `StorageKit`, then click Add Package.
+- In Xcode, select `File` > `Add Packages...`.
+- Enter `https://github.com/SparrowTek/StorageKit.git`.
+- Set the dependency rule (e.g. Up to Next Major Version) and add the `StorageKit` product.
 
 ## Getting started
-First import StorageKit
 
 ```swift
 import StorageKit
-```
-
-For any `Codable` object save and retrieve from disk.
 
-```swift
 struct User: Codable {
     let name: String
     let id: Int
 }
 ```
 
-### Store
+`Storage.Directory` supports `.documents` and `.caches`. All `store` functions overwrite any existing file with the same name. You can customize file protection via the optional `writingOptions` parameter (defaults to `.completeFileProtection`).
+
+### Store a Codable value
 ```swift
 do {
     let user = User(name: "Thomas", id: 123)
     try Storage.store(user, to: .documents, as: "user.json")
 } catch {
-    // TODO: handle error
+    // handle StorageError.createURL, StorageError.removeObject, or file write errors
 }
 ```
 
-### retrieve
+Pass a custom `JSONEncoder` or `writingOptions` if needed:
+```swift
+let encoder = JSONEncoder()
+encoder.dateEncodingStrategy = .iso8601
+try Storage.store(user,
+                  to: .documents,
+                  as: "user.json",
+                  encoder: encoder,
+                  writingOptions: .noFileProtection)
+```
+
+### Store raw Data
+```swift
+let data = Data([0x01, 0x02])
+try Storage.store(data, to: .caches, as: "bytes.bin", writingOptions: .completeFileProtectionUnlessOpen)
+```
+
+### Retrieve a Codable value
+`retrieve` returns an optional decoded value. Supply a `JSONDecoder` if you need custom settings.
 ```swift
 let user = Storage.retrieve("user.json", from: .documents, as: User.self)
 ```
 
-### delete
+### Delete a file
 ```swift
-do {
-    try Storage.remove("user.json", from: .documents)
-} catch {
-    // TODO: handle error
-}
+try Storage.remove("user.json", from: .documents)
 ```
 
-### does a file exist?
+### Check existence
 ```swift
 let exists = Storage.fileExists("user.json", in: .documents)
 ```
+
+### Clear a directory
+Removes every file in the chosen directory. Throws `StorageError.clearDirectory(failedURLs:)` if any removals fail.
+```swift
+try Storage.clear(.caches)
+```

Sources/StorageKit/StorageKit.swift

···
 public enum StorageError: Error {
     case createURL
     case removeObject
-    case clearDirectory
-    case createURLError
+    case clearDirectory(failedURLs: [URL])
 }
 
 public struct Storage {
···
     }
     
     /// Returns URL constructed from specified directory
-    private static func getURL(for directory: Directory, fileManager: FileManager) throws -> URL {
+    private static func getURL(for directory: Directory,
+                               fileManager: FileManager) throws -> URL {
         let searchPathDirectory: FileManager.SearchPathDirectory = switch directory {
         case .documents: .documentDirectory
         case .caches: .cachesDirectory
         }
         
-        guard let url = fileManager.urls(for: searchPathDirectory, in: .userDomainMask).first else { throw StorageError.createURLError }
+        guard let url = fileManager.urls(for: searchPathDirectory, in: .userDomainMask).first else { throw StorageError.createURL }
         return url
     }
     
···
     ///     - directory: `Directory` to look in
     ///     - fileManager: An optional FileManager` argument. Defaults to `FileManager.default`
     ///  - Returns: an optional `URL`
-    public static func url(for fileName: String, in directory: Directory, fileManager: FileManager = .default) -> URL? {
+    public static func url(for fileName: String,
+                           in directory: Directory,
+                           fileManager: FileManager = .default) -> URL? {
         try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false)
     }
     
+    /// Store Data to the specified directory on disk
+    ///
+    /// - Paramete\rs:
+    ///   - data: the data to store
+    ///   - directory: where to store the struct
+    ///   - fileName: what to name the file where the struct data will be stored
+    ///   - fileManager: An optional FileManager` argument. Defaults to `FileManager.default`
+    public static func store(_ data: Data,
+                             to directory: Directory,
+                             as fileName: String,
+                             fileManager: FileManager = .default,
+                             writingOptions: Data.WritingOptions = .completeFileProtection) throws {
+        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { throw StorageError.createURL }
+        
+        if fileExists(fileName, in: directory) {
+            try remove(fileName, from: directory)
+        }
+        
+        try data.write(to: url, options: writingOptions)
+    }
+    
     /// Store an encodable struct to the specified directory on disk
     ///
     /// - Parameters:
-    ///   - data: the data to store
+    ///   - object: the encodable struct to store
     ///   - directory: where to store the struct
     ///   - fileName: what to name the file where the struct data will be stored
     ///   - fileManager: An optional FileManager` argument. Defaults to `FileManager.default`
-    public static func store(_ data: Data, to directory: Directory, as fileName: String, fileManager: FileManager = .default) throws {
-        guard !fileExists(fileName, in: directory) else { return }
-        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { throw StorageError.createURLError }
-        try data.write(to: url, options: .completeFileProtection)
+    public static func store<T: Encodable>(_ object: T,
+                                           to directory: Directory,
+                                           as fileName: String,
+                                           encoder: JSONEncoder = JSONEncoder(),
+                                           fileManager: FileManager = .default,
+                                           writingOptions: Data.WritingOptions = .completeFileProtection) throws {
+        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { throw StorageError.createURL }
+        let data = try encoder.encode(object)
+        try store(data, to: directory, as: fileName, fileManager: fileManager, writingOptions: writingOptions)
+    }
+    
+    /// Retrieve and convert a struct from a file on disk
+    ///
+    /// - Parameters:
+    ///   - fileName: name of the file where struct data is stored
+    ///   - directory: directory where struct data is stored
+    ///   - type: struct type (i.e. Message.self)
+    /// - Returns: decoded struct model(s) of data
+    public static func retrieve<T: Decodable>(_ fileName: String,
+                                              from directory: Directory,
+                                              as type: T.Type,
+                                              decoder: JSONDecoder = JSONDecoder(),
+                                              fileManager: FileManager = .default) -> T? {
+        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { return nil }
+        guard fileManager.fileExists(atPath: url.path) else { return nil }
+        guard let data = fileManager.contents(atPath: url.path) else { return nil }
+        
+        return try? decoder.decode(type, from: data)
     }
     
     /// Remove specified file from specified directory
-    public static func remove(_ fileName: String, from directory: Directory, fileManager: FileManager = .default) throws {
-        guard !fileExists(fileName, in: directory) else { return }
-        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { throw StorageError.createURLError }
+    public static func remove(_ fileName: String,
+                              from directory: Directory,
+                              fileManager: FileManager = .default) throws {
+        guard fileExists(fileName, in: directory) else { return }
+        guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { throw StorageError.createURL }
         
         do {
             try fileManager.removeItem(at: url)
···
     }
     
     /// - Returns: `Bool` indicating whether file exists at specified directory with specified file name
-    public static func fileExists(_ fileName: String, in directory: Directory, fileManager: FileManager = .default) -> Bool {
+    public static func fileExists(_ fileName: String,
+                                  in directory: Directory,
+                                  fileManager: FileManager = .default) -> Bool {
         guard let url = try? getURL(for: directory, fileManager: fileManager).appendingPathComponent(fileName, isDirectory: false) else { return false }
         return fileManager.fileExists(atPath: url.path)
     }
     
     /// Remove all files at specified directory
-    public static func clear(_ directory: Directory, fileManager: FileManager = .default) throws {
-        guard let url = try? getURL(for: directory, fileManager: fileManager) else { return }
+    public static func clear(_ directory: Directory,
+                             fileManager: FileManager = .default) throws {
+        let url = try getURL(for: directory, fileManager: fileManager)
         let contents = try fileManager.contentsOfDirectory(at: url, includingPropertiesForKeys: nil, options: [])
+        var failedURLs: [URL] = []
         
         for fileUrl in contents {
-            try fileManager.removeItem(at: fileUrl)
+            do {
+                try fileManager.removeItem(at: fileUrl)
+            } catch {
+                failedURLs.append(fileUrl)
+                continue
+            }
+        }
+        
+        
+        if !failedURLs.isEmpty {
+            throw StorageError.clearDirectory(failedURLs: failedURLs)
         }
     }
 }