String+Functions.swift

import Foundation
import UIKit

extension String {
    
    //MARK: - Localized
    
    var localized: String {
        return NSLocalizedString(self, tableName: "Main", bundle: Bundle.main, value: "", comment: "")
    }
    
    func localized(arguments args: CVarArg...) -> String {
        return String(format: self.localized, arguments: args)
    }
    
    func trim() -> String {
        return self.trimmingCharacters(in: NSCharacterSet.whitespacesAndNewlines)
    }
    
    func timeAgo() -> String {
        guard !self.trim().isEmpty else {
            return ""
        }
        return timeAgoSinceDate(dateStringFormatter: "yyyy-MM-dd'T'HH:mm:ss.SSSZ", numericDates: true)
    }
    
    func getDate(dateStringFormatter: String) -> Date {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = dateStringFormatter
        let date = dateFormatter.date(from: self)
        return date!
    }
    
    func timeAgoSinceDate(dateStringFormatter: String, numericDates:Bool) -> String {
        let calendar = NSCalendar.current
        let unitFlags: Set<Calendar.Component> = [.minute, .hour, .day, .weekOfYear, .month, .year, .second]
        let now = NSDate()
        
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = dateStringFormatter
        if self.isEmpty {
            return "Just now".localized
        }else if let date = dateFormatter.date(from: self) {
            let earliest:Date = now.earlierDate(date)
            let latest:Date = (earliest == now as Date) ? date : now as Date
            let components = calendar.dateComponents(unitFlags, from: earliest as Date,  to: latest)
            if (components.year! >= 2) {
                return "\(components.year!) years ago".localized
            } else if (components.year! >= 1){
                if (numericDates){
                    return "1 year ago".localized
                } else {
                    return "Last year".localized
                }
            } else if (components.month! >= 2) {
                return "%d months ago".localized(arguments: components.month!)
            } else if (components.month! >= 1){
                if (numericDates){
                    return "1 month ago".localized
                } else {
                    return "Last month".localized
                }
            } else if (components.weekOfYear! >= 2) {
                return "%d weeks ago".localized(arguments: components.weekOfYear!)
            } else if (components.weekOfYear! >= 1){
                if (numericDates){
                    return "1 week ago".localized
                } else {
                    return "Last week".localized
                }
            } else if (components.day! >= 2) {
                return "%d days ago".localized(arguments: components.day!)
            } else if (components.day! >= 1){
                if (numericDates){
                    return "1 day ago".localized
                } else {
                    return "Yesterday".localized
                }
            } else if (components.hour! >= 2) {
                return "%d hours ago".localized(arguments: components.hour!)
            } else if (components.hour! >= 1){
                if (numericDates){
                    return "1 hour ago".localized
                } else {
                    return "An hour ago".localized
                }
            } else if (components.minute! >= 2) {
                return "%d minutes ago".localized(arguments: components.minute!)
            } else if (components.minute! >= 1){
                if (numericDates){
                    return "1 minute ago".localized
                } else {
                    return "A minute ago".localized
                }
            } else if (components.second! >= 3) {
                return "%d seconds ago".localized(arguments: components.second!)
            } else {
                return "Just now".localized
            }
        }
        return ""
    }
    
    var getHashtags : [String]? {
        get{
            let hashtagDetector = try? NSRegularExpression(pattern: "#(\\w+)", options: NSRegularExpression.Options.caseInsensitive)
            let results = hashtagDetector?.matches(in: self, options: NSRegularExpression.MatchingOptions.withoutAnchoringBounds, range: NSMakeRange(0, self.utf16.count)).map { $0 }
            
            return results?.map({
                (self as NSString).substring(with: $0.rangeAt(0))
            })
        }
    }
    
    var getMentions: [String]? {
        get {
            let hashtagDetector = try? NSRegularExpression(pattern: "@(\\w+)", options: NSRegularExpression.Options.caseInsensitive)
            let results = hashtagDetector?.matches(in: self, options: NSRegularExpression.MatchingOptions.withoutAnchoringBounds, range: NSMakeRange(0, self.utf16.count)).map { $0 }
            
            return results?.map({
                (self as NSString).substring(with: $0.rangeAt(0))
            })
        }
    }
    func height(withConstrainedWidth width: CGFloat, font: UIFont) -> CGFloat {
        let constraintRect = CGSize(width: width, height: .greatestFiniteMagnitude)
        let boundingBox = self.boundingRect(with: constraintRect, options: .usesLineFragmentOrigin, attributes: [NSFontAttributeName: font], context: nil)
        
        return boundingBox.height
    }
}

extension String {
    
    var parseJSONString: Any? {
        
        let data = self.data(using: String.Encoding.utf8, allowLossyConversion: false)
        
        if let jsonData = data {
            // Will return an object or nil if JSON decoding fails
            do {
                let object = try JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions.mutableContainers)
                return object
            } catch {
                return nil
            }
        } else {
            // Lossless conversion of the string was not possible
            return nil
        }
    }
}

extension String {
    func index(from: Int) -> Index? {
        guard self.characters.count > from else {
            return nil
        }
        return self.index(startIndex, offsetBy: from)
    }
    
    func substring(from: Int) -> String {
        if let fromIndex = index(from: from) {
            return substring(from: fromIndex)
        }
        return ""
    }
    
    func substring(to: Int) -> String {
        if let toIndex = index(from: to) {
            return substring(to: toIndex)
        }
        return ""
        
    }
    
    func substring(with r: Range<Int>) -> String {
        if let startIndex = index(from: r.lowerBound), let endIndex = index(from: r.upperBound) {
            return substring(with: startIndex..<endIndex)
        }
        return ""
    }
}