python-kacl 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

kacl/__init__.py

@@ -1,5 +1,5 @@
 # Version of the python-kacl package
-__version__ = "0.6.4"
+__version__ = "0.6.6"
 
 from kacl.document import KACLDocument
 from kacl.serializer import KACLMarkdownSerializer
@@ -14,14 +14,14 @@ def load(file):
     with open(file, "r") as f:
         document = f.read()
         try:
-            doc = KACLDocument.parse(document)
+            doc = KACLDocument.parse(document, file)
         finally:
             f.close()
     return doc
 
 
-def parse(text):
-    return KACLDocument.parse(text)
+def parse(text, file=None):
+    return KACLDocument.parse(text, file)
 
 
 def dump(document):

kacl/changes.py

@@ -11,6 +11,8 @@ class KACLChanges(KACLElement):
             line_number=element.line_number(),
         )
         self.__items = []
+        # initializes
+        self.items()
 
     def items(self):
         if not len(self.__items) and len(self.body().strip()):

kacl/config/kacl-default.yml

@@ -45,4 +45,6 @@ kacl:
         ## 🧭 Reference
 
         Code: [Source Code Management System]({link})
-
+  stash:
+    directory: .kacl_stash
+    always: False

kacl/config.py

@@ -72,6 +72,9 @@ class KACLConfig:
         if not self.issue_tracker_jira_password:
             self.issue_tracker_jira_password = os.getenv("JIRA_PASSWORD", None)
 
+        self.stash_dir = self.__config.get("stash", {}).get("dir", ".kacl_stash")
+        self.stash_always = self.__config.get("stash", {}).get("always", False)
+
     @staticmethod
     def merge(a, b, path=None):
         """merge two dictionaries

kacl/document.py

@@ -4,6 +4,7 @@ import os
 import git
 import semver
 
+import kacl
 from kacl.config import KACLConfig
 from kacl.element import KACLElement
 from kacl.exception import KACLException
@@ -28,6 +29,7 @@ class KACLDocument:
         versions=None,
         link_references=None,
         meta_data=None,
+        file_path=None,
         config=KACLConfig(),
     ):
         self.__data = data
@@ -38,6 +40,80 @@ class KACLDocument:
             self.__link_references = dict()
         self.__meta_data = meta_data
         self.config = config
+        self.stash = []
+        self.file_path = file_path
+
+    @property
+    def stash_directory(self):
+        return self._ensure_stash_directory()
+
+    def load_stash(self):
+        self._refresh_stash()
+        # get all unreleased changes from stash
+        for stashed_changelog in self.stash:
+            unreleased_stash_version = stashed_changelog.get("Unreleased")
+            for title, change in unreleased_stash_version.sections().items():
+                for change_item in change.items():
+                    self.add(section=title, data=change_item)
+
+    def _refresh_stash(self):
+        if not self.file_path:
+            return
+
+        self.stash = []
+        if self.file_path is None:
+            local_stash_dir = os.path.join(
+                os.path.abspath(os.getcwd()), self.config.stash_dir
+            )
+        else:
+            # the stash needs always to be relative to the current file_path
+            local_stash_dir = os.path.join(
+                os.path.abspath(os.path.dirname(self.file_path)), self.config.stash_dir
+            )
+
+        if not os.path.isdir(local_stash_dir):
+            return
+
+        # read all md files in the stash directory
+        for f in os.listdir(local_stash_dir):
+            if f.endswith(".md"):
+                md_file = os.path.join(local_stash_dir, f)
+                with open(md_file, "r") as fh:
+                    data = fh.read()
+                    try:
+                        doc = KACLDocument.parse(data, None)
+                        self.stash.append(doc)
+                    except Exception:
+                        continue
+
+    def _ensure_stash_directory(self):
+        # the stash needs always to be relative to the current file_path
+        local_stash_dir = os.path.join(
+            os.path.abspath(os.path.dirname(self.file_path)), self.config.stash_dir
+        )
+
+        if not os.path.isdir(local_stash_dir):
+            os.makedirs(local_stash_dir, exist_ok=True)
+
+        return local_stash_dir
+
+    def _get_stash_file(self):
+        # the stash file should be named after the current git branch
+        local_stash_dir = self._ensure_stash_directory()
+        try:
+            repo = git.Repo(
+                os.path.abspath(os.path.dirname(self.file_path)),
+                search_parent_directories=True,
+            )
+            branch_name = repo.active_branch.name
+            # sanitize branch name for filename
+            branch_name = branch_name.replace("/", "__").replace("\\", "_")
+            stash_file_name = f"{branch_name}.md"
+        except Exception:
+            # fallback to with date
+            stash_file_name = f"{datetime.datetime.now().strftime('%Y%m%d')}.md"
+
+        return os.path.join(local_stash_dir, stash_file_name)
 
     def validate(self):
         """Validates the current changelog and returns KACLValidation object containing all information
