init

Author: nerzh

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,24 @@
+// swift-tools-version:5.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "FileUtils",
+    products: [
+        .library(
+            name: "FileUtils",
+            targets: ["FileUtils"]),
+    ],
+    dependencies: [
+        // .package(url: /* package url */, from: "1.0.0"),
+    ],
+    targets: [
+        .target(
+            name: "FileUtils",
+            dependencies: []),
+        .testTarget(
+            name: "FileUtilsTests",
+            dependencies: ["FileUtils"]),
+    ]
+)

Package.swift

@@ -0,0 +1,3 @@
+# FileUtils
+
+A description of this package.

README.md

@@ -0,0 +1,58 @@
+//
+//  FileReader.swift
+//  
+//
+//  Created by Oleh Hudeichuk on 26.06.2020.
+//
+
+import Foundation
+
+class FileReader {
+
+    let fileURL: URL
+    private var file: UnsafeMutablePointer<FILE>? = nil
+
+    init(fileURL: URL) {
+        self.fileURL = fileURL
+    }
+
+    init(filePath: String) {
+        guard let fileURL: URL = URL(string: filePath) else { fatalError("Can't convert path \(filePath) to URL") }
+        self.fileURL = fileURL
+    }
+
+    deinit {
+        if self.file != nil { fatalError("Please, close file descriptor.") }
+    }
+
+    func open() throws {
+        guard let descriptor = fopen(fileURL.path, "r") else {
+            throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno), userInfo: nil)
+        }
+        self.file = descriptor
+    }
+
+    func close() {
+        if let descriptor = self.file {
+            self.file = nil
+            let success: Bool = fclose(descriptor) == 0
+            assert(success)
+        }
+    }
+
+    func readLine(maxLength: Int = 4096) throws -> String? {
+        guard let descriptor = self.file else {
+            throw NSError(domain: NSPOSIXErrorDomain, code: Int(EBADF), userInfo: nil)
+        }
+        var buffer = [CChar](repeating: 0, count: maxLength)
+        guard fgets(&buffer, Int32(maxLength), descriptor) != nil else {
+            if feof(descriptor) != 0 {
+                return nil
+            } else {
+                throw NSError(domain: NSPOSIXErrorDomain, code: Int(errno), userInfo: nil)
+            }
+        }
+
+        return String(cString: buffer)
+    }
+}

Sources/FileUtils/FileReader.swift

