python-kacl 0.7.2__tar.gz → 0.7.4__tar.gz

{python_kacl-0.7.2/python_kacl.egg-info → python_kacl-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-kacl
-Version: 0.7.2
+Version: 0.7.4
 Summary: Python module and CLI tool for validating and modifying Changelogs in "keep-a-changelog" format"
 Author-email: Matthias Schmieder <schmieder.matthias@gmail.com>
 License: MIT

{python_kacl-0.7.2 → python_kacl-0.7.4}/kacl/__init__.py

@@ -1,5 +1,5 @@
 # Version of the python-kacl package
-__version__ = "0.7.2"
+__version__ = "0.7.4"
 
 from kacl.document import KACLDocument
 from kacl.serializer import KACLMarkdownSerializer

{python_kacl-0.7.2 → python_kacl-0.7.4}/kacl/document.py

@@ -30,7 +30,7 @@ class KACLDocument:
         link_references=None,
         meta_data=None,
         file_path=None,
-        config=KACLConfig(),
+        config=None,
     ):
         self.__data = data
         self.__headers = headers if headers else []
@@ -39,7 +39,7 @@ class KACLDocument:
         if not self.__link_references:
             self.__link_references = dict()
         self.__meta_data = meta_data
-        self.config = config
+        self.config = config if config is not None else KACLConfig()
         self.stash = []
         self.file_path = file_path
 
@@ -82,6 +82,9 @@ class KACLDocument:
                     data = fh.read()
                     try:
                         doc = KACLDocument.parse(data, None)
+                        # stash documents must be validated against the same
+                        # config as the changelog they belong to
+                        doc.config = self.config
                         self.stash.append(doc)
                     except Exception:
                         continue
@@ -205,7 +208,7 @@ class KACLDocument:
             try:
                 v0 = versions[i]
                 v1 = versions[i + 1]
