Massive Refactor: Architecture Redesign and Technical Debt Cleanup (#528)

* Rename `data` folder with schema

* Start refactoring data models

* Work on entry models

* Keep working on entries

* Keep working on data models

* Push old data files

* Keep working on data models

* First draft of schema.cv

* Keep working on schema

* Keep working on schema

* Improve schema.models

* Keep working on rendercv.schema

* Work on schema.design

* Keep working on rendercv.schema

* Complete variant_class_generator

* Keep working rendercv.schema

* Keep working on rendercv.schema

* Final touches to rendercv.schema

* Improve json schema descriptions in rendercv.schema

* Start working on rendercv.schema tests

* Keep implementing rendercv.schema tests

* Add more tests for rendercv.schema

* Improve rendercv.schema

* Improve docstrings and comments in rendercv.schema

* Implement better pydantic error handling in `rendercv.schema`

* Improve variant class system

* Fix rendercv.schema tests

* Start working on rendercv.templater

* Update template names

* Switching to new rendercv typst template soon

* Work on new templater

* Rename renderer with renderer_old

* Don't use utils in rendercv.schema

* Complete connections

* Update renderer folder structure

* Work on new renderer

* Work on new renderer

* Date processing on new renderer

* Improve date processing, support multiple emails, phones, and websites

* Improve markdown to Typst

* Complete entry template processing

* Time span computation in new renderer

* Better entry templates

* Setup new templates

* Improve rendercv.schema

* Start adding tests for rendercv.renderer

* New markdown parser!

* Improve markdown to typst conversion

* Finalize markdown parser

* Add new test files for rendercv.renderer

* Fix cv and connections

* Add connections test

* Improve connection tests

* Improve entry templates

* Add model processor tests

* Improve templater

* Rename old folders

* Improve schema

* Add file generation logic to renderer

* Fix naming issues

* Fix schema tests

* Add path type tests

* Add font family and typst dimension type tests

* Rename old tests

* Fix design tests

* Start integration testing of renderer

* Improve entry tempates

* Handle nested highlights properly

* Finalize Typst preamble template

* Start working on new CLI

* Remove old test files

* Implement override dictionary in new schema

* Start working on new CLI

* Better prints on render command

* New structure

* New render printer

* Add all the commands to new CLI

* Work on new command in new cli

* Improve new command

* Add error handler to new cli

* Work on create theme command

* Complete create theme command

* Remove old source files

* Improve exceptions

* Create new docs

* Add writing tests guide

* Fix cli printer and write tests

* Test copy templates

* Add app tests

* Bring back accidentally removed files

* Imporve cli and tests

* Fix path issues

* Improve

* Improve

* Add reference file comparison tests

* Fix path resolver

* Start working on test_pdf_png

* Implement comparison of multiple files (png)

* Start testing typst

* Fix templating issues

* Fix header and entry templates issues

* Implement short second rows

* Fix date issues

* Fix nested bullets and add summary

* Update testdata

* Implement footer

* Update testdata

* Reimagined design and locale schema, first iteration

* Reimagined design and locale second iteration

* Update design and locale schemas

* Adapt templater to the new design and locale

* Fix tests

* Update lib.typ and testdata for the new locale and design

* Implement proper tests with all combinations of entries

* Remove some docstrings

* fix connections logic

* Improve

* Start working on examples

* Update testdata

* Fix long second row issue

* fix templating issues

* Fix lib.typ issues

* Update testdata

* Fix clean_trailing_parts

* Update test cv

* update test cv

* Update theme defaults

* update schema and fix moderncv

* Fix moderncv issues

* Update testdata

* Update testdata and examples

* Fix issues about photo

* Fix typst photo path issues

* improve entry templates from yaml

* add new locale

* Rename writing tests doc

* Update writing tests

* Improve tests

* Add more cli tests

* Increase test coverage

* Rename variant pydantic model generator

* Improve tests

* Update testdata and improve tests

* Format, fix pre-commit errors

* Fix scripts and update entry figures

* Improve tests

* Write docstrings of schema

* Write schema docstrings

* Setup api reference

* Start working on new docs

* Work on docs

* Improve progress panel of render command

* Finalize new docs index

* Complete CLI docs

* Work on YAML input structure page

* Finalize user guide

* Start working on developer guide

* Improve api reference

* Improve developer guide

* Improve developer guide

* Improve developer gide

* Improve developer guide

* Improve developer guide

* Update developer guide

* Improve developer guide

* Improve developer guide

* Improve developer guide

* Developer guide first draft

* update developer guide

* Update examples

* Update testdata

* Handle wrong installation (rendercv instead of rendercv[full])

* Remove unnecessary files

* Write set up vs code page

* Update README.md

* Change docs description

* Compress design options gif

* minor updates

* Polish all the json schema descriptions

* Update testdata and examples

* Remove some emdashed from docs

* Add whatsapp support

* Add TestEscapeTypstCharacters to tests

* Implement custom connections

* Add page break before sections feature

* Revert page break before sections feature

* Rebase to main

* Fix social network tests, update schema
This commit is contained in:
Sina Atalay
2025-12-09 17:03:56 +03:00
committed by GitHub
parent a45537deb4
commit 5cc5fbdf9e
613 changed files with 479343 additions and 120866 deletions

View File

@@ -0,0 +1,43 @@
from unittest.mock import MagicMock
import pytest
from rendercv.cli.render_command.parse_override_arguments import (
parse_override_arguments,
)
from rendercv.exception import RenderCVUserError
class TestParseOverrideArguments:
@pytest.mark.parametrize(
("args", "expected"),
[
(["--cv.name", "John"], {"cv.name": "John"}),
(
["--cv.name", "John", "--cv.email", "john@example.com"],
{"cv.name": "John", "cv.email": "john@example.com"},
),
([], {}),
],
)
def test_parses_key_value_pairs_into_dictionary(self, args, expected):
context = MagicMock()
context.args = args
result = parse_override_arguments(context)
assert result == expected
def test_raises_error_for_odd_number_of_arguments(self):
context = MagicMock()
context.args = ["--cv.name"]
with pytest.raises(RenderCVUserError):
parse_override_arguments(context)
def test_raises_error_when_key_doesnt_start_with_dashes(self):
context = MagicMock()
context.args = ["cv.name", "John"]
with pytest.raises(RenderCVUserError):
parse_override_arguments(context)

View File

@@ -0,0 +1,215 @@
import pathlib
import pytest
import typer
from rendercv.cli.render_command.progress_panel import CompletedStep, ProgressPanel
from rendercv.exception import RenderCVUserError, RenderCVValidationError
class TestProgressPanelUpdateProgress:
def test_adds_step_to_completed_steps(self):
panel = ProgressPanel(quiet=True)
test_path = pathlib.Path.cwd() / "output.pdf"
panel.update_progress("100", "Generated PDF", [test_path])
assert len(panel.completed_steps) == 1
assert panel.completed_steps[0].timing_ms == "100"
assert panel.completed_steps[0].message == "Generated PDF"
assert panel.completed_steps[0].paths == [test_path]
def test_handles_multiple_paths(self):
panel = ProgressPanel(quiet=True)
path1 = pathlib.Path.cwd() / "page1.png"
path2 = pathlib.Path.cwd() / "page2.png"
panel.update_progress("250", "Generated PNG", [path1, path2])
assert len(panel.completed_steps) == 1
assert panel.completed_steps[0].paths == [path1, path2]
def test_handles_empty_paths(self):
panel = ProgressPanel(quiet=True)
panel.update_progress("50", "Validated input", [])
assert len(panel.completed_steps) == 1
assert panel.completed_steps[0].paths == []
class TestProgressPanelFinishProgress:
def test_clears_completed_steps(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.append(
CompletedStep("100", "Test", [pathlib.Path.cwd() / "test.pdf"])
)
panel.finish_progress()
assert len(panel.completed_steps) == 0
class TestProgressPanelPrintProgressPanel:
def test_respects_quiet_mode(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.append(CompletedStep("100", "Test", []))
panel.print_progress_panel("Test Title")
# In quiet mode, nothing should be printed/updated
# We can't easily test the internal state of rich.live.Live, so we just
# verify the method doesn't raise an error
def test_displays_step_without_paths(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.append(CompletedStep("100", "Validated input", []))
# This should not raise an error
panel.print_progress_panel("Rendering your CV...")
def test_displays_step_with_single_path(self):
panel = ProgressPanel(quiet=True)
test_path = pathlib.Path.cwd() / "output.pdf"
panel.completed_steps.append(CompletedStep("250", "Generated PDF", [test_path]))
panel.print_progress_panel("Rendering your CV...")
def test_displays_step_with_multiple_paths(self):
panel = ProgressPanel(quiet=True)
path1 = pathlib.Path.cwd() / "page1.png"
path2 = pathlib.Path.cwd() / "page2.png"
panel.completed_steps.append(
CompletedStep("500", "Generated PNG", [path1, path2])
)
panel.print_progress_panel("Rendering your CV...")
def test_displays_multiple_steps(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.extend(
[
CompletedStep("100", "Step 1", []),
CompletedStep("200", "Step 2", [pathlib.Path.cwd() / "file.txt"]),
CompletedStep("300", "Step 3", []),
]
)
panel.print_progress_panel("Rendering your CV...")
def test_handles_empty_steps(self):
panel = ProgressPanel(quiet=True)
panel.print_progress_panel("Rendering your CV...")
class TestProgressPanelPrintUserError:
def test_exits_with_code_1(self):
panel = ProgressPanel(quiet=True)
error = RenderCVUserError(message="Test error message")
with pytest.raises(typer.Exit) as exc_info:
panel.print_user_error(error)
assert exc_info.value.exit_code == 1
def test_handles_error_without_message(self):
panel = ProgressPanel(quiet=True)
error = RenderCVUserError(message=None)
with pytest.raises(typer.Exit) as exc_info:
panel.print_user_error(error)
assert exc_info.value.exit_code == 1
class TestProgressPanelPrintValidationErrors:
def test_exits_with_code_1(self):
panel = ProgressPanel(quiet=True)
errors: list[RenderCVValidationError] = [
RenderCVValidationError(
location=("cv", "name"),
yaml_location=((1, 1), (1, 1)),
input="123",
message="Invalid name",
)
]
with pytest.raises(typer.Exit) as exc_info:
panel.print_validation_errors(errors)
assert exc_info.value.exit_code == 1
def test_clears_completed_steps_before_displaying_errors(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.append(
CompletedStep("100", "Test", [pathlib.Path.cwd() / "test.pdf"])
)
errors: list[RenderCVValidationError] = [
RenderCVValidationError(
location=("cv", "name"),
yaml_location=((1, 1), (1, 1)),
input="123",
message="Invalid name",
)
]
with pytest.raises(typer.Exit):
panel.print_validation_errors(errors)
# We can't check this after the exception, but the implementation shows
# it clears steps before displaying
def test_handles_multiple_validation_errors(self):
panel = ProgressPanel(quiet=True)
errors: list[RenderCVValidationError] = [
RenderCVValidationError(
location=("cv", "name"),
yaml_location=((1, 1), (1, 1)),
input="123",
message="Invalid name",
),
RenderCVValidationError(
location=("cv", "email"),
yaml_location=((2, 1), (2, 1)),
input="not-an-email",
message="Invalid email format",
),
]
with pytest.raises(typer.Exit) as exc_info:
panel.print_validation_errors(errors)
assert exc_info.value.exit_code == 1
class TestProgressPanelClear:
def test_clears_completed_steps(self):
panel = ProgressPanel(quiet=True)
panel.completed_steps.extend(
[
CompletedStep("100", "Step 1", []),
CompletedStep("200", "Step 2", []),
]
)
panel.clear()
assert len(panel.completed_steps) == 0
class TestCompletedStep:
def test_creates_step_without_paths(self):
step = CompletedStep("100", "Validated input", [])
assert step.timing_ms == "100"
assert step.message == "Validated input"
assert step.paths == []
def test_creates_step_with_paths(self):
test_path = pathlib.Path.cwd() / "output.pdf"
step = CompletedStep("250", "Generated PDF", [test_path])
assert step.timing_ms == "250"
assert step.message == "Generated PDF"
assert step.paths == [test_path]

View File

@@ -0,0 +1,144 @@
import os
from unittest.mock import MagicMock, patch
import pytest
from rendercv.cli.new_command.new_command import cli_command_new
from rendercv.cli.render_command.render_command import cli_command_render
class TestCliCommandRender:
@pytest.fixture
def default_arguments(self):
context = MagicMock()
context.args = []
return {
"design": None,
"locale": None,
"settings": None,
"typst_path": None,
"pdf_path": None,
"markdown_path": None,
"html_path": None,
"png_path": None,
"dont_generate_markdown": False,
"dont_generate_html": False,
"dont_generate_typst": False,
"dont_generate_pdf": False,
"dont_generate_png": False,
"watch": False,
"quiet": False,
"_": None,
"extra_data_model_override_arguments": context,
}
@pytest.fixture
def sample_cv_with_templates(self, tmp_path):
os.chdir(tmp_path)
cli_command_new(
full_name="John Doe",
create_typst_templates=False,
create_markdown_templates=False,
)
return tmp_path / "John_Doe_CV.yaml"
@pytest.mark.parametrize("quiet", [True, False])
def test_generates_all_output_files_by_default(
self, sample_cv_with_templates, default_arguments, quiet
):
os.chdir(sample_cv_with_templates.parent)
cli_command_render(
input_file_name=str(sample_cv_with_templates),
**{**default_arguments, "quiet": quiet},
)
rendercv_output = sample_cv_with_templates.parent / "rendercv_output"
assert (rendercv_output / "John_Doe_CV.typ").exists()
assert (rendercv_output / "John_Doe_CV.pdf").exists()
assert (rendercv_output / "John_Doe_CV_1.png").exists()
assert (rendercv_output / "John_Doe_CV.md").exists()
assert (rendercv_output / "John_Doe_CV.html").exists()
@pytest.mark.parametrize(
("flag", "missing_files"),
[
(
"dont_generate_markdown",
["John_Doe_CV.md", "John_Doe_CV.html"],
),
("dont_generate_html", ["John_Doe_CV.html"]),
(
"dont_generate_typst",
["John_Doe_CV.typ", "John_Doe_CV.pdf", "John_Doe_CV_1.png"],
),
("dont_generate_pdf", ["John_Doe_CV.pdf"]),
("dont_generate_png", ["John_Doe_CV_1.png"]),
],
)
def test_respects_dont_generate_flags(
self, sample_cv_with_templates, default_arguments, flag, missing_files
):
os.chdir(sample_cv_with_templates.parent)
cli_command_render(
input_file_name=str(sample_cv_with_templates),
**{**default_arguments, flag: True},
)
rendercv_output = sample_cv_with_templates.parent / "rendercv_output"
for file in missing_files:
assert not (rendercv_output / file).exists()
def test_uses_custom_output_paths(
self, sample_cv_with_templates, default_arguments
):
os.chdir(sample_cv_with_templates.parent)
custom_paths = {
"typst_path": "custom.typ",
"pdf_path": "custom.pdf",
"markdown_path": "custom.md",
"html_path": "custom.html",
"png_path": "custom.png",
}
cli_command_render(
input_file_name=str(sample_cv_with_templates),
**{**default_arguments, **custom_paths},
)
parent = sample_cv_with_templates.parent
assert (parent / "custom.typ").exists()
assert (parent / "custom.pdf").exists()
assert (parent / "custom.md").exists()
assert (parent / "custom.html").exists()
assert (parent / "custom_1.png").exists()
def test_accepts_relative_input_file_path(
self, sample_cv_with_templates, default_arguments
):
os.chdir(sample_cv_with_templates.parent)
cli_command_render(
input_file_name=sample_cv_with_templates.name,
**default_arguments,
)
rendercv_output = sample_cv_with_templates.parent / "rendercv_output"
assert (rendercv_output / "John_Doe_CV.pdf").exists()
@patch("rendercv.cli.render_command.render_command.run_function_if_file_changes")
def test_calls_watcher_when_watch_flag_is_true(
self, mock_watcher, sample_cv_with_templates, default_arguments
):
os.chdir(sample_cv_with_templates.parent)
cli_command_render(
input_file_name=str(sample_cv_with_templates),
**{**default_arguments, "watch": True},
)
mock_watcher.assert_called_once()
call_args = mock_watcher.call_args
assert call_args[0][0] == sample_cv_with_templates.absolute()

View File

@@ -0,0 +1,129 @@
import os
import pathlib
import pytest
import typer
from rendercv.cli.render_command.progress_panel import ProgressPanel
from rendercv.cli.render_command.run_rendercv import run_rendercv, timed_step
class TestTimedStep:
def test_returns_function_result(self):
def sample_func(x: int) -> int:
return x * 2
progress = ProgressPanel(quiet=True)
result = timed_step("Test", progress, sample_func, 5)
assert result == 10
def test_updates_progress_with_timing(self):
def sample_func():
return None
progress = ProgressPanel(quiet=True)
timed_step("Test message", progress, sample_func)
assert len(progress.completed_steps) == 0
def test_handles_single_path_result(self):
def sample_func() -> pathlib.Path:
return pathlib.Path.cwd() / "output.pdf"
progress = ProgressPanel(quiet=True)
result = timed_step("Generated PDF", progress, sample_func)
assert result == pathlib.Path.cwd() / "output.pdf"
assert len(progress.completed_steps) == 1
assert progress.completed_steps[0].paths == [pathlib.Path.cwd() / "output.pdf"]
def test_handles_list_path_result(self):
def sample_func() -> list[pathlib.Path]:
return [pathlib.Path.cwd() / "page1.png", pathlib.Path.cwd() / "page2.png"]
progress = ProgressPanel(quiet=True)
result = timed_step("Generated PNG", progress, sample_func)
assert len(result) == 2
assert len(progress.completed_steps) == 1
assert progress.completed_steps[0].paths == [
pathlib.Path.cwd() / "page1.png",
pathlib.Path.cwd() / "page2.png",
]
def test_pluralizes_message_for_multiple_paths(self):
def sample_func() -> list[pathlib.Path]:
return [pathlib.Path.cwd() / "page1.png", pathlib.Path.cwd() / "page2.png"]
progress = ProgressPanel(quiet=True)
timed_step("Generated PNG", progress, sample_func)
assert progress.completed_steps[0].message == "Generated PNGs"
def test_passes_args_and_kwargs_to_function(self):
def sample_func(a: int, b: int, c: int = 0) -> int:
return a + b + c
progress = ProgressPanel(quiet=True)
result = timed_step("Test", progress, sample_func, 1, 2, c=3)
assert result == 6
class TestRunRendercv:
def test_invalid_yaml(self, tmp_path):
invalid_yaml = tmp_path / "invalid.yaml"
invalid_yaml.write_text("invalid: yaml: content: :")
progress = ProgressPanel(quiet=True)
with pytest.raises(typer.Exit) as exc_info, progress:
run_rendercv(invalid_yaml, progress)
assert exc_info.value.exit_code == 1
def test_invalid_input_file(self, tmp_path):
invalid_schema = tmp_path / "invalid_schema.yaml"
invalid_schema.write_text("cv:\n name: 123")
progress = ProgressPanel(quiet=True)
with pytest.raises(typer.Exit) as exc_info, progress:
run_rendercv(invalid_schema, progress)
assert exc_info.value.exit_code == 1
def test_template_syntax_error(self, tmp_path):
os.chdir(tmp_path)
theme_folder = tmp_path / "badtheme"
theme_folder.mkdir()
template_file = theme_folder / "Header.j2.typ"
template_file.write_text(
"{% for item in items %}\n{{ item }\n", encoding="utf-8"
)
yaml_file = tmp_path / "test.yaml"
yaml_file.write_text(
"""cv:
name: John Doe
design:
theme: badtheme
""",
encoding="utf-8",
)
progress = ProgressPanel(quiet=True)
with pytest.raises(typer.Exit) as exc_info, progress:
run_rendercv(yaml_file, progress)
assert exc_info.value.exit_code == 1

View File

@@ -0,0 +1,82 @@
import threading
import time
from unittest.mock import MagicMock, patch
import typer
from rendercv.cli.render_command import watcher
class TestRunFunctionIfFileChanges:
def test_calls_function_immediately_on_start(self, tmp_path):
file_path = tmp_path / "test.yaml"
file_path.touch()
mock_function = MagicMock()
with (
patch.object(watcher.watchdog.observers, "Observer"),
patch.object(watcher.time, "sleep", side_effect=KeyboardInterrupt),
):
watcher.run_function_if_file_changes(file_path, mock_function)
mock_function.assert_called_once()
def test_calls_function_when_file_changes(self, tmp_path):
watched_file = tmp_path / "test.yaml"
watched_file.write_text("initial")
call_count = 0
def tracked_function():
nonlocal call_count
call_count += 1
watcher_thread = threading.Thread(
target=watcher.run_function_if_file_changes,
args=(watched_file, tracked_function),
daemon=True,
)
watcher_thread.start()
time.sleep(0.2)
initial_count = call_count
watched_file.write_text("first edit")
time.sleep(0.2)
assert call_count > initial_count
def test_continues_running_after_function_raises_typer_exit(self, tmp_path):
watched_file = tmp_path / "test.yaml"
watched_file.write_text("initial")
call_count = 0
should_raise = False
def tracked_function():
nonlocal call_count
call_count += 1
if should_raise:
raise typer.Exit(code=1)
watcher_thread = threading.Thread(
target=watcher.run_function_if_file_changes,
args=(watched_file, tracked_function),
daemon=True,
)
watcher_thread.start()
time.sleep(0.2)
should_raise = True
count_before_exit = call_count
watched_file.write_text("edit that raises exit")
time.sleep(0.2)
assert call_count > count_before_exit
should_raise = False
count_after_exit = call_count
watched_file.write_text("edit after exit")
time.sleep(0.2)
assert call_count > count_after_exit