워드프레스를 휴고로 변환하기

brew install hugo
hugo new site blog

chmod +x ./wp2hugo
xattr -d com.apple.quarantine ./wp2hugo

./wp2hugo --source <xml 파일명> --download-media --output ./my_hugo

PATH=/usr/bin:/bin:/usr/sbin:/sbin
set -euo pipefail

TARGET="blog/content/posts"  # 필요하면 경로 수정
RECURSIVE=0                  # 하위 폴더까지 처리하려면 1로 변경
DRY_RUN=1                    # 미리보기; 실제 변경하려면 0으로 변경

find_args=(-type f -name '*.md')
if [[ $RECURSIVE -eq 0 ]]; then
  find_args=("-maxdepth" "1" "${find_args[@]}")
fi

declare -a renames=()
declare -a warnings=()

while IFS= read -r -d '' src; do
  basename=${src##*/}
  decoded=$(python3 - "$basename" <<'PY'
import sys
from urllib.parse import unquote
print(unquote(sys.argv[1]), end="")
PY
)

  [[ "$decoded" == "$basename" ]] && continue

  dest_dir=${src%/*}
  dest="$dest_dir/$decoded"

  if [[ -e "$dest" && "$dest" != "$src" ]]; then
    warnings+=("skip (already exists): $src -> $dest")
    continue
  fi

  duplicate=0
  for ((i=0; i<${#renames[@]}; i+=2)); do
    if [[ "${renames[i+1]}" == "$dest" && "${renames[i]}" != "$src" ]]; then
      duplicate=1
      break
    fi
  done
  (( duplicate )) && {
    warnings+=("skip (duplicate target): $src -> $dest")
    continue
  }

  renames+=("$src" "$dest")
done < <(find "$TARGET" "${find_args[@]}" -print0)

if (( ${#renames[@]} == 0 )); then
  echo "No percent-encoded Markdown filenames found."
  exit 0
fi

if (( ${#warnings[@]} > 0 )); then
  echo "Warnings:"
  for warning in "${warnings[@]}"; do
    echo "  $warning"
  done
  echo
fi

echo "Planned renames:"
for ((i=0; i<${#renames[@]}; i+=2)); do
  src=${renames[i]}
  dest=${renames[i+1]}
  rel_src=${src#"$TARGET"/}
  rel_dest=${dest#"$TARGET"/}
  echo "  $rel_src -> $rel_dest"
done

if (( DRY_RUN )); then
  echo
  echo "Dry-run complete. DRY_RUN=0 으로 다시 실행하면 실제로 이름이 바뀝니다."
  exit 0
fi

echo
for ((i=0; i<${#renames[@]}; i+=2)); do
  mv "${renames[i]}" "${renames[i+1]}"
done

echo "Renaming complete."

PATH=/usr/bin:/bin:/usr/sbin:/sbin

/usr/bin/find blog/content/posts -type f -name '*.md' -print0 |
while IFS= read -r -d '' path; do
  dir=$(/usr/bin/dirname "$path")
  base=$(/usr/bin/basename "$path")
  new_base="${base//-/ }"
  [[ "$base" == "$new_base" ]] && continue
  new_path="$dir/$new_base"
  [[ -e "$new_path" ]] && { echo "이미 존재해서 건너뜀: $new_path"; continue; }
  /bin/mv "$path" "$new_path"
done

set -euo pipefail

POSTS_DIR="blog/content/posts"
STATIC_DIR="blog/static"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --posts)
      POSTS_DIR=$2
      shift 2
      ;;

    --static)
      STATIC_DIR=$2
      shift 2
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "Unknown option: $1" >&2
      usage
      exit 1
      ;;
    esac
  done

if [[ ! -d "$POSTS_DIR" ]]; then
  echo "posts 디렉터리를 찾을 수 없습니다: $POSTS_DIR" >&2
  exit 1
fi

if [[ ! -d "$STATIC_DIR" ]]; then
  echo "static 디렉터리를 찾을 수 없습니다: $STATIC_DIR" >&2
  exit 1
fi

find "$POSTS_DIR" -maxdepth 1 -type f -name '*.md' -print0 |
while IFS= read -r -d '' md_file; do
  bundle_dir="${md_file%.md}"
  bundle_index="$bundle_dir/index.md"

  if [[ -d "$bundle_dir" ]]; then
    echo "이미 폴더가 존재하여 건너뜁니다: $bundle_dir" >&2
    continue
  fi

  echo "▶︎ 변환 시작: $md_file"
  mkdir -p "$bundle_dir"
  mv "$md_file" "$bundle_index"

  python3 - "$bundle_index" "$STATIC_DIR" <<'PYTHON'
import shutil
import sys
import re

from pathlib import Path
index_path = Path(sys.argv[1])
static_root = Path(sys.argv[2])
bundle_dir = index_path.parent

try:
	text = index_path.read_text(encoding="utf-8")
except UnicodeDecodeError:
	text = index_path.read_text(encoding="utf-8-sig")

pattern = re.compile(r"(/wordpress/[^\s\"'\)\]]+)")
paths = []
seen = set()
for match in pattern.finditer(text):
	url = match.group(1)
	if url not in seen:
		seen.add(url)
		paths.append(url)
	if not paths:
		sys.exit(0)

replacements = {}

for url in paths:
	src = static_root / url.lstrip("/")
	if not src.exists():
		print(f"경고: 이미지 파일이 없음 -> {src}", file=sys.stderr)
		continue
	dest = bundle_dir / src.name
	if dest.exists():
		stem = dest.stem
		suffix = dest.suffix
		counter = 1
		while dest.exists():
			counter += 1
			dest = bundle_dir / f"{stem}-{counter}{suffix}"
	
	print(f" 이미지 이동: {src} -> {dest}")
	shutil.move(str(src), dest)
	replacements[url] = dest.name

for old, new in replacements.items():
	text = text.replace(old, new)

if replacements:
	index_path.write_text(text, encoding="utf-8")

PYTHON

  echo " 완료: $bundle_dir"
done

echo "모든 파일 처리가 끝났습니다."

hugo server

brew install go
hugo mode init vividian.net
hugo mod get github.com/hugo-sid/hugo-blog-awesome

#!/usr/bin/env bash
set -e

echo "🚧 Hugo 빌드 시작..."
hugo
echo "✅ Hugo 빌드 완료"

echo "⏳ 5초 대기 중..."
sleep 5

echo "🚀 원격 서버로 동기화 중..."
ssh -p [포트번호]] [아이디]@[아이피주소 or 도메인주소] 'rsync -av "[맥북에 있는 public 절대경로]" [시놀로지 나스 웹 서비스 절대경로]'

echo "🎉 배포 완료!"

./deploy.sh

#!/usr/bin/env bash
# Hugo 프론트매터를 정리하는 쉘 스크립트.
# blog/content 아래의 모든 Markdown 파일을 순회하며 워드프레스에서 넘어온 프론트매터를 지정한 형식으로 재구성한다.
# PyYAML(pip install pyyaml)이 설치되어 있어야 한다.
set -euo pipefail

ROOT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
CONTENT_DIR="${ROOT_DIR}/content"

if [[ ! -d "${CONTENT_DIR}" ]]; then
  echo "content 디렉터리를 찾을 수 없습니다: ${CONTENT_DIR}" >&2
  exit 1
fi

python3 - <<'PYTHON' "${CONTENT_DIR}"
from __future__ import annotations
import json
import re
import sys
from collections.abc import Iterable
from pathlib import Path

try:
	import yaml
except ModuleNotFoundError:
	print("PyYAML이 필요합니다. pip install pyyaml 후 다시 실행하세요.", file=sys.stderr)
	raise SystemExit(1)

CONTENT_DIR = Path(sys.argv[1])

def read_front_matter(lines: list[str]) -> tuple[dict, int]:
	if not lines or lines[0].strip() != "---":
		return {}, -1
	for idx in range(1, len(lines)):
		if lines[idx].strip() == "---":
			closing = idx
			break
		else:
			return {}, -1

	block = "\n".join(lines[1:closing])
	if not block.strip():
		return {}, closing

	try:
		data = yaml.safe_load(block) or {}
	except yaml.YAMLError as exc:
		raise ValueError(f"YAML 파싱 실패: {exc}") from exc
	if not isinstance(data, dict):
		data = {}
	return data, closing

def to_str(value) -> str:
	if value is None:
		return ""
	return str(value)

def normalize_sequence(value) -> list[str]:
	if value is None:
		return []
	if isinstance(value, str):
		stripped = value.strip()
		if not stripped:
			return []
		if stripped.startswith("[") and stripped.endswith("]"):
			try:
				parsed = yaml.safe_load(stripped)
				return normalize_sequence(parsed)
			except yaml.YAMLError:
				pass

		items = [part.strip() for part in re.split(r"[,\n]+", value)]
		return [itm for itm in items if itm]
	if isinstance(value, Iterable):
		cleaned: list[str] = []
		for itm in value:
			if itm is None:
				continue
			text = str(itm).strip()
			if text:
				cleaned.append(text)
		return cleaned
	return [str(value).strip()]

def make_slug(title: str, fallback: str) -> str:
	base = title.strip() or fallback
	base = re.sub(r"\s+", "-", base)
	base = re.sub(r"-+", "-", base)
	return base.strip("-")

def quote(value: str) -> str:
	escaped = value.replace("\\", "\\\\").replace('"', '\\"')
	return f'"{escaped}"'

def format_array(items: list[str]) -> str:
	return json.dumps(items, ensure_ascii=False)

def rebuild_front_matter(data: dict, md_path: Path) -> list[str]:
	title = to_str(data.get("title")).strip()
	date = to_str(data.get("date")).strip()
	author = to_str(data.get("author")).strip()
	url = to_str(data.get("url")).strip()
	guid = to_str(data.get("guid")).strip()
	tags = normalize_sequence(data.get("tags") or data.get("tag"))
	categories = normalize_sequence(data.get("categories") or data.get("category"))
	aliases: list[str] = []
	
	if url:
		aliases.append(url)
		aliases.extend(normalize_sequence(data.get("aliases") or data.get("alias")))
	if guid:
		aliases.append(url)

	seen = set()
	deduped = []
	for entry in aliases:
		if not entry or entry in seen:
			continue
		deduped.append(entry)
		seen.add(entry)

	fallback_slug = md_path.stem
	if md_path.name == "index.md":
		fallback_slug = md_path.parent.name or fallback_slug
	slug = make_slug(title, fallback_slug)

	front = [
		"---",
		f"title: {quote(title)}",
		f"date: {quote(date)}",
		f"author: {quote(author)}",
		f"slug: {quote(slug)}",
		f"url: {quote(url)}",
		'aliases: ""',
		'description: ""',
		f"tags: {format_array(tags)}",
		f"categories: {format_array(categories)}",
		f"keywords: {format_array(tags)}",
		'summary: ""',
		"---",
	]
	return front

def process_file(md_path: Path) -> bool:
	raw = md_path.read_text(encoding="utf-8")
	if raw.startswith("\ufeff"):
		raw = raw.lstrip("\ufeff")
	lines = raw.split("\n")
	try:
		data, closing = read_front_matter(lines)
	except ValueError as exc:
		print(f"[경고] {md_path}: {exc}", file=sys.stderr)
		return False
	if closing == -1:
		print(f"[건너뜀] 프론트매터 없음: {md_path}", file=sys.stderr)
		return False
	body = lines[closing + 1 :]
	new_front = rebuild_front_matter(data, md_path)
	new_lines = new_front + body
	new_content = "\n".join(new_lines)
	if not new_content.endswith("\n"):
		new_content += "\n"
	md_path.write_text(new_content, encoding="utf-8")
	return True

md_files = sorted(CONTENT_DIR.rglob("*.md"))
if not md_files:
	print("Markdown 파일을 찾지 못했습니다.", file=sys.stderr)
	raise SystemExit(1)

count = 0
for md_path in md_files:
	if process_file(md_path):
		count += 1

print(f"완료: {count}개 파일 업데이트")
PYTHON