-                if semver.VersionInfo.compare(v0.version(), v1.version()) < 1:
+                if semver.Version.parse(v0.version()).compare(v1.version()) < 1:
                     validation.add_error(
                         line=v1.raw(),
                         line_number=v1.line_number(),
@@ -502,7 +505,11 @@ class KACLDocument:
 
         if auto_link:
             link_provider = self.__get_link_provider()
-            for i in range(2):
+            # Only process the versions we just added/modified
+            # If add_unreleased=True: process Unreleased (index 0) and new version (index 1)
+            # If add_unreleased=False: only process new version (index 0)
+            versions_to_link = 2 if self.config.add_unreleased else 1
+            for i in range(versions_to_link):
                 fargs = {
                     "version": self.__versions[i].version(),
                     "previous_version": None,
@@ -615,7 +622,12 @@ class KACLDocument:
                     versions[i].set_link(link_provider.unreleased_changes(**fargs))
                 else:
                     versions[i].set_link(link_provider.compare_versions(**fargs))
-            versions[-1].set_link(link_provider.initial_version(**fargs))
+            versions[-1].set_link(
+                link_provider.initial_version(
+                    version=versions[-1].version(),
+                    latest_version=self.current_version(),
+                )
+            )
         elif len(versions) == 1:
             fargs = {
                 "version": versions[0].version(),

{python_kacl-0.7.2 → python_kacl-0.7.4}/kacl/kacl_cli.py

@@ -244,7 +244,12 @@ def next(ctx, version):
     is_flag=True,
     help="This option suppresses a link, even if available.",
 )
-def get(ctx, version, no_link):
+@click.option(
+    "--no-header",
+    is_flag=True,
+    help="This option suppresses the header and link.",
+)
+def get(ctx, version, no_link, no_header):
     """Returns a given version from the Changelog."""
     kacl_changelog = load_changelog(ctx)
 
@@ -252,10 +257,14 @@ def get(ctx, version, no_link):
     kacl_version = kacl_changelog.get(version)
 
     if kacl_version:
-        if no_link:
-            kacl_version.set_link(None)
-        kacl_changelog_content = kacl.dump(kacl_version)
-        click.echo(kacl_changelog_content)
+        if no_header:
+            kacl_changelog_content = kacl.dump(kacl_version.sections())
+            click.echo(kacl_changelog_content)
+        else:
+            if no_link:
+                kacl_version.set_link(None)
+            kacl_changelog_content = kacl.dump(kacl_version)
+            click.echo(kacl_changelog_content)
     else:
         click.echo(
             click.style("Error: ", fg="red")

{python_kacl-0.7.2 → python_kacl-0.7.4}/kacl/serializer.py

@@ -36,6 +36,15 @@ class KACLMarkdownSerializer:
             if document.has_link_reference():
                 link_references.append(self.__serialize_link_reference(document))
 
+        elif isinstance(document, dict):
+            # Validate that the dict contains KACLChanges objects (from version.sections())
+            if document and all(isinstance(v, KACLChanges) for v in document.values()):
+                data.extend([self.__serialize_sections(document), ""])
+            else:
+                raise TypeError(
+                    "Dict input must contain KACLChanges objects (from version.sections())"
+                )
+
         data.extend(link_references)
 
         if data[-1] != "":
@@ -72,7 +81,17 @@ class KACLMarkdownSerializer:
 
     def __serialize_version(self, obj):
         lines = [self.__serialize_header(obj), ""]
-        for title, changes in obj.sections().items():
+        lines.append(self.__serialize_sections(obj.sections()))
+        return "\n".join(lines).strip()
+
+    def __serialize_sections(self, sections_dict):
+        """Serialize a dictionary of section title -> KACLChanges.
+
+        Used by both __serialize_version (for full version with header)
+        and for standalone sections (for --no-header output).
+        """
+        lines = []
+        for title, changes in sections_dict.items():
             lines.extend(
                 [
                     self.__serialize_header(changes),
@@ -81,7 +100,6 @@ class KACLMarkdownSerializer:
                     "",
                 ]
             )
-
         return "\n".join(lines).strip()
 
     def __serialize_list(self, obj):

{python_kacl-0.7.2 → python_kacl-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-kacl"
-version = "0.7.2"
+version = "0.7.4"
 description = "Python module and CLI tool for validating and modifying Changelogs in \"keep-a-changelog\" format\""
 readme = "README.md"
 requires-python = ">=3.9"

{python_kacl-0.7.2 → python_kacl-0.7.4/python_kacl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-kacl
-Version: 0.7.2
+Version: 0.7.4
 Summary: Python module and CLI tool for validating and modifying Changelogs in "keep-a-changelog" format"
 Author-email: Matthias Schmieder <schmieder.matthias@gmail.com>
 License: MIT

{python_kacl-0.7.2 → python_kacl-0.7.4}/tests/test_cli.py

@@ -17,7 +17,35 @@ def test_verify():
     assert result.output == "Success\n"
 
     result = runner.invoke(cli, ["-f", "tests/data/CHANGELOG_invalid.md", "verify"])
-    assert result.exit_code == 10  # spawns 8 errors
+    assert result.exit_code == 11  # spawns 11 errors
+
+
+def test_verify_stash_with_custom_sections(tmp_path):
+    """Stash files must be validated against the loaded config, not the built-in defaults."""
+    runner = CliRunner()
+    resources_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data/")
+    changelog_file = os.path.join(resources_dir, "CHANGELOG.md")
+    stash_dir_local = os.path.join(resources_dir, "stash-custom-section")
+    config_file = os.path.join(resources_dir, "custom-sections-config.yml")
+
+    with runner.isolated_filesystem(temp_dir=tmp_path) as project_root_path:
+        shutil.copyfile(changelog_file, os.path.join(project_root_path, "CHANGELOG.md"))
+        shutil.copytree(stash_dir_local, os.path.join(project_root_path, ".kacl_stash"))
+
+        # without the custom config the stashed "Chore" section is rejected
+        result = runner.invoke(
+            cli, ["-f", "CHANGELOG.md", "verify"], catch_exceptions=False
+        )
+        assert result.exit_code != 0, result.output
+        assert '"Chore" is not a valid section' in result.output
+
+        # with a config that allows "Chore" the stashed changes must validate
+        result = runner.invoke(
+            cli,
+            ["-c", config_file, "-f", "CHANGELOG.md", "verify"],
+            catch_exceptions=False,
+        )
+        assert result.exit_code == 0, result.output
 
 
 def test_verify_invalid_duplicates():
@@ -35,7 +63,7 @@ def test_verify_with_json_output():
     )
     validation_result = json.loads(result.output)
 
-    assert len(validation_result["errors"]) == 10
+    assert len(validation_result["errors"]) == 11
     assert validation_result["valid"] is False
 
 
@@ -591,6 +619,31 @@ def test_get_suppress_available_link(tmp_path, snapshot):
         snapshot_directory(snapshot=snapshot, directory_path=project_root_path)
 
 
+def test_get_suppress_header(tmp_path, snapshot):
+    runner = CliRunner()
+    resources_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data/")
+    changelog_file = os.path.join(resources_dir, "CHANGELOG_missing_link.md")
+
+    with runner.isolated_filesystem(temp_dir=tmp_path) as project_root_path:
+        result = runner.invoke(
+            cli,
+            [
+                "-c",
+                os.path.join(resources_dir, "extension-config.yml"),
+                "-f",
+                changelog_file,
+                "get",
+                "--no-header",
+                "1.0.0",
+            ],
+            catch_exceptions=False,
+        )
+        assert result.exit_code == 0, result.output
+        with open(os.path.join(project_root_path, "output.md"), "w") as file:
+            file.write(result.output)
+        snapshot_directory(snapshot=snapshot, directory_path=project_root_path)
+
+
 @freeze_time("2023-01-01")
 def test_stash_no_pre_existing(tmp_path, snapshot):
     """Test stashing when there is no pre-existing stash file."""
@@ -740,3 +793,111 @@ def test_stash_without_modify(tmp_path, snapshot):
         assert "## 1.0.0" in result.output
 
         snapshot_directory(snapshot=snapshot, directory_path=project_root_path)
+
+
+@freeze_time("2023-01-01")
+def test_release_no_unreleased_with_link_generation(tmp_path, snapshot):
+    """Test that release with add_unreleased=False and auto-link generates correct links."""
+    runner = CliRunner()
+    resources_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data/")
+    changelog_file = os.path.join(resources_dir, "CHANGELOG_with_changes.md")
+
+    with runner.isolated_filesystem(temp_dir=tmp_path) as project_root_path:
+        shutil.copyfile(changelog_file, os.path.join(project_root_path, "CHANGELOG.md"))
+        result = runner.invoke(
+            cli,
+            [
+                "-c",
+                os.path.join(resources_dir, "no-unreleased-config.yml"),
+                "-f",
+                "CHANGELOG.md",
+                "release",
+                "2.0.0",
+                "-m",
+                "-g",  # --auto-link
+            ],
+            catch_exceptions=False,
+        )
+        assert result.exit_code == 0, result.output
+
+        # Read the updated changelog
+        with open(os.path.join(project_root_path, "CHANGELOG.md"), "r") as f:
+            content = f.read()
+
+        # Verify no Unreleased section exists
+        assert "## Unreleased" not in content or content.index(
+            "## 2.0.0"
+        ) < content.index("## Unreleased")
+
+        # Verify the new version has a link reference
+        assert "[2.0.0]:" in content
+
+        snapshot_directory(snapshot=snapshot, directory_path=project_root_path)
+
+
+def test_get_no_header_with_no_link(tmp_path, snapshot):
+    """Test combining --no-header and --no-link flags."""
+    runner = CliRunner()
+    resources_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data/")
+    changelog_file = os.path.join(resources_dir, "CHANGELOG_missing_link.md")
+
+    with runner.isolated_filesystem(temp_dir=tmp_path) as project_root_path:
+        result = runner.invoke(
+            cli,
+            [
+                "-c",
+                os.path.join(resources_dir, "extension-config.yml"),
+                "-f",
+                changelog_file,
+                "get",
+                "--no-header",
+                "--no-link",
+                "1.0.0",
+            ],
+            catch_exceptions=False,
+        )
+        assert result.exit_code == 0, result.output
+
+        # Verify no version header
+        assert "## 1.0.0" not in result.output
+        assert "## [1.0.0]" not in result.output
+
+        # Verify no link reference
+        assert "[1.0.0]:" not in result.output
+
+        # Verify sections are present
+        assert "### " in result.output
+
+        with open(os.path.join(project_root_path, "output.md"), "w") as file:
+            file.write(result.output)
+        snapshot_directory(snapshot=snapshot, directory_path=project_root_path)
+
+
+def test_get_no_header_output_format(tmp_path):
+    """Test that --no-header outputs only sections without version header."""
+    runner = CliRunner()
+    resources_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), "data/")
+    changelog_file = os.path.join(resources_dir, "CHANGELOG_with_changes.md")
+
+    result = runner.invoke(
+        cli,
+        [
+            "-f",
+            changelog_file,
+            "get",
+            "--no-header",
+            "1.0.0",
+        ],
+        catch_exceptions=False,
+    )
+    assert result.exit_code == 0, result.output
+
+    # Should not contain version header (## 1.0.0 or ## [1.0.0])
+    assert "## 1.0.0" not in result.output
+    assert "## [1.0.0]" not in result.output
+
+    # Should contain section headers (###)
+    assert "###" in result.output
+
+    # Should contain actual content
+    assert "New visual identity" in result.output

{python_kacl-0.7.2 → python_kacl-0.7.4}/tests/test_kacl.py

@@ -156,6 +156,37 @@ class TestKacl(TestCase):
         validation = changelog.validate()
         self.assertGreaterEqual(len(validation.errors()), 0)
 
+    def test_invalid_version_ordering(self):
+        invalid_files = [
+            "CHANGELOG_duplicate_version.md",
+            "CHANGELOG_ascending_versions.md",
+        ]
+
+        for filename in invalid_files:
+            changelog_file = os.path.join(
+                os.path.dirname(os.path.realpath(__file__)), "data", filename
+            )
+            changelog = kacl.load(changelog_file)
+            self.assertFalse(changelog.is_valid())
+
+            error_messages = [e.error_message() for e in changelog.validate().errors()]
+            self.assertTrue(
+                any("descending" in m for m in error_messages), error_messages
+            )
+
+    def test_valid_descending_versions_with_prerelease(self):
+        changelog_file = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "data/CHANGELOG_descending_prerelease.md",
+        )
+        changelog = kacl.load(changelog_file)
+
+        error_messages = [e.error_message() for e in changelog.validate().errors()]
+        ordering_errors = [
+            m for m in error_messages if "descending" in m or "Duplicate" in m
+        ]
+        self.assertEqual(ordering_errors, [], error_messages)
+
     def test_load_empty(self):
         changelog = kacl.parse("")
         self.assertFalse(changelog.is_valid())
@@ -396,6 +427,30 @@ class TestKacl(TestCase):
             for v in versions:
                 self.assertIsNotNone(v.link())
 
+    def test_link_generation_initial_version(self):
+        changelog_file = os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "data", "CHANGELOG.md"
+        )
+        changelog = kacl.load(changelog_file)
+        host_url = "https://github.com/user/repository"
+        changelog.generate_links(host_url=host_url)
+
+        versions = changelog.versions()
+
+        # the oldest version has to link to its own tag, not the penultimate one
+        initial_version = versions[-1]
+        self.assertEqual(
+            initial_version.link(),
+            f"{host_url}/tree/{initial_version.version()}",
+        )
+
+        # every version in between has to compare against its predecessor
+        for i in range(1, len(versions) - 1):
+            self.assertEqual(
+                versions[i].link(),
+                f"{host_url}/compare/{versions[i + 1].version()}...{versions[i].version()}",
+            )
+
 
 def test_squash(tmp_path, snapshot):
     changelog_file = os.path.join(
@@ -486,3 +541,119 @@ def test_complex_metadata(tmp_path):
         "---\nlist:\n- entry1\n- additional: true\n  key: value\ntitle: CHANGELOG\n---\n"
         in str(content)
     )
