YAML #

# Komentar dimulai dengan #

# Scalar — nilai primitif
nama: Budi Santoso
umur: 25
tinggi: 1.75
aktif: true
kosong: null            # atau ~

# String — tanda kutip opsional, wajib jika ada karakter khusus
kota: Jakarta
alamat: "Jl. Merdeka No. 1, Jakarta"
pesan: 'Ini "tanda kutip" dalam string'

# Multi-line string
deskripsi: |
  Ini baris pertama.
  Ini baris kedua.
  Newline dipertahankan.  

ringkasan: >
  Ini paragraf panjang yang
  di-wrap. Newline menjadi spasi,
  kecuali paragraf baru.  

# List (urutan)
buah:
  - apel
  - jeruk
  - mangga

# List inline
warna: [merah, hijau, biru]

# Map (mapping)
database:
  host: localhost
  port: 5432
  nama: mydb

# Map inline
koordinat: {lat: -6.2, lng: 106.8}

# Nested — list of maps
pengguna:
  - nama: Budi
    email: [email protected]
    peran: admin
  - nama: Siti
    email: [email protected]
    peran: user

# Anchor (&) dan Alias (*) — reuse nilai
default_db: &db_default
  host: localhost
  port: 5432

produksi:
  <<: *db_default       # merge dari anchor
  host: prod.example.com  # override field tertentu
  nama: prod_db

# Multi-document dalam satu file (dipisah ---)
---
dokumen: pertama
---
dokumen: kedua

dart pub add yaml

# pubspec.yaml
dependencies:
  yaml: ^3.1.2

import 'package:yaml/yaml.dart';

void main() {
  final yamlString = '''
nama: Budi Santoso
umur: 25
aktif: true
hobi:
  - membaca
  - coding
  - hiking
alamat:
  kota: Jakarta
  kodePos: '10110'
''';

  final doc = loadYaml(yamlString);

  // Hasil loadYaml adalah YamlMap — mirip Map tapi bukan Map Dart biasa
  print(doc.runtimeType);    // YamlMap

  // Akses nilai — mirip seperti Map
  print(doc['nama']);        // Budi Santoso
  print(doc['umur']);        // 25 (int)
  print(doc['aktif']);       // true (bool)

  // List
  final hobi = doc['hobi'] as YamlList;
  for (final h in hobi) {
    print(h); // membaca, coding, hiking
  }

  // Nested map
  final alamat = doc['alamat'] as YamlMap;
  print(alamat['kota']);     // Jakarta
  print(alamat['kodePos']);  // 10110 (String karena pakai tanda kutip di YAML)
}

import 'package:yaml/yaml.dart';

// Konversi rekursif YamlMap/YamlList ke tipe Dart native
dynamic yamlKeDart(dynamic node) {
  if (node is YamlMap) {
    return Map<String, dynamic>.fromEntries(
      node.entries.map(
        (e) => MapEntry(e.key.toString(), yamlKeDart(e.value)),
      ),
    );
  } else if (node is YamlList) {
    return node.map(yamlKeDart).toList();
  }
  return node; // scalar — String, int, double, bool, null
}

void main() {
  final doc = loadYaml('nama: Budi\numur: 25');
  final dartMap = yamlKeDart(doc) as Map<String, dynamic>;

  // Sekarang bisa dimodifikasi
  dartMap['email'] = '[email protected]';
  print(dartMap); // {nama: Budi, umur: 25, email: [email protected]}
}

import 'dart:io';
import 'package:yaml/yaml.dart';

Future<dynamic> bacaYaml(String path) async {
  final file = File(path);
  if (!await file.exists()) {
    throw FileSystemException('File YAML tidak ditemukan', path);
  }
  final konten = await file.readAsString();
  return loadYaml(konten);
}

// config.yaml:
// server:
//   host: localhost
//   port: 8080
//   ssl: false
// database:
//   url: postgresql://localhost/mydb
//   pool_size: 10

