Merge branch 'dev'

* dev:
  bump version to 1.4.3
  refactor: trimming range of kanji annotation
  update keywords when clicking "Search Lyrics...", #94
  update: Hashable conformance

LyricsX/Component/AppDelegate.swift

@@ -185,6 +185,7 @@ class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
 
     @IBAction func searchLyrics(_ sender: Any?) {
         searchLyricsWC.window?.makeKeyAndOrderFront(nil)
+        (searchLyricsWC.contentViewController as! SearchLyricsViewController?)?.reloadKeyword()
         NSApp.activate(ignoringOtherApps: true)
     }
 

LyricsX/Controller/SearchLyricsViewController.swift

@@ -57,6 +57,10 @@ class SearchLyricsViewController: NSViewController, NSTableViewDelegate, NSTable
     }
 
     override func viewWillAppear() {
+        self.reloadKeyword()
+    }
+
+    func reloadKeyword() {
         guard let track = AppController.shared.playerManager.player?.currentTrack else {
             searchTask?.cancel()
             searchTask = nil

LyricsX/Supporting Files/Info.plist

@@ -17,9 +17,9 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.4.2</string>
+	<string>1.4.3</string>
 	<key>CFBundleVersion</key>
-	<string>1965</string>
+	<string>1973</string>
 	<key>Fabric</key>
 	<dict>
 		<key>APIKey</key>

LyricsX/Utility/CFExtension.swift

@@ -94,43 +94,47 @@ extension CFStringTokenizer {
 
     func currentFuriganaAnnotation(in string: NSString) -> (NSString, NSRange)? {
         let range = currentTokenRange()
-        let tokenStr = string.substring(with: range) as NSString
+        let tokenStr = string.substring(with: range)
         guard let latin = currentTokenAttribute(.latinTranscription),
-            let katakana = latin.applyingTransform(.latinToKatakana, reverse: false) as NSString?,
-            let hiragana = latin.applyingTransform(.latinToHiragana, reverse: false) as NSString?,
-            katakana.length > 0,
+            let hiragana = latin.applyingTransform(.latinToHiragana, reverse: false),
+            let katakana = latin.applyingTransform(.hiraganaToKatakana, reverse: false),
+            !katakana.isEmpty,
             katakana != tokenStr,
             hiragana != tokenStr else {
                 return nil
         }
-        let prefixLength = tokenStr.commonPrefixLength(with: hiragana)
-        let suffixLength = tokenStr.commonSuffixLength(with: hiragana)
-        let trimmedRange = NSRange(location: prefixLength,
-                                   length: hiragana.length - prefixLength - suffixLength)
-        let trimmedString = hiragana.substring(with: trimmedRange) as NSString
-        let rangeToAnnotate = NSRange(location: range.location + prefixLength,
-                                      length: range.length - prefixLength - suffixLength)
-        return (trimmedString, rangeToAnnotate)
+        let (rangeToAnnotate, rangeInAnnotation) = rangeOfUncommonContent(tokenStr, hiragana)!
+        let annotation = String(hiragana[rangeInAnnotation]) as NSString
+        var nsrangeToAnnotate = NSRange(rangeToAnnotate, in: tokenStr)
+        nsrangeToAnnotate.location += range.location
+        return (annotation, nsrangeToAnnotate)
     }
 }
 
-private extension NSString {
-
-    func commonPrefixLength(with string: NSString) -> Int {
-        var i = 0
-        while i < length, i < string.length, character(at: i) == string.character(at: i) {
-            i += 1
+private func rangeOfUncommonContent(_ s1: String, _ s2: String) -> (Range<String.Index>, Range<String.Index>)? {
+    guard s1 != s2 else {
+        return nil
+    }
+    var (l1, l2) = (s1.startIndex, s2.startIndex)
+    while s1[l1] == s2[l2] {
+        guard let nl1 = s1.index(l1, offsetBy: 1, limitedBy: s1.endIndex),
+            let nl2 = s2.index(l2, offsetBy: 1, limitedBy: s2.endIndex) else {
+                break
         }
-        return i
+        (l1, l2) = (nl1, nl2)
     }
 
-    func commonSuffixLength(with string: NSString) -> Int {
-        var i = 0
-        while i < length, i < string.length, character(at: length - 1 - i) == string.character(at: string.length - 1 - i) {
-            i += 1
+    var (r1, r2) = (s1.endIndex, s2.endIndex)
+    while s1[r1] == s2[r2] {
+        guard let nr1 = s1.index(r1, offsetBy: -1, limitedBy: s1.startIndex),
+            let nr2 = s2.index(r2, offsetBy: -1, limitedBy: s2.startIndex) else {
+                break
         }
-        return i
+        (r1, r2) = (nr1, nr2)
     }
+    let range1 = (l1...r1).relative(to: s1.indices)
+    let range2 = (l2...r2).relative(to: s1.indices)
+    return (range1, range2)
 }
 
 extension CFStringTokenizer: IteratorProtocol, Sequence {

LyricsX/Utility/Regex.swift

@@ -163,10 +163,8 @@ extension MatchResult: Equatable, Hashable {
         return lhs.captures.elementsEqual(rhs.captures, by: ==)
     }
 
-    var hashValue: Int {
-        return captures.reduce(0) { r, e in
-            hashCombine(seed: r, value: e?.hashValue ?? 0)
-        }
+    public func hash(into hasher: inout Hasher) {
+        captures.forEach { hasher.combine($0) }
     }
 }
 
@@ -176,35 +174,7 @@ extension Regex: Equatable, Hashable {
         return lhs._regex == rhs._regex
     }
 
-    var hashValue: Int {
-        return _regex.hashValue
-    }
-}
-
-// MARK: -
-
-private func hashCombine(seed: Int, value: Int) -> Int {
-    func hashCombine32(seed: inout UInt32, value: UInt32) {
-        seed ^= (value &+ 0x9e3779b9 &+ (seed<<6) &+ (seed>>2))
-    }
-    func hashCombine64(seed: inout UInt64, value: UInt64) {
-        let mul: UInt64 = 0x9ddfea08eb382d69
-        var a = (value ^ seed) &* mul
-        a ^= (a >> 47)
-        var b = (seed ^ a) &* mul
-        b ^= (b >> 47)
-        seed = b &* mul
-    }
-
-    if MemoryLayout<Int>.size == 64 {
-        var us = UInt64(UInt(bitPattern: seed))
-        let uv = UInt64(UInt(bitPattern: value))
-        hashCombine64(seed: &us, value: uv)
-        return Int(truncatingIfNeeded: Int64(bitPattern: us))
-    } else {
-        var us = UInt32(UInt(bitPattern: seed))
-        let uv = UInt32(UInt(bitPattern: value))
-        hashCombine32(seed: &us, value: uv)
-        return Int(truncatingIfNeeded: Int32(bitPattern: us))
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(_regex)
     }
 }