4.0.0

.github/workflows/main.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Extract program version
         id: program_version
         run: |
-          echo ::set-output name=version::$(check50 --version | cut --delimiter ' ' --fields 2)
+          echo "version=$(check50 --version | cut --delimiter ' ' --fields 2)" >> $GITHUB_OUTPUT
 
       - name: Create Release
         if: ${{ github.ref == 'refs/heads/main' }}

CONTRIBUTING_LANG.md

@@ -0,0 +1,48 @@
+# Check50 Language Translations
+Thank you for your interest in making CS50's tooling more accessible for all. Before contributing, please read this in full to avoid any complications.
+
+## Instructions
+CS50 uses GitHub to host code, track issues and feature requests, as well as accept pull requests. Please do not email staff members regarding specific issues or features.
+
+In order to add or edit a language for `check50`, please follow these steps.
+
+1. Fork the `check50` repository.
+2. Once in the `check50` directory, run `pip install babel` and `pip install -e .`
+3. If the language you are looking to add already exists in `check50/locale/`, please skip to step 6.
+    - See all of the 2 letter language codes [here](https://www.loc.gov/standards/iso639-2/php/code_list.php)
+4. Generate the template of strings to translate by running `python3 setup.py extract_messages`. This will create a file in `check50/locale/` called `check50.pot`
+5. Run `python setup.py init_catalog -l <LANG>`, where `<LANG>` is the 2 letter language code (see [here](https://www.loc.gov/standards/iso639-2/php/code_list.php)), to create a file called `check50.po` located at `check50/locale/<LANG>/LC_MESSAGES/`. This file is where the translations will be inputted.
+6. The original English strings are found at every `msgid` occurence. Translations should be inputted directly under at every `msgstr` occurence.
+7. To test your translations, run `python3 setup.py compile_catalog` to compile the `check50.po` file into `check50.mo`.
+8. `pip3 install .` to install the new version of `check50` containing these translations.
+
+## Design and Formatting
+Please follow the formatting of the `msgstr` English strings. For example, if the `msgid` string is
+
+```
+msgid ""
+"check50 is not intended for use in interactive mode. Some behavior may "
+"not function as expected."
+```
+
+The `msgstr` string should replicate the spacing of the English string.
+
+Example:
+```
+msgstr ""
+"check50 không thể sử dụng bằng chế độ tương tác, có thể "
+"không hoạt động như mong đợi."
+```
+
+Instead of:
+```
+msgstr ""
+"check50 không thể sử dụng bằng chế độ tương tác, có thể không hoạt động như mong đợi."
+```
+
+
+## Translation Error Reports
+
+
+## References
+This document was adapted from the open-source contribution guidelines for [Meta's Draft](https://github.com/facebookarchive/draft-js/blob/main/CONTRIBUTING.md)

check50/__init__.py

@@ -23,6 +23,15 @@ def _setup_translation():
 _set_version()
 _setup_translation()
 
+# Discourage use of check50 in the interactive mode, due to a naming conflict of
+# the `_` variable. check50 uses it for translations, but Python stores the
+# result of the last expression in a variable called `_`.
+import sys
+if hasattr(sys, 'ps1') or sys.flags.interactive:
+    import warnings
+    warnings.warn(_("check50 is not intended for use in interactive mode. "
+                    "Some behavior may not function as expected."))
+
 from ._api import (
     import_checks,
     data, _data,
@@ -38,7 +47,9 @@ def _setup_translation():
 
 from . import regex
 from .runner import check
+from .config import config
 from pexpect import EOF
 
 __all__ = ["import_checks", "data", "exists", "hash", "include", "regex",
-           "run", "log", "Failure", "Mismatch", "Missing", "check", "EOF"]
+           "run", "log", "Failure", "Mismatch", "Missing", "check", "EOF",
+           "config"]

check50/__main__.py

@@ -7,6 +7,7 @@
 import logging
 import os
 import platform
+import shutil
 import site
 from pathlib import Path
 import subprocess
@@ -20,12 +21,14 @@
 import requests
 import termcolor
 
-from . import _exceptions, internal, renderer, __version__
+from . import _exceptions, internal, renderer, assertions, __version__
 from .contextmanagers import nullcontext
 from .runner import CheckRunner
 
 LOGGER = logging.getLogger("check50")
 
+gettext.install("check50", str(importlib.resources.files("check50").joinpath("locale")))
+
 lib50.set_local_path(os.environ.get("CHECK50_PATH", "~/.local/share/check50"))
 
 
@@ -258,6 +261,20 @@ def process_args(args):
     if args.ansi_log and "ansi" not in seen_output:
         LOGGER.warning(_("--ansi-log has no effect when ansi is not among the output formats"))
 
+    if args.https or args.ssh:
+        if args.offline:
+            LOGGER.warning(_("Using either --https and --ssh will have no effect when running offline"))
+            args.auth_method = None
+        elif args.https and args.ssh:
+            LOGGER.warning(_("--https and --ssh have no effect when used together"))
+            args.auth_method = None
+        elif args.https:
+            args.auth_method = "https"
+        else:
+            args.auth_method = "ssh"
+    else:
+        args.auth_method = None
+
 
 class LoggerWriter:
     def __init__(self, logger, level):
@@ -273,10 +290,10 @@ def flush(self):
 
 
 def check_version(package_name=__package__, timeout=1):
-    """Check for newer version of the package on PyPI"""    
+    """Check for newer version of the package on PyPI"""
     if not __version__:
         return
-    
+
     try:
         current = packaging.version.parse(__version__)
         latest = max(requests.get(f"https://pypi.org/pypi/{package_name}/json", timeout=timeout).json()["releases"], key=packaging.version.parse)
@@ -333,6 +350,18 @@ def main():
     parser.add_argument("--no-install-dependencies",
                         action="store_true",
                         help=_("do not install dependencies (only works with --local)"))
+    parser.add_argument("--assertion-rewrite",
+                        action="store",
+                        nargs="?",
+                        const="enabled",
+                        choices=["true", "enabled", "1", "on", "false", "disabled", "0", "off"],
+                        help=_("enable or disable assertion rewriting; overrides ENABLE_CHECK50_ASSERT flag in the checks file"))
+    parser.add_argument("--https",
+                        action="store_true",
+                        help=_("force authentication via HTTPS"))
+    parser.add_argument("--ssh",
+                        action="store_true",
+                        help=_("force authentication via SSH"))
     parser.add_argument("-V", "--version",
                         action="version",
                         version=f"%(prog)s {__version__}")
@@ -387,7 +416,27 @@ def main():
             if not args.no_install_dependencies:
                 install_dependencies(config["dependencies"])
 
-            checks_file = (internal.check_dir / config["checks"]).resolve()
+            # Store the original checks file and leave as is
+            original_checks_file = (internal.check_dir / config["checks"]).resolve()
+
+            # If the user has enabled the rewrite feature
+            assertion_rewrite_enabled = False
+            if args.assertion_rewrite is not None:
+                assertion_rewrite_enabled = args.assertion_rewrite.lower() in ("true", "1", "enabled", "on")
+            else:
+                assertion_rewrite_enabled = assertions.rewrite_enabled(str(original_checks_file))
+
+            if assertion_rewrite_enabled:
+                # Create a temporary copy of the checks file
+                with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as tmp:
+                    checks_file = Path(tmp.name)
+                    shutil.copyfile(original_checks_file, checks_file)
+
+                # Rewrite all assert statements in the copied checks file to check50_assert
+                assertions.rewrite(str(checks_file))
+            else:
+                # Don't rewrite any assert statements and continue
+                checks_file = original_checks_file
 
             # Have lib50 decide which files to include
             included_files = lib50.files(config.get("files"))[0]

check50/_api.py

@@ -11,6 +11,7 @@
 from pexpect.exceptions import EOF, TIMEOUT
 
 from . import internal, regex
+from .config import config
 
 _log = []
 internal.register.before_every(_log.clear)
@@ -238,7 +239,9 @@ def stdout(self, output=None, str_output=None, regex=True, timeout=3, show_timeo
         :type show_timeout: bool
         :raises check50.Mismatch: if ``output`` is specified and nothing that the \
                                   process outputs matches it
-        :raises check50.Failure: if process times out or if it outputs invalid UTF-8 text.
+        :raises check50.Missing: if the process times out
+        :raises check50.Failure: if the process outputs invalid UTF-8 text or \
+                                 otherwise fails to verify output
 
         Example usage::
 
@@ -422,6 +425,8 @@ class Missing(Failure):
     """
 
     def __init__(self, missing_item, collection, help=None):
+        if isinstance(collection, list):
+            collection = _process_list(collection, _raw)
         super().__init__(rationale=_("Did not find {} in {}").format(_raw(missing_item), _raw(collection)), help=help)
 
         if missing_item == EOF:
@@ -453,15 +458,19 @@ class Mismatch(Failure):
     """
 
     def __init__(self, expected, actual, help=None):
-        super().__init__(rationale=_("expected {}, not {}").format(_raw(expected), _raw(actual)), help=help)
+        def _safe_truncate(x, y):
+            return _truncate(x, y) if x not in (EOF, TIMEOUT) else x
 
-        if expected == EOF:
-            expected = "EOF"
+        expected, actual = _safe_truncate(expected, actual), _safe_truncate(actual, expected)
 
-        if actual == EOF:
-            actual = "EOF"
+        rationale = _("expected: {}\n    actual:   {}").format(
+            _raw(expected),
+            _raw(actual)
+        )
 
-        self.payload.update({"expected": expected, "actual": actual})
+        super().__init__(rationale=rationale, help=help)
+
+        self.payload.update({"expected": _raw(expected), "actual": _raw(actual)})
 
 
 def hidden(failure_rationale):
@@ -493,19 +502,95 @@ def wrapper(*args, **kwargs):
         return wrapper
     return decorator
 
+def _process_list(lst, processor, flatten="shallow", joined_by="\n"):
+    """
+    Applies a function `processor` to every element of a list.
+
+    `flatten` has 3 choices:
+        - `none`: Apply `processor` to every element of a list without flattening (e.g. `['1', '2', '[3]']`).
+        - `shallow`: Flatten by one level only and apply `processor` (e.g. `'1\\n2\\n[3]'`).
+        - `deep`: Recursively flatten and apply `processor` (e.g. `'1\\n2\\n3'`).
+
+    Example usage:
+        if isinstance(obj, list):
+            return _process_list(obj, _raw, joined_by=" ")
+
+    :param lst: A list to be modified.
+    :type lst: list
+    :param processor: The function that processes each item.
+    :type processor: callable
+    :param flatten: The level of flattening to apply. One of "none", "shallow", or "deep".
+    :type flatten: str
+    :param joined_by: If `flatten` is one of "shallow" or "deep", uses this string to join the elements of the list.
+    :param joined_by: str
+    :rtype: list | str
+    """
+    match flatten:
+        case "shallow":
+            return joined_by.join(processor(item) for item in lst)
+        case "deep":
+            def _flatten_deep(x):
+                for item in x:
+                    if isinstance(item, list):
+                        yield from _flatten_deep(item)
+                    else:
+                        yield item
+
+            return joined_by.join(processor(item) for item in _flatten_deep(lst))
+        case _:
+            # for "none" and every other case
+            return [processor(item) for item in lst]
+
+def _truncate(s, other):
+    def normalize(obj):
+        if isinstance(obj, list):
+            return _process_list(obj, str)
+        else:
+            return str(obj)
+
+    s, other = normalize(s), normalize(other)
 
-def _raw(s):
-    """Get raw representation of s, truncating if too long."""
+    if not config.dynamic_truncate:
+        if len(s) > config.truncate_len:
+            s = s[:config.truncate_len] + "..."
+        return s
 
-    if isinstance(s, list):
-        s = "\n".join(_raw(item) for item in s)
+    # find the index of first difference
+    limit = min(len(s), len(other))
+    i = limit
+    for index in range(limit):
+        if s[index] != other[index]:
+            i = index
+            break
 
+    # If the diff is within the first config.truncate_len characters,
+    # start from the beginning (no need for "..." at the start)
+    if i < config.truncate_len:
+        start = 0
+        end = min(config.truncate_len, len(s))
+    else:
+        # center around diff for differences further into the string
+        start = max(i - (config.truncate_len // 2), 0)
+        end = min(start + config.truncate_len, len(s))
+
+    snippet = s[start:end]
+
+    if start > 0:
+        snippet = "..." + snippet
+    if end < len(s):
+        snippet = snippet + "..."
+
+    return snippet
+
+
+def _raw(s):
+    """Get raw representation of s."""
     if s == EOF:
         return "EOF"
+    elif s == TIMEOUT:
+        return "TIMEOUT"
 
     s = f'"{repr(str(s))[1:-1]}"'
-    if len(s) > 15:
-        s = s[:15] + "...\""  # Truncate if too long
     return s
 
 

check50/assertions/__init__.py

@@ -0,0 +1 @@
+from .rewrite import rewrite, rewrite_enabled