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

feat: tag deletion and other elements

Browse Source
This commit is contained in:
Chili Palmer
2026-04-23 14:34:20 +02:00
parent 2062cd0df7
commit 2833c99c1c
7 changed files with 460 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
lib/bds/frontmatter.ex
View File

@@ -1,6 +1,8 @@
defmodule BDS.Frontmatter do
@moduledoc false
@list_item_prefix " - "
def serialize_document(fields, body) when is_list(fields) do
frontmatter =
fields
@@ -11,6 +13,22 @@ defmodule BDS.Frontmatter do
|> Enum.join("\n")
end
def parse_document(contents) when is_binary(contents) do
case String.split(contents, "\n---\n", parts: 2) do
[frontmatter_with_marker, body] ->
frontmatter = String.replace_prefix(frontmatter_with_marker, "---\n", "")
{:ok,
%{
fields: parse_frontmatter(frontmatter),
body: String.trim_trailing(body, "\n")
}}
_parts ->
{:error, :invalid_frontmatter}
end
end
defp serialize_field({_key, nil}), do: []
defp serialize_field({_key, ""}), do: []
defp serialize_field({_key, false}), do: []
@@ -26,4 +44,53 @@ defmodule BDS.Frontmatter do
defp serialize_field({key, value}) do
["#{key}: #{value}"]
end
defp parse_frontmatter(frontmatter) do
frontmatter
|> String.split("\n", trim: true)
|> parse_lines(%{})
end
defp parse_lines([], acc), do: acc
defp parse_lines([line | rest], acc) do
cond do
String.starts_with?(line, @list_item_prefix) ->
parse_lines(rest, acc)
String.ends_with?(line, ":") ->
key = String.trim_trailing(line, ":")
{items, remaining} = take_list_items(rest, [])
parse_lines(remaining, Map.put(acc, key, Enum.reverse(items)))
String.contains?(line, ": ") ->
[key, raw_value] = String.split(line, ": ", parts: 2)
parse_lines(rest, Map.put(acc, key, parse_scalar(raw_value)))
true ->
parse_lines(rest, acc)
end
end
defp take_list_items([line | rest], items) do
if String.starts_with?(line, @list_item_prefix) do
value = line |> String.replace_prefix(@list_item_prefix, "") |> parse_scalar()
take_list_items(rest, [value | items])
else
{items, [line | rest]}
end
end
defp take_list_items([], items), do: {items, []}
defp parse_scalar("true"), do: true
defp parse_scalar("false"), do: false
defp parse_scalar(value) do
if Regex.match?(~r/^-?\d+$/, value) do
String.to_integer(value)
else
value
end
end
end

55
lib/bds/scripts.ex
View File

@@ -104,6 +104,19 @@ defmodule BDS.Scripts do
end
end
def rebuild_scripts_from_files(project_id) do
project = Projects.get_project!(project_id)
scripts =
project
|> Projects.project_data_dir()
|> Path.join("scripts")
|> list_matching_files("*.lua")
|> Enum.map(&upsert_script_from_file(project_id, project, &1))
{:ok, scripts}
end
defp default_entrypoint(:macro), do: "render"
defp default_entrypoint(_kind), do: "main"
@@ -175,6 +188,48 @@ defmodule BDS.Scripts do
end
end
defp upsert_script_from_file(project_id, project, path) do
contents = File.read!(path)
{:ok, %{fields: fields}} = Frontmatter.parse_document(contents)
relative_path = Path.relative_to(path, Projects.project_data_dir(project))
now = System.system_time(:second)
attrs = %{
id: Map.get(fields, "id") || Ecto.UUID.generate(),
project_id: project_id,
slug: Map.fetch!(fields, "slug"),
title: Map.get(fields, "title") || "",
kind: parse_script_kind(Map.fetch!(fields, "kind")),
entrypoint: Map.get(fields, "entrypoint") || "main",
enabled: Map.get(fields, "enabled", true),
version: Map.get(fields, "version", 1),
file_path: relative_path,
status: :published,
content: nil,
created_at: Map.get(fields, "created_at", now),
updated_at: Map.get(fields, "updated_at", now)
}
script = Repo.get_by(Script, project_id: project_id, slug: attrs.slug) || %Script{}
script
|> Script.changeset(attrs)
|> Repo.insert_or_update!()
end
defp parse_script_kind(kind) when is_atom(kind), do: kind
defp parse_script_kind(kind), do: String.to_existing_atom(kind)
defp list_matching_files(dir, pattern) do
if File.dir?(dir) do
Path.join(dir, pattern)
|> Path.wildcard()
|> Enum.sort()
else
[]
end
end
defp maybe_put(map, _key, nil), do: map
defp maybe_put(map, key, value), do: Map.put(map, key, value)

