Implement VCS ignoring in Swift and use fzy to fuzzy match

Author: qvacua

Diff for: .github/workflows/vimr-deps-release-on-tag.yml

@@ -10,10 +10,10 @@ private let iconsCache = NSCache<NSURL, NSImage>()
 
 public final class FileUtils {
   private static let keysToGet: [URLResourceKey] = [
+    .isRegularFileKey,
     .isDirectoryKey,
+    .isPackageKey,
     .isHiddenKey,
-    .isAliasFileKey,
-    .isSymbolicLinkKey,
   ]
 
   private static let scanOptions: FileManager.DirectoryEnumerationOptions = [
@@ -56,7 +56,7 @@ public final class FileUtils {
     let result = pathCompsOnlyMin[0]
     let possibleParent = NSURL.fileURL(withPathComponents: Array(result[0...commonIdx]))!
 
-    return possibleParent.isDir ? possibleParent : possibleParent.parent
+    return possibleParent.hasDirectoryPath ? possibleParent : possibleParent.parent
   }
 
   public static func icon(forType type: String) -> NSImage { workspace.icon(forFileType: type) }

Diff for: Commons/Sources/Commons/FileUtils.swift

@@ -125,34 +125,13 @@ public extension URL {
 
   var shellEscapedPath: String { self.path.shellEscapedPath }
 
-  var isDir: Bool { self.resourceValue(URLResourceKey.isDirectoryKey.rawValue) }
-
-  var isHidden: Bool { self.resourceValue(URLResourceKey.isHiddenKey.rawValue) }
-
-  var isPackage: Bool { self.resourceValue(URLResourceKey.isPackageKey.rawValue) }
-
-  /// Wrapper function for NSURL.getResourceValue for Bool values.
-  /// Returns also `false` when
-  /// - there is no value for the given `key` or
-  /// - the value cannot be converted to `NSNumber`.
-  ///
-  /// - parameters:
-  ///   - key: The `key`-parameter of `NSURL.getResourceValue`.
-  private func resourceValue(_ key: String) -> Bool {
-    var rsrc: AnyObject?
-
-    do {
-      try (self as NSURL).getResourceValue(&rsrc, forKey: URLResourceKey(rawValue: key))
-    } catch let error as NSError {
-      // FIXME: How to error handle?
-      log.error("ERROR while getting \(key): \(error)")
-      return false
-    }
+  var isRegularFile: Bool {
+    (try? self.resourceValues(forKeys: [.isRegularFileKey]))?.isRegularFile ?? false
+  }
 
-    if let result = rsrc as? NSNumber { return result.boolValue }
+  var isHidden: Bool { (try? self.resourceValues(forKeys: [.isHiddenKey]))?.isHidden ?? false }
 
-    return false
-  }
+  var isPackage: Bool { (try? self.resourceValues(forKeys: [.isPackageKey]))?.isPackage ?? false }
 }
 
 public extension ValueTransformer {

Diff for: Commons/Sources/Commons/FoundationCommons.swift

@@ -53,14 +53,6 @@ then continuously invoke the `build_nvimserver_for_local_dev` script.
 
 ### VimR
 
-#### Dependencies
-
-* Tag with the name `vimr-deps-yyyy-mm-dd`. GitHub actions will build the universal version,
-  create a release and upload it.
-* Update `resources/vimr-deps_version.txt` and push.
-
-#### Executable
-
 * Set a new version of VimR via
     ```bash
     is_snapshot=true ./bin/set_new_versions.sh # for snapshot or

Diff for: DEVELOP.md

@@ -0,0 +1,23 @@
+// swift-tools-version:5.6
+
+import PackageDescription
+
+let package = Package(
+  name: "Ignore",
+  platforms: [.macOS(.v10_13)],
+  products: [
+    .library(name: "Ignore", targets: ["Ignore"]),
+  ],
+  dependencies: [
+    .package(url: "https://github.com/qvacua/misc.swift", exact: "0.0.1"),
+    .package(url: "https://github.com/Quick/Nimble", from: "10.0.0"),
+  ],
+  targets: [
+    .target(name: "Ignore", dependencies: [.product(name: "WildmatchC", package: "misc.swift")]),
+    .testTarget(
+      name: "IgnoreTests",
+      dependencies: ["Ignore", "Nimble"],
+      resources: [.copy("Resources")]
+    ),
+  ]
+)

Diff for: Ignore/Package.swift

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

Diff for: Ignore/README.md

@@ -0,0 +1,105 @@
+/// Tae Won Ha - http://taewon.de - @hataewon
+/// See LICENSE
+
+import Foundation
+
+/// Reads the file at the given ``URL`` line by line.
+/// The Unix line ending `LF` is used to determine lines.
+/// Thus, it supports `LF` and `CRLF` files. It does not support the legacy Mac line ending `CR`.
+public final class FileLineReader: Sequence {
+  public static let defaultLineBufferCount = 1024
+
+  public let url: URL
+
+  public var lineBufferCount: Int
+  public var encoding: String.Encoding
+
+  /// - Parameters:
+  ///   - url: URL of the file.
+  ///   - encoding: Encoding of the file. It's mutable.
+  ///     After mutating, the next iterator will use the new value.
+  ///   - lineBufferCount: The initial size of the buffer for reading lines. It's mutable.
+  ///     After mutating, the next iterator will use the new value.
+  ///     The default is ``FileLineReader/defaultLineBufferCount``.
+  public init(url: URL, encoding: String.Encoding, lineBufferCount: Int = defaultLineBufferCount) {
+    self.lineBufferCount = lineBufferCount
+    self.url = url
+    self.encoding = encoding
+  }
+
+  public func makeIterator() -> AnyIterator<String> {
+    guard let file = fopen(url.path, "r") else { return AnyIterator { nil } }
+
+    let iterator = LfLineIterator(
+      file: file,
+      encoding: self.encoding,
+      lineBufferCount: self.lineBufferCount
+    )
+    return AnyIterator { iterator.next() }
+  }
+}
+
+private class LfLineIterator: IteratorProtocol {
+  init(
+    file: UnsafeMutablePointer<FILE>,
+    encoding: String.Encoding,
+    lineBufferCount: Int
+  ) {
+    self.file = file
+    self.encoding = encoding
+    self.buffer = Array(repeating: 0, count: lineBufferCount)
+  }
+
+  deinit { fclose(self.file) }
+
+  func next() -> String? {
+    var readCharCount = 0
+    while true {
+      let nextChar = getc(self.file)
+
+      if nextChar == EOF {
+        if readCharCount == 0 { return nil }
+        return String(
+          data: Data(
+            bytesNoCopy: self.buffer[0..<readCharCount].unsafeMutableRawPointer,
+            count: readCharCount,
+            deallocator: .none
+          ), encoding: self.encoding
+        )
+      }
+
+      if readCharCount >= self.buffer.count {
+        // Array.append()
+        // https://developer.apple.com/documentation/swift/array/3126937-append
+        // "Complexity: O(1) on average, over many calls to append(_:) on the same array."
+        self.buffer.append(UInt8(nextChar))
+      } else {
+        self.buffer[readCharCount] = UInt8(nextChar)
+      }
+      readCharCount += 1
+
+      if nextChar == Self.unixLineEnding {
+        return String(
+          data: Data(
+            bytesNoCopy: self.buffer[0..<readCharCount].unsafeMutableRawPointer,
+            count: readCharCount,
+            deallocator: .none
+          ), encoding: self.encoding
+        )
+      }
+    }
+  }
+
+  private let encoding: String.Encoding
+  private var buffer: [UInt8]
+  private let file: UnsafeMutablePointer<FILE>
+
+  private static let unixLineEnding = "\n".utf8.first!
+}
+
+private extension ArraySlice {
+  @inline(__always)
+  var unsafeMutableRawPointer: UnsafeMutableRawPointer {
+    UnsafeMutableRawPointer(mutating: self.withUnsafeBytes { $0.baseAddress! })
+  }
+}

Diff for: Ignore/Sources/Ignore/FileLineReader.swift

@@ -0,0 +1,105 @@
+/// Tae Won Ha - http://taewon.de - @hataewon
+/// See LICENSE
+
+import Foundation
+import WildmatchC
+
+public struct Filter: CustomStringConvertible {
+  public let base: URL
+  public let pattern: String
+
+  public let isAllow: Bool
+  public let isOnlyForDirectories: Bool
+  public let isRelativeToBase: Bool
+
+  public init(base: URL, pattern: String) {
+    self.base = base
+
+    var effectivePattern: String
+
+    self.isAllow = pattern.first == "!"
+    effectivePattern = self.isAllow ? String(pattern.dropFirst()) : pattern
+
+    self.isOnlyForDirectories = effectivePattern.last == "/"
+    effectivePattern =
+      self.isOnlyForDirectories ? String(effectivePattern.dropLast(1)) : effectivePattern
+
+    self.isRelativeToBase = effectivePattern.contains("/")
+    if self.isRelativeToBase {
+      effectivePattern = base.path
+        + (effectivePattern.first == "/" ? effectivePattern : "/" + effectivePattern)
+    }
+
+    self.pattern = effectivePattern
+    self.patternCstr = Array(self.pattern.utf8CString)
+  }
+
+  public func disallows(_ url: URL) -> Bool {
+    if self.isOnlyForDirectories {
+      guard url.hasDirectoryPath else { return false }
+    }
+
+    if self.isRelativeToBase {
+      let matches = self.matches(url.path)
+      if self.isAllow { return !matches } else { return matches }
+    }
+
+    let matches = self.matches(url.lastPathComponent)
+    if self.isAllow { return false } else { return matches }
+  }
+
+  public func explicitlyAllows(_ url: URL) -> Bool {
+    if self.isOnlyForDirectories {
+      guard url.hasDirectoryPath else { return false }
+    }
+
+    if self.isRelativeToBase {
+      if self.isAllow { return self.matches(url.path) }
+      return false
+    }
+
+    if self.isAllow { return self.matches(url.lastPathComponent) } else { return false }
+  }
+
+  /// Ignores whether the pattern is only applicable for directories.
+  public func disallows(_ string: String) -> Bool {
+    if self.isAllow { return false } else { return self.matches(string) }
+  }
+
+  /// Ignores whether the pattern is only applicable for directories.
+  public func explicitlyAllows(_ string: String) -> Bool {
+    if self.isAllow { return self.matches(string) }
+    return false
+  }
+
+  public func matches(_ url: URL) -> Bool {
+    if self.isOnlyForDirectories {
+      guard url.hasDirectoryPath else { return false }
+    }
+
+    if self.isRelativeToBase {
+      return url.path.withCString { stringCstr in
+        wildmatch(patternCstr, stringCstr, WM_WILDSTAR) == WM_MATCH
+      }
+    }
+
+    return url.lastPathComponent.withCString { stringCstr in
+      wildmatch(patternCstr, stringCstr, WM_WILDSTAR) == WM_MATCH
+    }
+  }
+
+  /// Ignores whether the pattern is only applicable for directories.
+  public func matches(_ string: String) -> Bool {
+    string.withCString {
+      stringCstr in
+      wildmatch(patternCstr, stringCstr, WM_WILDSTAR) == WM_MATCH
+    }
+  }
+
+  public var description: String {
+    "Ignore(isAllow: \(self.isAllow), isOnlyDirectory: \(self.isOnlyForDirectories), "
+      + "isAbsolute: \(self.isRelativeToBase), pattern: \(self.pattern), baseUrl: \(self.base))"
+  }
+
+  private let patternCstr: [CChar]
+}