hugo/RuDS
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

feat: more completion for M4

Browse Source
This commit is contained in:
Chili Palmer
2026-04-13 21:20:41 +02:00
parent eca5fafc1c
commit a96a6ee31c
15 changed files with 527 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -837,6 +837,7 @@ name = "bds-ui"
version = "0.1.0"
dependencies = [
"anyhow",
"base64",
"bds-core",
"bds-editor",
"chrono",

1
Cargo.toml
View File

@@ -14,6 +14,7 @@ license = "MIT"
[workspace.dependencies]
# Foundation
base64 = "0.22"
rusqlite = { version = "0.33", features = ["bundled", "vtab"] }
refinery = { version = "0.8", features = ["rusqlite"] }
uuid = { version = "1", features = ["v4", "serde"] }

67
crates/bds-core/src/engine/ai.rs
View File

@@ -302,7 +302,7 @@ pub fn run_one_shot(
let settings = load_ai_settings(conn, offline_mode)?;
let endpoint = active_endpoint(conn, offline_mode)?;
let model = select_model(&settings, &endpoint, &request.operation)?;
let prompt = build_one_shot_prompt(request)?;
let user_content = build_one_shot_user_content(request)?;
let schema = response_schema(&request.operation);
let payload = json!({
"model": model,
@@ -313,7 +313,7 @@ pub fn run_one_shot(
},
{
"role": "user",
"content": prompt,
"content": user_content,
}
],
"response_format": {
@@ -412,37 +412,63 @@ fn build_system_prompt(base_prompt: &str, operation: &OneShotOperation) -> Strin
}
}
fn build_one_shot_prompt(request: &OneShotRequest) -> EngineResult<String> {
fn build_one_shot_user_content(request: &OneShotRequest) -> EngineResult<Value> {
match &request.operation {
OneShotOperation::AnalyzeTaxonomy => Ok(format!(
"Suggest tags and categories for this post: {}",
serde_json::to_string(&request.content)?
)),
).into()),
OneShotOperation::AnalyzePost => Ok(format!(
"Analyze this post and suggest title, excerpt, and slug: {}",
serde_json::to_string(&request.content)?
)),
).into()),
OneShotOperation::DetectLanguage => Ok(format!(
"Detect the language of this text: {}",
serde_json::to_string(&request.content)?
)),
).into()),
OneShotOperation::TranslatePost { target_language } => Ok(format!(
"Translate this post to {}: {}",
target_language,
serde_json::to_string(&request.content)?
)),
OneShotOperation::AnalyzeImage => Ok(format!(
"Analyze this image metadata and return title, alt, and caption suggestions: {}",
serde_json::to_string(&request.content)?
)),
).into()),
OneShotOperation::AnalyzeImage => build_image_analysis_user_content(&request.content),
OneShotOperation::TranslateMedia { target_language } => Ok(format!(
"Translate this media metadata to {}: {}",
target_language,
serde_json::to_string(&request.content)?
)),
).into()),
}
}
fn build_image_analysis_user_content(content: &Value) -> EngineResult<Value> {
let image_data_url = content
.get("image_data_url")
.and_then(Value::as_str)
.filter(|value| !value.trim().is_empty())
.ok_or_else(|| EngineError::Validation("image analysis requires image data".to_string()))?;
let mut metadata = content.clone();
if let Some(object) = metadata.as_object_mut() {
object.remove("image_data_url");
}
Ok(json!([
{
"type": "text",
"text": format!(
"Analyze this image and return title, alt, and caption suggestions. Metadata: {}",
serde_json::to_string(&metadata)?
)
},
{
"type": "image_url",
"image_url": {
"url": image_data_url
}
}
]))
}
fn response_schema(operation: &OneShotOperation) -> (&'static str, Value) {
match operation {
OneShotOperation::AnalyzeTaxonomy => (
@@ -731,6 +757,23 @@ mod tests {
);
}
#[test]
fn image_analysis_user_content_is_multimodal() {
let content = build_image_analysis_user_content(&json!({
"title": "Existing title",
"alt": "Existing alt",
"image_data_url": "data:image/jpeg;base64,abc123"
}))
.unwrap();
let parts = content.as_array().unwrap();
assert_eq!(parts.len(), 2);
assert_eq!(parts[0]["type"], "text");
assert!(parts[0]["text"].as_str().unwrap().contains("Existing title"));
assert_eq!(parts[1]["type"], "image_url");
assert_eq!(parts[1]["image_url"]["url"], "data:image/jpeg;base64,abc123");
}
fn spawn_test_server(handler: impl Fn(String) -> String + Send + 'static) -> String {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();

38
crates/bds-core/src/engine/generation.rs
View File

@@ -11,7 +11,7 @@ use crate::db::queries;
use crate::engine::site_assets::write_bundled_site_assets;
use crate::engine::validate_site::SiteValidationReport;
use crate::engine::{EngineError, EngineResult};
use crate::model::{Post, ProjectMetadata};
use crate::model::{CategorySettings, Post, ProjectMetadata};
use crate::render::{
GeneratedWriteOutcome, build_calendar_json, build_canonical_post_path,
build_site_render_artifacts, render_markdown_to_html, write_generated_bytes,
@@ -49,11 +49,14 @@ pub fn generate_starter_site(
_language: &str,
) -> EngineResult<GenerationReport> {
let mut report = GenerationReport::default();
let data_dir = project_data_dir(output_dir);
let category_settings = load_category_settings(&data_dir);
let list_posts = filter_posts_for_lists(posts, &category_settings);
let input_posts = posts
.iter()
.map(|source| (source.post.clone(), source.body_markdown.clone()))
.collect::<Vec<_>>();
let artifacts = build_site_render_artifacts(conn, output_dir.parent().unwrap_or(output_dir), project_id, metadata, &input_posts)
let artifacts = build_site_render_artifacts(conn, &data_dir, project_id, metadata, &input_posts)
.map_err(|error| EngineError::Parse(error.to_string()))?;
for page in &artifacts.pages {
@@ -67,12 +70,12 @@ pub fn generate_starter_site(
output_dir,
project_id,
"calendar.json",
&build_calendar_json(&posts.iter().map(|source| source.post.clone()).collect::<Vec<_>>())?,
&build_calendar_json(&list_posts.iter().map(|source| source.post.clone()).collect::<Vec<_>>())?,
&mut report,
)?;
for render_language in render_languages(metadata) {
let localized_posts = localized_sources(conn, output_dir.parent().unwrap_or(output_dir), posts, &render_language, metadata)?;
let localized_posts = localized_sources(conn, &data_dir, &list_posts, &render_language, metadata)?;
let prefix = if render_language == metadata.main_language.clone().unwrap_or_else(|| "en".to_string()) {
String::new()
} else {
@@ -142,6 +145,8 @@ pub fn apply_validation_sections(
let section_set = sections.iter().copied().collect::<HashSet<_>>();
let data_dir = project_data_dir(output_dir);
let category_settings = load_category_settings(&data_dir);
let list_posts = filter_posts_for_lists(posts, &category_settings);
let input_posts = posts
.iter()
.map(|source| (source.post.clone(), source.body_markdown.clone()))
@@ -170,7 +175,7 @@ pub fn apply_validation_sections(
output_dir,
project_id,
"calendar.json",
&build_calendar_json(&posts.iter().map(|source| source.post.clone()).collect::<Vec<_>>())?,
&build_calendar_json(&list_posts.iter().map(|source| source.post.clone()).collect::<Vec<_>>())?,
&mut report,
)?;
@@ -178,7 +183,7 @@ pub fn apply_validation_sections(
let localized_posts = localized_sources(
conn,
&data_dir,
posts,
&list_posts,
&render_language,
metadata,
)?;
@@ -511,6 +516,27 @@ fn localized_sources(
Ok(localized)
}
fn load_category_settings(data_dir: &Path) -> HashMap<String, CategorySettings> {
crate::engine::meta::read_category_meta_json(data_dir).unwrap_or_default()
}
fn filter_posts_for_lists(
posts: &[PublishedPostSource],
category_settings: &HashMap<String, CategorySettings>,
) -> Vec<PublishedPostSource> {
posts.iter()
.filter(|source| {
!source.post.categories.iter().any(|category| {
category_settings
.get(category)
.map(|settings| !settings.render_in_lists)
.unwrap_or(false)
})
})
.cloned()
.collect()
}
fn build_rss_xml(metadata: &ProjectMetadata, posts: &[PublishedPostSource], language: &str) -> String {
let base_url = metadata.public_url.as_deref().unwrap_or("").trim_end_matches('/');
let last_build = posts

101
crates/bds-core/src/engine/preview.rs
View File

@@ -607,6 +607,38 @@ mod tests {
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[test]
fn preview_server_serves_media_and_asset_files() {
let _guard = preview_port_guard().lock().unwrap();
let (dir, _db) = setup_preview_fixture();
std::fs::create_dir_all(dir.path().join("assets")).unwrap();
std::fs::write(dir.path().join("media/ok.txt"), "ok").unwrap();
std::fs::write(dir.path().join("assets/site.css"), "body { color: red; }").unwrap();
let server = start_preview_server(
dir.path().join("bds.db"),
dir.path().to_path_buf(),
"project-1".into(),
)
.unwrap();
let client = reqwest::blocking::Client::new();
let media = client
.get(format!("http://{PREVIEW_HOST}:{PREVIEW_PORT}/media/ok.txt"))
.send()
.unwrap();
let asset = client
.get(format!("http://{PREVIEW_HOST}:{PREVIEW_PORT}/assets/site.css"))
.send()
.unwrap();
let media_body = media.text().unwrap();
let asset_body = asset.text().unwrap();
server.stop().unwrap();
assert_eq!(media_body, "ok");
assert!(asset_body.contains("color: red"));
}
#[test]
fn preview_server_serves_style_preview() {
let _guard = preview_port_guard().lock().unwrap();
@@ -659,4 +691,73 @@ mod tests {
assert!(body.contains("data-theme=\"nightfall\""));
assert!(body.contains("data-mode=\"dark\""));
}
#[test]
fn preview_respects_category_list_visibility_and_show_title_rules() {
let dir = tempfile::tempdir().unwrap();
std::fs::create_dir_all(dir.path().join("meta")).unwrap();
crate::engine::meta::write_category_meta_json(
dir.path(),
&std::collections::HashMap::from([
(
"hidden".to_string(),
crate::model::CategorySettings {
render_in_lists: false,
show_title: true,
post_template_slug: None,
list_template_slug: None,
},
),
(
"featured".to_string(),
crate::model::CategorySettings {
render_in_lists: true,
show_title: false,
post_template_slug: None,
list_template_slug: None,
},
),
]),
)
.unwrap();
let db = Database::open_in_memory().unwrap();
let mut hidden = make_post();
hidden.post.title = "Hidden Post".into();
hidden.post.slug = "hidden-post".into();
hidden.post.categories = vec!["hidden".into()];
hidden.body_markdown = "Hidden body".into();
let mut featured = make_post();
featured.post.title = "Featured Post".into();
featured.post.slug = "featured-post".into();
featured.post.categories = vec!["featured".into()];
featured.body_markdown = "Featured body".into();
let hidden_response = build_preview_response(
db.conn(),
dir.path(),
"project-1",
&make_metadata(),
&[(hidden.post.clone(), hidden.body_markdown.clone()), (featured.post.clone(), featured.body_markdown.clone())],
"/category/hidden",
)
.unwrap();
assert_eq!(hidden_response.status_code, 404);
let featured_response = build_preview_response(
db.conn(),
dir.path(),
"project-1",
&make_metadata(),
&[(hidden.post, hidden.body_markdown), (featured.post, featured.body_markdown)],
"/category/featured",
)
.unwrap();
assert_eq!(featured_response.status_code, 200);
assert!(featured_response.html.contains("Featured body"));
assert!(!featured_response.html.contains("<h2 class=\"post-title\""));
assert!(!featured_response.html.contains("Featured Post"));
}
}

4
crates/bds-core/src/engine/site_assets.rs
View File

@@ -45,6 +45,10 @@ const BUNDLED_SITE_ASSETS: &[BundledSiteAsset] = &[
BundledSiteAsset { relative_path: "assets/tag-cloud.js", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/assets/tag-cloud.js") },
BundledSiteAsset { relative_path: "assets/vanilla-calendar.min.css", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/assets/vanilla-calendar.min.css") },
BundledSiteAsset { relative_path: "assets/vanilla-calendar.min.js", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/assets/vanilla-calendar.min.js") },
BundledSiteAsset { relative_path: "images/close.png", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/images/close.png") },
BundledSiteAsset { relative_path: "images/loading.gif", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/images/loading.gif") },
BundledSiteAsset { relative_path: "images/next.png", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/images/next.png") },
BundledSiteAsset { relative_path: "images/prev.png", bytes: include_bytes!("../../../../fixtures/golden-generated-sites/rfc1437-sample/images/prev.png") },
];
pub(crate) fn copy_bundled_site_assets(project_dir: &Path) -> EngineResult<()> {

9
crates/bds-core/src/render/macros.rs
View File

@@ -52,10 +52,17 @@ fn render_macro(invocation: &str, context: &MacroRenderContext) -> Option<String
"vimeo" => Some(render_vimeo(&args)),
"photo_archive" => Some(render_photo_archive(&args, context)),
"tag_cloud" => Some(render_tag_cloud(&args, context)),
_ => None,
_ => Some(unsupported_macro(name)),
}
}
fn unsupported_macro(name: &str) -> String {
format!(
"<section class=\"macro-unsupported\"><p>Unsupported macro: <code>{}</code></p></section>",
escape_html_attr(name),
)
}
fn tokenize_invocation(invocation: &str) -> Vec<String> {
let mut tokens = Vec::new();
let mut current = String::new();

121
crates/bds-core/src/render/site.rs
View File

@@ -54,7 +54,8 @@ pub struct PreviewRenderResult {
struct TemplateBundle {
post_templates: Vec<Template>,
template_source_by_slug: HashMap<String, String>,
list_template: String,
list_template_sources: HashMap<String, String>,
default_list_template: String,
not_found_template: String,
partials: HashMap<String, String>,
}
@@ -71,6 +72,7 @@ struct RouteSpec {
url_path: String,
page_title: String,
archive_context: Option<Value>,
list_template_slug: Option<String>,
posts: Vec<RenderPostRecord>,
current_page: usize,
total_pages: usize,
@@ -99,7 +101,8 @@ pub fn build_site_render_artifacts(
let mut artifacts = SiteRenderArtifacts::default();
for language in languages {
let localized_posts = load_language_posts(conn, data_dir, published_posts, &language, &main_language)?;
let routes = build_language_routes(&localized_posts, metadata, &language, &tags);
let localized_list_posts = filter_posts_for_lists(&localized_posts, &category_settings);
let routes = build_language_routes(&localized_list_posts, metadata, &language, &tags, &category_settings);
let post_data_json_by_id = build_post_data_json_by_id(&localized_posts);
let menu_items = build_menu_items(data_dir, &language, &main_language)?;
let rendered_list_pages = routes
@@ -109,8 +112,9 @@ pub fn build_site_render_artifacts(
route,
metadata,
&language,
&localized_posts,
&localized_list_posts,
&tags,
&category_settings,
&menu_items,
&post_data_json_by_id,
&bundle,
@@ -206,8 +210,9 @@ fn load_template_bundle(
let templates = queries::template::list_templates_by_project(conn, project_id).unwrap_or_default();
let mut template_source_by_slug = HashMap::new();
let mut post_templates = Vec::new();
let mut list_template_sources = HashMap::new();
let mut partials = starter_partials();
let mut list_template = STARTER_POST_LIST_TEMPLATE.to_string();
let mut default_list_template = STARTER_POST_LIST_TEMPLATE.to_string();
let mut not_found_template = STARTER_NOT_FOUND_TEMPLATE.to_string();
for template in templates {
@@ -223,8 +228,12 @@ fn load_template_bundle(
post_templates.push(hydrated);
}
TemplateKind::List => {
if template.slug == "list" || list_template == STARTER_POST_LIST_TEMPLATE {
list_template = source;
list_template_sources.insert(template.slug.clone(), source.clone());
if template.slug == "list"
|| template.slug == "post-list"
|| default_list_template == STARTER_POST_LIST_TEMPLATE
{
default_list_template = source;
}
}
TemplateKind::NotFound => {
@@ -242,6 +251,13 @@ fn load_template_bundle(
}
}
list_template_sources
.entry("post-list".to_string())
.or_insert_with(|| STARTER_POST_LIST_TEMPLATE.to_string());
list_template_sources
.entry("list".to_string())
.or_insert_with(|| STARTER_POST_LIST_TEMPLATE.to_string());
if !post_templates.iter().any(|template| template.slug == "post") {
post_templates.push(Template {
id: "starter-post-template".to_string(),
@@ -263,7 +279,8 @@ fn load_template_bundle(
Ok(TemplateBundle {
post_templates,
template_source_by_slug,
list_template,
list_template_sources,
default_list_template,
not_found_template,
partials,
})
@@ -330,10 +347,18 @@ fn build_language_routes(
metadata: &ProjectMetadata,
language: &str,
tags: &[Tag],
category_settings: &HashMap<String, CategorySettings>,
) -> Vec<RouteSpec> {
let per_page = metadata.max_posts_per_page.max(1) as usize;
let mut routes = Vec::new();
routes.extend(paginated_route_specs(posts, per_page, language_root_prefix(language, metadata), metadata.name.clone(), None));
routes.extend(paginated_route_specs(
posts,
per_page,
language_root_prefix(language, metadata),
metadata.name.clone(),
None,
None,
));
let mut category_posts: BTreeMap<String, Vec<RenderPostRecord>> = BTreeMap::new();
let mut tag_posts: BTreeMap<String, Vec<RenderPostRecord>> = BTreeMap::new();
@@ -361,6 +386,9 @@ fn build_language_routes(
format!("{}/category/{slug}", language_root_prefix(language, metadata)),
category.clone(),
Some(json!({"kind": "category", "name": category})),
category_settings
.get(&category)
.and_then(|settings| settings.list_template_slug.clone()),
));
}
@@ -377,6 +405,7 @@ fn build_language_routes(
format!("{}/tag/{slug}", language_root_prefix(language, metadata)),
display_name.clone(),
Some(json!({"kind": "tag", "name": display_name})),
None,
));
}
@@ -387,6 +416,7 @@ fn build_language_routes(
format!("{}/{year}", language_root_prefix(language, metadata)),
format!("{} {year}", metadata.name),
Some(json!({"kind": "year", "year": year})),
None,
));
}
@@ -397,6 +427,7 @@ fn build_language_routes(
format!("{}/{year}/{month:02}", language_root_prefix(language, metadata)),
format!("{} {year}-{month:02}", metadata.name),
Some(json!({"kind": "month", "year": year, "month": month})),
None,
));
}
@@ -409,6 +440,7 @@ fn paginated_route_specs(
base_path: String,
page_title: String,
archive_context: Option<Value>,
list_template_slug: Option<String>,
) -> Vec<RouteSpec> {
let total_items = posts.len();
let total_pages = total_items.max(1).div_ceil(per_page.max(1));
@@ -436,6 +468,7 @@ fn paginated_route_specs(
url_path,
page_title: page_title.clone(),
archive_context: archive_context.clone(),
list_template_slug: list_template_slug.clone(),
posts: slice,
current_page,
total_pages: total_pages.max(1),
@@ -452,6 +485,7 @@ fn render_list_route(
language: &str,
posts: &[RenderPostRecord],
tags: &[Tag],
category_settings: &HashMap<String, CategorySettings>,
menu_items: &[Value],
post_data_json_by_id: &HashMap<String, Value>,
bundle: &TemplateBundle,
@@ -459,6 +493,11 @@ fn render_list_route(
let main_language = main_language(metadata);
let canonical_map = canonical_post_path_by_slug(posts, language, main_language);
let taxonomy_counts = build_taxonomy_counts(posts, tags);
let list_template = route
.list_template_slug
.as_deref()
.and_then(|slug| bundle.list_template_sources.get(slug))
.unwrap_or(&bundle.default_list_template);
let context = json!({
"language": language,
"language_prefix": language_prefix(language, main_language),
@@ -474,7 +513,7 @@ fn render_list_route(
"show_archive_range_heading": false,
"min_date": route.posts.last().map(|record| timestamp_parts(record.post.published_at.unwrap_or(record.post.created_at))),
"max_date": route.posts.first().map(|record| timestamp_parts(record.post.published_at.unwrap_or(record.post.created_at))),
"day_blocks": build_day_blocks(&route.posts),
"day_blocks": build_day_blocks(&route.posts, category_settings),
"is_list_page": route.current_page > 1,
"is_first_page": route.current_page == 1,
"is_last_page": route.current_page >= route.total_pages,
@@ -497,7 +536,7 @@ fn render_list_route(
"not_found_back_label": serde_json::Value::Null,
});
Ok(render_liquid_template(&bundle.list_template, &bundle.partials, &context)?)
Ok(render_liquid_template(list_template, &bundle.partials, &context)?)
}
#[allow(clippy::too_many_arguments)]
@@ -707,7 +746,10 @@ fn route_href(route: &RouteSpec, page: usize) -> String {
}
}
fn build_day_blocks(posts: &[RenderPostRecord]) -> Vec<Value> {
fn build_day_blocks(
posts: &[RenderPostRecord],
category_settings: &HashMap<String, CategorySettings>,
) -> Vec<Value> {
let mut blocks = Vec::new();
let mut current_key = String::new();
let mut current_posts = Vec::new();
@@ -730,12 +772,13 @@ fn build_day_blocks(posts: &[RenderPostRecord]) -> Vec<Value> {
}
current_key = key;
current_label = format!("{:02}.{:02}.{:04}", timestamp.day(), timestamp.month(), timestamp.year());
let show_title = should_show_list_title(&record.post, category_settings);
current_posts.push(json!({
"id": record.post.id,
"title": record.post.title,
"slug": record.post.slug,
"content": record.post.excerpt.clone().unwrap_or_else(|| record.body_markdown.clone()),
"show_title": true,
"content": resolve_list_content(record, category_settings),
"show_title": show_title,
}));
}
@@ -750,6 +793,58 @@ fn build_day_blocks(posts: &[RenderPostRecord]) -> Vec<Value> {
blocks
}
fn filter_posts_for_lists(
posts: &[RenderPostRecord],
category_settings: &HashMap<String, CategorySettings>,
) -> Vec<RenderPostRecord> {
posts.iter()
.filter(|record| !is_post_excluded_from_lists(&record.post, category_settings))
.cloned()
.collect()
}
fn is_post_excluded_from_lists(
post: &Post,
category_settings: &HashMap<String, CategorySettings>,
) -> bool {
post.categories.iter().any(|category| {
category_settings
.get(category)
.map(|settings| !settings.render_in_lists)
.unwrap_or(false)
})
}
fn should_show_list_title(
post: &Post,
category_settings: &HashMap<String, CategorySettings>,
) -> bool {
if post.categories.is_empty() {
return true;
}
!post.categories.iter().any(|category| {
category_settings
.get(category)
.map(|settings| !settings.show_title)
.unwrap_or(false)
})
}
fn resolve_list_content(
record: &RenderPostRecord,
category_settings: &HashMap<String, CategorySettings>,
) -> String {
let show_title = should_show_list_title(&record.post, category_settings);
let excerpt = record.post.excerpt.as_deref().map(str::trim).unwrap_or("");
if show_title && !excerpt.is_empty() {
record.post.excerpt.clone().unwrap_or_default()
} else {
record.body_markdown.clone()
}
}
fn canonical_post_path_by_slug(
posts: &[RenderPostRecord],
language: &str,

109
crates/bds-core/tests/m4_generation_engine.rs
View File

@@ -1,11 +1,15 @@
use std::collections::HashMap;
use bds_core::db::queries::project::insert_project;
use bds_core::db::queries::template::insert_template;
use bds_core::db::Database;
use bds_core::engine::generation::{
PublishedPostSource, apply_validation_sections, generate_starter_site,
sections_from_validation_report,
};
use bds_core::engine::meta::write_category_meta_json;
use bds_core::engine::validate_site::validate_site;
use bds_core::model::{Post, PostStatus, Project, ProjectMetadata};
use bds_core::model::{CategorySettings, Post, PostStatus, Project, ProjectMetadata, Template, TemplateKind, TemplateStatus};
use tempfile::TempDir;
fn make_project() -> Project {
@@ -64,6 +68,23 @@ fn make_post(slug: &str, published_at: i64) -> Post {
}
}
fn make_list_template(slug: &str, content: &str) -> Template {
Template {
id: format!("template-{slug}"),
project_id: "p1".into(),
slug: slug.into(),
title: slug.into(),
kind: TemplateKind::List,
enabled: true,
version: 1,
file_path: String::new(),
status: TemplateStatus::Published,
content: Some(content.into()),
created_at: 1,
updated_at: 1,
}
}
fn setup() -> (Database, TempDir) {
let mut db = Database::open_in_memory().unwrap();
db.migrate().unwrap();
@@ -147,6 +168,92 @@ fn multilingual_generation_writes_language_aware_atom_and_sitemap_routes() {
assert!(sitemap.contains("https://example.com/category/article"));
}
#[test]
fn generation_respects_category_list_settings_and_writes_bundled_images() {
let (db, dir) = setup();
insert_template(
db.conn(),
&make_list_template(
"featured-list",
"FEATURED:{% for day_block in day_blocks %}{% for post in day_block.posts %}[{{ post.title }}|{{ post.show_title }}]{% endfor %}{% endfor %}",
),
)
.unwrap();
write_category_meta_json(
dir.path(),
&HashMap::from([
(
"hidden".to_string(),
CategorySettings {
render_in_lists: false,
show_title: true,
post_template_slug: None,
list_template_slug: None,
},
),
(
"featured".to_string(),
CategorySettings {
render_in_lists: true,
show_title: false,
post_template_slug: None,
list_template_slug: Some("featured-list".to_string()),
},
),
]),
)
.unwrap();
let mut hidden_post = make_post("hidden-post", 1_710_000_000_000);
hidden_post.title = "Hidden Post".into();
hidden_post.categories = vec!["hidden".into()];
let mut featured_post = make_post("featured-post", 1_710_086_400_000);
featured_post.title = "Featured Post".into();
featured_post.categories = vec!["featured".into()];
let posts = vec![
PublishedPostSource {
post: hidden_post,
body_markdown: "Hidden body".into(),
},
PublishedPostSource {
post: featured_post,
body_markdown: "Featured body".into(),
},
];
let report = generate_starter_site(db.conn(), dir.path(), "p1", &make_metadata(), &posts, "en").unwrap();
for asset in [
"images/close.png",
"images/loading.gif",
"images/next.png",
"images/prev.png",
] {
assert!(report.written_paths.contains(&asset.to_string()));
assert!(dir.path().join(asset).exists(), "missing bundled image {asset}");
}
assert!(!report.written_paths.contains(&"category/hidden/index.html".to_string()));
assert!(report.written_paths.contains(&"category/featured/index.html".to_string()));
let index_html = std::fs::read_to_string(dir.path().join("index.html")).unwrap();
assert!(!index_html.contains("Hidden Post"));
assert!(index_html.contains("[Featured Post|false]"));
let featured_html = std::fs::read_to_string(dir.path().join("category/featured/index.html")).unwrap();
assert!(featured_html.contains("FEATURED:[Featured Post|false]"));
let feed = std::fs::read_to_string(dir.path().join("feed.xml")).unwrap();
assert!(!feed.contains("hidden-post"));
assert!(feed.contains("featured-post"));
let calendar = std::fs::read_to_string(dir.path().join("calendar.json")).unwrap();
assert!(!calendar.contains("2024-03-09"));
assert!(calendar.contains("2024-03-10"));
}
#[test]
fn generation_engine_skips_unchanged_outputs_on_second_run() {
let (db, dir) = setup();

18
crates/bds-core/tests/m4_page_renderer.rs
View File

@@ -91,6 +91,24 @@ fn markdown_filter_expands_builtin_macros_from_runtime_context() {
assert!(rendered.contains("data-tag-cloud=\"true\""));
}
#[test]
fn markdown_filter_marks_unsupported_macros_visibly() {
let template = "{{ body | markdown: nil, nil, canonical_post_path_by_slug, canonical_media_path_by_source_path, language, language_prefix }}";
let partials = HashMap::new();
let context = serde_json::json!({
"body": "[[custom_block foo=bar]]",
"canonical_post_path_by_slug": {},
"canonical_media_path_by_source_path": {},
"language": "en",
"language_prefix": ""
});
let rendered = render_liquid_template(template, &partials, &context).unwrap();
assert!(rendered.contains("macro-unsupported"));
assert!(rendered.contains("Unsupported macro"));
assert!(rendered.contains("custom_block"));
}
#[test]
fn starter_single_post_template_renders_with_partials() {
let template = include_str!("../../../assets/starter-templates/single-post.liquid");

1
crates/bds-ui/Cargo.toml
View File

@@ -11,6 +11,7 @@ iced = { workspace = true }
muda = { workspace = true }
rfd = { workspace = true }
serde_json = { workspace = true }
base64 = { workspace = true }
dirs = { workspace = true }
chrono = { workspace = true }
open = { workspace = true }

42
crates/bds-ui/src/app.rs
View File

@@ -2,6 +2,7 @@ use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use base64::Engine as _;
use chrono::Datelike;
use iced::{Element, Subscription, Task, window};
use rusqlite::Error as SqlError;
@@ -6815,9 +6816,20 @@ impl BdsApp {
self.notify(ToastLevel::Error, "database unavailable");
return Task::none();
};
let Some(data_dir) = &self.data_dir else {
self.notify(ToastLevel::Error, "project data directory unavailable");
return Task::none();
};
let Some(state) = self.media_editors.get(media_id).cloned() else {
return Task::none();
};
let image_data_url = match build_ai_image_data_url(data_dir, &state.media_id, &state.file_path, &state.mime_type) {
Ok(value) => value,
Err(error) => {
self.notify(ToastLevel::Error, &error);
return Task::none();
}
};
let request = ai::OneShotRequest {
operation: ai::OneShotOperation::AnalyzeImage,
content: json!({
@@ -6826,6 +6838,7 @@ impl BdsApp {
"caption": state.caption,
"filename": state.original_name,
"mime_type": state.mime_type,
"image_data_url": image_data_url,
}),
};
match ai::run_one_shot(db.conn(), self.offline_mode, &request) {
@@ -7043,6 +7056,35 @@ fn content_sample(content: &str, max_len: usize) -> String {
content.chars().take(max_len).collect()
}
fn build_ai_image_data_url(
data_dir: &Path,
media_id: &str,
file_path: &str,
mime_type: &str,
) -> Result<String, String> {
if !mime_type.starts_with("image/") {
return Err("AI image analysis requires an image".to_string());
}
let source_path = data_dir.join(file_path.trim_start_matches('/'));
let thumbnail_relative = bds_core::util::thumbnail_path(media_id, "ai", "jpg");
let thumbnail_path = data_dir.join(&thumbnail_relative);
if !thumbnail_path.exists() {
bds_core::util::thumbnail::generate_all_thumbnails(
&source_path,
&data_dir.join("thumbnails"),
media_id,
)
.map_err(|error| format!("failed to generate AI thumbnail: {error}"))?;
}
let bytes = std::fs::read(&thumbnail_path)
.map_err(|error| format!("failed to read AI thumbnail: {error}"))?;
let encoded = base64::engine::general_purpose::STANDARD.encode(bytes);
Ok(format!("data:image/jpeg;base64,{encoded}"))
}
fn split_csv_values(value: &str) -> Vec<String> {
value
.split(',')

7
crates/bds-ui/src/views/media_editor.rs
View File

@@ -222,6 +222,7 @@ pub fn view<'a>(
state: &'a MediaEditorState,
locale: UiLocale,
data_dir: Option<&Path>,
ai_enabled: bool,
) -> Element<'a, Message> {
let header = inputs::toolbar(
vec![
@@ -230,18 +231,18 @@ pub fn view<'a>(
vec![
if state.mime_type.starts_with("image/") {
button(text(t(locale, "editor.aiAnalyze")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::AnalyzeWithAi))
.on_press_maybe(ai_enabled.then_some(Message::MediaEditor(MediaEditorMsg::AnalyzeWithAi)))
.padding([6, 16])
.into()
} else {
Space::new(0, 0).into()
},
button(text(t(locale, "editor.detectLanguage")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::DetectLanguage))
.on_press_maybe(ai_enabled.then_some(Message::MediaEditor(MediaEditorMsg::DetectLanguage)))
.padding([6, 16])
.into(),
button(text(t(locale, "editor.translate")).size(13))
.on_press(Message::MediaEditor(MediaEditorMsg::TranslateMetadata))
.on_press_maybe(ai_enabled.then_some(Message::MediaEditor(MediaEditorMsg::TranslateMetadata)))
.padding([6, 16])
.into(),
button(text(t(locale, "common.save")).size(13))

17
crates/bds-ui/src/views/post_editor.rs
View File

@@ -372,6 +372,7 @@ pub fn view<'a>(
state: &'a PostEditorState,
locale: UiLocale,
word_wrap: bool,
ai_enabled: bool,
preview_widget: Option<Element<'a, Message>>,
) -> Element<'a, Message> {
let on_translation = state.active_language != state.canonical_language;
@@ -389,7 +390,7 @@ pub fn view<'a>(
.size(13)
.shaping(Shaping::Advanced),
)
.on_press(Message::PostEditor(PostEditorMsg::ToggleQuickActions))
.on_press_maybe(ai_enabled.then_some(Message::PostEditor(PostEditorMsg::ToggleQuickActions)))
.padding([6, 16])
.style(status_bar::dropdown_trigger)
.into();
@@ -479,10 +480,10 @@ pub fn view<'a>(
Space::with_width(Length::Fill),
container(
column![
quick_action_item(locale, t(locale, "editor.aiAnalyze"), PostEditorMsg::AnalyzeWithAi),
quick_action_item(locale, t(locale, "editor.suggestTaxonomy"), PostEditorMsg::AnalyzeTaxonomy),
quick_action_item(locale, t(locale, "editor.translate"), PostEditorMsg::Translate),
quick_action_item(locale, t(locale, "editor.detectLanguage"), PostEditorMsg::DetectLanguage),
quick_action_item(locale, t(locale, "editor.aiAnalyze"), PostEditorMsg::AnalyzeWithAi, ai_enabled),
quick_action_item(locale, t(locale, "editor.suggestTaxonomy"), PostEditorMsg::AnalyzeTaxonomy, ai_enabled),
quick_action_item(locale, t(locale, "editor.translate"), PostEditorMsg::Translate, ai_enabled),
quick_action_item(locale, t(locale, "editor.detectLanguage"), PostEditorMsg::DetectLanguage, ai_enabled),
]
.spacing(4)
)
@@ -574,7 +575,7 @@ pub fn view<'a>(
|lang| Message::PostEditor(PostEditorMsg::LanguageChanged(lang)),
);
let detect_language = button(text(t(locale, "editor.detectLanguage")).size(12).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(PostEditorMsg::DetectLanguage))
.on_press_maybe(ai_enabled.then_some(Message::PostEditor(PostEditorMsg::DetectLanguage)))
.padding([6, 12]);
let template_input = inputs::labeled_input(
&t(locale, "editor.templateSlug"),
@@ -979,10 +980,10 @@ fn mode_button<'a>(
.into()
}
fn quick_action_item<'a>(locale: UiLocale, label: String, msg: PostEditorMsg) -> Element<'a, Message> {
fn quick_action_item<'a>(locale: UiLocale, label: String, msg: PostEditorMsg, enabled: bool) -> Element<'a, Message> {
let _ = locale;
button(text(label).size(12).shaping(Shaping::Advanced))
.on_press(Message::PostEditor(msg))
.on_press_maybe(enabled.then_some(Message::PostEditor(msg)))
.padding([6, 12])
.style(status_bar::dropdown_item)
.width(Length::Fixed(220.0))

37
crates/bds-ui/src/views/workspace.rs
View File

@@ -124,6 +124,7 @@ pub fn view<'a>(
tabs,
active_tab,
locale,
offline_mode,
data_dir,
post_preview_widget,
post_editors,
@@ -347,6 +348,7 @@ fn route_content_area<'a>(
tabs: &'a [Tab],
active_tab: Option<&'a str>,
locale: UiLocale,
offline_mode: bool,
data_dir: Option<&'a Path>,
post_preview_widget: Option<Element<'a, Message>>,
post_editors: &'a HashMap<String, PostEditorState>,
@@ -376,14 +378,14 @@ fn route_content_area<'a>(
ContentRoute::Post(tab_id) => {
if let Some(state) = post_editors.get(tab_id) {
let wrap = settings_state.map(|s| s.wrap_long_lines).unwrap_or(true);
post_editor::view(state, locale, wrap, post_preview_widget)
post_editor::view(state, locale, wrap, is_ai_enabled(settings_state, offline_mode), post_preview_widget)
} else {
loading_view(locale)
}
}
ContentRoute::Media(tab_id) => {
if let Some(state) = media_editors.get(tab_id) {
media_editor::view(state, locale, data_dir)
media_editor::view(state, locale, data_dir, is_ai_enabled(settings_state, offline_mode))
} else {
loading_view(locale)
}
@@ -488,6 +490,20 @@ fn route_kind<'a>(
}
}
fn is_ai_enabled(settings_state: Option<&SettingsViewState>, offline_mode: bool) -> bool {
let Some(state) = settings_state else {
return false;
};
if offline_mode {
!state.airplane_endpoint_url.trim().is_empty() && !state.airplane_endpoint_model.trim().is_empty()
} else {
!state.online_endpoint_url.trim().is_empty()
&& !state.online_endpoint_model.trim().is_empty()
&& (state.online_api_key_configured || !state.online_api_key_input.trim().is_empty())
}
}
#[cfg(test)]
mod tests {
use super::*;
@@ -597,6 +613,23 @@ mod tests {
_ => panic!("expected site validation route"),
}
}
#[test]
fn ai_actions_require_configured_endpoint_for_current_mode() {
let mut settings = SettingsViewState::default();
assert!(!is_ai_enabled(Some(&settings), false));
assert!(!is_ai_enabled(Some(&settings), true));
settings.online_endpoint_url = "https://api.example.com/v1".to_string();
settings.online_endpoint_model = "gpt-4.1-mini".to_string();
settings.online_api_key_configured = true;
assert!(is_ai_enabled(Some(&settings), false));
assert!(!is_ai_enabled(Some(&settings), true));
settings.airplane_endpoint_url = "http://localhost:11434/v1".to_string();
settings.airplane_endpoint_model = "llama3.2".to_string();
assert!(is_ai_enabled(Some(&settings), true));
}
}
fn loading_view<'a>(locale: UiLocale) -> Element<'a, Message> {