scriv 1.6.0__py3-none-any.whl

scriv/__init__.py

@@ -0,0 +1,5 @@
+"""
+Scriv changelog management tool.
+"""
+
+__version__ = "1.6.0"

scriv/__main__.py

@@ -0,0 +1,5 @@
+"""Enable 'python -m scriv'."""
+
+from .cli import cli
+
+cli(prog_name="scriv")

scriv/changelog.py

@@ -0,0 +1,117 @@
+"""Changelog and Fragment definitions for Scriv."""
+
+import datetime
+import logging
+from pathlib import Path
+
+import attr
+import jinja2
+
+from .config import Config
+from .format import FormatTools, SectionDict, get_format_tools
+from .util import partition_lines
+
+logger = logging.getLogger(__name__)
+
+
+@attr.s
+class Fragment:
+    """A changelog fragment."""
+
+    path = attr.ib(type=Path)
+    format = attr.ib(type=str, default=None)
+    content = attr.ib(type=str, default=None)
+
+    def __attrs_post_init__(
+        self,
+    ):  # noqa: D105 (Missing docstring in magic method)
+        if self.format is None:
+            self.format = self.path.suffix.lstrip(".")
+
+    def write(self) -> None:
+        """Write the content to the file."""
+        self.path.write_text(self.content)
+
+    def read(self) -> None:
+        """Read the content of the fragment."""
+        self.content = self.path.read_text()
+
+
+@attr.s
+class Changelog:
+    """A changelog file."""
+
+    path = attr.ib(type=Path)
+    config = attr.ib(type=Config)
+    newline = attr.ib(type=str, default="")
+    text_before = attr.ib(type=str, default="")
+    changelog = attr.ib(type=str, default="")
+    text_after = attr.ib(type=str, default="")
+
+    def read(self) -> None:
+        """Read the changelog if it exists."""
+        logger.info(f"Reading changelog {self.path}")
+        if self.path.exists():
+            with self.path.open("r", encoding="utf-8") as f:
+                changelog_text = f.read()
+                if f.newlines:  # .newlines may be None, str, or tuple
+                    if isinstance(f.newlines, str):
+                        self.newline = f.newlines
+                    else:
+                        self.newline = f.newlines[0]
+            before, marker, after = partition_lines(
+                changelog_text, self.config.insert_marker
+            )
+            if marker:
+                self.text_before = before + marker
+                rest = after
+            else:
+                self.text_before = ""
+                rest = before
+            self.changelog, marker, after = partition_lines(
+                rest, self.config.end_marker
+            )
+            self.text_after = marker + after
+        else:
+            logger.warning(f"Changelog {self.path} doesn't exist")
+
+    def format_tools(self) -> FormatTools:
+        """Get the appropriate FormatTools for this changelog."""
+        return get_format_tools(self.config.format, self.config)
+
+    def entry_header(self, version, date=None) -> str:
+        """Format the header for a new entry."""
+        title_data = {
+            "date": date or datetime.datetime.now(),
+            "version": version,
+        }
+        title_template = jinja2.Template(self.config.entry_title_template)
+        new_title = title_template.render(config=self.config, **title_data)
+        if new_title.strip():
+            anchor = f"changelog-{version}" if version else None
+            new_header = self.format_tools().format_header(
+                new_title, anchor=anchor
+            )
+        else:
+            new_header = ""
+        return new_header
+
+    def entry_text(self, sections: SectionDict) -> str:
+        """Format the text of a new entry."""
+        return self.format_tools().format_sections(sections)
+
+    def add_entry(self, header: str, text: str) -> None:
+        """Add a new entry to the top of the changelog."""
+        self.changelog = header + text + self.changelog
+
+    def write(self) -> None:
+        """Write the changelog."""
+        f = self.path.open("w", encoding="utf-8", newline=self.newline or None)
+        with f:
+            f.write(self.text_before)
+            f.write(self.changelog)
+            f.write(self.text_after)
+
+    def entries(self) -> SectionDict:
+        """Parse the changelog into a SectionDict."""
+        return self.format_tools().parse_text(self.changelog)

scriv/cli.py

@@ -0,0 +1,32 @@
+"""Scriv command-line interface."""
+
+import logging
+
+import click
+import click_log
+
+from . import __version__
+from .collect import collect
+from .create import create
+from .ghrel import github_release
+from .print import print_
+
+click_log.basic_config(logging.getLogger())
+
+
+@click.group(
+    help=f"""\
+        Manage changelogs.
+
+        Version {__version__}
+    """
+)
+@click.version_option()
+def cli() -> None:  # noqa: D401
+    """The main entry point for the scriv command."""
+
+
+cli.add_command(create)
+cli.add_command(collect)
+cli.add_command(github_release)
+cli.add_command(print_)

scriv/collect.py

@@ -0,0 +1,104 @@
+"""Collecting fragments."""
+
+import logging
+import sys
+from typing import Optional
+
+import click
+
+from .gitinfo import git_add, git_config_bool, git_edit, git_rm
+from .scriv import Scriv
+from .util import Version, scriv_command
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--add/--no-add",
+    default=None,
+    help="'git add' the updated changelog file and removed fragments.",
+)
+@click.option(
+    "--edit/--no-edit",
+    default=None,
+    help="Open the changelog file in your text editor.",
+)
+@click.option(
+    "--title", default=None, help="The title text to use for this entry."
+)
+@click.option(
+    "--keep", is_flag=True, help="Keep the fragment files that are collected."
+)
+@click.option(
+    "--version", default=None, help="The version name to use for this entry."
+)
+@scriv_command
+def collect(
+    add: Optional[bool],
+    edit: Optional[bool],
+    title: str,
+    keep: bool,
+    version: str,
+) -> None:
+    """
+    Collect and combine fragments into the changelog.
+    """
+    if title is not None and version is not None:
+        sys.exit("Can't provide both --title and --version.")
+
+    if add is None:
+        add = git_config_bool("scriv.collect.add")
+    if edit is None:
+        edit = git_config_bool("scriv.collect.edit")
+
+    scriv = Scriv()
+    logger.info(f"Collecting from {scriv.config.fragment_directory}")
+    frags = scriv.fragments_to_combine()
+    if not frags:
+        logger.info("No changelog fragments to collect")
+        sys.exit(2)
+
+    changelog = scriv.changelog()
+    changelog.read()
+
+    if title is None:
+        version = Version(version or scriv.config.version)
+        if version:
+            # Check that we haven't used this version before.
+            for etitle in changelog.entries().keys():
+                if etitle is None:
+                    continue
+                eversion = Version.from_text(etitle)
+                if eversion is None:
+                    sys.exit(
+                        f"Entry {etitle!r} is not a valid version! "
+                        + "If scriv should ignore this heading, add "
+                        + "'scriv-end-here' somewhere before it."
+                    )
+                if eversion == version:
+                    sys.exit(
+                        f"Entry {etitle!r} already uses "
+                        + f"version {str(version)!r}."
+                    )
+        new_header = changelog.entry_header(version=version)
+    else:
+        new_header = changelog.format_tools().format_header(title)
+
+    new_text = changelog.entry_text(scriv.combine_fragments(frags))
+    changelog.add_entry(new_header, new_text)
+    changelog.write()
+
+    if edit:
+        git_edit(changelog.path)
+
+    if add:
+        git_add(changelog.path)
+
+    if not keep:
+        for frag in frags:
+            logger.info(f"Deleting fragment file {str(frag.path)!r}")
+            if add:
+                git_rm(frag.path)
+            else:
+                frag.path.unlink()