+
+
+def test_release_no_unreleased_with_autolink(tmp_path):
+    """Test that auto-linking works correctly when add_unreleased=False."""
+    from kacl.config import KACLConfig
+
+    changelog_file = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "data/CHANGELOG_with_changes.md",
+    )
+    config_file = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "data/no-unreleased-config.yml",
+    )
+
+    # Load changelog and set custom config
+    changelog = kacl.load(changelog_file)
+    changelog.config = KACLConfig(config_file)
+    assert changelog.is_valid()
+
+    # Release with auto-linking
+    changelog.release(version="2.0.0", auto_link=True)
+
+    # Verify the new version has a link
+    new_version = changelog.get("2.0.0")
+    assert new_version is not None
+    assert new_version.link() is not None
+
+    # Verify there's no Unreleased section after release
+    versions = changelog.versions()
+    assert (
+        versions[0].version() == "2.0.0"
+    ), "First version should be the new release, not Unreleased"
+
+    # Verify the link points to the correct comparison
+    content = kacl.dump(changelog)
+    assert "[2.0.0]:" in content, "New version should have a link reference"
+
+
+def test_serializer_sections_dict(tmp_path):
+    """Test that serializer correctly handles version.sections() dict (for --no-header)."""
+    changelog_file = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "data/CHANGELOG_with_changes.md",
+    )
+    changelog = kacl.load(changelog_file)
+    version = changelog.get("1.0.0")
+
+    # Get sections dict (what's passed when using --no-header)
+    sections = version.sections()
+
+    # Serialize the sections dict
+    content = kacl.dump(sections)
+
+    # Verify output doesn't include version header
+    assert "## 1.0.0" not in content
+    assert "## [1.0.0]" not in content
+
+    # Verify it includes section headers and content
+    assert "### Added" in content
+    assert "New visual identity" in content
+
+
+def test_serializer_invalid_dict():
+    """Test that serializer rejects invalid dict input."""
+    import pytest
+
+    # Try to serialize a plain dict that's not from version.sections()
+    invalid_dict = {"key": "value", "another": "item"}
+
+    with pytest.raises(TypeError) as exc_info:
+        kacl.dump(invalid_dict)
+
+    assert "KACLChanges" in str(exc_info.value)
+
+
+def test_release_no_unreleased_multiple_versions(tmp_path):
+    """Test auto-link with add_unreleased=False doesn't overwrite existing version links."""
+    from kacl.config import KACLConfig
+
+    changelog_file = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "data/CHANGELOG_keepachangelog.com.md",
+    )
+    config_file = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "data/no-unreleased-config.yml",
+    )
+
+    # Load changelog and set custom config
+    changelog = kacl.load(changelog_file)
+    changelog.config = KACLConfig(config_file)
+
+    # Get the second version's link before release (should not be modified)
+    versions_before = changelog.versions()
+    if len(versions_before) > 1:
+        second_version_before = versions_before[1]
+        second_version_link_before = second_version_before.link()
+
+    # Release with auto-linking (allow_no_changes since the test file may not have unreleased changes)
+    changelog.release(version="2.0.0", auto_link=True, allow_no_changes=True)
+
+    # Get versions after release
+    versions_after = changelog.versions()
+
+    # First version should be the new release (not Unreleased)
+    assert versions_after[0].version() == "2.0.0"
+
+    # New version should have a link
+    assert versions_after[0].link() is not None
+
+    # Second version's link should not have been modified
+    if len(versions_before) > 1 and second_version_link_before:
+        second_version_after = versions_after[1]
+        # The link might be updated during auto-link, but shouldn't be broken
+        assert second_version_after.link() is not None