bin/jinja_template_render.sh

#!/usr/bin/env bash

##############################################################
# Jinja2 Template Renderer - Ninja Edition
# A sophisticated template rendering engine with style
##############################################################

set -uo pipefail
# Note: Using -u and pipefail, but not -e to allow graceful error handling

# Terminal colors using tput
BLACK="" RED="" GREEN="" YELLOW="" BLUE="" MAGENTA="" CYAN="" WHITE="" GRAY=""
BOLD="" DIM="" ITALIC="" UNDERLINE="" RESET=""

if [[ -t 1 ]] && command -v tput >/dev/null 2>&1; then
    COLORS=$(tput colors 2>/dev/null || echo 0)
    if [[ ${COLORS:-0} -ge 8 ]]; then
        BLACK=$(tput setaf 0 2>/dev/null || echo "")
        RED=$(tput setaf 1 2>/dev/null || echo "")
        GREEN=$(tput setaf 2 2>/dev/null || echo "")
        YELLOW=$(tput setaf 3 2>/dev/null || echo "")
        BLUE=$(tput setaf 4 2>/dev/null || echo "")
        MAGENTA=$(tput setaf 5 2>/dev/null || echo "")
        CYAN=$(tput setaf 6 2>/dev/null || echo "")
        WHITE=$(tput setaf 7 2>/dev/null || echo "")
        GRAY=$(tput setaf 8 2>/dev/null || echo "")
        BOLD=$(tput bold 2>/dev/null || echo "")
        DIM=$(tput dim 2>/dev/null || echo "")
        ITALIC=$(tput sitm 2>/dev/null || echo "")
        UNDERLINE=$(tput smul 2>/dev/null || echo "")
        RESET=$(tput sgr0 2>/dev/null || echo "")
    fi
fi

# Ninja-themed icons (ASCII compatible)
readonly NINJA="[NINJA]"
readonly SHURIKEN="*"
readonly KATANA=">>"
readonly SCROLL="[SCROLL]"
readonly FIRE="[FIRE]"
readonly STAR="*"
readonly CHECK="[OK]"
readonly CROSS="[X]"
readonly ARROW="-->"
readonly LIGHTNING="[!]"
readonly GEAR="[GEAR]"
readonly TARGET="[TARGET]"

# Script configuration
OUTPUT_DIR="${PWD}/output"
TEMPLATES=()
VAR_FILES=()
CLI_VARS=()
VERBOSE=false
PREVIEW=false
WATCH=false
STRICT=false
DRY_RUN=false

# Performance tracking
START_TIME=0
TEMPLATE_COUNT=0
VAR_COUNT=0

##############################################################
# Ninja UI Functions
##############################################################

print_ninja_banner() {
    echo "${MAGENTA}${BOLD}"
    cat << 'EOF'
    TPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPW
    Q                                                       Q
    Q       <20>  JINJA2 TEMPLATE RENDERER - NINJA EDITION   Q
    Q                                                       Q
    Q   >w  Fast " Powerful " Stealthy Template Magic  <20>  Q
    Q                                                       Q
    ZPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP]
EOF
    echo "${RESET}"
}

