pre-commit-crocodile 2.0.0__py3-none-any.whl

pre_commit_crocodile/hooks/prepare_commit_message.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from os import environ
+from pathlib import Path
+from re import match, search
+import sys
+from sys import argv, exit as sys_exit, path
+from typing import List, NamedTuple, Optional, Tuple
+
+# Bind sources
+sys.dont_write_bytecode = True
+path.append(str(Path(__file__).resolve().parent))
+
+# Components, pylint: disable=import-error,wrong-import-position
+from configurations import (
+    COMMITS_CHANGES_PATTERN,
+    COMMITS_CHANGES_SECTION,
+    COMMITS_COMMENTS_PREFIX,
+    COMMITS_DEFAULT_BODY,
+    COMMITS_DEFAULT_SCOPE,
+    COMMITS_DEFAULT_SUBJECT,
+    COMMITS_DEFAULT_TYPE,
+    CHANGES_EVALUATORS,
+    COMMITS_FOOTER_SIGNOFF,
+    CHANGES_MATCHERS,
+    COMMITS_MESSAGE_EOL,
+)
+
+# Parse commit input
+def parse_commit_input(filepath: str) -> Tuple[bool, bool, str, List[str]]:
+
+    # Variables
+    capture: bool = False
+    changes: List[str] = []
+    context: List[str] = []
+    empty: bool = True
+    signoff: bool = False
+
+    # Read commit template
+    with open(filepath, encoding='utf8', mode='r') as file:
+        for line in file:
+
+            # Get line content
+            content = line.rstrip()
+
+            # Append context
+            context += [content]
+
+            # Detect signoff
+            if content and content.startswith(COMMITS_FOOTER_SIGNOFF):
+                signoff = True
+
+            # Detect contents
+            if content and not any(
+                    content.startswith(prefix) for prefix in [
+                        COMMITS_COMMENTS_PREFIX,
+                        COMMITS_FOOTER_SIGNOFF,
+                    ]):
+                empty = False
+
+            # Detect section
+            if content.startswith(COMMITS_CHANGES_SECTION):
+                capture = True
+                continue
+
+            # Parse section
+            if capture:
+                matches = match(COMMITS_CHANGES_PATTERN, content)
+                if matches:
+                    changes.append(matches.group(2).strip())
+                elif not content.strip() or content.startswith('#'):
+                    capture = False
+
+    # Result
+    return empty, signoff, COMMITS_MESSAGE_EOL.join(context), changes
+
+# Prepare commit title, pylint: disable=too-many-branches,too-many-locals,too-many-nested-blocks
+def prepare_commit_title(changes: List[str]) -> Tuple[str, str]:
+
+    # Types
+    Result = NamedTuple('Result', [
+        ('priority', int),
+        ('level', int),
+        ('commit_type', str),
+        ('commit_scope', str),
+    ])
+
+    # Variables
+    commit_scope: str = COMMITS_DEFAULT_SCOPE
+    commit_type: str = COMMITS_DEFAULT_TYPE
+    level: int
+    levels: List[int]
+    priority: int = 0
+    results: List[Result] = []
+
+    # Evaluate common changes
+    for changes_evaluator in CHANGES_EVALUATORS:
+        priority += 1
+        for type_change in changes_evaluator.changes:
+            for change in changes:
+                if not search(type_change, change):
+                    continue
+                for parser in changes_evaluator.parsers:
+                    matches = search(parser.match, change)
+                    if not matches or not isinstance(matches.lastindex, int):
+                        continue
+                    level = 0
+                    for group in parser.groups:
+                        level += 1
+                        if matches.lastindex >= group:
+                            results += [
+                                Result(
+                                    priority=priority,
+                                    level=level,
+                                    commit_type=parser.commit_type,
+                                    commit_scope=matches.group(group),
+                                )
+                            ]
+
+    # Match common changes
+    for changes_matcher in CHANGES_MATCHERS:
+        priority += 1
+        for matcher_type in changes_matcher.types:
+            for type_change in matcher_type.changes:
+                for change in changes:
+                    if search(type_change, change):
+                        results += [
+                            Result(
+                                priority=priority,
+                                level=0,
+                                commit_type=matcher_type.commit_type,
+                                commit_scope=changes_matcher.commit_scope,
+                            )
+                        ]
+
+    # Parse results
+    if results:
+        priority = min((result.priority for result in results))
+        results = [result for result in set(results) if result.priority == priority]
+        levels = sorted([result.level for result in results])
+        level = min((level for level in set(levels) if levels.count(level) == 1),
+                    default=levels[-1])
+        for result in [result for result in set(results) if result.level == level]:
+            commit_type = result.commit_type
+            commit_scope = result.commit_scope
+            break
+
+    # Result
+    return commit_type, commit_scope
+
+# Prepare commit message
+def prepare_commit_template(
+    commit_type: str,
+    commit_scope: str,
+    commit_subject: str,
+    commit_body: str,
+    signoff: bool,
+) -> str:
+
+    # Variables
+    commit_lines: List[str] = []
+
+    # Prepare commit title
+    commit_lines += [
+        f'{commit_type}({commit_scope}): {commit_subject}',
+    ]
+
+    # Prepare commit body
+    template_body = not ([
+        line for line in commit_body.splitlines()
+        if not line.startswith(COMMITS_COMMENTS_PREFIX)
+    ])
+    if commit_body:
+        commit_lines += [
+            '',
+            commit_body,
+        ]
+
+    # Append commit separator
+    if commit_body and signoff:
+        commit_lines += [
+            f'{COMMITS_COMMENTS_PREFIX} ---' if template_body else '---',
+        ]
+
+    # Append comments separator
+    if not signoff:
+        commit_lines += [
+            '',
+        ]
+
+    # Result
+    return str(COMMITS_MESSAGE_EOL.join(commit_lines))
+
+# Main, pylint: disable=too-many-branches,too-many-statements
+def main() -> None:
+
+    # Variables
+    changes: List[str]
+    commit_scope: str
+    commit_type: str
+    context: str
+    empty: bool
+    filepath: str
+    signoff: bool
+    source: Optional[str]
+
+    # Validate arguments
+    if len(argv) <= 1:
+        sys_exit(1)
+
+    # Parse arguments
+    filepath = argv[1]
+    source = argv[2] if len(argv) > 2 else None
+
+    # Ignore commit source, documentation:
+    # - message (if a -m or -F option was given)
+    # - template (if a -t option was given or the configuration option commit.template is set)
+    # - merge (if the commit is a merge or a .git/MERGE_MSG file exists)
+    # - squash (if a .git/SQUASH_MSG file exists)
+    # - commit, followed by a commit object name (if a -c, -C or --amend option was given)
+    if source and source in ['template', 'squash', 'commit']:
+        sys_exit(0)
+
+    # Parse commit input
+    empty, signoff, context, changes = parse_commit_input(filepath)
+
+    # Existing commit input
+    if not empty:
+        sys_exit(0)
+
+    # Prepare commit title
+    commit_type, commit_scope = prepare_commit_title(changes)
+
+    # Prepare commit template
+    commit_template = prepare_commit_template(
+        commit_type=commit_type,
+        commit_scope=commit_scope,
+        commit_subject=COMMITS_DEFAULT_SUBJECT,
+        commit_body=COMMITS_DEFAULT_BODY,
+        signoff=signoff,
+    )
+
+    # Write commit template
+    if environ.get('GIT_EXEC_PATH', ''):
+        with open(filepath, encoding='utf8', mode='w') as file:
+            file.write(commit_template + context)
+
+    # Dump commit template
+    else:
+        print(commit_template + context)
+
+    # Result
+    sys_exit(0)
+
+# Entrypoint
+if __name__ == '__main__': # pragma: no cover
+    main()

