mirror of
https://github.com/kbenestad/mdcms.git
synced 2026-06-18 15:24:32 +00:00
1356 lines
47 KiB
Python
1356 lines
47 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# MD-CMS v0.2.2 — Companion CLI
|
|
#
|
|
# LICENCE
|
|
# Copyright 2026 Kristian Benestad | docs.benestad.net
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "Licence");
|
|
# you may not use this file except in compliance with the Licence.
|
|
# You may obtain a copy of the Licence at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the Licence is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the Licence for the specific language governing permissions and
|
|
# limitations under the Licence.
|
|
|
|
"""MD-CMS v0.2.2 — Companion CLI.
|
|
|
|
Scans `pages/` and `posts/` in the active website directory and writes
|
|
`nav.yml` and `search.json`. Also manages a registry of named website paths
|
|
so the tool can be invoked from anywhere on the system.
|
|
"""
|
|
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
import subprocess
|
|
import time
|
|
import urllib.request
|
|
import webbrowser
|
|
import zipfile
|
|
from pathlib import Path
|
|
|
|
VERSION = "0.2"
|
|
DATE = "2026-04-16"
|
|
BANNER_URL = f"https://raw.githubusercontent.com/kbenestad/mdcms/refs/heads/main/resources/banner/v{VERSION}.txt"
|
|
HELP_URL = "https://docs.benestad.net"
|
|
|
|
CONFIG_DIR = Path.home() / ".mdcms"
|
|
PATHS_FILE = CONFIG_DIR / "paths.json"
|
|
|
|
SEP = "-" * 80
|
|
|
|
|
|
# ─── Path registry ───────────────────────────────────────────
|
|
|
|
def load_registry():
|
|
if PATHS_FILE.exists():
|
|
try:
|
|
return json.loads(PATHS_FILE.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
pass
|
|
return {"active": None, "paths": {}}
|
|
|
|
|
|
def save_registry(reg):
|
|
CONFIG_DIR.mkdir(parents=True, exist_ok=True)
|
|
PATHS_FILE.write_text(json.dumps(reg, indent=2), encoding="utf-8")
|
|
|
|
|
|
def active_path():
|
|
reg = load_registry()
|
|
name = reg.get("active")
|
|
if not name:
|
|
return None, None
|
|
p = reg["paths"].get(name)
|
|
if not p:
|
|
return None, None
|
|
return name, Path(p)
|
|
|
|
|
|
# ─── Frontmatter parser ──────────────────────────────────────
|
|
|
|
def parse_frontmatter(filepath):
|
|
"""Return (meta_dict, body_text). Meta is a flat key:value map."""
|
|
try:
|
|
content = Path(filepath).read_text(encoding="utf-8")
|
|
except (OSError, UnicodeDecodeError) as e:
|
|
print(f" Warning: could not read {filepath}: {e}")
|
|
return None, ""
|
|
|
|
match = re.match(r"^---\s*\n(.*?)\n---\s*\n", content, re.DOTALL)
|
|
if not match:
|
|
return {}, content
|
|
|
|
meta = {}
|
|
for line in match.group(1).split("\n"):
|
|
line = line.strip()
|
|
if not line or line.startswith("#"):
|
|
continue
|
|
colon = line.find(":")
|
|
if colon == -1:
|
|
continue
|
|
key = line[:colon].strip()
|
|
value = line[colon + 1:].strip()
|
|
if (value.startswith('"') and value.endswith('"')) or \
|
|
(value.startswith("'") and value.endswith("'")):
|
|
value = value[1:-1]
|
|
if value.lower() == "true":
|
|
value = True
|
|
elif value.lower() == "false":
|
|
value = False
|
|
elif re.match(r"^\d+$", value):
|
|
value = int(value)
|
|
meta[key] = value
|
|
|
|
return meta, content[match.end():]
|
|
|
|
|
|
# ─── Scanner ─────────────────────────────────────────────────
|
|
|
|
CATEGORY_CODE_RE = re.compile(r"^[a-zA-Z0-9\-]+$")
|
|
|
|
|
|
def parse_config_categories(text):
|
|
"""Extract category info from config.yml.
|
|
|
|
Returns {'use': bool, 'default_code': str|None, 'codes': [str, ...]}.
|
|
Only looks at `categories-use`, `default-category.code`, and `categories[].code`.
|
|
The `code` field must be the first key of each category item (per spec example).
|
|
"""
|
|
use = False
|
|
default_code = None
|
|
codes = []
|
|
in_default = False
|
|
in_categories = False
|
|
|
|
for raw in text.splitlines():
|
|
line = raw.rstrip()
|
|
stripped = line.strip()
|
|
if not stripped or stripped.startswith("#"):
|
|
continue
|
|
if not line.startswith(" "):
|
|
in_default = False
|
|
in_categories = False
|
|
if line.startswith("categories-use:"):
|
|
val = line.split(":", 1)[1].strip().strip('"\'')
|
|
use = val.lower() in ("yes", "true")
|
|
elif line.rstrip(":") == "default-category":
|
|
in_default = True
|
|
elif line.rstrip(":") == "categories":
|
|
in_categories = True
|
|
continue
|
|
if in_default and line.startswith(" ") and not line.startswith(" "):
|
|
m = re.match(r"^ (\S+):\s*(.*)$", line)
|
|
if m and m.group(1) == "code":
|
|
default_code = m.group(2).strip().strip('"\'')
|
|
if in_categories and line.startswith(" - "):
|
|
m = re.match(r"^ - (\S+):\s*(.*)$", line)
|
|
if m and m.group(1) == "code":
|
|
codes.append(m.group(2).strip().strip('"\''))
|
|
|
|
return {"use": use, "default_code": default_code, "codes": codes}
|
|
|
|
|
|
def identify_variant(path_rel, known_codes):
|
|
"""Split a .md path into (base_without_ext, category_code_or_None).
|
|
|
|
`base_without_ext` includes the directory and base name but no extension
|
|
and no category suffix. `known_codes` is the set of valid category codes
|
|
(default + additional). A trailing `.<code>` in the filename is only
|
|
recognised as a category suffix if `<code>` is in `known_codes`.
|
|
"""
|
|
if not path_rel.endswith(".md"):
|
|
return None, None
|
|
stem = path_rel[:-3]
|
|
base_name = os.path.basename(stem)
|
|
if "." in base_name:
|
|
head, _, suffix = stem.rpartition(".")
|
|
if suffix in known_codes:
|
|
return head, suffix
|
|
return stem, None
|
|
|
|
|
|
def scan_and_categorize(directory, known_codes):
|
|
"""Scan a directory for .md files. Each returned record includes `base` and
|
|
`code` (`None` for files without a category suffix)."""
|
|
records = []
|
|
if not os.path.isdir(directory):
|
|
return records
|
|
for root, dirs, files in os.walk(directory):
|
|
dirs.sort()
|
|
for name in sorted(files):
|
|
if not name.endswith(".md"):
|
|
continue
|
|
full = os.path.join(root, name)
|
|
rel = os.path.relpath(full, ".").replace("\\", "/")
|
|
base, code = identify_variant(rel, known_codes)
|
|
if base is None:
|
|
continue
|
|
meta, body = parse_frontmatter(full)
|
|
if meta is None or meta.get("draft", False):
|
|
continue
|
|
records.append({
|
|
"file": rel,
|
|
"base": base,
|
|
"code": code,
|
|
"title": meta.get("title") or os.path.basename(base).replace("_", " ").replace("-", " ").title(),
|
|
"sort": meta.get("sort"),
|
|
"section-id": meta.get("section-id"),
|
|
"author": meta.get("author"),
|
|
"date": str(meta.get("date", "")),
|
|
"datetime": str(meta.get("datetime", "")),
|
|
"created": str(meta.get("created", "")),
|
|
"modified": str(meta.get("modified", "")),
|
|
"language": meta.get("language", "en"),
|
|
"keywords": meta.get("keywords", ""),
|
|
"description": meta.get("description", ""),
|
|
"body": body[:5000],
|
|
})
|
|
return records
|
|
|
|
|
|
def group_by_base(records):
|
|
"""Group records by their conceptual base path. Returns {base: {code: record}}."""
|
|
groups = {}
|
|
for r in records:
|
|
groups.setdefault(r["base"], {})[r["code"]] = r
|
|
return groups
|
|
|
|
|
|
def select_primary(variants_dict, default_code):
|
|
"""Pick a representative record for a page group.
|
|
|
|
Priority: default-coded variant → base file → first available.
|
|
"""
|
|
if default_code and default_code in variants_dict:
|
|
return variants_dict[default_code]
|
|
if None in variants_dict:
|
|
return variants_dict[None]
|
|
return next(iter(variants_dict.values()))
|
|
|
|
|
|
def _coerce(v):
|
|
"""Coerce a YAML scalar string to a Python value."""
|
|
if v == "" or v.lower() in ("null", "~"):
|
|
return None
|
|
if v == "true":
|
|
return True
|
|
if v == "false":
|
|
return False
|
|
if (v.startswith('"') and v.endswith('"')) or (v.startswith("'") and v.endswith("'")):
|
|
return v[1:-1]
|
|
if re.match(r"^-?\d+$", v):
|
|
return int(v)
|
|
m = re.match(r"^\[(.*)\]$", v)
|
|
if m:
|
|
inner = m.group(1).strip()
|
|
return [_coerce(x.strip()) for x in inner.split(",")] if inner else []
|
|
return v
|
|
|
|
|
|
def _emit_value(v):
|
|
"""Quote a YAML scalar if it contains characters that would confuse the parser."""
|
|
if v is None:
|
|
return ""
|
|
s = str(v)
|
|
if s == "" or any(c in s for c in ':"\'#') or s.lower() in ("true", "false", "null"):
|
|
return '"' + s.replace('"', '\\"') + '"'
|
|
return s
|
|
|
|
|
|
def parse_nav_yml(text):
|
|
"""Parse the nav.yml subset we emit. Returns (sections, pages) as lists of dicts.
|
|
|
|
Handles:
|
|
- top-level keys `sections:` and `pages:`
|
|
- list items at 2-space indent: ` - key: value`
|
|
- item properties at 4-space indent: ` key: value`
|
|
- one level of nested dict at 6-space indent (for `categorynames`)
|
|
Ignores unknown top-level keys. Not a general YAML parser.
|
|
"""
|
|
sections, pages = [], []
|
|
block = None
|
|
item = None
|
|
nested_key = None
|
|
|
|
def flush():
|
|
nonlocal item
|
|
if item is None:
|
|
return
|
|
if block == "sections":
|
|
sections.append(item)
|
|
elif block == "pages":
|
|
pages.append(item)
|
|
item = None
|
|
|
|
for raw in text.splitlines():
|
|
line = raw.rstrip()
|
|
stripped = line.lstrip()
|
|
if not stripped or stripped.startswith("#"):
|
|
continue
|
|
|
|
# Top-level key
|
|
if not line.startswith(" "):
|
|
flush()
|
|
key = line.split(":", 1)[0].strip()
|
|
block = key if key in ("sections", "pages") else None
|
|
nested_key = None
|
|
continue
|
|
|
|
if block is None:
|
|
continue
|
|
|
|
# 6-space nested dict content
|
|
m = re.match(r"^ (\S[^:]*):\s*(.*)$", line)
|
|
if m and nested_key is not None and item is not None:
|
|
item.setdefault(nested_key, {})[m.group(1).strip()] = _coerce(m.group(2).strip())
|
|
continue
|
|
|
|
# 2-space list item start
|
|
m = re.match(r"^ - (\S[^:]*):\s*(.*)$", line)
|
|
if m:
|
|
flush()
|
|
item = {m.group(1).strip(): _coerce(m.group(2).strip())}
|
|
nested_key = None
|
|
continue
|
|
|
|
if item is None:
|
|
continue
|
|
|
|
# 4-space item property
|
|
m = re.match(r"^ (\S[^:]*):\s*(.*)$", line)
|
|
if m:
|
|
key = m.group(1).strip()
|
|
val = m.group(2).strip()
|
|
if val == "":
|
|
nested_key = key
|
|
item[key] = {}
|
|
else:
|
|
nested_key = None
|
|
item[key] = _coerce(val)
|
|
|
|
flush()
|
|
return sections, pages
|
|
|
|
|
|
# ─── Section merge (phase 2) ─────────────────────────────────
|
|
|
|
def merge_sections(page_entries, existing_sections):
|
|
"""Merge existing sections with auto-created stubs for new section-ids.
|
|
|
|
Returns (merged_sections, auto_created_codes).
|
|
Preserves every field on existing sections; only adds new entries.
|
|
"""
|
|
by_code = {s["code"]: dict(s) for s in existing_sections if s.get("code")}
|
|
|
|
referenced = sorted({p.get("section-id") for p in page_entries if p.get("section-id")})
|
|
|
|
auto_created = []
|
|
for code in referenced:
|
|
if code in by_code:
|
|
continue
|
|
used_sorts = {s.get("sort") for s in by_code.values() if isinstance(s.get("sort"), int)}
|
|
next_sort = 100
|
|
while next_sort in used_sorts:
|
|
next_sort += 10
|
|
by_code[code] = {
|
|
"code": code,
|
|
"defaultname": code.replace("-", " ").replace("_", " ").title(),
|
|
"sort": next_sort,
|
|
"pagesvisibility": "visible",
|
|
}
|
|
auto_created.append(code)
|
|
|
|
merged = sorted(by_code.values(), key=lambda s: (s.get("sort") or 999, s["code"]))
|
|
return merged, auto_created
|
|
|
|
|
|
def build_page_nav(page_groups, existing_pages, categories_use=False, default_code=None):
|
|
"""Produce the page nav list. One entry per conceptual page (grouped by base).
|
|
|
|
When `categories_use`, adds `variants` (list of category codes with an
|
|
actual file on disk — the base file counts as the default category) and
|
|
`titles` (per-category titles). Preserves nav.yml `sort` when the file
|
|
path matches.
|
|
"""
|
|
existing_by_file = {p["file"]: p for p in existing_pages if p.get("file")}
|
|
out = []
|
|
for base, variants in sorted(page_groups.items()):
|
|
file = base + ".md"
|
|
primary = select_primary(variants, default_code)
|
|
|
|
existing = existing_by_file.get(file, {})
|
|
sort = existing.get("sort")
|
|
if sort is None:
|
|
sort = primary.get("sort")
|
|
if sort is None:
|
|
sort = 100
|
|
|
|
entry = {
|
|
"file": file,
|
|
"title": primary.get("title", ""),
|
|
"section-id": primary.get("section-id"),
|
|
"sort": sort,
|
|
}
|
|
|
|
if categories_use:
|
|
covered = set()
|
|
titles = {}
|
|
for code, record in variants.items():
|
|
key = code if code is not None else default_code
|
|
if key is None:
|
|
continue
|
|
covered.add(key)
|
|
titles[key] = record.get("title", "")
|
|
entry["variants"] = sorted(covered)
|
|
entry["titles"] = titles
|
|
|
|
out.append(entry)
|
|
out.sort(key=lambda p: (p["sort"], p["file"]))
|
|
return out
|
|
|
|
|
|
# ─── Generators ──────────────────────────────────────────────
|
|
|
|
def generate_nav_yml(sections, pages, categories_use=False):
|
|
"""Emit nav.yml with `sections:` and `pages:` blocks."""
|
|
lines = [
|
|
"# nav.yml — generated by mdcms.py",
|
|
"# Manual edits to section metadata (defaultname, sort, parent, parent-sort,",
|
|
"# pagesvisibility, categorynames) are preserved on rebuild. New sections",
|
|
"# are auto-created from page frontmatter section-id values.",
|
|
"",
|
|
"sections:",
|
|
]
|
|
if not sections:
|
|
lines.append(" # (none yet — add section-id to page frontmatter to auto-create)")
|
|
else:
|
|
for s in sections:
|
|
lines.append(f" - code: {s['code']}")
|
|
lines.append(f" defaultname: {_emit_value(s.get('defaultname', s['code']))}")
|
|
lines.append(f" sort: {s.get('sort', 100)}")
|
|
if s.get("parent"):
|
|
lines.append(f" parent: {s['parent']}")
|
|
lines.append(f" parent-sort: {s.get('parent-sort', 100)}")
|
|
lines.append(f" pagesvisibility: {s.get('pagesvisibility', 'visible')}")
|
|
cn = s.get("categorynames") or {}
|
|
if cn:
|
|
lines.append(" categorynames:")
|
|
for k, v in cn.items():
|
|
lines.append(f" {k}: {_emit_value(v)}")
|
|
lines.append("")
|
|
|
|
lines.append("pages:")
|
|
if not pages:
|
|
lines.append(" # (no pages)")
|
|
else:
|
|
for p in pages:
|
|
lines.append(f" - file: {p['file']}")
|
|
lines.append(f" title: {_emit_value(p['title'])}")
|
|
if p.get("section-id"):
|
|
lines.append(f" section-id: {p['section-id']}")
|
|
lines.append(f" sort: {p.get('sort', 100)}")
|
|
if categories_use and p.get("variants"):
|
|
lines.append(f" variants: [{', '.join(p['variants'])}]")
|
|
if categories_use and p.get("titles"):
|
|
lines.append(" titles:")
|
|
for code, title in p["titles"].items():
|
|
lines.append(f" {code}: {_emit_value(title)}")
|
|
lines.append("")
|
|
return "\n".join(lines)
|
|
|
|
|
|
def generate_search_json(records, categories_use=False, default_code=None):
|
|
"""Emit search.json. When `categories_use`, each entry gets a `category` field
|
|
and the `file` is the conceptual base path (so search results link to the
|
|
same URL regardless of which variant matched)."""
|
|
out = []
|
|
for r in records:
|
|
file_path = (r["base"] + ".md") if "base" in r else r.get("file", "")
|
|
entry = {
|
|
"file": file_path,
|
|
"title": r.get("title", ""),
|
|
"section-id": r.get("section-id"),
|
|
"keywords": r.get("keywords", ""),
|
|
"description": r.get("description", ""),
|
|
"author": r.get("author"),
|
|
"date": r.get("date", ""),
|
|
"datetime": r.get("datetime", ""),
|
|
"language": r.get("language", "en"),
|
|
"body": r.get("body", ""),
|
|
}
|
|
if categories_use:
|
|
code = r.get("code")
|
|
entry["category"] = code if code is not None else default_code
|
|
out.append(entry)
|
|
return json.dumps(out, indent=2, ensure_ascii=False)
|
|
|
|
|
|
# ─── Banner ──────────────────────────────────────────────────
|
|
|
|
def load_banner():
|
|
try:
|
|
req = urllib.request.Request(BANNER_URL, headers={"User-Agent": f"mdcms/{VERSION}"})
|
|
with urllib.request.urlopen(req, timeout=3) as r:
|
|
return r.read().decode("utf-8").strip()
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
# ─── UI helpers ──────────────────────────────────────────────
|
|
|
|
def clear():
|
|
os.system("cls" if os.name == "nt" else "clear")
|
|
|
|
|
|
def header():
|
|
print(f"MD-CMS v{VERSION} ({DATE}) (C) Kristian Benestad")
|
|
print("Apache 2.0 Licence")
|
|
print(SEP)
|
|
|
|
|
|
def pause():
|
|
input("\nPress Enter to continue...")
|
|
|
|
|
|
# ─── Build actions (options 3 & 4) ───────────────────────────
|
|
|
|
def do_build_nav_and_search(project):
|
|
"""Option 3: scan pages/ and posts/ in project/website/, write nav.yml and search.json."""
|
|
site = project / "website"
|
|
if not site.is_dir():
|
|
print(f" Error: {site} not found.")
|
|
return
|
|
os.chdir(site)
|
|
print(f"Working directory: {site}")
|
|
print()
|
|
|
|
if not os.path.isdir("pages"):
|
|
print(" Error: pages/ folder not found.")
|
|
return
|
|
|
|
# Load category config from config.yml so filename parsing can recognise
|
|
# category suffixes. Missing / disabled = no category handling.
|
|
cat_cfg = {"use": False, "default_code": None, "codes": []}
|
|
if os.path.isfile("config.yml"):
|
|
try:
|
|
cat_cfg = parse_config_categories(Path("config.yml").read_text(encoding="utf-8"))
|
|
except Exception as e:
|
|
print(f" Warning: could not read category config ({e}).")
|
|
|
|
# Validate codes
|
|
all_declared = [c for c in [cat_cfg["default_code"]] + cat_cfg["codes"] if c]
|
|
invalid = [c for c in all_declared if not CATEGORY_CODE_RE.match(c)]
|
|
if invalid:
|
|
print(f" Error: invalid category code(s) {invalid}. Must match [a-zA-Z0-9-]+.")
|
|
return
|
|
|
|
if cat_cfg["use"] and not cat_cfg["default_code"]:
|
|
print(" Error: categories-use: yes but no default-category.code defined.")
|
|
return
|
|
|
|
known_codes = set(all_declared) if cat_cfg["use"] else set()
|
|
|
|
# Scan
|
|
page_records = scan_and_categorize("pages", known_codes)
|
|
post_records = scan_and_categorize("posts", known_codes)
|
|
print(f"Scanned pages/ — {len(page_records)} file(s)")
|
|
print(f"Scanned posts/ — {len(post_records)} file(s)")
|
|
|
|
page_groups = group_by_base(page_records)
|
|
|
|
# Existing nav.yml → preserve manual edits
|
|
existing_sections, existing_pages = [], []
|
|
if os.path.isfile("nav.yml"):
|
|
try:
|
|
existing_sections, existing_pages = parse_nav_yml(
|
|
Path("nav.yml").read_text(encoding="utf-8")
|
|
)
|
|
except Exception as e:
|
|
print(f" Warning: could not parse existing nav.yml ({e}); starting fresh.")
|
|
|
|
# One representative record per conceptual page, for section-id discovery
|
|
primary_entries = [select_primary(v, cat_cfg["default_code"]) for v in page_groups.values()]
|
|
sections, auto_created = merge_sections(primary_entries, existing_sections)
|
|
|
|
page_nav = build_page_nav(
|
|
page_groups, existing_pages,
|
|
categories_use=cat_cfg["use"],
|
|
default_code=cat_cfg["default_code"],
|
|
)
|
|
|
|
Path("nav.yml").write_text(
|
|
generate_nav_yml(sections, page_nav, categories_use=cat_cfg["use"]),
|
|
encoding="utf-8",
|
|
)
|
|
print("Wrote nav.yml")
|
|
|
|
# Filter out draft-section pages from search.
|
|
draft_codes = {s["code"] for s in sections if s.get("pagesvisibility") == "draft"}
|
|
live_pages = [r for r in page_records if r.get("section-id") not in draft_codes]
|
|
Path("search.json").write_text(
|
|
generate_search_json(
|
|
live_pages + post_records,
|
|
categories_use=cat_cfg["use"],
|
|
default_code=cat_cfg["default_code"],
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
print(f"Wrote search.json ({len(live_pages) + len(post_records)} entries)")
|
|
|
|
if auto_created:
|
|
print()
|
|
print(f" Notice: {len(auto_created)} section(s) auto-created from page frontmatter:")
|
|
for c in auto_created:
|
|
print(f" - {c}")
|
|
print(" Edit nav.yml to customise defaultname, sort, parent, or pagesvisibility.")
|
|
|
|
|
|
def do_build_search_only(project):
|
|
"""Option 4: regenerate search.json only."""
|
|
site = project / "website"
|
|
if not site.is_dir():
|
|
print(f" Error: {site} not found.")
|
|
return
|
|
os.chdir(site)
|
|
|
|
cat_cfg = {"use": False, "default_code": None, "codes": []}
|
|
if os.path.isfile("config.yml"):
|
|
try:
|
|
cat_cfg = parse_config_categories(Path("config.yml").read_text(encoding="utf-8"))
|
|
except Exception:
|
|
pass
|
|
known_codes = set(c for c in [cat_cfg["default_code"]] + cat_cfg["codes"] if c) if cat_cfg["use"] else set()
|
|
|
|
page_records = scan_and_categorize("pages", known_codes)
|
|
post_records = scan_and_categorize("posts", known_codes)
|
|
|
|
draft_codes = set()
|
|
if os.path.isfile("nav.yml"):
|
|
try:
|
|
sections, _ = parse_nav_yml(Path("nav.yml").read_text(encoding="utf-8"))
|
|
draft_codes = {s["code"] for s in sections if s.get("pagesvisibility") == "draft"}
|
|
except Exception:
|
|
pass
|
|
live_pages = [r for r in page_records if r.get("section-id") not in draft_codes]
|
|
|
|
Path("search.json").write_text(
|
|
generate_search_json(
|
|
live_pages + post_records,
|
|
categories_use=cat_cfg["use"],
|
|
default_code=cat_cfg["default_code"],
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
print(f"Wrote search.json — {len(live_pages) + len(post_records)} entries.")
|
|
|
|
|
|
# ─── Option 7: path management ───────────────────────────────
|
|
|
|
def manage_paths():
|
|
while True:
|
|
clear()
|
|
header()
|
|
reg = load_registry()
|
|
print("Website paths\n")
|
|
if not reg["paths"]:
|
|
print(" (none defined)")
|
|
else:
|
|
for name, p in reg["paths"].items():
|
|
marker = "*" if name == reg.get("active") else " "
|
|
print(f" {marker} {name} → {p}")
|
|
print()
|
|
print(" a Add a path")
|
|
print(" s Set active path")
|
|
print(" r Remove a path")
|
|
print(" b Back")
|
|
print()
|
|
choice = input("Select: ").strip().lower()
|
|
|
|
if choice == "a":
|
|
name = input("Name: ").strip()
|
|
if not name:
|
|
continue
|
|
p = input("Path to project root (containing website/ folder): ").strip()
|
|
if not p:
|
|
continue
|
|
path = Path(p).expanduser().resolve()
|
|
if not path.is_dir():
|
|
print(f" Not a directory: {path}")
|
|
pause()
|
|
continue
|
|
if not (path / "website").is_dir():
|
|
print(f" No website/ subfolder in: {path}")
|
|
pause()
|
|
continue
|
|
reg["paths"][name] = str(path)
|
|
if not reg.get("active"):
|
|
reg["active"] = name
|
|
save_registry(reg)
|
|
pause()
|
|
elif choice == "s":
|
|
if not reg["paths"]:
|
|
pause()
|
|
continue
|
|
name = input("Name to activate: ").strip()
|
|
if name in reg["paths"]:
|
|
reg["active"] = name
|
|
save_registry(reg)
|
|
else:
|
|
print(" Not found.")
|
|
pause()
|
|
elif choice == "r":
|
|
if not reg["paths"]:
|
|
pause()
|
|
continue
|
|
name = input("Name to remove: ").strip()
|
|
if name in reg["paths"]:
|
|
del reg["paths"][name]
|
|
if reg.get("active") == name:
|
|
reg["active"] = next(iter(reg["paths"]), None)
|
|
save_registry(reg)
|
|
else:
|
|
print(" Not found.")
|
|
pause()
|
|
elif choice == "b":
|
|
return
|
|
|
|
|
|
# ─── Option 8: webserver ─────────────────────────────────────
|
|
|
|
def start_webserver(project):
|
|
port = 8800
|
|
site = project / "website"
|
|
if not site.is_dir():
|
|
print(f"\n Error: {site} not found.")
|
|
return
|
|
os.chdir(site)
|
|
print(f"\nStarting python3 -m http.server {port} in {site}")
|
|
print("Press Ctrl+C to stop.\n")
|
|
try:
|
|
proc = subprocess.Popen([sys.executable, "-m", "http.server", str(port)])
|
|
time.sleep(0.8)
|
|
webbrowser.open(f"http://localhost:{port}/")
|
|
proc.wait()
|
|
except KeyboardInterrupt:
|
|
proc.terminate()
|
|
print("\nStopped.")
|
|
|
|
|
|
# ─── Option 9 & 10 ───────────────────────────────────────────
|
|
|
|
def online_help():
|
|
print(f"Opening {HELP_URL} ...")
|
|
webbrowser.open(HELP_URL)
|
|
pause()
|
|
|
|
|
|
def about():
|
|
clear()
|
|
header()
|
|
print("MD-CMS is a lightweight Markdown-based CMS by Kristian Benestad.")
|
|
print()
|
|
print(f" Docs: https://docs.benestad.net")
|
|
print(f" Repo: https://github.com/kbenestad/mdcms")
|
|
print()
|
|
print("Licensed under the Apache License, Version 2.0.")
|
|
print(" https://www.apache.org/licenses/LICENSE-2.0")
|
|
pause()
|
|
|
|
|
|
# ─── Validation ──────────────────────────────────────────────
|
|
|
|
def _read_file(path):
|
|
"""Read a file, returning (text, error). On failure text is None."""
|
|
try:
|
|
return Path(path).read_text(encoding="utf-8"), None
|
|
except OSError as e:
|
|
return None, str(e)
|
|
|
|
|
|
def validate_config(site):
|
|
"""Check config.yml for missing or invalid values.
|
|
|
|
Returns a list of dicts: {'field': ..., 'issue': ..., 'current': ...}.
|
|
"""
|
|
path = site / "config.yml"
|
|
text, err = _read_file(path)
|
|
if text is None:
|
|
return [{"field": "config.yml", "issue": f"Cannot read file: {err}", "current": None}]
|
|
|
|
issues = []
|
|
|
|
# Simple key extraction from the raw text (reuses our non-YAML parser style)
|
|
def get_top(key):
|
|
for line in text.splitlines():
|
|
if line.startswith(key + ":"):
|
|
return line.split(":", 1)[1].strip().strip('"\'')
|
|
return None
|
|
|
|
# sitename
|
|
sn = get_top("sitename")
|
|
if not sn:
|
|
issues.append({"field": "sitename", "issue": "Missing site name", "current": sn})
|
|
|
|
# navigation
|
|
nav = get_top("navigation")
|
|
if nav and nav not in ("sidebar", "topbar"):
|
|
issues.append({"field": "navigation", "issue": f"Must be 'sidebar' or 'topbar'", "current": nav})
|
|
|
|
# category validation
|
|
cat_cfg = parse_config_categories(text)
|
|
if cat_cfg["use"]:
|
|
if not cat_cfg["default_code"]:
|
|
issues.append({"field": "default-category.code",
|
|
"issue": "categories-use: yes but no default category code defined",
|
|
"current": None})
|
|
if not cat_cfg["codes"]:
|
|
issues.append({"field": "categories",
|
|
"issue": "categories-use: yes but no additional categories defined",
|
|
"current": None})
|
|
|
|
# Validate all codes
|
|
all_codes = [c for c in [cat_cfg["default_code"]] + cat_cfg["codes"] if c]
|
|
for code in all_codes:
|
|
if not CATEGORY_CODE_RE.match(code):
|
|
issues.append({"field": f"category code '{code}'",
|
|
"issue": "Must match [a-zA-Z0-9-]+",
|
|
"current": code})
|
|
|
|
# Check for duplicate codes
|
|
seen = set()
|
|
for code in all_codes:
|
|
if code in seen:
|
|
issues.append({"field": f"category code '{code}'",
|
|
"issue": "Duplicate category code",
|
|
"current": code})
|
|
seen.add(code)
|
|
|
|
return issues
|
|
|
|
|
|
def validate_nav(site):
|
|
"""Check nav.yml for missing or invalid values.
|
|
|
|
Returns a list of dicts: {'field': ..., 'issue': ..., 'current': ...}.
|
|
"""
|
|
path = site / "nav.yml"
|
|
text, err = _read_file(path)
|
|
if text is None:
|
|
return [{"field": "nav.yml", "issue": f"Cannot read file: {err}", "current": None}]
|
|
|
|
try:
|
|
sections, pages = parse_nav_yml(text)
|
|
except Exception as e:
|
|
return [{"field": "nav.yml", "issue": f"Parse error: {e}", "current": None}]
|
|
|
|
issues = []
|
|
|
|
# Load category config to check categorynames
|
|
config_text, _ = _read_file(site / "config.yml")
|
|
cat_cfg = parse_config_categories(config_text) if config_text else {"use": False, "default_code": None, "codes": []}
|
|
sectionnames_mode = None
|
|
if config_text:
|
|
for line in config_text.splitlines():
|
|
if line.startswith("categories-sectionnames:"):
|
|
sectionnames_mode = line.split(":", 1)[1].strip().strip('"\'')
|
|
|
|
all_codes = [c for c in [cat_cfg["default_code"]] + cat_cfg["codes"] if c]
|
|
|
|
# Section checks
|
|
section_codes = set()
|
|
for i, s in enumerate(sections):
|
|
label = f"sections[{i}]"
|
|
if not s.get("code"):
|
|
issues.append({"field": f"{label}.code", "issue": "Missing section code", "current": None})
|
|
else:
|
|
section_codes.add(s["code"])
|
|
if not s.get("defaultname"):
|
|
issues.append({"field": f"{label}.defaultname",
|
|
"issue": f"Missing default name for section '{s.get('code', '?')}'",
|
|
"current": None})
|
|
pv = s.get("pagesvisibility", "visible")
|
|
if pv not in ("visible", "hidden", "draft"):
|
|
issues.append({"field": f"{label}.pagesvisibility",
|
|
"issue": f"Must be visible, hidden, or draft",
|
|
"current": pv})
|
|
if s.get("parent") and s.get("parent-sort") is None:
|
|
issues.append({"field": f"{label}.parent-sort",
|
|
"issue": f"parent is set but parent-sort is missing",
|
|
"current": None})
|
|
|
|
# categorynames check
|
|
if cat_cfg["use"] and sectionnames_mode == "per-category":
|
|
cn = s.get("categorynames") or {}
|
|
for code in all_codes:
|
|
if code not in cn:
|
|
issues.append({"field": f"{label}.categorynames.{code}",
|
|
"issue": f"Missing category name for '{code}' in section '{s.get('code', '?')}'",
|
|
"current": None})
|
|
|
|
# Page checks
|
|
for i, p in enumerate(pages):
|
|
label = f"pages[{i}]"
|
|
if not p.get("file"):
|
|
issues.append({"field": f"{label}.file", "issue": "Missing file path", "current": None})
|
|
if not p.get("title"):
|
|
issues.append({"field": f"{label}.title",
|
|
"issue": f"Missing title for '{p.get('file', '?')}'",
|
|
"current": None})
|
|
sid = p.get("section-id")
|
|
if sid and sid not in section_codes:
|
|
issues.append({"field": f"{label}.section-id",
|
|
"issue": f"Section-id '{sid}' not defined in sections",
|
|
"current": sid})
|
|
|
|
return issues
|
|
|
|
|
|
def _print_issues(issues, label):
|
|
"""Print validation issues in a readable format."""
|
|
if not issues:
|
|
print(f"\n {label}: no issues found.")
|
|
return
|
|
print(f"\n {label}: {len(issues)} issue(s):\n")
|
|
for iss in issues:
|
|
cur = f" (current: {iss['current']})" if iss["current"] is not None else ""
|
|
print(f" • {iss['field']}: {iss['issue']}{cur}")
|
|
|
|
|
|
# ─── Option 1: Prepare for upload ───────────────────────────
|
|
|
|
def do_prepare_for_upload(project):
|
|
"""Validate config + nav, build search.json, create zip."""
|
|
site = project / "website"
|
|
if not site.is_dir():
|
|
print(f"\n Error: {site} not found.")
|
|
return
|
|
|
|
print()
|
|
|
|
# Step 1: Validate config.yml
|
|
config_issues = validate_config(site)
|
|
_print_issues(config_issues, "config.yml")
|
|
|
|
# Step 2: Validate nav.yml
|
|
nav_issues = validate_nav(site)
|
|
_print_issues(nav_issues, "nav.yml")
|
|
|
|
total_issues = len(config_issues) + len(nav_issues)
|
|
if total_issues > 0:
|
|
print()
|
|
fix = input(f" {total_issues} issue(s) found. Continue anyway? (y/n): ").strip().lower()
|
|
if fix != "y":
|
|
print(" Aborted.")
|
|
return
|
|
|
|
# Step 3: Build search.json
|
|
print()
|
|
try:
|
|
do_build_search_only(project)
|
|
except Exception as e:
|
|
print(f" Error building search.json: {e}")
|
|
return
|
|
|
|
# Step 4: Create zip
|
|
print()
|
|
cwd = Path.cwd()
|
|
default_dest = cwd / "website.zip"
|
|
dest_input = input(f" Zip destination [{default_dest}]: ").strip()
|
|
dest = Path(dest_input) if dest_input else default_dest
|
|
dest = dest.expanduser().resolve()
|
|
|
|
# Ensure parent directory exists
|
|
dest.parent.mkdir(parents=True, exist_ok=True)
|
|
|
|
try:
|
|
count = 0
|
|
with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zf:
|
|
for root, dirs, files in os.walk(site):
|
|
dirs.sort()
|
|
for name in sorted(files):
|
|
full = Path(root) / name
|
|
arcname = full.relative_to(site)
|
|
zf.write(full, arcname)
|
|
count += 1
|
|
print(f"\n Created {dest} ({count} files)")
|
|
except OSError as e:
|
|
print(f"\n Error creating zip: {e}")
|
|
|
|
|
|
# ─── Option 2: Build from scratch ───────────────────────────
|
|
|
|
def do_build_from_scratch(project):
|
|
"""Interactive wizard to create config.yml, folder structure, and home.md."""
|
|
site = project / "website"
|
|
|
|
print("\n Build from scratch wizard\n")
|
|
|
|
# Check for existing config
|
|
if (site / "config.yml").exists():
|
|
overwrite = input(" config.yml already exists. Overwrite? (y/n): ").strip().lower()
|
|
if overwrite != "y":
|
|
print(" Aborted.")
|
|
return
|
|
|
|
# Gather settings
|
|
sitename = input(" Site name: ").strip() or "My Site"
|
|
|
|
nav_choice = ""
|
|
while nav_choice not in ("sidebar", "topbar"):
|
|
nav_choice = input(" Navigation layout (sidebar/topbar) [sidebar]: ").strip().lower() or "sidebar"
|
|
|
|
nav_pos = "left"
|
|
if nav_choice == "sidebar":
|
|
while nav_pos not in ("left", "right"):
|
|
nav_pos = input(" Navigation position (left/right) [left]: ").strip().lower() or "left"
|
|
|
|
search_choice = input(" Enable search? (yes/no) [yes]: ").strip().lower() or "yes"
|
|
search_on = search_choice in ("yes", "y", "true")
|
|
|
|
# Categories
|
|
use_categories = input(" Use categories? (yes/no) [no]: ").strip().lower()
|
|
use_categories = use_categories in ("yes", "y")
|
|
|
|
cat_block = ""
|
|
if use_categories:
|
|
default_code = input(" Default category code (e.g. en): ").strip() or "en"
|
|
default_name = input(f" Default category display name [{default_code}]: ").strip() or default_code
|
|
select_text = input(" Category selector label [Select language]: ").strip() or "Select language"
|
|
|
|
extra_cats = []
|
|
print(" Add additional categories (leave code blank to finish):")
|
|
while True:
|
|
code = input(" Code: ").strip()
|
|
if not code:
|
|
break
|
|
if not CATEGORY_CODE_RE.match(code):
|
|
print(f" Invalid code '{code}'. Must match [a-zA-Z0-9-]+.")
|
|
continue
|
|
name = input(f" Display name [{code}]: ").strip() or code
|
|
direction = input(f" Direction (ltr/rtl) [ltr]: ").strip().lower() or "ltr"
|
|
extra_cats.append({"code": code, "name": name, "direction": direction})
|
|
|
|
if not extra_cats:
|
|
print(" No additional categories added — disabling categories.")
|
|
use_categories = False
|
|
else:
|
|
cat_block = f"""
|
|
# ─── Category settings ───────────────────────────
|
|
categories-use: yes
|
|
categories-sectionnames: same
|
|
categories-selecttext: "{select_text}"
|
|
|
|
# ─── Default category ────────────────────────────
|
|
default-category:
|
|
code: {default_code}
|
|
name: {default_name}
|
|
direction: ltr
|
|
message: "Read in {default_name}"
|
|
|
|
# ─── Additional categories ───────────────────────
|
|
categories:
|
|
"""
|
|
for c in extra_cats:
|
|
cat_block += f""" - code: {c['code']}
|
|
name: {c['name']}
|
|
direction: {c['direction']}
|
|
message: "{c['name']}"
|
|
notfoundmessage: "Not available in {c['name']}"
|
|
"""
|
|
|
|
# Create folder structure
|
|
for d in ["pages", "posts", "assets/fonts", "assets/images"]:
|
|
(site / d).mkdir(parents=True, exist_ok=True)
|
|
|
|
# Write config.yml
|
|
config_text = f"""# ─── Site settings ───────────────────────────────
|
|
sitename: {sitename}
|
|
navigation: {nav_choice}
|
|
{"nav-position: " + nav_pos if nav_choice == "sidebar" else ""}
|
|
search: {"true" if search_on else "false"}
|
|
{cat_block}
|
|
# ─── Appearance ──────────────────────────────────
|
|
light:
|
|
bg: "#ededed"
|
|
bg-nav: "#ffffff"
|
|
font-colour: "#1a1a1a"
|
|
accent: "#29307d"
|
|
accent-hover: "#f9ad18"
|
|
|
|
dark:
|
|
bg: "#14171c"
|
|
bg-nav: "#1a1e25"
|
|
font-colour: "#d4d4d4"
|
|
accent: "#7b83d4"
|
|
accent-hover: "#f9ad18"
|
|
"""
|
|
(site / "config.yml").write_text(config_text, encoding="utf-8")
|
|
print(f"\n Wrote config.yml")
|
|
|
|
# Write home.md if it doesn't exist
|
|
home = site / "pages" / "home.md"
|
|
if not home.exists():
|
|
home.write_text(
|
|
f"---\ntitle: Home\nsort: 100\n---\n\n# Welcome to {sitename}\n\n"
|
|
"This is the default landing page.\n",
|
|
encoding="utf-8",
|
|
)
|
|
print(" Created pages/home.md")
|
|
|
|
# Create .gitkeep files in empty dirs
|
|
for d in ["posts", "assets/fonts", "assets/images"]:
|
|
gk = site / d / ".gitkeep"
|
|
if not gk.exists() and not any((site / d).iterdir()):
|
|
gk.write_text("", encoding="utf-8")
|
|
|
|
# Run option 3 to generate nav.yml + search.json
|
|
print()
|
|
try:
|
|
do_build_nav_and_search(project)
|
|
except Exception as e:
|
|
print(f" Error during build: {e}")
|
|
|
|
|
|
# ─── Option 5: Correct config.yml ───────────────────────────
|
|
|
|
def do_correct_config(project):
|
|
"""Check config.yml for missing/invalid values and prompt to fix."""
|
|
site = project / "website"
|
|
config_path = site / "config.yml"
|
|
|
|
issues = validate_config(site)
|
|
_print_issues(issues, "config.yml")
|
|
|
|
if not issues:
|
|
return
|
|
|
|
fix = input("\n Fix interactively? (y/n): ").strip().lower()
|
|
if fix != "y":
|
|
return
|
|
|
|
text, err = _read_file(config_path)
|
|
if text is None:
|
|
print(f" Cannot read config.yml: {err}")
|
|
return
|
|
|
|
lines = text.splitlines()
|
|
|
|
for iss in issues:
|
|
field = iss["field"]
|
|
print(f"\n Issue: {field} — {iss['issue']}")
|
|
|
|
if field == "sitename":
|
|
val = input(" Enter site name: ").strip()
|
|
if val:
|
|
# Find and replace or append
|
|
replaced = False
|
|
for i, ln in enumerate(lines):
|
|
if ln.startswith("sitename:"):
|
|
lines[i] = f"sitename: {val}"
|
|
replaced = True
|
|
break
|
|
if not replaced:
|
|
lines.insert(0, f"sitename: {val}")
|
|
print(f" Set sitename to: {val}")
|
|
|
|
elif field == "navigation":
|
|
val = ""
|
|
while val not in ("sidebar", "topbar"):
|
|
val = input(" Navigation (sidebar/topbar): ").strip().lower()
|
|
for i, ln in enumerate(lines):
|
|
if ln.startswith("navigation:"):
|
|
lines[i] = f"navigation: {val}"
|
|
break
|
|
|
|
elif "category code" in field and "Invalid" in iss.get("issue", ""):
|
|
print(" Please edit config.yml manually to fix category codes.")
|
|
|
|
else:
|
|
print(" Please edit config.yml manually to fix this issue.")
|
|
|
|
# Write back
|
|
config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
|
|
print("\n Saved config.yml")
|
|
|
|
|
|
# ─── Option 6: Correct nav.yml ─────────────────────────────
|
|
|
|
def do_correct_nav(project):
|
|
"""Check nav.yml for missing/invalid values and prompt to fix."""
|
|
site = project / "website"
|
|
nav_path = site / "nav.yml"
|
|
|
|
issues = validate_nav(site)
|
|
_print_issues(issues, "nav.yml")
|
|
|
|
if not issues:
|
|
return
|
|
|
|
# For missing categorynames, offer to auto-fill from defaultname
|
|
text, err = _read_file(nav_path)
|
|
if text is None:
|
|
print(f" Cannot read nav.yml: {err}")
|
|
return
|
|
|
|
try:
|
|
sections, pages = parse_nav_yml(text)
|
|
except Exception as e:
|
|
print(f" Cannot parse nav.yml: {e}")
|
|
return
|
|
|
|
# Separate auto-fixable (missing categorynames) from manual fixes
|
|
catname_issues = [i for i in issues if ".categorynames." in i["field"]]
|
|
other_issues = [i for i in issues if ".categorynames." not in i["field"]]
|
|
|
|
if other_issues:
|
|
print("\n The following issues require manual editing of nav.yml:")
|
|
for iss in other_issues:
|
|
print(f" • {iss['field']}: {iss['issue']}")
|
|
|
|
if catname_issues:
|
|
print(f"\n {len(catname_issues)} missing category name(s) found.")
|
|
fill = input(" Auto-fill missing categorynames from defaultname? (y/n): ").strip().lower()
|
|
if fill == "y":
|
|
# Load category codes
|
|
config_text, _ = _read_file(site / "config.yml")
|
|
cat_cfg = parse_config_categories(config_text) if config_text else {"use": False, "default_code": None, "codes": []}
|
|
all_codes = [c for c in [cat_cfg["default_code"]] + cat_cfg["codes"] if c]
|
|
|
|
for s in sections:
|
|
cn = s.get("categorynames") or {}
|
|
changed = False
|
|
for code in all_codes:
|
|
if code not in cn:
|
|
cn[code] = s.get("defaultname", s.get("code", ""))
|
|
changed = True
|
|
if changed:
|
|
s["categorynames"] = cn
|
|
|
|
# Regenerate nav.yml
|
|
config_text2, _ = _read_file(site / "config.yml")
|
|
cat_use = False
|
|
if config_text2:
|
|
cat_use = parse_config_categories(config_text2)["use"]
|
|
|
|
nav_path.write_text(
|
|
generate_nav_yml(sections, pages, categories_use=cat_use),
|
|
encoding="utf-8",
|
|
)
|
|
print(" Saved nav.yml with auto-filled category names.")
|
|
print(" Edit nav.yml to provide correct translations.")
|
|
|
|
|
|
# ─── Sections-sitemap (§2.3) ────────────────────────────────
|
|
# Note: sections-sitemap is not yet implemented. Section headings
|
|
# remain non-clickable in the renderer.
|
|
|
|
|
|
# ─── Main menu ───────────────────────────────────────────────
|
|
|
|
def main_menu():
|
|
while True:
|
|
clear()
|
|
header()
|
|
banner = load_banner()
|
|
if banner:
|
|
print(banner)
|
|
print()
|
|
name, website = active_path()
|
|
if name:
|
|
print(f"WEBSITE: {name} ({website})")
|
|
else:
|
|
print("WEBSITE: (none — select in option 7)")
|
|
print()
|
|
print(" 1 Prepare for upload")
|
|
print(" 2 Build config.yml and nav.yml from scratch")
|
|
print(" 3 Build nav.yml and search.json (new pages/sections)")
|
|
print(" 4 Build search.json (updated pages only)")
|
|
print(" 5 Correct missing values in config.yml")
|
|
print(" 6 Correct missing values in nav.yml")
|
|
print(" 7 Define website path")
|
|
print(" 8 Start python webserver")
|
|
print(" 9 Online help")
|
|
print(" 10 About MD-CMS")
|
|
print()
|
|
print(SEP)
|
|
choice = input("Select option (q to quit): ").strip().lower()
|
|
|
|
if choice == "q":
|
|
return
|
|
if choice == "7":
|
|
manage_paths()
|
|
continue
|
|
if choice == "10":
|
|
about()
|
|
continue
|
|
if choice == "9":
|
|
online_help()
|
|
continue
|
|
|
|
# Options 1-6 and 8 require an active website path
|
|
if choice in {"1", "2", "3", "4", "5", "6", "8"}:
|
|
if not website:
|
|
print("\n No active website path. Use option 7 first.")
|
|
pause()
|
|
continue
|
|
if not (website / "website").is_dir() and choice != "2":
|
|
print(f"\n Error: {website / 'website'} not found.")
|
|
pause()
|
|
continue
|
|
|
|
if choice == "1":
|
|
try:
|
|
do_prepare_for_upload(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "2":
|
|
try:
|
|
do_build_from_scratch(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "3":
|
|
try:
|
|
do_build_nav_and_search(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "4":
|
|
try:
|
|
do_build_search_only(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "5":
|
|
try:
|
|
do_correct_config(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "6":
|
|
try:
|
|
do_correct_nav(website)
|
|
except Exception as e:
|
|
print(f"\n Error: {e}")
|
|
pause()
|
|
elif choice == "8":
|
|
start_webserver(website)
|
|
|
|
|
|
def main():
|
|
try:
|
|
main_menu()
|
|
except KeyboardInterrupt:
|
|
print()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|