704 lines
26 KiB
Bash
Executable file
704 lines
26 KiB
Bash
Executable file
#!/bin/bash
|
|
|
|
# Build script for localized content
|
|
# This script converts markdown files to HTML and deploys them to localized public directories
|
|
|
|
set -e
|
|
|
|
# Configuration - Use environment variable or fallback to default
|
|
CONTENT_DIR="${SITE_CONTENT_PATH:-site/content}"
|
|
PUBLIC_DIR="public"
|
|
|
|
# Supported languages
|
|
LANGUAGES=("en" "es")
|
|
|
|
# Function to read content types from content-kinds.toml
|
|
get_enabled_content_types() {
|
|
local content_kinds_file="${CONTENT_DIR}/content-kinds.toml"
|
|
local enabled_types=()
|
|
|
|
if [ ! -f "$content_kinds_file" ]; then
|
|
echo "⚠️ Warning: content-kinds.toml not found at $content_kinds_file, using default types" >&2
|
|
echo "blog recipes"
|
|
return
|
|
fi
|
|
|
|
# More robust TOML parsing - process line by line and track state
|
|
local in_content_kinds_section=false
|
|
local current_name=""
|
|
local current_directory=""
|
|
local current_enabled=""
|
|
|
|
while IFS= read -r line; do
|
|
# Skip comments and empty lines
|
|
[[ "$line" =~ ^[[:space:]]*# ]] && continue
|
|
[[ -z "${line// }" ]] && continue
|
|
|
|
# Check for new content_kinds section
|
|
if [[ "$line" =~ ^\[\[content_kinds\]\] ]]; then
|
|
# Process previous section if we have one
|
|
if [[ "$in_content_kinds_section" == true && "$current_enabled" == "true" && -n "$current_directory" ]]; then
|
|
if [ -d "${CONTENT_DIR}/${current_directory}" ]; then
|
|
enabled_types+=("$current_directory")
|
|
echo "✅ Content type '$current_name' -> directory '${current_directory}' exists" >&2
|
|
else
|
|
echo "⚠️ WARNING: Content type '$current_name' enabled in content-kinds.toml but directory '${CONTENT_DIR}/${current_directory}' does not exist - SKIPPING" >&2
|
|
fi
|
|
fi
|
|
|
|
# Reset for new section
|
|
in_content_kinds_section=true
|
|
current_name=""
|
|
current_directory=""
|
|
current_enabled=""
|
|
continue
|
|
fi
|
|
|
|
# If we're in a content_kinds section, parse the fields
|
|
if [[ "$in_content_kinds_section" == true ]]; then
|
|
# Check for another section starting (end current one)
|
|
if [[ "$line" =~ ^\[\[ ]]; then
|
|
# Process current section before moving to next
|
|
if [[ "$current_enabled" == "true" && -n "$current_directory" ]]; then
|
|
if [ -d "${CONTENT_DIR}/${current_directory}" ]; then
|
|
enabled_types+=("$current_directory")
|
|
echo "✅ Content type '$current_name' -> directory '${current_directory}' exists" >&2
|
|
else
|
|
echo "⚠️ WARNING: Content type '$current_name' enabled in content-kinds.toml but directory '${CONTENT_DIR}/${current_directory}' does not exist - SKIPPING" >&2
|
|
fi
|
|
fi
|
|
in_content_kinds_section=false
|
|
continue
|
|
fi
|
|
|
|
# Extract fields
|
|
if [[ "$line" =~ ^name[[:space:]]*=[[:space:]]*\"([^\"]+)\" ]]; then
|
|
current_name="${BASH_REMATCH[1]}"
|
|
elif [[ "$line" =~ ^directory[[:space:]]*=[[:space:]]*\"([^\"]+)\" ]]; then
|
|
current_directory="${BASH_REMATCH[1]}"
|
|
elif [[ "$line" =~ ^enabled[[:space:]]*=[[:space:]]*true ]]; then
|
|
current_enabled="true"
|
|
fi
|
|
fi
|
|
done < "$content_kinds_file"
|
|
|
|
# Don't forget to process the last section
|
|
if [[ "$in_content_kinds_section" == true && "$current_enabled" == "true" && -n "$current_directory" ]]; then
|
|
if [ -d "${CONTENT_DIR}/${current_directory}" ]; then
|
|
enabled_types+=("$current_directory")
|
|
echo "✅ Content type '$current_name' -> directory '${current_directory}' exists" >&2
|
|
else
|
|
echo "⚠️ WARNING: Content type '$current_name' enabled in content-kinds.toml but directory '${CONTENT_DIR}/${current_directory}' does not exist - SKIPPING" >&2
|
|
fi
|
|
fi
|
|
|
|
|
|
if [ ${#enabled_types[@]} -eq 0 ]; then
|
|
echo "⚠️ Warning: No enabled content types found, using defaults" >&2
|
|
echo "blog recipes"
|
|
else
|
|
echo "${enabled_types[@]}"
|
|
fi
|
|
}
|
|
|
|
# Get the script directory and project root
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
|
|
|
|
echo "🌍 Building localized markdown content to HTML..."
|
|
echo "📁 Using content root: $CONTENT_DIR"
|
|
|
|
# Get enabled content types from content-kinds.toml
|
|
CONTENT_TYPES=($(get_enabled_content_types))
|
|
echo "📋 Enabled content types: ${CONTENT_TYPES[*]}"
|
|
|
|
# Build the markdown converter with content-static feature
|
|
echo "🔧 Building markdown converter..."
|
|
cd "$PROJECT_ROOT"
|
|
cargo build --bin markdown_converter --features content-static --quiet
|
|
|
|
CONVERTER="./target/debug/markdown_converter"
|
|
|
|
# Check if converter was built successfully
|
|
if [ ! -f "$CONVERTER" ]; then
|
|
echo "❌ Error: Markdown converter not found. Build may have failed."
|
|
exit 1
|
|
fi
|
|
|
|
# Create public directories for all content types
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
mkdir -p "${PUBLIC_DIR}/${content_type}"
|
|
echo "📁 Created directory: ${PUBLIC_DIR}/${content_type}"
|
|
done
|
|
|
|
# Function to extract frontmatter from markdown file
|
|
extract_frontmatter() {
|
|
local input_file="$1"
|
|
|
|
# Extract YAML frontmatter between --- delimiters
|
|
if head -1 "$input_file" | grep -q "^---$"; then
|
|
awk '/^---$/{flag++; next} flag==1 && /^---$/{flag++} flag==1{print}' "$input_file"
|
|
fi
|
|
}
|
|
|
|
# Function to extract tags/categories from frontmatter
|
|
extract_metadata() {
|
|
local input_file="$1"
|
|
local metadata_type="$2" # "tags" or "categories"
|
|
|
|
local frontmatter=$(extract_frontmatter "$input_file")
|
|
|
|
if [ -n "$frontmatter" ]; then
|
|
# Extract array values (both ["item1", "item2"] and [item1, item2] formats)
|
|
echo "$frontmatter" | grep -E "^${metadata_type}:" | sed 's/.*: *\[//' | sed 's/\]//' | sed 's/"//g' | sed "s/'//g" | tr ',' '\n' | sed 's/^ *//' | sed 's/ *$//' | grep -v '^$'
|
|
fi
|
|
}
|
|
|
|
# Function to extract single category from frontmatter
|
|
extract_single_category() {
|
|
local input_file="$1"
|
|
|
|
local frontmatter=$(extract_frontmatter "$input_file")
|
|
|
|
if [ -n "$frontmatter" ]; then
|
|
# Extract single category value
|
|
echo "$frontmatter" | grep -E "^category:" | sed 's/category: *"*//' | sed 's/"*$//'
|
|
fi
|
|
}
|
|
|
|
# Function to convert markdown to HTML
|
|
convert_markdown() {
|
|
local input_file="$1"
|
|
local output_file="$2"
|
|
local title="$3"
|
|
local lang="$4"
|
|
local content_type="$5"
|
|
|
|
echo " Converting: $(basename "$input_file") -> $(basename "$output_file")"
|
|
|
|
# Extract title from frontmatter if not provided
|
|
if [ -z "$title" ]; then
|
|
title=$(grep -m1 "^# " "$input_file" | sed 's/^# //' || echo "$(basename "$input_file" .md)")
|
|
fi
|
|
|
|
# Create output directory if it doesn't exist
|
|
mkdir -p "$(dirname "$output_file")"
|
|
|
|
# Convert markdown to HTML
|
|
$CONVERTER \
|
|
"$input_file" \
|
|
-o "$output_file" 2>/dev/null || {
|
|
echo " ⚠️ Warning: Failed to convert $input_file"
|
|
}
|
|
}
|
|
|
|
# Function to generate category index.json
|
|
generate_category_index() {
|
|
local content_type="$1"
|
|
local lang="$2"
|
|
local category="$3"
|
|
local category_dir="$4"
|
|
local category_target="$5"
|
|
local content_source="$6"
|
|
local index_file="$category_target/index.json"
|
|
|
|
echo " 🔍 Generating category index: $category"
|
|
|
|
# Get emoji from global meta.toml file
|
|
local global_meta="${CONTENT_DIR}/${content_type}/meta.toml"
|
|
local root_emoji="📝"
|
|
|
|
if [ -f "$global_meta" ]; then
|
|
# Extract emoji from [[categories]] section using new global structure
|
|
root_emoji=$(awk -v cat="$category" '
|
|
/^\[\[categories\]\]/ { in_category = 1; current_id = ""; current_emoji = ""; next }
|
|
/^\[\[/ && !/^\[\[categories\]\]/ { in_category = 0; next }
|
|
in_category && /^id = / {
|
|
gsub(/^id = "/, "", $0);
|
|
gsub(/"$/, "", $0);
|
|
current_id = $0;
|
|
next
|
|
}
|
|
in_category && /^emoji = / {
|
|
gsub(/^emoji = "/, "", $0);
|
|
gsub(/"$/, "", $0);
|
|
current_emoji = $0;
|
|
next
|
|
}
|
|
# Check if we found a matching category
|
|
in_category && current_id == cat && current_emoji != "" {
|
|
print current_emoji;
|
|
exit
|
|
}
|
|
# Start of new section resets current values
|
|
/^\[/ { in_category = 0 }
|
|
' "$global_meta" || echo "📝")
|
|
fi
|
|
|
|
# Read category metadata from category meta.toml
|
|
local category_title="$category"
|
|
local category_emoji="$root_emoji" # Use root emoji as default
|
|
local category_css_class="category-$category"
|
|
local category_description=""
|
|
|
|
if [ -f "$category_dir/meta.toml" ]; then
|
|
category_title=$(grep '^title = ' "$category_dir/meta.toml" 2>/dev/null | sed 's/title = "//' | sed 's/"//' || echo "$category")
|
|
# Emoji comes from global meta.toml only (no override from category meta.toml)
|
|
category_css_class=$(grep '^css_class = ' "$category_dir/meta.toml" 2>/dev/null | sed 's/css_class = "//' | sed 's/"//' || echo "category-$category")
|
|
category_description=$(grep '^description = ' "$category_dir/meta.toml" 2>/dev/null | sed 's/description = "//' | sed 's/"//' || echo "")
|
|
fi
|
|
|
|
# Start JSON structure
|
|
cat > "$index_file" << EOF
|
|
{
|
|
"generated_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
|
|
"content_type": "$content_type",
|
|
"language": "$lang",
|
|
"category": "$category",
|
|
"title": "$category_title",
|
|
"emoji": "$category_emoji",
|
|
"css_class": "$category_css_class",
|
|
"description": "$category_description",
|
|
"posts": [
|
|
EOF
|
|
|
|
local first_post=true
|
|
|
|
# Process each markdown file in the category
|
|
for md_file in "$category_dir"/*.md; do
|
|
if [ -f "$md_file" ]; then
|
|
local filename=$(basename "$md_file" .md)
|
|
local post_id="$filename"
|
|
|
|
# Extract frontmatter data
|
|
local frontmatter_data=""
|
|
if head -1 "$md_file" | grep -q "^---$"; then
|
|
frontmatter_data=$(awk '/^---$/{flag++; next} flag==1 && /^---$/{flag++} flag==1{print}' "$md_file")
|
|
fi
|
|
|
|
# Extract basic post info
|
|
local post_title=$(echo "$frontmatter_data" | grep '^title:' | sed 's/title:[[:space:]]*//' | tr -d '"' || echo "$filename")
|
|
local post_css_class=$(echo "$frontmatter_data" | grep '^css_class:' | sed 's/css_class:[[:space:]]*//' | tr -d '"' || echo "")
|
|
local published=$(echo "$frontmatter_data" | grep '^published:' | sed 's/published:[[:space:]]*//' | tr -d '"' || echo "true")
|
|
|
|
# Only include published posts
|
|
if [ "$published" = "true" ]; then
|
|
if [ "$first_post" = true ]; then
|
|
first_post=false
|
|
else
|
|
echo "," >> "$index_file"
|
|
fi
|
|
|
|
cat >> "$index_file" << EOF
|
|
{
|
|
"id": "$post_id",
|
|
"title": "$post_title",
|
|
"css_class": "$post_css_class",
|
|
"html_file": "$filename.html"
|
|
}
|
|
EOF
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Close JSON structure
|
|
cat >> "$index_file" << EOF
|
|
|
|
]
|
|
}
|
|
EOF
|
|
|
|
echo " ✅ Generated category index: $index_file"
|
|
}
|
|
|
|
# Function to get emoji from TOML file
|
|
get_emoji_from_toml() {
|
|
local content_type="$1" # "blog" or "prescriptions"
|
|
local lang="$2"
|
|
local item_name="$3"
|
|
local emoji_file="$CONTENT_DIR/$content_type/$lang/categories.toml"
|
|
|
|
if [ -f "$emoji_file" ]; then
|
|
# Simple grep approach to find the emoji for the given item
|
|
local emoji
|
|
if [ "$content_type" = "blog" ]; then
|
|
# Look for the tag in the categories file
|
|
emoji=$(grep "^$item_name *= *" "$emoji_file" 2>/dev/null | sed 's/.*= *"\([^"]*\)".*/\1/' || echo "🏷️")
|
|
if [ "$emoji" = "🏷️" ]; then
|
|
# Try with quotes around the key
|
|
emoji=$(grep "^\"$item_name\" *= *" "$emoji_file" 2>/dev/null | sed 's/.*= *"\([^"]*\)".*/\1/' || echo "🏷️")
|
|
fi
|
|
else
|
|
# Look for the category in the categories file
|
|
emoji=$(grep "^\"$item_name\" *= *" "$emoji_file" 2>/dev/null | sed 's/.*= *"\([^"]*\)".*/\1/' || echo "🏷️")
|
|
fi
|
|
|
|
if [ -n "$emoji" ] && [ "$emoji" != "🏷️" ]; then
|
|
echo "$emoji"
|
|
else
|
|
echo "🏷️" # Default fallback emoji
|
|
fi
|
|
else
|
|
echo "🏷️" # Default fallback emoji
|
|
fi
|
|
}
|
|
|
|
# Function to generate index.json with categories/tags
|
|
generate_filter_index() {
|
|
local content_type="$1" # "blog" or "prescriptions"
|
|
local lang="$2"
|
|
local source_dir="$3"
|
|
local target_dir="$4"
|
|
|
|
echo " - Generating filter index for $content_type ($lang)..."
|
|
|
|
# Create temporary files for metadata collection
|
|
local temp_file="/tmp/filter_metadata_$$"
|
|
local count_file="/tmp/filter_counts_$$"
|
|
local total_files=0
|
|
|
|
# Clear temp files
|
|
> "$temp_file"
|
|
> "$count_file"
|
|
|
|
# Process each markdown file
|
|
for md_file in "$source_dir"/*.md; do
|
|
if [ -f "$md_file" ]; then
|
|
total_files=$((total_files + 1))
|
|
|
|
if [ "$content_type" = "blog" ]; then
|
|
# Extract tags for blog posts
|
|
extract_metadata "$md_file" "tags" >> "$temp_file"
|
|
else
|
|
# Extract categories for other content types (avoid duplicates from single category + categories array)
|
|
local file_categories="/tmp/file_categories_$$"
|
|
> "$file_categories"
|
|
|
|
# Extract single category
|
|
local single_category=$(extract_single_category "$md_file")
|
|
if [ -n "$single_category" ]; then
|
|
echo "$single_category" >> "$file_categories"
|
|
fi
|
|
|
|
# Extract tags array
|
|
extract_metadata "$md_file" "tags" >> "$file_categories"
|
|
|
|
# Add unique categories from this file to temp_file
|
|
if [ -s "$file_categories" ]; then
|
|
sort "$file_categories" | uniq >> "$temp_file"
|
|
fi
|
|
rm -f "$file_categories"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Count occurrences and sort
|
|
if [ -s "$temp_file" ]; then
|
|
sort "$temp_file" | uniq -c | sort -nr > "$count_file"
|
|
fi
|
|
|
|
# Generate the filter index JSON
|
|
local filter_index_file="$target_dir/filter-index.json"
|
|
|
|
if [ "$content_type" = "blog" ]; then
|
|
# Generate blog tags index
|
|
cat > "$filter_index_file" << EOF
|
|
{
|
|
"generated_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
|
|
"content_type": "blog",
|
|
"language": "$lang",
|
|
"total_posts": $total_files,
|
|
"tags": [
|
|
EOF
|
|
|
|
local first_tag=true
|
|
while IFS= read -r line; do
|
|
if [ -n "$line" ]; then
|
|
local count=$(echo "$line" | awk '{print $1}')
|
|
local tag=$(echo "$line" | awk '{$1=""; print $0}' | sed 's/^ *//')
|
|
|
|
if [ "$first_tag" = true ]; then
|
|
first_tag=false
|
|
else
|
|
echo "," >> "$filter_index_file"
|
|
fi
|
|
local emoji=$(get_emoji_from_toml "$content_type" "$lang" "$tag")
|
|
printf ' {"name": "%s", "count": %d, "emoji": "%s"}' "$tag" "$count" "$emoji" >> "$filter_index_file"
|
|
fi
|
|
done < "$count_file"
|
|
|
|
cat >> "$filter_index_file" << EOF
|
|
|
|
]
|
|
}
|
|
EOF
|
|
else
|
|
# Generate categories index for other content types
|
|
cat > "$filter_index_file" << EOF
|
|
{
|
|
"generated_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
|
|
"content_type": "$content_type",
|
|
"language": "$lang",
|
|
"total_${content_type}": $total_files,
|
|
"tags": [
|
|
EOF
|
|
|
|
local first_category=true
|
|
while IFS= read -r line; do
|
|
if [ -n "$line" ]; then
|
|
local count=$(echo "$line" | awk '{print $1}')
|
|
local category=$(echo "$line" | awk '{$1=""; print $0}' | sed 's/^ *//')
|
|
|
|
if [ "$first_category" = true ]; then
|
|
first_category=false
|
|
else
|
|
echo "," >> "$filter_index_file"
|
|
fi
|
|
local emoji=$(get_emoji_from_toml "$content_type" "$lang" "$category")
|
|
printf ' {"name": "%s", "count": %d, "emoji": "%s"}' "$category" "$count" "$emoji" >> "$filter_index_file"
|
|
fi
|
|
done < "$count_file"
|
|
|
|
cat >> "$filter_index_file" << EOF
|
|
|
|
]
|
|
}
|
|
EOF
|
|
fi
|
|
|
|
# Clean up temp files
|
|
rm -f "$temp_file" "$count_file"
|
|
|
|
echo " ✅ Generated filter index: $filter_index_file"
|
|
}
|
|
|
|
# Process content for each type and language
|
|
echo "📝 Processing content..."
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
echo "🔄 Processing content type: $content_type"
|
|
|
|
for lang in "${LANGUAGES[@]}"; do
|
|
content_source="${CONTENT_DIR}/${content_type}/${lang}"
|
|
content_target="${PUBLIC_DIR}/${content_type}/${lang}"
|
|
|
|
if [ -d "$content_source" ]; then
|
|
echo " - Processing $content_type content for language: $lang"
|
|
mkdir -p "$content_target"
|
|
|
|
# Convert all markdown files (including category subdirectories)
|
|
# First, handle any top-level markdown files (backward compatibility)
|
|
for md_file in "$content_source"/*.md; do
|
|
if [ -f "$md_file" ]; then
|
|
filename=$(basename "$md_file" .md)
|
|
# Use filename as base for HTML file (Rust converter will normalize internally)
|
|
html_file="$content_target/$filename.html"
|
|
|
|
# Extract title from filename (convert dashes to spaces and capitalize)
|
|
title=$(echo "$filename" | sed 's/-/ /g' | sed 's/\b\w/\U&/g')
|
|
|
|
convert_markdown "$md_file" "$html_file" "$title" "$lang" "$content_type"
|
|
fi
|
|
done
|
|
|
|
# Process category directories
|
|
for category_dir in "$content_source"/*/; do
|
|
if [ -d "$category_dir" ]; then
|
|
category=$(basename "$category_dir")
|
|
category_target="$content_target/$category"
|
|
mkdir -p "$category_target"
|
|
|
|
echo " 📁 Processing category: $category"
|
|
|
|
# Process category meta.toml if it exists
|
|
if [ -f "$category_dir/meta.toml" ]; then
|
|
echo " Processing category meta.toml for $category..."
|
|
$CONVERTER "$category_dir/meta.toml" -o /dev/null
|
|
fi
|
|
|
|
# Convert all markdown files in the category
|
|
for md_file in "$category_dir"/*.md; do
|
|
if [ -f "$md_file" ]; then
|
|
filename=$(basename "$md_file" .md)
|
|
# Use filename as base for HTML file
|
|
html_file="$category_target/$filename.html"
|
|
|
|
# Extract title from filename
|
|
title=$(echo "$filename" | sed 's/-/ /g' | sed 's/\b\w/\U&/g')
|
|
|
|
convert_markdown "$md_file" "$html_file" "$title" "$lang" "$content_type"
|
|
fi
|
|
done
|
|
|
|
# Generate category index.json if there are posts
|
|
category_posts_count=$(find "$category_dir" -name "*.md" 2>/dev/null | wc -l)
|
|
if [ $category_posts_count -gt 0 ]; then
|
|
generate_category_index "$content_type" "$lang" "$category" "$category_dir" "$category_target" "$content_source"
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# Copy index.json if it exists
|
|
if [ -f "$content_source/index.json" ]; then
|
|
cp "$content_source/index.json" "$content_target/"
|
|
echo " ✅ ${content_type} index copied for $lang"
|
|
else
|
|
echo " ⚠️ Warning: No ${content_type} index.json found for $lang"
|
|
fi
|
|
|
|
# Process meta.toml to generate meta.json for API access
|
|
if [ -f "$content_source/meta.toml" ]; then
|
|
echo " Processing meta.toml for $content_type ($lang)..."
|
|
$CONVERTER "$content_source/meta.toml" -o /dev/null
|
|
else
|
|
echo " ⚠️ Warning: No ${content_type} meta.toml found for $lang"
|
|
fi
|
|
|
|
# Generate filter index (use content_type name for filter generation)
|
|
generate_filter_index "$content_type" "$lang" "$content_source" "$content_target"
|
|
|
|
# Count converted files
|
|
html_count=$(find "$content_target" -name "*.html" | wc -l)
|
|
echo " ✅ Converted $html_count ${content_type} items for $lang"
|
|
else
|
|
echo " ⚠️ Warning: No ${content_type} content directory found for $lang"
|
|
fi
|
|
done
|
|
done
|
|
|
|
# Create fallback symlinks for backward compatibility
|
|
echo "🔗 Creating backward compatibility links..."
|
|
|
|
# Create fallback index for each content type (default to English)
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
if [ -f "${PUBLIC_DIR}/${content_type}/en/index.json" ]; then
|
|
ln -sf "en/index.json" "${PUBLIC_DIR}/${content_type}/index.json" 2>/dev/null || true
|
|
echo " ✅ Created fallback ${content_type} index"
|
|
fi
|
|
done
|
|
|
|
# Validate content structure
|
|
echo "🔍 Validating content structure..."
|
|
|
|
validate_json() {
|
|
local file="$1"
|
|
local type="$2"
|
|
local lang="$3"
|
|
|
|
if command -v jq >/dev/null 2>&1; then
|
|
if jq empty "$file" 2>/dev/null; then
|
|
echo " ✅ Valid JSON: $type ($lang)"
|
|
else
|
|
echo " ❌ Invalid JSON: $type ($lang)"
|
|
return 1
|
|
fi
|
|
else
|
|
echo " ⚠️ jq not available, skipping JSON validation"
|
|
fi
|
|
}
|
|
|
|
for lang in "${LANGUAGES[@]}"; do
|
|
# Validate index for each content type
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
content_index="${PUBLIC_DIR}/${content_type}/${lang}/index.json"
|
|
if [ -f "$content_index" ]; then
|
|
validate_json "$content_index" "$content_type" "$lang"
|
|
fi
|
|
done
|
|
done
|
|
|
|
# Generate content statistics
|
|
echo "📊 Content Statistics:"
|
|
|
|
# Initialize totals for each content type (using eval for better bash compatibility)
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
eval "total_${content_type//[^a-zA-Z0-9]/_}=0"
|
|
done
|
|
|
|
for lang in "${LANGUAGES[@]}"; do
|
|
echo " Language: $lang"
|
|
|
|
# Count HTML files for each content type
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
html_count=$(find "${PUBLIC_DIR}/${content_type}/${lang}" -name "*.html" 2>/dev/null | wc -l)
|
|
echo " 📝 ${content_type} (HTML): $html_count"
|
|
# Update total using eval for compatibility
|
|
var_name="total_${content_type//[^a-zA-Z0-9]/_}"
|
|
current_total=$(eval echo \$$var_name)
|
|
eval "$var_name=$((current_total + html_count))"
|
|
done
|
|
|
|
# Count source markdown files for comparison
|
|
echo -n " 📄 Source files: "
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
md_count=$(find "${CONTENT_DIR}/${content_type}/${lang}" -name "*.md" -type f 2>/dev/null | wc -l)
|
|
echo -n "$md_count ${content_type}, "
|
|
done
|
|
echo ""
|
|
done
|
|
|
|
echo ""
|
|
echo "📈 Total converted files:"
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
var_name="total_${content_type//[^a-zA-Z0-9]/_}"
|
|
total=$(eval echo \$$var_name)
|
|
echo " 📝 ${content_type} HTML files: $total"
|
|
done
|
|
|
|
# Optional: Generate content manifest
|
|
MANIFEST_FILE="${PUBLIC_DIR}/content-manifest.json"
|
|
echo "📋 Generating content manifest..."
|
|
|
|
if command -v jq >/dev/null 2>&1; then
|
|
cat > "$MANIFEST_FILE" << EOF
|
|
{
|
|
"generated_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")",
|
|
"version": "1.0",
|
|
"languages": $(printf '%s\n' "${LANGUAGES[@]}" | jq -R . | jq -s .),
|
|
"content_types": $(printf '%s\n' "${CONTENT_TYPES[@]}" | jq -R . | jq -s .),
|
|
"content_root_path": "$CONTENT_DIR",
|
|
"build_info": {
|
|
"source_format": "markdown",
|
|
"output_format": "html",
|
|
"converter": "rustelo_markdown_converter",
|
|
"features": ["syntax-highlighting", "css-classes", "localization"]
|
|
},
|
|
"structure": {
|
|
$(for content_type in "${CONTENT_TYPES[@]}"; do
|
|
echo " \"$content_type\": {"
|
|
for lang in "${LANGUAGES[@]}"; do
|
|
html_count=$(find "${PUBLIC_DIR}/${content_type}/${lang}" -name "*.html" 2>/dev/null | wc -l)
|
|
md_count=$(find "${CONTENT_DIR}/${content_type}/${lang}" -name "*.md" -type f 2>/dev/null | wc -l)
|
|
has_index="false"
|
|
[ -f "${PUBLIC_DIR}/${content_type}/${lang}/index.json" ] && has_index="true"
|
|
echo " \"$lang\": { \"html_count\": $html_count, \"markdown_count\": $md_count, \"has_index\": $has_index },"
|
|
done | sed '$ s/,$//'
|
|
echo " },"
|
|
done | sed '$ s/,$//')
|
|
}
|
|
}
|
|
EOF
|
|
echo " ✅ Content manifest generated: $MANIFEST_FILE"
|
|
else
|
|
echo " ⚠️ jq not available, skipping manifest generation"
|
|
fi
|
|
|
|
echo ""
|
|
echo "🎉 Build complete! Your localized content has been converted to HTML."
|
|
echo ""
|
|
echo "📁 Generated HTML files:"
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
find "${PUBLIC_DIR}/${content_type}" -name "*.html" 2>/dev/null | sort
|
|
done
|
|
echo ""
|
|
echo "Next steps:"
|
|
echo " 1. Markdown files have been converted to HTML with localization"
|
|
echo " 2. Your Leptos application can now serve the generated HTML content"
|
|
echo " 3. Users can switch languages and see content in their preferred language"
|
|
echo ""
|
|
echo "Content locations:"
|
|
for content_type in "${CONTENT_TYPES[@]}"; do
|
|
echo " 📝 ${content_type} HTML: ${PUBLIC_DIR}/${content_type}/{lang}/*.html"
|
|
done
|
|
echo " 📋 Manifest: ${PUBLIC_DIR}/content-manifest.json"
|
|
echo ""
|
|
echo "🔄 To rebuild content after making changes, run this script again."
|