@@ -0,0 +1,102 @@
+import Foundation
+
+
+public class FileUtils {}
+
+public extension FileUtils {
+
+    class func clearFile(_ url: URL?) {
+        clearFile(url?.path)
+    }
+
+    class func clearFile(_ path: String?) {
+        guard let path = path else { return }
+        do {
+            try "".write(to: URL(fileURLWithPath: path), atomically: true, encoding: .utf8)
+        } catch {
+            fatalError("CLEAR FILE: Can't write to file \(path)")
+        }
+    }
+
+    class func createFile(_ url: URL?) {
+        createFile(url?.path)
+    }
+
+    class func createFile(_ path: String?) {
+        guard let path = path else { return }
+        FileManager.default.createFile(atPath: path, contents: nil, attributes: nil)
+    }
+
+    class func urls(for directory: FileManager.SearchPathDirectory, skipsHiddenFiles: Bool = true ) -> [URL] {
+        var fileURLs: [URL] = .init()
+
+        if let documentsURL = FileManager.default.urls(for: directory, in: .userDomainMask).first {
+            do {
+                fileURLs = try FileManager.default.contentsOfDirectory(at: documentsURL,
+                                                                       includingPropertiesForKeys: nil,
+                                                                       options: skipsHiddenFiles ? [.skipsHiddenFiles] : [] )
+            } catch {}
+        }
+
+        return fileURLs
+    }
+
+    class func urls(for directory: String, skipsHiddenFiles: Bool = true ) -> [URL] {
+        guard let documentsURL = URL(string: directory) else { return [] }
+        return urls(for: documentsURL, skipsHiddenFiles: skipsHiddenFiles)
+    }
+
+    class func urls(for directory: URL, skipsHiddenFiles: Bool = true ) -> [URL] {
+        do {
+            return try FileManager.default.contentsOfDirectory(at: directory,
+                                                               includingPropertiesForKeys: [],
+                                                               options: skipsHiddenFiles ? [.skipsHiddenFiles] : [] )
+        } catch {
+            return []
+        }
+    }
+
+    class func readDirectory(for directory: URL, skipsHiddenFiles: Bool = true ) -> [URL] {
+        urls(for: directory, skipsHiddenFiles: skipsHiddenFiles)
+    }
+
+    class func readDirectory(for directory: String, skipsHiddenFiles: Bool = true ) -> [URL] {
+        urls(for: directory, skipsHiddenFiles: skipsHiddenFiles)
+    }
+
+    class func isDirectory(_ url: URL) -> Bool {
+        (try? url.resourceValues(forKeys: [.isDirectoryKey]))?.isDirectory ?? false
+    }
+
+    class func isDirectory(_ path: String) -> Bool {
+        guard let url = URL(string: path) else { fatalError("\(path) - can not convert to URL") }
+        return isDirectory(url)
+    }
+
+    class func isFile(_ url: URL) -> Bool {
+        !isDirectory(url)
+    }
+
+    class func isFile(_ path: String) -> Bool {
+        guard let url = URL(string: path) else { fatalError("\(path) - can not convert to URL") }
+        return isFile(url)
+    }
+
+    class func fileExist(_ url: URL) -> Bool {
+        fileExist(url.path)
+    }
+
+    class func fileExist(_ path: String) -> Bool {
+        FileManager.default.fileExists(atPath: path)
+    }
+
+    class func directoryExist(_ url: URL) -> Bool {
+        directoryExist(url.path)
+    }
+
+    class func directoryExist(_ path: String) -> Bool {
+        var isDirectory = ObjCBool(true)
+        let exists = FileManager.default.fileExists(atPath: path, isDirectory: &isDirectory)
+        return exists && isDirectory.boolValue
+    }
+}

Sources/FileUtils/FileUtils.swift

@@ -0,0 +1,25 @@
+//
+//  Mode.swift
+//  
+//
+//  Created by Oleh Hudeichuk on 26.06.2020.
+//
+
+import Foundation
+
+public extension FileUtils {
+    
+    struct Mode: OptionSet {
+
+        public var rawValue: Int
+        public typealias RawValue = Int
+        public init(rawValue: RawValue) {
+            self.rawValue = rawValue
+        }
+
+//        public static var rewrite = Mode(rawValue: 1)
+        public static var append = Mode(rawValue: 2)
+        public static var clear = Mode(rawValue: 3)
+        public static var createFile = Mode(rawValue: 4)
+    }
+}

Sources/FileUtils/Mode.swift

@@ -0,0 +1,33 @@
+//
+//  ReadFile.swift
+//  
+//
+//  Created by Oleh Hudeichuk on 27.06.2020.
+//
+
+import Foundation
+
+public extension FileUtils {
+
+    class func readFile(_ url: URL, encoding: String.Encoding = .utf8) throws -> String {
+        try String(contentsOf: url, encoding: encoding)
+    }
+
+    class func readFileByLine(_ url: URL, _ handler: (_ line: String) -> Void) throws {
+        let file: FileReader = .init(fileURL: url)
+        try file.open()
+        defer { file.close() }
+        while let line: String = try file.readLine() {
+            handler(line)
+        }
+    }
+
+    class func readFileByLine(_ path: String, _ handler: (_ line: String) -> Void) throws {
+        let file: FileReader = .init(filePath: path)
+        try file.open()
+        defer { file.close() }
+        while let line: String = try file.readLine() {
+            handler(line)
+        }
+    }
+}

Sources/FileUtils/ReadFile.swift

