Add Yaml support

[albertodebortoli]

The changes in this PR are not backward compatible, hence leading to a major version bump (v2).

• Remove generate-packages command as the tool shouldn't make assumption on the environment. The generate-package command is enough and any logic on top should be implemented in the user space.
• Rework generate-package command: the options are now clearer and the command doesn't expect the spec file to be named as the containing folder.
• Add support for YAML format for both the dependencies and the specs files using jpsim/Yams.
• Add tests for files in YAML format.
• Use .copy in testTarget.resources which sorts some warnings.
• Update README.md
• Remove generated Example's Package.swift

[akuzminskyi]

looks like merge conflict file

[albertodebortoli]

🤦‍♂️

[akuzminskyi]

broken indent because guard in the .compactMap block. and return(line 40) below looks correct

[akuzminskyi]

ditto

[akuzminskyi]

Why not replace String to ProductType, as a result you will remove custom decoding, and also it will be typesafe to use productType

The same in Target below

[albertodebortoli]

I think it's beyond this PR but I'll take a look.

[akuzminskyi]

I think we need to add the same for init(from decoder: Decoder) throws {

---

if those variable mean the same maybe better to use non-option enum?

[albertodebortoli]

I thought the same but I thought it was beyond the scope of this PR.

[albertodebortoli]

Regarding the 2 comments on using Decodable better, I tried but it seems that the reason why it wasn't done before is that Stencil doesn't allow fetching properties from computed vars on objects passed in the context. I'm therefore keen in leaving it as it is.

Otherwise, this should work:

enum Ref: Decodable {
    case version(String)
    case revision(String)
    case branch(String)

    enum CodingKeys: String, CodingKey {
        case version
        case revision
        case branch
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)

        if let version = try container.decodeIfPresent(String.self, forKey: .version) {
            self = .version(version)
        } else if let revision = try container.decodeIfPresent(String.self, forKey: .revision) {
            self = .revision(revision)
        } else if let branch = try container.decodeIfPresent(String.self, forKey: .branch) {
            self = .branch(branch)
        } else {
            throw DecodingError.dataCorruptedError(forKey: CodingKeys.version, in: container, debugDescription: "Expected one of version, revision, or branch to be present.")
        }
    }
}

struct Dependency: Decodable {

    let name: String
    let url: String
    let ref: Ref

    enum CodingKeys: String, CodingKey {
        case name
        case url
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        self.name = try container.decode(String.self, forKey: .name)
        self.url = try container.decode(String.self, forKey: .url)
        self.ref = try Ref(from: decoder)
    }

    init(name: String, url: String, ref: Ref) {
        self.name = name
        self.url = url
        self.ref = ref
    }
}

struct Spec: Decodable {
    struct Product: Decodable {
        let name: String
        let productType: ProductType
        let targets: [String]

        var type: String {
            productType.rawValue
        }

        enum CodingKeys: CodingKey {
            case name
            case productType
            case targets
        }
    }
    ...
    
    struct RemoteDependency: Decodable {
        let name: String
        let url: String?
        let ref: Ref?

        var version: String? {
            if case let .version(value) = ref {
                return value
            }
            return nil
        }

        var revision: String? {
            if case let .revision(value) = ref {
                return value
            }
            return nil
        }

        var branch: String? {
            if case let .branch(value) = ref {
                return value
            }
            return nil
        }

        enum CodingKeys: CodingKey {
            case name
            case url
        }

        init(from decoder: Decoder) throws {
            let container = try decoder.container(keyedBy: CodingKeys.self)
            self.name = try container.decode(String.self, forKey: .name)
            self.url = try container.decodeIfPresent(String.self, forKey: .url)
            self.ref = (try? Ref(from: decoder)) ?? nil
        }

        init(name: String, url: String?, ref: Ref) {
            self.name = name
            self.url = url
            self.ref = ref
        }
    }
    ...