24
lib/bds/tags.ex
View File

@@ -73,6 +73,30 @@ defmodule BDS.Tags do
end
end
def delete_tag(tag_id) do
case Repo.get(Tag, tag_id) do
nil ->
{:error, :not_found}
tag ->
Repo.transaction(fn ->
affected_posts = posts_with_tag(tag.project_id, tag.name)
Enum.each(affected_posts, fn post ->
updated_tags = Enum.reject(post.tags || [], &(&1 == tag.name))
update_post_tags(post, updated_tags)
end)
Repo.delete!(tag)
write_tags_json(tag.project_id)
end)
|> case do
{:ok, _} -> {:ok, :deleted}
{:error, reason} -> {:error, reason}
end
end
end
def rename_tag(tag_id, new_name) do
case Repo.get(Tag, tag_id) do
nil ->

145
lib/bds/templates.ex
View File

@@ -4,9 +4,11 @@ defmodule BDS.Templates do
import Ecto.Query
alias BDS.Frontmatter
alias BDS.Posts
alias BDS.Projects
alias BDS.Repo
alias BDS.Slug
alias BDS.Tags
alias BDS.Templates.Template
def create_template(attrs) do
@@ -71,24 +73,58 @@ defmodule BDS.Templates do
end
content_changed? = has_attr?(attrs, :content) and attr(attrs, :content) != template.content
slug_changed? = next_slug != template.slug
now = System.system_time(:second)
next_status = if(template.status == :published and content_changed?, do: :draft, else: template.status)
next_file_path = next_template_file_path(template, next_slug)
updates = %{}
|> maybe_put(:title, attr(attrs, :title))
|> maybe_put(:kind, attr(attrs, :kind))
|> maybe_put(:enabled, attr(attrs, :enabled))
|> maybe_put(:content, attr(attrs, :content))
|> Map.put(:file_path, next_file_path)
|> Map.put(:slug, next_slug)
|> Map.put(:version, template.version + 1)
|> Map.put(:updated_at, now)
|> maybe_put(:status, if(template.status == :published and content_changed?, do: :draft, else: nil))
|> Map.put(:status, next_status)
template
|> Template.changeset(updates)
|> Repo.update()
Repo.transaction(fn ->
updated_template =
template
|> Template.changeset(updates)
|> Repo.update!()
if slug_changed? do
cascade_template_slug_change(template, updated_template, now)
end
if template.file_path not in [nil, ""] and next_file_path != template.file_path do
rewrite_template_file(template, updated_template)
end
updated_template
end)
|> case do
{:ok, updated_template} -> {:ok, updated_template}
{:error, reason} -> {:error, reason}
end
end
end
def rebuild_templates_from_files(project_id) do
project = Projects.get_project!(project_id)
templates =
project
|> Projects.project_data_dir()
|> Path.join("templates")
|> list_matching_files("*.liquid")
|> Enum.map(&upsert_template_from_file(project_id, project, &1))
{:ok, templates}
end
def delete_template(template_id, opts \\ []) do
case Repo.get(Template, template_id) do
nil ->
@@ -154,6 +190,9 @@ defmodule BDS.Templates do
Path.join(Projects.project_data_dir(project), relative_path)
end
defp next_template_file_path(%Template{file_path: ""}, _next_slug), do: ""
defp next_template_file_path(%Template{}, next_slug), do: template_file_path(next_slug)
defp serialize_template_file(template, content) do
Frontmatter.serialize_document(
[
@@ -195,14 +234,108 @@ defmodule BDS.Templates do
|> Repo.update_all(set: [post_template_slug: nil, updated_at: now])
Enum.each(affected_posts, fn post ->
BDS.Posts.rewrite_published_post(post.id)
Posts.rewrite_published_post(post.id)
end)
BDS.Tags.sync_tags_json(template.project_id)
Tags.sync_tags_json(template.project_id)
:ok
end
defp cascade_template_slug_change(original_template, updated_template, updated_at) do
affected_posts =
Repo.all(
from(post in BDS.Posts.Post,
where: post.project_id == ^original_template.project_id and post.template_slug == ^original_template.slug
)
)
from(post in BDS.Posts.Post,
where: post.project_id == ^original_template.project_id and post.template_slug == ^original_template.slug
)
|> Repo.update_all(set: [template_slug: updated_template.slug, updated_at: updated_at])
from(tag in BDS.Tags.Tag,
where: tag.project_id == ^original_template.project_id and tag.post_template_slug == ^original_template.slug
)
|> Repo.update_all(set: [post_template_slug: updated_template.slug, updated_at: updated_at])
Enum.each(affected_posts, fn post ->
Posts.rewrite_published_post(post.id)
end)
Tags.sync_tags_json(original_template.project_id)
end
defp rewrite_template_file(original_template, updated_template) do
body = published_template_body(original_template)
new_full_path = full_file_path(updated_template.project_id, updated_template.file_path)
:ok = File.mkdir_p(Path.dirname(new_full_path))
:ok = File.write(new_full_path, serialize_template_file(updated_template, body))
if original_template.file_path != updated_template.file_path do
_ = delete_file_if_present(original_template.project_id, original_template.file_path)
end
:ok
end
defp published_template_body(%Template{content: content}) when is_binary(content), do: content
defp published_template_body(template) do
case File.read(full_file_path(template.project_id, template.file_path)) do
{:ok, contents} ->
case Frontmatter.parse_document(contents) do
{:ok, %{body: body}} -> body
{:error, _reason} -> ""
end
{:error, _reason} ->
""
end
end
defp upsert_template_from_file(project_id, project, path) do
contents = File.read!(path)
{:ok, %{fields: fields}} = Frontmatter.parse_document(contents)
relative_path = Path.relative_to(path, Projects.project_data_dir(project))
now = System.system_time(:second)
attrs = %{
id: Map.get(fields, "id") || Ecto.UUID.generate(),
project_id: project_id,
slug: Map.fetch!(fields, "slug"),
title: Map.get(fields, "title") || "",
kind: parse_template_kind(Map.fetch!(fields, "kind")),
enabled: Map.get(fields, "enabled", true),
version: Map.get(fields, "version", 1),
file_path: relative_path,
status: :published,
content: nil,
created_at: Map.get(fields, "created_at", now),
updated_at: Map.get(fields, "updated_at", now)
}
template = Repo.get_by(Template, project_id: project_id, slug: attrs.slug) || %Template{}
template
|> Template.changeset(attrs)
|> Repo.insert_or_update!()
end
defp parse_template_kind(kind) when is_atom(kind), do: kind
defp parse_template_kind(kind), do: String.to_existing_atom(kind)
defp list_matching_files(dir, pattern) do
if File.dir?(dir) do
Path.join(dir, pattern)
|> Path.wildcard()
|> Enum.sort()
else
[]
end
end
defp delete_file_if_present(_project_id, file_path) when file_path in [nil, ""], do: :ok
defp delete_file_if_present(project_id, file_path) do