Future<void> main() async {
  final config = await bacaYaml('config.yaml');

  final host = config['server']['host'] as String;
  final port = config['server']['port'] as int;
  final dbUrl = config['database']['url'] as String;

  print('Server: $host:$port');
  print('Database: $dbUrl');
}

import 'package:yaml/yaml.dart';

class KonfigurasiServer {
  final String host;
  final int port;
  final bool ssl;
  final Duration timeout;

  const KonfigurasiServer({
    required this.host,
    required this.port,
    required this.ssl,
    required this.timeout,
  });

  factory KonfigurasiServer.fromYaml(YamlMap yaml) {
    return KonfigurasiServer(
      host: yaml['host'] as String? ?? 'localhost',
      port: yaml['port'] as int? ?? 8080,
      ssl: yaml['ssl'] as bool? ?? false,
      timeout: Duration(
        seconds: yaml['timeout_detik'] as int? ?? 30,
      ),
    );
  }

  @override
  String toString() =>
      'KonfigurasiServer(${ssl ? "https" : "http"}://$host:$port, timeout: ${timeout.inSeconds}s)';
}

class KonfigurasiAplikasi {
  final KonfigurasiServer server;
  final String namaAplikasi;
  final String lingkungan;
  final List<String> fiturAktif;

  const KonfigurasiAplikasi({
    required this.server,
    required this.namaAplikasi,
    required this.lingkungan,
    required this.fiturAktif,
  });

  factory KonfigurasiAplikasi.fromYaml(YamlMap yaml) {
    final fiturRaw = yaml['fitur_aktif'];
    final fitur = fiturRaw is YamlList
        ? fiturRaw.map((f) => f as String).toList()
        : <String>[];

    return KonfigurasiAplikasi(
      namaAplikasi: yaml['nama'] as String,
      lingkungan: yaml['lingkungan'] as String? ?? 'development',
      server: KonfigurasiServer.fromYaml(yaml['server'] as YamlMap),
      fiturAktif: fitur,
    );
  }
}

// Penggunaan
Future<void> main() async {
  final yamlString = await File('app_config.yaml').readAsString();
  final doc = loadYaml(yamlString) as YamlMap;
  final config = KonfigurasiAplikasi.fromYaml(doc);

  print(config.namaAplikasi);
  print(config.server);
  print('Fitur: ${config.fiturAktif.join(', ')}');
}

import 'package:yaml/yaml.dart';

void main() {
  final yamlMultiDoc = '''
---
nama: Budi
peran: admin
---
nama: Siti
peran: user
---
nama: Andi
peran: developer
''';

  // loadYamlDocuments — parsing semua dokumen sekaligus
  final dokumen = loadYamlDocuments(yamlMultiDoc);

  for (final doc in dokumen) {
    final map = doc.contents as YamlMap;
    print('${map['nama']}: ${map['peran']}');
  }
  // Budi: admin
  // Siti: user
  // Andi: developer
}

dart pub add yaml_writer

import 'package:yaml_writer/yaml_writer.dart';

void main() {
  final data = {
    'nama': 'Aplikasi Toko',
    'versi': '1.0.0',
    'server': {
      'host': 'localhost',
      'port': 8080,
    },
    'fitur': ['autentikasi', 'pembayaran', 'notifikasi'],
    'database': {
      'url': 'postgresql://localhost/toko',
      'pool': 10,
    },
  };

  final writer = YamlWriter();
  final output = writer.write(data);
  print(output);
}
// Output:
// nama: Aplikasi Toko
// versi: 1.0.0
// server:
//   host: localhost
//   port: 8080
// fitur:
//   - autentikasi
//   - pembayaran
//   - notifikasi
// database:
//   url: "postgresql://localhost/toko"
//   pool: 10

import 'dart:io';
import 'package:yaml_writer/yaml_writer.dart';

Future<void> simpanKonfigurasi(Map<String, dynamic> data, String path) async {
  final writer = YamlWriter();
  final yamlString = writer.write(data);
  await File(path).writeAsString(yamlString);
  print('Konfigurasi disimpan ke $path');
}