pre_commit_crocodile/package/bundle.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+# Bundle class, pylint: disable=too-few-public-methods
+class Bundle:
+
+    # Modules
+    MODULE: str = 'pre_commit_crocodile'
+
+    # Names
+    NAME: str = 'pre-commit-crocodile'
+
+    # Packages
+    PACKAGE: str = 'pre-commit-crocodile'
+
+    # Resources
+    RESOURCES_ASSETS: str = f'{MODULE}.assets'
+
+    # Details
+    DESCRIPTION: str = 'Git hooks intended for developers using pre-commit'
+
+    # Sources
+    REPOSITORY: str = 'https://gitlab.com/RadianDevCore/tools/pre-commit-crocodile'
+
+    # Releases
+    RELEASE_FIRST_TIMESTAMP: int = 1579337311
+
+    # Environment
+    ENV_DEBUG_REVISION_SHA: str = 'DEBUG_REVISION_SHA'
+    ENV_DEBUG_UPDATES_DAILY: str = 'DEBUG_UPDATES_DAILY'
+    ENV_DEBUG_UPDATES_DISABLE: str = 'DEBUG_UPDATES_DISABLE'
+    ENV_DEBUG_UPDATES_FAKE: str = 'DEBUG_UPDATES_FAKE'
+    ENV_DEBUG_UPDATES_OFFLINE: str = 'DEBUG_UPDATES_OFFLINE'
+    ENV_DEBUG_VERSION_FAKE: str = 'DEBUG_VERSION_FAKE'
+    ENV_NO_COLOR: str = 'NO_COLOR'