@@ -46,6 +122,14 @@ class KACLDocument:
             [KACLValidation] -- object holding all error information
         """
         validation = KACLValidation()
+
+        # first load the stash
+        self._refresh_stash()
+        for stashed_changelog in self.stash:
+            val = stashed_changelog.validate()
+            for e in val.errors():
+                validation.add(e)
+
         # 1. assert only one header and starts on first line
         if len(self.__headers) == 0:
             validation.add_error(
@@ -213,18 +297,38 @@ class KACLDocument:
 
         return False
 
-    def add(self, section, data):
+    def add(self, section, data, stash=False):
         """adds a new change to a given section in the 'unreleased' version
 
         Arguments:
             section {[str]} -- section to add data to
             data {[str]} -- change information
+            stash {[bool]} -- if true the change will be stashed instead of added to the changelog (default: {False})
         """
-        unreleased_version = self.get("Unreleased")
-        if unreleased_version is None:
-            unreleased_version = KACLVersion(version="Unreleased")
-            self.__versions.insert(0, unreleased_version)
-        unreleased_version.add(section.capitalize(), data)
+
+        if stash:
+            # check if the stash directory already contains the required changelog file, if not initialize it
+            stash_file = self._get_stash_file()
+
+            if not os.path.exists(stash_file):
+                kacl_changelog = kacl.new()
+                kacl_changelog_content = kacl.dump(kacl_changelog)
+                with open(stash_file, "w") as f:
+                    f.write(kacl_changelog_content)
+                f.close()
+
+            kacl_changelog = kacl.load(stash_file)
+            kacl_changelog.add(section.capitalize(), data)
+            kacl_changelog_content = kacl.dump(kacl_changelog)
+            with open(stash_file, "w") as f:
+                f.write(kacl_changelog_content)
+            f.close()
+        else:
+            unreleased_version = self.get("Unreleased")
+            if unreleased_version is None:
+                unreleased_version = KACLVersion(version="Unreleased")
+                self.__versions.insert(0, unreleased_version)
+            unreleased_version.add(section.capitalize(), data)
 
     def release(
         self,
@@ -584,7 +688,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
         )
 
     @staticmethod
-    def parse(data):
+    def parse(data, file=None):
         """Parses a given text object and returns the KACLDocument
 
         Arguments:
@@ -624,6 +728,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
             versions=versions,
             link_references=link_references,
             meta_data=meta_data,
+            file_path=file,
         )
 
     def __get_link_provider(

kacl/kacl_cli.py

@@ -69,6 +69,7 @@ def load_changelog(ctx):
     # read the changelog
     kacl_changelog = kacl.load(kacl_config.changelog_file_path)
     kacl_changelog.config = kacl_config
+    kacl_changelog.load_stash()
 
     # share the objects
     return kacl_changelog
@@ -128,14 +129,28 @@ def cli(ctx, version=None, config=None, file=None):
     is_flag=True,
     help="This option will add the changes directly into changelog file.",
 )
-def add(ctx, section, message, modify):
+@click.option(
+    "-s",
+    "--stash",
+    is_flag=True,
+    help="This option will stash changes instead of applying them.",
+)
+def add(ctx, section, message, modify, stash):
     """Adds a given message to a specified unreleased section. Use '--modify' to directly modify the changelog file."""
     kacl_changelog = load_changelog(ctx)
 
