cfengine 0.11.2__tar.gz → 0.12.1__tar.gz

{cfengine-0.11.2 → cfengine-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cfengine
-Version: 0.11.2
+Version: 0.12.1
 Summary: Human-oriented CLI for interacting with CFEngine tools
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cfengine
-Version: 0.11.2
+Version: 0.12.1
 Summary: Human-oriented CLI for interacting with CFEngine tools
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ src/cfengine_cli/format.py
 src/cfengine_cli/lint.py
 src/cfengine_cli/main.py
 src/cfengine_cli/paths.py
+src/cfengine_cli/policy_language.py
 src/cfengine_cli/profile.py
 src/cfengine_cli/shell.py
 src/cfengine_cli/utils.py

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine_cli/commands.py

@@ -4,7 +4,7 @@ import re
 import json
 from cfengine_cli.profile import profile_cfengine, generate_callstack
 from cfengine_cli.dev import dispatch_dev_subcommand
-from cfengine_cli.lint import lint_single_arg, lint_folder
+from cfengine_cli.lint import lint_folder, lint_single_arg
 from cfengine_cli.shell import user_command
 from cfengine_cli.paths import bin
 from cfengine_cli.version import cfengine_cli_version_string
@@ -94,21 +94,20 @@ def format(names, line_length) -> int:
     return 0
 
 
-def _lint(files) -> int:
-
+def _lint(files, strict) -> int:
     if not files:
-        return lint_folder(".")
+        return lint_folder(".", strict)
 
     errors = 0
 
     for file in files:
-        errors += lint_single_arg(file)
+        errors += lint_single_arg(file, strict)
 
     return errors
 
 
-def lint(files) -> int:
-    errors = _lint(files)
+def lint(files, strict) -> int:
+    errors = _lint(files, strict)
     if errors == 0:
         print("Success, no errors found.")
     else:

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine_cli/docs.py

@@ -409,7 +409,7 @@ def check_docs() -> int:
 
     Run by the command:
     cfengine dev lint-docs"""
-    r = lint_folder(".")
+    r = lint_folder(".", strict=False)
     if r != 0:
         return r
     _process_markdown_code_blocks(

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine_cli/lint.py

@@ -14,13 +14,50 @@ import os
 import json
 import itertools
 import tree_sitter_cfengine as tscfengine
+from dataclasses import dataclass
 from tree_sitter import Language, Parser
 from cfbs.validate import validate_config
 from cfbs.cfbs_config import CFBSConfig
 from cfbs.utils import find
-
-DEPRECATED_PROMISE_TYPES = ["defaults", "guest_environments"]
-ALLOWED_BUNDLE_TYPES = ["agent", "common", "monitor", "server", "edit_line", "edit_xml"]
+from cfengine_cli.policy_language import (
+    DEPRECATED_PROMISE_TYPES,
+    ALLOWED_BUNDLE_TYPES,
+    BUILTIN_PROMISE_TYPES,
+    BUILTIN_FUNCTIONS,
+)
+
+
+@dataclass
+class _State:
+    block_type: str | None = None  # "bundle" | "body" | "promise" | None
+    promise_type: str | None = None  # "vars" | "files" | "classes" | ... | None
+    attribute_name: str | None = None  # "if" | "string" | "slist" | ... | None
+
+    def update(self, node) -> "_State":
+        """Updates and returns the state that should apply to the children of `node`."""
+        if node.type == "bundle_block":
+            return _State(block_type="bundle")
+        if node.type == "body_block":
+            return _State(block_type="body")
+        if node.type == "promise_block":
+            return _State(block_type="promise")
+        if node.type == "bundle_section":
+            for child in node.children:
+                if child.type == "promise_guard":
+                    return _State(
+                        block_type=self.block_type,
+                        promise_type=_text(child)[:-1],  # strip trailing ':'
+                    )
+            return _State(block_type=self.block_type)
+        if node.type == "attribute":
+            for child in node.children:
+                if child.type == "attribute_name":
+                    return _State(
+                        block_type=self.block_type,
+                        promise_type=self.promise_type,
+                        attribute_name=_text(child),
+                    )
+        return self
 
 
 def lint_cfbs_json(filename) -> int:
@@ -90,16 +127,9 @@ def _find_node_type(filename, lines, node, node_type):
     return matches
 
 
-def _find_nodes(filename, lines, node):
-    matches = []
-    visitor = lambda x: matches.append(x)
-    _walk_generic(filename, lines, node, visitor)
-    return matches
-
-
-def _single_node_checks(filename, lines, node):
-    """Things which can be checked by only looking at one node,
-    not needing to recurse into children."""
+def _node_checks(filename, lines, node, user_definition, strict, state: _State):
+    """Checks we run on each node in the syntax tree,
+    utilizes state for checks which require context."""
     line = node.range.start_point[0] + 1
     column = node.range.start_point[1] + 1
     if node.type == "attribute_name" and _text(node) == "ifvarclass":
@@ -117,6 +147,19 @@ def _single_node_checks(filename, lines, node):
                 f"Deprecation: Promise type '{promise_type}' is deprecated at {filename}:{line}:{column}"
             )
             return 1
+        if strict and (
+            (
+                promise_type
+                not in BUILTIN_PROMISE_TYPES.union(
+                    user_definition.get("custom_promise_types", set())
+                )
+            )
+        ):
+            _highlight_range(node, lines)
+            print(
+                f"Error: Undefined promise type '{promise_type}' at {filename}:{line}:{column}"
+            )
+            return 1
     if node.type == "bundle_block_name":
         if _text(node) != _text(node).lower():
             _highlight_range(node, lines)
@@ -138,10 +181,52 @@ def _single_node_checks(filename, lines, node):
                 f"Error: Bundle type must be one of ({', '.join(ALLOWED_BUNDLE_TYPES)}), not '{_text(node)}' at {filename}:{line}:{column}"
             )
             return 1
+    if node.type == "calling_identifier":
+        if (
+            strict
+            and _text(node) in user_definition.get("all_bundle_names", set())
+            and state.promise_type in user_definition.get("custom_promise_types", set())
+        ):
+            _highlight_range(node, lines)
+            print(
+                f"Error: Call to bundle '{_text(node)}' inside custom promise: '{state.promise_type}' at {filename}:{line}:{column}"
+            )
+            return 1
+        if strict and (
+            _text(node)
+            not in BUILTIN_FUNCTIONS.union(
+                user_definition.get("all_bundle_names", set()),
+                user_definition.get("all_body_names", set()),
+            )
+        ):
+            _highlight_range(node, lines)
+            print(
+                f"Error: Call to unknown function / bundle / body '{_text(node)}' at at {filename}:{line}:{column}"
+            )
+            return 1
     return 0
 
 
-def _walk(filename, lines, node) -> int:
+def _stateful_walk(
+    filename, lines, node, user_definition, strict, state: _State | None = None
+) -> int:
+    if state is None:
+        state = _State()
+
+    errors = _node_checks(filename, lines, node, user_definition, strict, state)
+
+    child_state = state.update(node)
+    for child in node.children:
+        errors += _stateful_walk(
+            filename, lines, child, user_definition, strict, child_state
+        )
+    return errors
+
+
+def _walk(filename, lines, node, user_definition=None, strict=True) -> int:
+    if user_definition is None:
+        user_definition = {}
+
     error_nodes = _find_node_type(filename, lines, node, "ERROR")
     if error_nodes:
         for node in error_nodes:
@@ -154,15 +239,42 @@ def _walk(filename, lines, node) -> int:
     line = node.range.start_point[0] + 1
     column = node.range.start_point[1] + 1
 
-    errors = 0
-    for node in _find_nodes(filename, lines, node):
-        errors += _single_node_checks(filename, lines, node)
+    return _stateful_walk(filename, lines, node, user_definition, strict)
 
-    return errors
+
+def _parse_user_definition(filename, lines, root_node):
+    promise_blocks = _find_node_type(filename, lines, root_node, "promise_block_name")
+    bundle_blocks = _find_node_type(filename, lines, root_node, "bundle_block_name")
+    body_blocks = _find_node_type(filename, lines, root_node, "body_block_name")
+
+    return {
+        "custom_promise_types": {_text(x) for x in promise_blocks},
+        "all_bundle_names": {_text(x) for x in bundle_blocks},
+        "all_body_names": {_text(x) for x in body_blocks},
+    }
+
+
+def _parse_policy_file(filename):
+    assert os.path.isfile(filename)
+    PY_LANGUAGE = Language(tscfengine.language())
+    parser = Parser(PY_LANGUAGE)
+
+    with open(filename, "rb") as f:
+        original_data = f.read()
+    tree = parser.parse(original_data)
+    lines = original_data.decode().split("\n")
+
+    return tree, lines, original_data
 
 
 def lint_policy_file(
-    filename, original_filename=None, original_line=None, snippet=None, prefix=None
+    filename,
+    original_filename=None,
+    original_line=None,
+    snippet=None,
+    prefix=None,
+    user_definition=None,
+    strict=True,
 ):
     assert original_filename is None or type(original_filename) is str
     assert original_line is None or type(original_line) is int
@@ -177,14 +289,11 @@ def lint_policy_file(
         assert snippet and snippet > 0
     assert os.path.isfile(filename)
     assert filename.endswith((".cf", ".cfengine3", ".cf3", ".cf.sub"))
-    PY_LANGUAGE = Language(tscfengine.language())
-    parser = Parser(PY_LANGUAGE)
 
-    with open(filename, "rb") as f:
-        original_data = f.read()
-    tree = parser.parse(original_data)
-    lines = original_data.decode().split("\n")
+    if user_definition is None:
+        user_definition = {}
 
+    tree, lines, original_data = _parse_policy_file(filename)
     root_node = tree.root_node
     if root_node.type != "source_file":
         if snippet:
@@ -214,7 +323,7 @@ def lint_policy_file(
         else:
             print(f"Error: Empty policy file '{filename}'")
         errors += 1
-    errors += _walk(filename, lines, root_node)
+    errors += _walk(filename, lines, root_node, user_definition, strict)
     if prefix:
         print(prefix, end="")
     if errors == 0:
@@ -235,8 +344,9 @@ def lint_policy_file(
     return errors
 
 
-def lint_folder(folder):
+def lint_folder(folder, strict=True):
     errors = 0
+    policy_files = []
     while folder.endswith(("/.", "/")):
         folder = folder[0:-1]
     for filename in itertools.chain(
@@ -246,22 +356,44 @@ def lint_folder(folder):
             continue
         if filename.startswith(".") and not filename.startswith("./"):
             continue
-        errors += lint_single_file(filename)
+
+        if filename.endswith((".cf", ".cfengine3", ".cf3", ".cf.sub")):
+            policy_files.append(filename)
+        else:
+            errors += lint_single_file(filename)
+
+    user_definition = {}
+
+    # First pass: Gather custom types
+    for filename in policy_files if strict else []:
+        tree, lines, _ = _parse_policy_file(filename)
+        if tree.root_node.type == "source_file":
+            for key, val in _parse_user_definition(
+                filename, lines, tree.root_node
+            ).items():
+                user_definition[key] = user_definition.get(key, set()).union(val)
+
+    # Second pass: lint all policy files
+    for filename in policy_files:
+        errors += lint_policy_file(
+            filename, user_definition=user_definition, strict=strict
+        )
     return errors
 
 
-def lint_single_file(file):
+def lint_single_file(file, user_definition=None, strict=True):
     assert os.path.isfile(file)
     if file.endswith("/cfbs.json"):
         return lint_cfbs_json(file)
     if file.endswith(".json"):
         return lint_json(file)
     assert file.endswith(".cf")
-    return lint_policy_file(file)
+    return lint_policy_file(file, user_definition=user_definition, strict=strict)
 
 
-def lint_single_arg(arg):
+def lint_single_arg(arg, strict=True):
     if os.path.isdir(arg):
-        return lint_folder(arg)
+        return lint_folder(arg, strict)
     assert os.path.isfile(arg)
-    return lint_single_file(arg)
+
+    return lint_single_file(arg, strict)

{cfengine-0.11.2 → cfengine-0.12.1}/src/cfengine_cli/main.py

@@ -52,6 +52,12 @@ def _get_arg_parser():
         "lint",
         help="Look for syntax errors and other simple mistakes",
     )
+    lnt.add_argument(
+        "--strict",
+        type=str,
+        default="yes",
+        help="Strict mode. Default=yes, checks for undefined promise types, bundles, bodies, functions",
+    )
     lnt.add_argument("files", nargs="*", help="Files to format")
     subp.add_parser(
         "report",
@@ -132,7 +138,7 @@ def run_command_with_args(args) -> int:
     if args.command == "format":
         return commands.format(args.files, args.line_length)
     if args.command == "lint":
-        return commands.lint(args.files)
+        return commands.lint(args.files, (args.strict.lower() in ("y", "ye", "yes")))
     if args.command == "report":
         return commands.report()
     if args.command == "run":

cfengine-0.12.1/src/cfengine_cli/policy_language.py

@@ -0,0 +1,239 @@
+# These constants are temporary and may change in the future
+# TODO: Find a way to extract these from the generated "syntax-definition"-json file
+
+DEPRECATED_PROMISE_TYPES = ["defaults", "guest_environments"]
+ALLOWED_BUNDLE_TYPES = ["agent", "common", "monitor", "server", "edit_line", "edit_xml"]
+BUILTIN_PROMISE_TYPES = {
+    "access",
+    "build_xpath",
+    "classes",
+    "commands",
+    "databases",
+    "defaults",
+    "delete_attribute",
+    "delete_lines",
+    "delete_text",
+    "delete_tree",
+    "field_edits",
+    "files",
+    "guest_environments",
+    "insert_lines",
+    "insert_text",
+    "insert_tree",
+    "measurements",
+    "meta",
+    "methods",
+    "packages",
+    "processes",
+    "replace_patterns",
+    "reports",
+    "roles",
+    "services",
+    "set_attribute",
+    "set_text",
+    "storage",
+    "users",
+    "vars",
+}
+BUILTIN_FUNCTIONS = {
+    "accessedbefore",
+    "accumulated",
+    "ago",
+    "and",
+    "basename",
+    "bundlesmatching",
+    "bundlestate",
+    "callstack_callers",
+    "callstack_promisers",
+    "canonify",
+    "canonifyuniquely",
+    "cf_version_after",
+    "cf_version_at",
+    "cf_version_before",
+    "cf_version_between",
+    "cf_version_maximum",
+    "cf_version_minimum",
+    "changedbefore",
+    "classesmatching",
+    "classfiltercsv",
+    "classfilterdata",
+    "classify",
+    "classmatch",
+    "concat",
+    "countclassesmatching",
+    "countlinesmatching",
+    "data_expand",
+    "data_readstringarray",
+    "data_readstringarrayidx",
+    "data_regextract",
+    "data_sysctlvalues",
+    "datastate",
+    "difference",
+    "dirname",
+    "diskfree",
+    "escape",
+    "eval",
+    "every",
+    "execresult",
+    "execresult_as_data",
+    "expandrange",
+    "file_hash",
+    "fileexists",
+    "filesexist",
+    "filesize",
+    "filestat",
+    "filter",
+    "findfiles",
+    "findfiles_up",
+    "findlocalgroups",
+    "findlocalusers",
+    "findprocesses",
+    "format",
+    "getacls",
+    "getbundlemetatags",
+    "getclassmetatags",
+    "getenv",
+    "getfields",
+    "getgid",
+    "getgroupinfo",
+    "getgroups",
+    "getindices",
+    "getuid",
+    "getuserinfo",
+    "getusers",
+    "getvalues",
+    "getvariablemetatags",
+    "grep",
+    "groupexists",
+    "hash",
+    "hash_to_int",
+    "hashmatch",
+    "host2ip",
+    "hostinnetgroup",
+    "hostrange",
+    "hostsseen",
+    "hostswithclass",
+    "hostswithgroup",
+    "hubknowledge",
+    "ifelse",
+    "int",
+    "intersection",
+    "ip2host",
+    "iprange",
+    "irange",
+    "is_type",
+    "isconnectable",
+    "isdir",
+    "isexecutable",
+    "isgreaterthan",
+    "isipinsubnet",
+    "islessthan",
+    "islink",
+    "isnewerthan",
+    "isnewerthantime",
+    "isplain",
+    "isreadable",
+    "isvariable",
+    "join",
+    "lastnode",
+    "laterthan",
+    "ldaparray",
+    "ldaplist",
+    "ldapvalue",
+    "length",
+    "lsdir",
+    "makerule",
+    "maparray",
+    "mapdata",
+    "maplist",
+    "max",
+    "mean",
+    "mergedata",
+    "min",
+    "network_connections",
+    "none",
+    "not",
+    "now",
+    "nth",
+    "on",
+    "or",
+    "packagesmatching",
+    "packageupdatesmatching",
+    "parseintarray",
+    "parsejson",
+    "parserealarray",
+    "parsestringarray",
+    "parsestringarrayidx",
+    "parseyaml",
+    "peerleader",
+    "peerleaders",
+    "peers",
+    "processexists",
+    "product",
+    "randomint",
+    "read_module_protocol",
+    "readcsv",
+    "readdata",
+    "readenvfile",
+    "readfile",
+    "readintarray",
+    "readintlist",
+    "readjson",
+    "readrealarray",
+    "readreallist",
+    "readstringarray",
+    "readstringarrayidx",
+    "readstringlist",
+    "readtcp",
+    "readyaml",
+    "regarray",
+    "regcmp",
+    "regex_replace",
+    "regextract",
+    "registryvalue",
+    "regldap",
+    "regline",
+    "reglist",
+    "remoteclassesmatching",
+    "remotescalar",
+    "returnszero",
+    "reverse",
+    "rrange",
+    "search_up",
+    "selectservers",
+    "shuffle",
+    "some",
+    "sort",
+    "splayclass",
+    "splitstring",
+    "storejson",
+    "strcmp",
+    "strftime",
+    "string",
+    "string_downcase",
+    "string_head",
+    "string_length",
+    "string_mustache",
+    "string_replace",
+    "string_reverse",
+    "string_split",
+    "string_tail",
+    "string_trim",
+    "string_upcase",
+    "sublist",
+    "sum",
+    "sysctlvalue",
+    "translatepath",
+    "type",
+    "unique",
+    "url_get",
+    "usemodule",
+    "userexists",
+    "useringroup",
+    "validdata",
+    "validjson",
+    "variablesmatching",
+    "variablesmatching_as_data",
+    "variance",
+    "version_compare",
+}

{cfengine-0.11.2 → cfengine-0.12.1}/uv.lock

@@ -329,7 +329,7 @@ wheels = [
 
 [[package]]
 name = "requests"
-version = "2.32.5"
+version = "2.33.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -337,9 +337,9 @@ dependencies = [
     { name = "idna" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/64/8860370b167a9721e8956ae116825caff829224fbca0ca6e7bf8ddef8430/requests-2.33.0.tar.gz", hash = "sha256:c7ebc5e8b0f21837386ad0e1c8fe8b829fa5f544d8df3b2253bff14ef29d7652", size = 134232, upload-time = "2026-03-25T15:10:41.586Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+    { url = "https://files.pythonhosted.org/packages/56/5d/c814546c2333ceea4ba42262d8c4d55763003e767fa169adc693bd524478/requests-2.33.0-py3-none-any.whl", hash = "sha256:3324635456fa185245e24865e810cecec7b4caf933d7eb133dcde67d48cee69b", size = 65017, upload-time = "2026-03-25T15:10:40.382Z" },
 ]
 
 [[package]]