git.r.bdr.sh - rbdr/lyricli/blob - Sources/lyricli/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                         lyrics = lyricsResult
  40                         requestFinished = true
  41                         asyncLock.signal()
  42                     })
  43
  44                     while !requestFinished {
  45                         asyncLock.wait()
  46                     }
  47                     asyncLock.unlock()
  48                 }
  49             }
  50         }
  51
  52         return lyrics
  53     }
  54
  55     // Initializes with a track
  56     init(withTrack targetTrack: Track) {
  57
  58         track = targetTrack
  59     }
  60
  61     // Fetch the lyrics URL from the API, triggers the request to fetch the
  62     // lyrics page
  63     private func fetchLyricsFromAPI(withURL url: URL, completionHandler: @escaping (String?) -> Void) {
  64
  65         var apiRequest = URLRequest(url: url)
  66         apiRequest.httpMethod = "GET"
  67
  68         let task = URLSession.shared.dataTask(with: apiRequest, completionHandler: {data, _, _ -> Void in
  69
  70             // If the response is parseable JSON, and has a url, we'll look for
  71             // the lyrics in there
  72
  73             if let data = data {
  74                 if let jsonResponse = try? JSONSerialization.jsonObject(with: data) {
  75                     if let jsonResponse = jsonResponse as? [String: Any] {
  76                         if let lyricsUrlString = jsonResponse["url"] as? String {
  77                             if let lyricsUrl = URL(string: lyricsUrlString) {
  78
  79                                 // At this point we have a valid wiki url
  80                                 self.fetchLyricsFromPage(withURL: lyricsUrl, completionHandler: completionHandler)
  81                                 return
  82                             }
  83                         }
  84                     }
  85                 }
  86             }
  87
  88             completionHandler(nil)
  89         })
  90         task.resume()
  91     }
  92
  93     // Fetch the lyrics from the page and send it to the parser
  94     private func fetchLyricsFromPage(withURL url: URL, completionHandler: @escaping (String?) -> Void) {
  95
  96         var pageRequest = URLRequest(url: url)
  97         pageRequest.httpMethod = "GET"
  98
  99         let task = URLSession.shared.dataTask(with: pageRequest, completionHandler: {data, _, _ -> Void in
 100
 101             // If the response is parseable JSON, and has a url, we'll look for
 102             // the lyrics in there
 103
 104             if let data = data {
 105                 if let htmlBody = String(data: data, encoding: String.Encoding.utf8) {
 106                     self.parseHtmlBody(htmlBody, completionHandler: completionHandler)
 107                     return
 108                 }
 109             }
 110
 111             completionHandler(nil)
 112         })
 113         task.resume()
 114     }
 115
 116     // Parses the wiki to find the lyrics, decodes the lyrics object
 117     private func parseHtmlBody(_ body: String, completionHandler: @escaping (String?) -> Void) {
 118
 119         // Look for the lyrics lightbox
 120
 121         if let regex = try? NSRegularExpression(pattern: lyricsMatcher) {
 122             let matches = regex.matches(in: body, range: NSRange(location: 0, length: body.count))
 123
 124             for match in matches {
 125
 126                 let nsBody = body as NSString
 127                 let range = match.range(at: 1)
 128                 let encodedLyrics = nsBody.substring(with: range)
 129
 130                 let decodedLyrics = decodeLyrics(encodedLyrics)
 131
 132                 completionHandler(decodedLyrics)
 133                 return
 134             }
 135         }
 136
 137         completionHandler(nil)
 138     }
 139
 140     // Escapes the HTML entities
 141     private func decodeLyrics(_ lyrics: String) -> String {
 142
 143         let unescapedLyrics = lyrics.htmlUnescape()
 144         return unescapedLyrics.replacingOccurrences(of: "<br />", with: "\n")
 145     }
 146 }