+    if not modify:
+        stash = False
+    else:
+        # check if we need to stash
+        stash = stash or kacl_changelog.config.stash_always
+
     # add changes to changelog
-    kacl_changelog.add(section=section, data=message)
+    kacl_changelog.add(section=section, data=message, stash=stash)
+
     kacl_changelog_content = kacl.dump(kacl_changelog)
-    if modify:
+    # if stashing is enabled, do not modify the changelog file
+    if modify and not stash:
         with open(kacl_changelog.config.changelog_file_path, "w") as f:
             f.write(kacl_changelog_content)
         f.close()
@@ -472,6 +487,13 @@ def release(
         if no_commit:
             return
 
+        # delete all file in the stash directory
+        stash_files = []
+        for f in os.listdir(kacl_changelog.stash_directory):
+            stash_file = os.path.join(kacl_changelog.stash_directory, f)
+            os.remove(stash_file)
+            stash_files.append(stash_file)
+
         if commit or tag or kacl_config.git_create_commit or kacl_config.git_create_tag:
             vcs_context = {
                 "latest_version": latest_version,
@@ -516,6 +538,11 @@ def release(
                     repo.git.add(kacl_config.changelog_file_path)
                     for f in kacl_config.git_commit_additional_files:
                         repo.git.add(f)
+                    for f in stash_files:
+                        try:
+                            repo.git.add(f)
+                        except git.GitCommandError:
+                            pass
                     repo.git.commit("-m", commit_message.format(**vcs_context))
 
                 if tag or kacl_config.git_create_tag:
@@ -618,6 +645,52 @@ def new(output_file):
         click.echo(kacl_changelog_content)
 
 
+@cli.command()
+@click.option(
+    "-f",
+    "--force",
+    required=False,
+    is_flag=True,
+    help="Will overwrite existing files.",
+)
+def init(force):
+    """Initializes a project with all necessary kacl setting."""
+    kacl_changelog = kacl.new()
+    kacl_changelog_content = kacl.dump(kacl_changelog)
+
+    if os.path.exists("CHANGELOG.md") and not force:
+        click.echo(
+            click.style("Error: ", fg="red")
+            + "CHANGELOG.md already exists. Use '--force' to overwrite."
+        )
+        sys.exit(1)
+
+    if os.path.exists(".kacl.yml") and not force:
+        click.echo(
+            click.style("Error: ", fg="red")
+            + ".kacl.yml already exists. Use '--force' to overwrite."
+        )
+        sys.exit(1)
+
+    with open("CHANGELOG.md", "w") as f:
+        f.write(kacl_changelog_content)
+    f.close()
+
+    default_config_file = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "config", "kacl-default.yml"
+    )
+
+    # copy the default config file
+    if os.path.exists(default_config_file):
+        with open(default_config_file, "r") as df:
+            default_config_content = df.read()
+        df.close()
+
+        with open(".kacl.yml", "w") as cf:
+            cf.write(default_config_content)
+        cf.close()
+
+
 @cli.command("add-comments")
 @click.pass_context
 @click.option(

kacl/serializer.py

@@ -19,7 +19,11 @@ class KACLMarkdownSerializer:
                 data.extend(serialized_metadata)
 
             data.append(self.__serialize_header(document.header()))
-            data.append(document.header().body())
+            # check if the body starts with a newline. if not add one
+            if document.header().body().startswith("\n"):
+                data.append(document.header().body())
+            else:
+                data.append("\n" + document.header().body())
 
             for version in document.versions():
                 data.extend([self.__serialize_version(version), ""])
@@ -67,11 +71,12 @@ class KACLMarkdownSerializer:
             return f"# {obj.title()}"
 
     def __serialize_version(self, obj):
-        lines = [self.__serialize_header(obj)]
+        lines = [self.__serialize_header(obj), ""]
         for title, changes in obj.sections().items():
             lines.extend(
                 [
                     self.__serialize_header(changes),
+                    "",
                     self.__serialize_list(changes.items()),
                     "",
                 ]