Apple lance Pkl, un langage de programmation open-source de type configuration en tant que code

1
2
$ export DATABASE_PASSWORD=hunter2
$ pkl eval --format yaml sidecars.pkl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
sidecars:
- username: admin
  password: hunter2
  host: localhost
  port: 6000
  dbName: myapp
- username: admin
  password: hunter2
  host: localhost
  port: 6001
  dbName: myapp
- username: admin
  password: hunter2
  host: localhost
  port: 6002
  dbName: myapp
- username: admin
  password: hunter2
  host: localhost
  port: 6003
  dbName: myapp

1
2
$ export DATABASE_PASSWORD=hunter2
$ pkl eval --format json sidecars.pkl

1
2
3
{
  "sidecars": [
    {
      "username": "admin",
      "password": "hunter2",
      "host": "localhost",
      "port": 6000,
      "dbName": "myapp"
    },
    {
      "username": "admin",
      "password": "hunter2",
      "host": "localhost",
      "port": 6001,
      "dbName": "myapp"
    },
    {
      "username": "admin",
      "password": "hunter2",
      "host": "localhost",
      "port": 6002,
      "dbName": "myapp"
    },
    {
      "username": "admin",
      "password": "hunter2",
      "host": "localhost",
      "port": 6003,
      "dbName": "myapp"
    }
  ]
}

1
2
$ export DATABASE_PASSWORD=hunter2
$ pkl eval --format xml sidecars.pkl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <sidecars>
    <Database>
      <username>admin</username>
      <password>hunter2</password>
      <host>localhost</host>
      <port>6000</port>
      <dbName>myapp</dbName>
    </Database>
    <Database>
      <username>admin</username>
      <password>hunter2</password>
      <host>localhost</host>
      <port>6001</port>
      <dbName>myapp</dbName>
    </Database>
    <Database>
      <username>admin</username>
      <password>hunter2</password>
      <host>localhost</host>
      <port>6002</port>
      <dbName>myapp</dbName>
    </Database>
    <Database>
      <username>admin</username>
      <password>hunter2</password>
      <host>localhost</host>
      <port>6003</port>
      <dbName>myapp</dbName>
    </Database>
  </sidecars>
</root>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import PklSwift

public enum Application {}

extension Application {
    public enum Environment: String, CaseIterable, Decodable, Hashable {
        case dev = "dev"
        case qa = "qa"
        case prod = "prod"
    }

    public struct Module: PklRegisteredType, Decodable, Hashable {
        public static var registeredIdentifier: String = "Application"

        /// The hostname that this server responds to.
        public var hostname: String

        /// The port to listen on.
        public var port: UInt16

        /// The environment to deploy to.
        public var environment: Environment

        /// The database connection for this application
        public var database: Database

        public init(hostname: String, port: UInt16, environment: Environment, database: Database) {
            self.hostname = hostname
            self.port = port
            self.environment = environment
            self.database = database
        }
    }

    public struct Database: PklRegisteredType, Decodable, Hashable {
        public static var registeredIdentifier: String = "Application#Database"

        /// The username for this database.
        public var username: String

        /// The password for this database.
        public var password: String

        /// The remote host for this database.
        public var host: String

        /// The remote port for this database.
        public var port: UInt16

        /// The name of the database.
        public var dbName: String

        public init(username: String, password: String, host: String, port: UInt16, dbName: String) {
            self.username = username
            self.password = password
            self.host = host
            self.port = port
            self.dbName = dbName
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package application

type Application struct {
	// The hostname that this server responds to.
	Hostname string `pkl:"hostname"`

	// The port to listen on.
	Port uint16 `pkl:"port"`

	// The environment to deploy to.
	Environment Environment.Environment `pkl:"environment"`

	// The database connection for this application
	Database *Database `pkl:"database"`
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Code generated from Pkl module `Application`. DO NOT EDIT.
package application

type Database struct {
	// The username for this database.
	Username string `pkl:"username"`

	// The password for this database.
	Password string `pkl:"password"`

	// The remote host for this database.
	Host string `pkl:"host"`

	// The remote port for this database.
	Port uint16 `pkl:"port"`

	// The name of the database.
	DbName string `pkl:"dbName"`
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Code generated from Pkl module `Application`. DO NOT EDIT.
package Environment

import (
	"encoding"
	"fmt"
)

type Environment string

const (
	Dev  Environment = "dev"
	Qa   Environment = "qa"
	Prod Environment = "prod"
)

// String returns the string representation of Environment
func (rcv Environment) String() string {
	return string(rcv)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
import java.lang.Object;
import java.lang.Override;
import java.lang.String;
import java.lang.StringBuilder;
import java.util.Objects;
import org.pkl.config.java.mapper.Named;
import org.pkl.config.java.mapper.NonNull;

public final class Application {
  /**
   * The hostname that this server responds to.
   */
  public final @NonNull String hostname;

  /**
   * The port to listen on.
   */
  public final int port;

  /**
   * The environment to deploy to.
   */
  public final @NonNull Environment environment;

  /**
   * The database connection for this application
   */
  public final @NonNull Database database;

  public Application(@Named("hostname") @NonNull String hostname, @Named("port") int port,
      @Named("environment") @NonNull Environment environment,
      @Named("database") @NonNull Database database) {
    this.hostname = hostname;
    this.port = port;
    this.environment = environment;
    this.database = database;
  }

  public static final class Database {
    /**
     * The username for this database.
     */
    public final @NonNull String username;

    /**
     * The password for this database.
     */
    public final @NonNull String password;

    /**
     * The remote host for this database.
     */
    public final @NonNull String host;

    /**
     * The remote port for this database.
     */
    public final int port;

    /**
     * The name of the database.
     */
    public final @NonNull String dbName;

    public Database(@Named("username") @NonNull String username,
        @Named("password") @NonNull String password, @Named("host") @NonNull String host,
        @Named("port") long port, @Named("dbName") @NonNull String dbName) {
      this.username = username;
      this.password = password;
      this.host = host;
      this.port = port;
      this.dbName = dbName;
    }
  }

  public enum Environment {
    DEV("dev"),

    QA("qa"),

    PROD("prod");

    private String value;

    private Environment(String value) {
      this.value = value;
    }

    @Override
    public String toString() {
      return this.value;
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import kotlin.Int
import kotlin.Long
import kotlin.String

data class Application(
  /**
   * The hostname that this server responds to.
   */
  val hostname: String,
  /**
   * The port to listen on.
   */
  val port: Int,
  /**
   * The environment to deploy to.
   */
  val environment: Environment,
  /**
   * The database connection for this application
   */
  val database: Database
) {
  data class Database(
    /**
     * The username for this database.
     */
    val username: String,
    /**
     * The password for this database.
     */
    val password: String,
    /**
     * The remote host for this database.
     */
    val host: String,
    /**
     * The remote port for this database.
     */
    val port: Int,
    /**
     * The name of the database.
     */
    val dbName: String
  )

  enum class Environment(
    val value: String
  ) {
    DEV("dev"),

    QA("qa"),

    PROD("prod");

    override fun toString() = value
  }
}