pre_commit_crocodile/package/settings.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from configparser import ConfigParser
+from pathlib import Path
+from sys import stdout
+from typing import Optional, Union
+
+# Components
+from ..prints.colors import Colors
+from ..system.platform import Platform
+
+# Settings class
+class Settings:
+
+    # Types
+    Value = Union[int, str]
+
+    # Constants
+    SETTINGS_FILE: str = 'settings.ini'
+
+    # Members
+    __folder: Path
+    __persistent: bool
+    __path: Path
+    __settings: ConfigParser
+
+    # Constructor
+    def __init__(self, name: str) -> None:
+
+        # Prepare paths
+        self.__folder = Platform.userspace(name)
+        self.__path = self.__folder / Settings.SETTINGS_FILE
+        self.__persistent = False
+
+        # Parse settings
+        self.__settings = ConfigParser()
+        self.__settings.read(self.__path)
+
+        # Prepare missing settings
+        try:
+            if self.get('package', 'name') != name:
+                raise ValueError('Missing settings files')
+            self.__persistent = True
+        except ValueError:
+            try:
+                self.__prepare()
+                self.__reset(name)
+                self.__persistent = True
+            except PermissionError: # pragma: no cover
+                self.__persistent = False
+
+        # Initialize settings
+        if not Path(self.__path).is_file():
+            self.__write()
+
+    # Prepare
+    def __prepare(self) -> None:
+
+        # Prepare folder path
+        if not Platform.IS_SIMULATED:
+            self.__folder.mkdir(parents=True, exist_ok=True)
+
+    # Reset
+    def __reset(self, name: str) -> None:
+
+        # Prepare barebone settings
+        self.__settings = ConfigParser()
+        self.set('package', 'name', name)
+
+    # Writer
+    def __write(self) -> None:
+
+        # Write initial settings
+        if self.__persistent and not Platform.IS_SIMULATED:
+            with open(self.__path, encoding='utf8', mode='w') as output:
+                self.__settings.write(output)
+
+    # Has
+    def has(self, group: str, key: str) -> bool:
+
+        # Check settings key in group
+        return group in self.__settings and key in self.__settings[group]
+
+    # Get
+    def get(self, group: str, key: str) -> Optional[Value]:
+
+        # Get settings key in group
+        if group in self.__settings and key in self.__settings[group]:
+            return self.__settings[group][key]
+
+        # Default fallback
+        return None
+
+    # Get bool
+    def get_bool(self, group: str, key: str) -> Optional[bool]:
+
+        # Get settings key as boolean
+        try:
+            value: str = str(self.get(group, key))
+            return value.lower() == 'true' or int(value) == 1
+        except (TypeError, ValueError):
+            return False
+
+    # Set
+    def set(self, group: str, key: str, value: Value) -> None:
+
+        # Prepare group
+        if group not in self.__settings:
+            self.__settings[group] = {}
+
+        # Unset key
+        if str(value) == 'UNSET':
+            del self.__settings[group][key]
+
+        # Set key
+        else:
+            self.__settings[group][key] = str(value)
+
+        # Write updated settings
+        self.__write()
+
+    # Set bool
+    def set_bool(self, group: str, key: str, value: Value) -> None:
+
+        # Set settings key as boolean
+        self.set(group, key, 1 if value else 0)
+
+    # Show
+    def show(self) -> None:
+
+        # Settings file path
+        print(' ')
+        print(
+            f' {Colors.GREEN}===[ {Colors.YELLOW}Settings:' \
+                f' {Colors.BOLD}{self.__path} {Colors.GREEN}]==={Colors.RESET}'
+        )
+        print(' ')
+
+        # Settings simulated contents
+        if Platform.IS_SIMULATED:
+            self.__settings.write(stdout)
+
+        # Settings file contents
+        else:
+            with open(self.__path, encoding='utf8', mode='r') as data:
+                print(data.read())
+            Platform.flush()

