Initial dotenv, playground

dotenv.swift

import UIKit

enum ParserError: Error {
    case missingKey
    case genericError
}

struct Value: Hashable, Equatable {
    let innerValue: String

    init(string: String) {
        self.innerValue = string
    }

    var boolValue: Bool {
        let numberFormatter = NumberFormatter()
        if let number = numberFormatter.number(from: innerValue) {
            return number.boolValue
        } else if let bool = Bool(innerValue) {
            return bool
        }
        return false
    }
}

extension Value: CustomDebugStringConvertible, CustomStringConvertible {
    var description: String {
        return innerValue
    }

    var debugDescription: String {
        return description
    }
}

let arrTests = ["one", "1", "false", "0", "true", "True", "yes"].map { Value(string: $0).boolValue }
print(arrTests)

struct Secret: Hashable, Equatable {

    let key: String
    let value: Value

    init?(string: String) {
        guard string.isEmpty == false else { return nil }

        var elements = string.split(separator: "=")
        let firstElement = elements.removeFirst()
        let key = String(firstElement)
        let value = String(elements.joined())
        self.key = key
        self.value = Value(string: value)
    }
}

extension Secret: CustomPlaygroundDisplayConvertible, CustomDebugStringConvertible, CustomStringConvertible {
    var playgroundDescription: Any {
        return debugDescription
    }

    var debugDescription: String {
        return String(format: "%@=%@", key, value.debugDescription)
    }

    var description: String {
        return String(format: "Key: %@, Value: %@", key, value.description)
    }
}



struct DotEnv {
    private let secrets: Set<Secret>

    subscript(string: String) -> Value? {
        guard let index = secrets.firstIndex (where: { $0.key == string }) else {
            return nil
        }
        return secrets[index].value
    }

    var keys: [String] {
        return secrets.map { $0.key }
    }

    var count: Int {
        return secrets.count
    }

    init(fileName: String = "env") {
        let path = Bundle.main.path(forResource: fileName, ofType: nil)!
        do {
            let data = try String(contentsOfFile: path, encoding: .utf8)
            let myStrings = data.components(separatedBy: .newlines)
            self.secrets = Set(myStrings.compactMap({ Secret(string: $0) }))
        } catch {
            print(error.localizedDescription)
            fatalError()
        }
    }
}


let dotEnv = DotEnv()

dotEnv["client_key"]
dotEnv.count
dotEnv.keys
dotEnv["client_key"]