git.r.bdr.sh - rbdr/lyricli/blob - Sources/lyrics_engine.swift

   1 import Foundation
   2 import HTMLEntities
   3
   4 // Given a track, attempts to fetch the lyrics from lyricswiki
   5 class LyricsEngine {
   6
   7     // URL of the API endpoint to use
   8     private let apiURL = "https://lyrics.wikia.com/api.php?action=lyrics&func=getSong&fmt=realjson"
   9
  10     // Method used to call the API
  11     private let apiMethod = "GET"
  12
  13     // Regular expxression used to find the lyrics in the lyricswiki HTML
  14     private let lyricsMatcher = "class='lyricbox'>(.+)<div"
  15
  16     // The track we'll be looking for
  17     private let track: Track
  18
  19     // Fetches the lyrics and returns if found
  20     var lyrics: String? {
  21
  22         var lyrics: String?
  23
  24         // Encode the track artist and name and finish building the API call URL
  25
  26         if let artist = track.artist.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) {
  27             if let name: String = track.name.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) {
  28                 if let url = URL(string: "\(apiURL)&artist=\(artist)&song=\(name)") {
  29
  30                     // We'll lock until the async call is finished
  31
  32                     var requestFinished = false
  33                     let asyncLock = NSCondition()
  34                     asyncLock.lock()
  35
  36                     // Call the API and unlock when you're done
  37
  38                     fetchLyricsFromAPI(withURL: url, completionHandler: {lyricsResult -> Void in
  39                         if let lyricsResult = lyricsResult {
  40                             lyrics = lyricsResult
  41                             requestFinished = true
  42                             asyncLock.signal()
  43                         }
  44                     })
  45
  46                     while !requestFinished {
  47                         asyncLock.wait()
  48                     }
  49                     asyncLock.unlock()
  50                 }
  51             }
  52         }
  53
  54         return lyrics
  55     }
  56
  57     // Initializes with a track
  58     init(withTrack targetTrack: Track) {
  59
  60         track = targetTrack
  61     }
  62
  63     // Fetch the lyrics URL from the API, triggers the request to fetch the
  64     // lyrics page
  65     private func fetchLyricsFromAPI(withURL url: URL, completionHandler: @escaping (String?) -> Void) {
  66
  67         var apiRequest = URLRequest(url: url)
  68         apiRequest.httpMethod = "GET"
  69
  70         let task = URLSession.shared.dataTask(with: apiRequest, completionHandler: {data, _, _ -> Void in
  71
  72             // If the response is parseable JSON, and has a url, we'll look for
  73             // the lyrics in there
  74
  75             if let data = data {
  76                 if let jsonResponse = try? JSONSerialization.jsonObject(with: data) {
  77                     if let jsonResponse = jsonResponse as? [String: Any] {
  78                         if let lyricsUrlString = jsonResponse["url"] as? String {
  79                             if let lyricsUrl = URL(string: lyricsUrlString) {
  80
  81                                 // At this point we have a valid wiki url
  82                                 self.fetchLyricsFromPage(withURL: lyricsUrl, completionHandler: completionHandler)
  83                                 return
  84                             }
  85                         }
  86                     }
  87                 }
  88             }
  89
  90             completionHandler(nil)
  91         })
  92         task.resume()
  93     }
  94
  95     // Fetch the lyrics from the page and send it to the parser
  96     private func fetchLyricsFromPage(withURL url: URL, completionHandler: @escaping (String?) -> Void) {
  97
  98         var pageRequest = URLRequest(url: url)
  99         pageRequest.httpMethod = "GET"
 100
 101         let task = URLSession.shared.dataTask(with: pageRequest, completionHandler: {data, _, _ -> Void in
 102
 103             // If the response is parseable JSON, and has a url, we'll look for
 104             // the lyrics in there
 105
 106             if let data = data {
 107                 if let htmlBody = String(data: data, encoding: String.Encoding.utf8) {
 108                     self.parseHtmlBody(htmlBody, completionHandler: completionHandler)
 109                     return
 110                 }
 111             }
 112
 113             completionHandler(nil)
 114         })
 115         task.resume()
 116     }
 117
 118     // Parses the wiki to find the lyrics, decodes the lyrics object
 119     private func parseHtmlBody(_ body: String, completionHandler: @escaping (String?) -> Void) {
 120
 121         // Look for the lyrics lightbox
 122
 123         if let regex = try? NSRegularExpression(pattern: lyricsMatcher) {
 124             let matches = regex.matches(in: body, range: NSRange(location: 0, length: body.characters.count))
 125
 126             for match in matches {
 127
 128                 let nsBody = body as NSString
 129                 let range = match.rangeAt(1)
 130                 let encodedLyrics = nsBody.substring(with: range)
 131
 132                 let decodedLyrics = decodeLyrics(encodedLyrics)
 133
 134                 completionHandler(decodedLyrics)
 135                 return
 136             }
 137         }
 138
 139         completionHandler(nil)
 140     }
 141
 142     // Escapes the HTML entities
 143     private func decodeLyrics(_ lyrics: String) -> String {
 144
 145         let unescapedLyrics = lyrics.htmlUnescape()
 146         return unescapedLyrics.replacingOccurrences(of: "<br />", with: "\n")
 147     }
 148 }