print_ninja_art() {
    echo "${CYAN}${DIM}"
    cat << 'EOF'
                    ___
                 __/_  `.  .-"""-.
                 \_,` | \-'  /   )`-')
                  "") `"`    \  ((`"`
                 ___Y  ,    .'7 /|
                (_,___/...-` (_/_/

         Silently rendering your templates...
EOF
    echo "${RESET}"
}

# Animated ninja message
ninja_say() {
    local message="$1"
    echo "${CYAN}${NINJA}${RESET} ${BOLD}${message}${RESET}"
}

ninja_success() {
    echo "${GREEN}${CHECK} ${NINJA}${RESET} ${GREEN}$*${RESET}"
}

ninja_error() {
    echo "${RED}${CROSS} ${NINJA}${RESET} ${RED}$*${RESET}" >&2
}

ninja_warn() {
    echo "${YELLOW}${LIGHTNING}${RESET} ${YELLOW}$*${RESET}"
}

ninja_info() {
    echo "${BLUE}${SHURIKEN}${RESET} ${BLUE}$*${RESET}"
}

ninja_verbose() {
    [[ "$VERBOSE" == true ]] && echo "${DIM}  ${ARROW} $*${RESET}"
}

ninja_progress() {
    local current=$1
    local total=$2
    local item=$3
    local percent=$((current * 100 / total))
    local bar_length=30
    local filled=$((bar_length * current / total))
    local bar=""

    for ((i=0; i<bar_length; i++)); do
        if ((i < filled)); then
            bar+="${FIRE}"
        else
            bar+="<22>"
        fi
    done

    echo -ne "\r${CYAN}${GEAR}${RESET} [${bar}] ${percent}% - ${ITALIC}${item}${RESET}"

    if ((current == total)); then
        echo "" # New line when complete
    fi
}

# Typing animation effect
ninja_type() {
    local text="$1"
    local delay="${2:-0.03}"

    for ((i=0; i<${#text}; i++)); do
        echo -n "${text:$i:1}"
        sleep "$delay"
    done
    echo ""
}

##############################################################
# Help and Usage
##############################################################

show_help() {
    cat << EOF
${BOLD}${MAGENTA}JINJA2 TEMPLATE RENDERER - NINJA EDITION${RESET}

${BOLD}USAGE:${RESET}
    $(basename "$0") [OPTIONS] <template> [template...]

${BOLD}DESCRIPTION:${RESET}
    A sophisticated Jinja2 template rendering engine with support for
    multiple variable sources, glob patterns, and ninja-style operations.

${BOLD}ARGUMENTS:${RESET}
    <template>               Template file(s) to render (glob patterns supported)
                             Examples: template.j2, templates/*.j2, **/*.jinja2

${BOLD}OPTIONS:${RESET}
    -o, --output DIR         Output directory (default: ./output)
    -v, --var KEY=VALUE      Define template variable (can be used multiple times)
    -f, --file FILE          Load variables from JSON/YAML file (repeatable)
    -V, --verbose            Enable verbose ninja commentary
    -p, --preview            Preview rendered output without saving
    -s, --strict             Enable strict mode (fail on undefined variables)
    -d, --dry-run            Perform dry run without writing files
    -w, --watch              Watch templates and re-render on changes (experimental)
    -h, --help               Show this legendary scroll of knowledge

${BOLD}VARIABLE SOURCES:${RESET}
    Variables are merged in this order (later sources override earlier):
    1. YAML files (loaded via yq)
    2. JSON files (loaded via jq)
    3. CLI variables (-v KEY=VALUE)

${BOLD}EXAMPLES:${RESET}
    ${DIM}# Render single template with CLI variables${RESET}
    $(basename "$0") template.j2 -v name=Ninja -v level=Master

    ${DIM}# Render multiple templates with YAML config${RESET}
    $(basename "$0") templates/*.j2 -f config.yaml -o dist/

    ${DIM}# Render with multiple variable sources${RESET}
    $(basename "$0") app.j2 -f base.yaml -f env.json -v debug=true

    ${DIM}# Preview without saving${RESET}
    $(basename "$0") template.j2 -f vars.yaml --preview --verbose

    ${DIM}# Strict mode with dry run${RESET}
    $(basename "$0") *.j2 -f vars.json --strict --dry-run

${BOLD}TEMPLATE SYNTAX:${RESET}
    Jinja2 template example:
    ${DIM}
    Hello {{ name }}!
    {% for item in items %}
      - {{ item }}
    {% endfor %}
    {% if debug %}Debug mode enabled{% endif %}
    ${RESET}

${BOLD}REQUIREMENTS:${RESET}
    - Python 3 with jinja2 package
    - jq (for JSON parsing)
    - yq (for YAML parsing)

${MAGENTA}${NINJA} May your templates be swift and your renders be flawless! ${KATANA}${RESET}

EOF
}

##############################################################
# Variable Collection Functions
##############################################################

# Parse CLI variable in KEY=VALUE format
parse_cli_var() {
    local var="$1"

    if [[ ! "$var" =~ ^[a-zA-Z_][a-zA-Z0-9_]*=.* ]]; then
        ninja_error "Invalid variable format: $var (expected KEY=VALUE)"
        return 1
    fi

    CLI_VARS+=("$var")
    ninja_verbose "Added CLI variable: ${CYAN}$var${RESET}"
}

# Load variables from YAML file
load_yaml_vars() {
    local file="$1"

    if [[ ! -f "$file" ]]; then
        ninja_error "YAML file not found: $file"
        return 1
    fi

    if ! command -v yq &> /dev/null; then
        ninja_error "yq not found. Install with: pip install yq"
        return 1
    fi

    ninja_verbose "Loading YAML variables from: ${MAGENTA}$file${RESET}"

    # Validate YAML syntax
    if ! yq -e '.' "$file" &> /dev/null; then
        ninja_error "Invalid YAML syntax in: $file"
        return 1
    fi

    VAR_FILES+=("yaml:$file")
}

# Load variables from JSON file
load_json_vars() {
    local file="$1"

    if [[ ! -f "$file" ]]; then
        ninja_error "JSON file not found: $file"
        return 1
    fi

    if ! command -v jq &> /dev/null; then
        ninja_error "jq not found. Install with: apt-get install jq"
        return 1
    fi

    ninja_verbose "Loading JSON variables from: ${MAGENTA}$file${RESET}"

    # Validate JSON syntax
    if ! jq empty "$file" &> /dev/null; then
        ninja_error "Invalid JSON syntax in: $file"
        return 1
    fi

    VAR_FILES+=("json:$file")
}

# Build Python dictionary from all variable sources
build_context_dict() {
    local python_dict="{"
    local first=true

    # Process variable files (YAML and JSON)
    for var_file in "${VAR_FILES[@]}"; do
        local type="${var_file%%:*}"
        local file="${var_file#*:}"

        if [[ "$type" == "yaml" ]]; then
            # Convert YAML to JSON using yq
            local json_content
            json_content=$(yq -o json '.' "$file" 2>/dev/null) || {
                ninja_error "Failed to parse YAML: $file"
                return 1
            }

            # Extract key-value pairs and fix Python boolean casing
            while IFS= read -r line; do
                if [[ -n "$line" ]]; then
                    # Fix boolean values: true -> True, false -> False
                    line="${line//: true/: True}"
                    line="${line//: false/: False}"
                    # Convert hyphens to underscores in key names for Jinja2 compatibility
                    # Extract key and value, replace hyphens in key only
                    if [[ "$line" =~ ^\"([^\"]+)\":[[:space:]]*(.+)$ ]]; then
                        local key="${BASH_REMATCH[1]}"
                        local value="${BASH_REMATCH[2]}"
                        key="${key//-/_}"  # Replace all hyphens with underscores
                        line="\"$key\": $value"
                    fi

                    if [[ "$first" == true ]]; then
                        first=false
                    else
                        python_dict+=", "
                    fi
                    python_dict+="$line"
                fi
            done < <(echo "$json_content" | jq -r 'to_entries | .[] | "\"\(.key)\": \(.value | tojson)"')

        elif [[ "$type" == "json" ]]; then
            # Process JSON file and fix Python boolean casing
            while IFS= read -r line; do
                if [[ -n "$line" ]]; then
                    # Fix boolean values: true -> True, false -> False
                    line="${line//: true/: True}"
                    line="${line//: false/: False}"
                    # Convert hyphens to underscores in key names for Jinja2 compatibility
                    if [[ "$line" =~ ^\"([^\"]+)\":[[:space:]]*(.+)$ ]]; then
                        local key="${BASH_REMATCH[1]}"
                        local value="${BASH_REMATCH[2]}"
                        key="${key//-/_}"  # Replace all hyphens with underscores
                        line="\"$key\": $value"
                    fi

                    if [[ "$first" == true ]]; then
                        first=false
                    else
                        python_dict+=", "
                    fi
                    python_dict+="$line"
                fi
            done < <(jq -r 'to_entries | .[] | "\"\(.key)\": \(.value | tojson)"' "$file")
        fi
    done

    # Process CLI variables (these override file variables)
    for var in "${CLI_VARS[@]}"; do
        local key="${var%%=*}"
        local value="${var#*=}"

        if [[ "$first" == true ]]; then
            first=false
        else
            python_dict+=", "
        fi

        # Auto-detect value type and format for Python
        if [[ "$value" =~ ^[0-9]+$ ]]; then
            # Integer
            python_dict+="\"$key\": $value"
        elif [[ "$value" =~ ^[0-9]+\.[0-9]+$ ]]; then
            # Float
            python_dict+="\"$key\": $value"
        elif [[ "$value" == "true" ]] || [[ "$value" == "false" ]]; then
            # Boolean
            python_dict+="\"$key\": ${value^}"
        elif [[ "$value" == "null" ]]; then
            # Null
            python_dict+="\"$key\": None"
        elif [[ "$value" =~ ^\[.*\]$ ]] || [[ "$value" =~ ^\{.*\}$ ]]; then
            # JSON array or object
            python_dict+="\"$key\": $value"
        else
            # String (escape quotes)
            value="${value//\"/\\\"}"
            python_dict+="\"$key\": \"$value\""
        fi
    done

    python_dict+="}"
    echo "$python_dict"
}

##############################################################
# Template Rendering Engine
##############################################################

render_template() {
    local template_file="$1"
    local output_file="$2"
    local context="$3"

    ninja_verbose "Rendering: ${CYAN}$(basename "$template_file")${RESET}"

    # Create Python rendering script
    local python_script=$(cat <<'PYTHON_EOF'
import sys
import json
import os
from jinja2 import Environment, FileSystemLoader, StrictUndefined, TemplateError

def render_template(template_path, context_dict, strict=False):
    """Render a Jinja2 template with given context."""
    try:
        # Setup Jinja2 environment
        template_dir = os.path.dirname(os.path.abspath(template_path))
        template_name = os.path.basename(template_path)

        env_kwargs = {
            'loader': FileSystemLoader(template_dir),
            'trim_blocks': True,
            'lstrip_blocks': True,
            'keep_trailing_newline': True,
        }

        if strict:
            env_kwargs['undefined'] = StrictUndefined

        env = Environment(**env_kwargs)

        # Load and render template
        template = env.get_template(template_name)
        rendered = template.render(**context_dict)

        return rendered, None

    except TemplateError as e:
        return None, f"Template Error: {e}"
    except Exception as e:
        return None, f"Unexpected Error: {e}"

if __name__ == '__main__':
    if len(sys.argv) != 4:
        print("Usage: script.py <template> <context_json> <strict>", file=sys.stderr)
        sys.exit(1)

    template_path = sys.argv[1]
    context_json = sys.argv[2]
    strict = sys.argv[3].lower() == 'true'

    # Parse context
    try:
        context = eval(context_json)  # Safe in this controlled context
    except Exception as e:
        print(f"Failed to parse context: {e}", file=sys.stderr)
        sys.exit(1)

    # Render template
    result, error = render_template(template_path, context, strict)

    if error:
        print(error, file=sys.stderr)
        sys.exit(1)

    print(result, end='')
PYTHON_EOF
)

    # Check if Python and Jinja2 are available
    if ! python3 -c "import jinja2" 2>/dev/null; then
        ninja_error "Python jinja2 module not found. Install with: pip install jinja2"
        return 1
    fi

    # Render template
    local rendered
    local strict_flag="false"
    [[ "$STRICT" == true ]] && strict_flag="true"

    if rendered=$(python3 -c "$python_script" "$template_file" "$context" "$strict_flag" 2>&1); then
        if [[ "$PREVIEW" == true ]]; then
            # Preview mode - just display
            echo ""
            echo "${CYAN}${BOLD}PPP Preview: $(basename "$template_file") PPP${RESET}"
            echo "$rendered"
            echo "${CYAN}${BOLD}PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP${RESET}"
            echo ""
        elif [[ "$DRY_RUN" == true ]]; then
            ninja_verbose "Would write to: ${GREEN}$output_file${RESET}"
        else
            # Write to output file
            echo "$rendered" > "$output_file"
            ninja_verbose "Wrote: ${GREEN}$output_file${RESET}"
        fi
        return 0
    else
        ninja_error "Failed to render $(basename "$template_file")"
        echo "${RED}$rendered${RESET}" >&2
        return 1
    fi
}

##############################################################
# Template Discovery and Processing
##############################################################

discover_templates() {
    local pattern="$1"
    local found_templates=()

    # Check if pattern contains glob characters
    if [[ "$pattern" == *"*"* ]] || [[ "$pattern" == *"?"* ]]; then
        # Glob expansion
        shopt -s nullglob globstar
        for file in $pattern; do
            if [[ -f "$file" ]]; then
                found_templates+=("$file")
            fi
        done
        shopt -u nullglob globstar
    else
        # Direct file
        if [[ -f "$pattern" ]]; then
            found_templates+=("$pattern")
        else
            ninja_error "Template not found: $pattern"
            return 1
        fi
    fi

    if [[ ${#found_templates[@]} -eq 0 ]]; then
        ninja_error "No templates found matching: $pattern"
        return 1
    fi

    printf '%s\n' "${found_templates[@]}"
}

process_templates() {
    local context="$1"
    local all_templates=()

    # Discover all templates from patterns
    ninja_info "Discovering templates with ninja precision..."

    for pattern in "${TEMPLATES[@]}"; do
        while IFS= read -r template; do
            all_templates+=("$template")
        done < <(discover_templates "$pattern")
    done

    TEMPLATE_COUNT=${#all_templates[@]}

    if [[ $TEMPLATE_COUNT -eq 0 ]]; then
        ninja_error "No templates to render!"
        return 1
    fi

    ninja_success "Found ${BOLD}$TEMPLATE_COUNT${RESET}${GREEN} template(s)${RESET}"

    # Create output directory
    if [[ "$PREVIEW" == false ]] && [[ "$DRY_RUN" == false ]]; then
        mkdir -p "$OUTPUT_DIR"
        ninja_verbose "Output directory: ${GREEN}$OUTPUT_DIR${RESET}"
    fi

    # Render each template
    echo ""
    ninja_say "Initiating stealth rendering sequence..."
    echo ""

    local success_count=0
    local fail_count=0

    for i in "${!all_templates[@]}"; do
        local template="${all_templates[$i]}"
        local template_name
        template_name=$(basename "$template")
        local output_name="${template_name%.j2}"
        output_name="${output_name%.jinja2}"
        output_name="${output_name%.jinja}"
        local output_file="$OUTPUT_DIR/$output_name"

        # Show progress
        ninja_progress $((i + 1)) "$TEMPLATE_COUNT" "$template_name"

        # Render template
        if render_template "$template" "$output_file" "$context"; then
            ((success_count++))
        else
            ((fail_count++))
        fi
    done

    echo ""

    # Summary
    if [[ $fail_count -eq 0 ]]; then
        ninja_success "All $TEMPLATE_COUNT templates rendered successfully! ${STAR}"
    else
        ninja_warn "Rendered: $success_count success, $fail_count failed"
    fi

    return 0
}

##############################################################
# Main Function
##############################################################

main() {
    START_TIME=$(date +%s)

    # Parse arguments
    while [[ $# -gt 0 ]]; do
        case $1 in
            -o|--output)
                OUTPUT_DIR="$2"
                shift 2
                ;;
            -v|--var)
                parse_cli_var "$2"
                shift 2
                ;;
            -f|--file)
                VAR_FILE_ARG="$2"
                VAR_FILE_EXT="${VAR_FILE_ARG##*.}"

                case "$VAR_FILE_EXT" in
                    yaml|yml)
                        load_yaml_vars "$VAR_FILE_ARG"
                        ;;
                    json)
                        load_json_vars "$VAR_FILE_ARG"
                        ;;
                    *)
                        ninja_error "Unsupported file format: .$VAR_FILE_EXT (use .yaml, .yml, or .json)"
                        exit 1
                        ;;
                esac
                shift 2
                ;;
            -V|--verbose)
                VERBOSE=true
                shift
                ;;
            -p|--preview)
                PREVIEW=true
                shift
                ;;
            -s|--strict)
                STRICT=true
                shift
                ;;
            -d|--dry-run)
                DRY_RUN=true
                shift
                ;;
            -w|--watch)
                WATCH=true
                shift
                ;;
            -h|--help)
                show_help
                exit 0
                ;;
            -*)
                ninja_error "Unknown option: $1"
                echo "Use -h or --help for usage information"
                exit 1
                ;;
            *)
                TEMPLATES+=("$1")
                shift
                ;;
        esac
    done

    # Show ninja banner
    print_ninja_banner

    if [[ "$VERBOSE" == true ]]; then
        print_ninja_art
    fi

    # Validate inputs
    if [[ ${#TEMPLATES[@]} -eq 0 ]]; then
        ninja_error "No templates specified!"
        echo "Use -h or --help for usage information"
        exit 1
    fi

    # Build context dictionary
    ninja_info "Gathering ninja scrolls and ancient wisdom..."

    local context
    if ! context=$(build_context_dict); then
        exit 1
    fi

    VAR_COUNT=$(echo "$context" | grep -o '"[^"]*":' | wc -l)

    if [[ "$VERBOSE" == true ]]; then
        ninja_verbose "Context dictionary built with ${CYAN}$VAR_COUNT${RESET} variables"
        echo "${DIM}$context${RESET}"
    fi

    ninja_success "Loaded ${BOLD}$VAR_COUNT${RESET}${GREEN} variable(s)${RESET}"

    # Show mode indicators
    [[ "$STRICT" == true ]] && ninja_warn "Strict mode: ${BOLD}ENABLED${RESET}"
    [[ "$DRY_RUN" == true ]] && ninja_warn "Dry run mode: ${BOLD}ENABLED${RESET}"
    [[ "$PREVIEW" == true ]] && ninja_info "Preview mode: ${BOLD}ENABLED${RESET}"

    # Process templates
    if ! process_templates "$context"; then
        exit 1
    fi

    # Calculate execution time
    local end_time
    end_time=$(date +%s)
    local duration=$((end_time - START_TIME))

    echo ""
    ninja_success "Mission complete in ${BOLD}${duration}s${RESET} ${TARGET}"

    if [[ "$PREVIEW" == false ]] && [[ "$DRY_RUN" == false ]]; then
        ninja_info "Output directory: ${CYAN}${BOLD}$OUTPUT_DIR${RESET}"
    fi

    echo ""
    echo "${MAGENTA}${NINJA} The ninja vanishes into the shadows... ${KATANA}${RESET}"
    echo ""
}

# Execute main function
main "$@"