// Hal yang sama dalam tiga format:

// YAML
server:
  host: localhost
  port: 8080
fitur:
  - auth
  - payment

// JSON
{
  "server": {"host": "localhost", "port": 8080},
  "fitur": ["auth", "payment"]
}

// TOML
[server]
host = "localhost"
port = 8080
fitur = ["auth", "payment"]

# config/base.yaml — konfigurasi dasar
app:
  nama: Aplikasi Toko
  versi: 1.0.0
  debug: false

logging:
  level: info
  format: json

database:
  pool_size: 5
  timeout_detik: 30

# config/development.yaml — override untuk development
app:
  debug: true

logging:
  level: debug
  format: text

database:
  url: postgresql://localhost/toko_dev
  pool_size: 2

import 'dart:io';
import 'package:yaml/yaml.dart';

// Loader konfigurasi multi-environment
Future<Map<String, dynamic>> muatKonfigurasi(String lingkungan) async {
  // Muat base config
  final base = await _bacaYaml('config/base.yaml');

  // Muat environment config
  final envPath = 'config/$lingkungan.yaml';
  final envFile = File(envPath);
  if (!await envFile.exists()) {
    return base;
  }

  final env = await _bacaYaml(envPath);

  // Deep merge — env override base
  return _deepMerge(base, env);
}

Future<Map<String, dynamic>> _bacaYaml(String path) async {
  final yaml = loadYaml(await File(path).readAsString());
  return _yamlKeDart(yaml) as Map<String, dynamic>;
}

// Deep merge dua Map — nilai kanan menimpa kiri, nested Map di-merge
Map<String, dynamic> _deepMerge(
    Map<String, dynamic> base, Map<String, dynamic> override) {
  final hasil = Map<String, dynamic>.from(base);
  for (final entry in override.entries) {
    final baseValue = base[entry.key];
    final overrideValue = entry.value;

    if (baseValue is Map<String, dynamic> && overrideValue is Map<String, dynamic>) {
      hasil[entry.key] = _deepMerge(baseValue, overrideValue);
    } else {
      hasil[entry.key] = overrideValue;
    }
  }
  return hasil;
}

dynamic _yamlKeDart(dynamic node) {
  if (node is YamlMap) {
    return Map<String, dynamic>.fromEntries(
      node.entries.map((e) => MapEntry(e.key.toString(), _yamlKeDart(e.value))),
    );
  } else if (node is YamlList) {
    return node.map(_yamlKeDart).toList();
  }
  return node;
}

// Penggunaan
Future<void> main() async {
  final lingkungan = Platform.environment['APP_ENV'] ?? 'development';
  final config = await muatKonfigurasi(lingkungan);

  print('Lingkungan: $lingkungan');
  print('Debug mode: ${config['app']['debug']}');
  print('Database URL: ${config['database']['url']}');
}

// ANTI-PATTERN: asumsi tipe tanpa cast atau validasi
final doc = loadYaml(yamlString);
final port = doc['server']['port'] * 2; // ✗ dynamic — bisa crash

// BENAR: cast eksplisit dengan fallback
final port = (doc['server']['port'] as int?) ?? 8080;
final portDikalikan = port * 2;

// ANTI-PATTERN: gunakan YAML sebagai database runtime
// YAML tidak mendukung penulisan parsial — seluruh file harus ditulis ulang
Future<void> tambahPengguna(String nama) async {
  final doc = loadYaml(await File('users.yaml').readAsString());
  // ✗ tidak efisien dan rentan race condition untuk data yang sering berubah
}

// BENAR: YAML untuk konfigurasi statis, database untuk data dinamis
// Gunakan SQLite, Hive, atau file JSON untuk data yang sering berubah

# ANTI-PATTERN: tab dan spasi tercampur
server:
  host: localhost
	port: 8080      # ← TAB — akan menyebabkan YamlException!

# BENAR: selalu gunakan spasi (bukan tab), konsisten 2 atau 4 spasi
server:
  host: localhost
  port: 8080