@@ -0,0 +1,95 @@
+//
+//  WriteFile.swift
+//  
+//
+//  Created by Oleh Hudeichuk on 27.06.2020.
+//
+
+import Foundation
+
+public extension FileUtils {
+
+    class func writeFile(to: URL?,
+                         _ data: Data?,
+                         _ mode: FileUtils.Mode = [.clear]
+    ) throws {
+        if data == nil || to == nil { return }
+        if mode.contains(.createFile) && !fileExist(to!) {
+            createFile(to)
+        }
+        if mode.contains(.clear) { clearFile(to) }
+        let fileHandle: FileHandle = try FileHandle(forWritingTo: to!)
+        if mode.contains(.append) {
+            fileHandle.seekToEndOfFile()
+        }
+        fileHandle.write(data!)
+        fileHandle.closeFile()
+    }
+
+    class func writeFile(to path: String?,
+                         _ data: Data?,
+                         _ mode: FileUtils.Mode = [.clear]
+    ) {
+        if data == nil || path == nil { return }
+        if mode.contains(.createFile) && !fileExist(path!) {
+            createFile(path)
+        }
+        if mode.contains(.clear) { clearFile(path) }
+        let fileHandle: FileHandle? = FileHandle(forWritingAtPath: path!)
+        if mode.contains(.append) {
+            fileHandle?.seekToEndOfFile()
+        }
+        fileHandle?.write(data!)
+        fileHandle?.closeFile()
+    }
+
+    class func writeFile(to path: String?,
+                         _ text: String?,
+                         _ encoding: String.Encoding = .utf8,
+                         _ mode: FileUtils.Mode = [.clear]
+    ) {
+        writeFile(to: path, text?.data(using: encoding))
+    }
+
+    class func writeFile(to: URL?,
+                         _ text: String?,
+                         _ encoding: String.Encoding = .utf8,
+                         _ mode: FileUtils.Mode = [.clear]
+    ) throws {
+        try writeFile(to: to, text?.data(using: encoding))
+    }
+
+    class func writeFilePosix(to: String,
+                        _ text: String,
+                        _ encoding: String.Encoding = .utf8,
+                        _ oflag: Int32 = O_TRUNC | O_WRONLY | O_CREAT,
+                        _ mode: mode_t = 0o755
+    ) {
+        let fileDescriptor: Int32 = open(to, oflag, mode)
+        if fileDescriptor < 0 {
+            perror("could not open \(to)")
+        } else {
+            guard let size: Int = text.data(using: encoding)?.count else { return }
+            write(fileDescriptor, text, size)
+            close(fileDescriptor)
+        }
+    }
+
+    class func writeFilePosix(to: String,
+                              _ data: Data?,
+                              _ oflag: Int32 = O_TRUNC | O_WRONLY | O_CREAT,
+                              _ mode: mode_t = 0o755
+    ) {
+        let fileDescriptor: Int32 = open(to, oflag, mode)
+        if fileDescriptor < 0 {
+            perror("could not open \(to)")
+        } else {
+            guard let size: Int = data?.count else { return }
+            var data = data
+            withUnsafePointer(to: &data!) { (pointer: UnsafePointer<Data>) -> Void in
+                write(fileDescriptor, pointer, size)
+            }
+            close(fileDescriptor)
+        }
+    }
+}

Sources/FileUtils/WriteFile.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import FileUtils
+
+final class FileUtilsTests: XCTestCase {
+    func testExample() {
+        // This is an example of a functional test case.
+        // Use XCTAssert and related functions to verify your tests produce the correct
+        // results.
+//        XCTAssertEqual(FileUtils().text, "Hello, World!")
+    }
+
+    static var allTests = [
+        ("testExample", testExample),
+    ]
+}

Tests/FileUtilsTests/FileUtilsTests.swift

@@ -0,0 +1,18 @@
+#if !canImport(ObjectiveC)
+import XCTest
+
+extension FileUtilsTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__FileUtilsTests = [
+        ("testExample", testExample),
+    ]
+}
+
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(FileUtilsTests.__allTests__FileUtilsTests),
+    ]
+}
+#endif