pre_commit_crocodile/package/updates.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+
+# Standard libraries
+from datetime import datetime
+from os import access, environ, W_OK
+from time import localtime, strftime, time
+from typing import Optional
+
+# Modules libraries
+from pkg_resources import parse_version
+
+# Components
+from ..prints.boxes import Boxes
+from ..prints.colors import Colors
+from ..system.platform import Platform
+from .bundle import Bundle
+from .settings import Settings
+from .version import Version
+
+# Updates class
+class Updates:
+
+    # Members
+    __enabled: bool
+    __name: str
+    __settings: Settings
+
+    # Constructor
+    def __init__(
+        self,
+        name: str,
+        settings: Settings,
+    ) -> None:
+
+        # Initialize members
+        self.__name = name
+        self.__settings = settings
+
+        # Detect migration
+        self.__migration()
+
+        # Prepare enabled
+        if not self.__settings.has('updates', 'enabled'):
+            self.__settings.set_bool('updates', 'enabled', True)
+
+        # Check enabled
+        self.__enabled = bool(self.__settings.get_bool('updates', 'enabled')) and \
+            not environ.get(Bundle.ENV_DEBUG_UPDATES_DISABLE, '')
+
+    # Migration
+    def __migration(self) -> None:
+
+        # Acquire versions
+        current_version = Version.get()
+        package_version = self.__settings.get('package', 'version')
+        if not package_version:
+            package_version = '0.0.0'
+
+        # Refresh package version
+        if not package_version or current_version != package_version:
+            self.__settings.set('package', 'version', current_version)
+
+    # Checker
+    def check(
+        self,
+        older: bool = False,
+    ) -> bool:
+
+        # Reference version
+        version = '0.0.0' if older else Version.get()
+
+        # Fake test updates
+        if Bundle.ENV_DEBUG_UPDATES_FAKE in environ:
+            available = environ[Bundle.ENV_DEBUG_UPDATES_FAKE]
+            if parse_version(available) >= parse_version(version):
+
+                # Show updates message
+                release_date = datetime.utcfromtimestamp(Bundle.RELEASE_FIRST_TIMESTAMP)
+                Updates.message(
+                    name=self.__name,
+                    older=older,
+                    available=available,
+                    date=release_date,
+                )
+                return True
+
+        # Check if not offline
+        if not environ.get(Bundle.ENV_DEBUG_UPDATES_OFFLINE, ''):
+
+            # Modules libraries, pylint: disable=import-outside-toplevel
+            from update_checker import UpdateChecker
+
+            # Check for updates
+            check = UpdateChecker(bypass_cache=True).check(self.__name, version)
+            if check: # pragma: no cover
+
+                # Show updates message
+                Updates.message(
+                    name=self.__name,
+                    older=older,
+                    available=check.available_version,
+                    date=check.release_date,
+                )
+                return True
+
+        # Older offline failure
+        if older:
+
+            # Show offline message
+            Updates.message(
+                name=self.__name,
+                offline=True,
+            )
+            return True
+
+        # Result
+        return False
+
+    # Daily
+    @property
+    def daily(self) -> bool:
+
+        # Acquire updates check last timestamp
+        last = self.__settings.get('updates', 'last_timestamp')
+
+        # Fake test updates
+        if Bundle.ENV_DEBUG_UPDATES_DAILY in environ:
+            last = None
+
+        # Handle daily checks
+        current = int(time())
+        if not last or strftime('%Y-%m-%d', localtime(current)) != strftime(
+                '%Y-%m-%d', localtime(int(last))):
+            self.__settings.set('updates', 'last_timestamp', current)
+            return True
+
+        # Default fallback
+        return False
+
+    # Enabled
+    @property
+    def enabled(self) -> bool:
+        return self.__enabled
+
+    # Message, pylint: disable=too-many-arguments
+    @staticmethod
+    def message(
+        name: str,
+        offline: bool = False,
+        older: bool = False,
+        available: Optional[str] = None,
+        date: Optional[datetime] = None,
+    ) -> None:
+
+        # Modules libraries, pylint: disable=import-outside-toplevel
+        from update_checker import pretty_date
+
+        # Create message box
+        box = Boxes()
+
+        # Acquire current version
+        version = Version.get()
+
+        # Detect package installer
+        package_install: str = ''
+        if Platform.PATH_SEPARATOR + 'pipx' + Platform.PATH_SEPARATOR in Version.path():
+            package_install = 'pipx upgrade' # pragma: no cover
+        else:
+            package_install = 'pip3 install -U' # pragma: no cover
+
+        # Detect package ownership
+        writable = access(__file__, W_OK)
+        if Platform.IS_USER_SUDO or not writable:
+            package_install = 'sudo ' + package_install # pragma: no cover
+
+        # Prepare package specification
+        package_specification: str = ''
+        if 'pipx' in package_install:
+            package_specification = f'{name}' # pragma: no cover
+        else:
+            package_specification = f'{name}>={available}' # pragma: no cover
+
+        # Evaluate same version
+        same = available and available == version
+
+        # Version message prefix
+        version_outdated = not offline and available and not older and not same
+        version_prefix = f'{Colors.YELLOW_LIGHT}Version: {Colors.BOLD}{name}' \
+            f' {Colors.RED if version_outdated else Colors.GREEN}{version}'
+
+        # Offline version message
+        if offline:
+            box.add(f'{version_prefix} {Colors.BOLD}not found, network might be down')
+
+        # Updated version message
+        elif same:
+            box.add(
+                f'{version_prefix} {Colors.BOLD}was released {pretty_date(date)}{Colors.BOLD}!'
+            )
+
+        # Older version message
+        elif older:
+            box.add(
+                f'{version_prefix} {Colors.BOLD}newer than {Colors.RED}{available}' \
+                    f' {Colors.BOLD}from {pretty_date(date)}{Colors.BOLD}!'
+            )
+
+        # Newer version message
+        else:
+            box.add(
+                f'{version_prefix} {Colors.BOLD}updated {pretty_date(date)}' \
+                    f' to {Colors.GREEN}{available}{Colors.BOLD}!'
+            )
+
+        # Changelog message
+        box.add(
+            f'{Colors.YELLOW_LIGHT}Changelog: {Colors.CYAN}{Bundle.REPOSITORY}/-/releases'
+        )
+
+        # Update message
+        if available:
+            box.add(
+                f'{Colors.YELLOW_LIGHT}Update: {Colors.BOLD}' \
+                    f"Run {Colors.GREEN}{package_install} '{package_specification}'"
+            )
+
+        # Print message box
+        box.print()