How do I handle multi-line strings in YAML?

Use literal (|) for preserving line breaks or folded (>) for wrapping lines. The formatter preserves these indicators and properly indents the content while maintaining readability.

Before Formatting (Messy):

name: myapp
version: 1.0.0
database:
host: localhost
    port: 5432
username: admin
services:
- name: web
  port: 80
  replicas: 3
- name: api
port: 8080
  replicas: 2
config:
  debug: true
      timeout: 30
  features: [auth, logging, metrics]
            

After Formatting (Clean):

name: myapp
version: 1.0.0
database:
  host: localhost
  port: 5432
  username: admin
services:
  - name: web
    port: 80
    replicas: 3
  - name: api
    port: 8080
    replicas: 2
config:
  debug: true
  timeout: 30
  features:
    - auth
    - logging
    - metrics
            

Kubernetes Style (2-space):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.20
        ports:
        - containerPort: 80
            

CI/CD Configuration (4-space):

name: CI Pipeline
on:
    push:
        branches: [main, develop]
    pull_request:
        branches: [main]
jobs:
    test:
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v2
            - name: Setup Node.js
              uses: actions/setup-node@v2
              with:
                  node-version: '16'
            - name: Install dependencies
              run: npm ci
            - name: Run tests
              run: npm test
            

Multi-line Strings and Comments:

# Application configuration
app:
  name: MyApplication
  version: "2.1.0"
  
  # Database connection settings
  database:
    host: localhost
    port: 5432
    credentials: |
      username: app_user
      password: secure_password_123
      ssl_mode: require
  
  # Multi-line description
  description: >
    This is a long description that spans
    multiple lines but will be folded into
    a single line when parsed.
  
  # Script content preserved with literal block
  startup_script: |
    #!/bin/bash
    echo "Starting application..."
    ./start.sh --verbose
    echo "Application started successfully"

# Environment-specific overrides
environments:
  development:
    debug: true
    log_level: debug
  production:
    debug: false
    log_level: error
            

Docker Compose Format:

version: '3.8'
services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "80:80"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    depends_on:
      - db
      - redis
    volumes:
      - ./app:/usr/src/app
      - /usr/src/app/node_modules
    networks:
      - app-network
  
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network
  
  redis:
    image: redis:6-alpine
    networks:
      - app-network

volumes:
  postgres_data:

networks:
  app-network:
    driver: bridge
            

JavaScript YAML Formatting:

// Using js-yaml library
const yaml = require('js-yaml');

function formatYAML(yamlString, options = {}) {
  try {
    // Parse YAML
    const data = yaml.load(yamlString);
    
    // Format with options
    const formatted = yaml.dump(data, {
      indent: options.indent || 2,
      lineWidth: options.lineWidth || 120,
      noRefs: true,
      sortKeys: options.sortKeys || false,
      quotingType: options.quotingType || '"',
      forceQuotes: options.forceQuotes || false
    });
    
    return formatted;
  } catch (error) {
    throw new Error('Invalid YAML: ' + error.message);
  }
}

// Usage example
const messyYAML = `
name:myapp
database:
  host:localhost
port:5432
features: [auth,logging]`;

const formatted = formatYAML(messyYAML, {
  indent: 2,
  sortKeys: false
});

console.log(formatted);
/*
name: myapp
database:
  host: localhost
  port: 5432
features:
  - auth
  - logging
*/
            

Python YAML Formatting:

import yaml
from io import StringIO

def format_yaml(yaml_string, indent=2, sort_keys=False):
    """Format YAML string with proper indentation"""
    try:
        # Parse YAML
        data = yaml.safe_load(yaml_string)
        
        # Format with custom options
        output = StringIO()
        yaml.dump(data, 
                  output, 
                  default_flow_style=False,
                  indent=indent,
                  sort_keys=sort_keys,
                  allow_unicode=True,
                  width=120)
        
        return output.getvalue()
        
    except yaml.YAMLError as e:
        raise ValueError(f"Invalid YAML: {e}")

def format_yaml_file(input_file, output_file, indent=2):
    """Format YAML file and save to new file"""
    with open(input_file, 'r', encoding='utf-8') as f:
        yaml_content = f.read()
    
    formatted = format_yaml(yaml_content, indent)
    
    with open(output_file, 'w', encoding='utf-8') as f:
        f.write(formatted)
    
    print(f"Formatted YAML saved to {output_file}")

# Usage example
yaml_str = '''
name:myapp
database:
  host:localhost
  port:5432
features: [auth,logging]
'''

formatted = format_yaml(yaml_str, indent=2)
print(formatted)