cja 0.2.2__tar.gz → 0.2.3__tar.gz

{cja-0.2.2 → cja-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cja
-Version: 0.2.2
+Version: 0.2.3
 Summary: CMake-compatible build system that generates Ninja build files
 Author: Jan Niklas Hasse
 Author-email: Jan Niklas Hasse <jhasse@bixense.com>

{cja-0.2.2 → cja-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cja"
-version = "0.2.2"
+version = "0.2.3"
 description = "CMake-compatible build system that generates Ninja build files"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{cja-0.2.2 → cja-0.2.3}/src/cja/build_context.py

@@ -47,6 +47,21 @@ class CustomCommand:
     defined_line: int = 0
 
 
+@dataclass
+class CustomTarget:
+    """A custom target (phony build target)."""
+
+    name: str
+    commands: list[list[str]]
+    depends: list[str]
+    all: bool = False
+    working_directory: str | None = None
+    verbatim: bool = False
+    comment: str = ""
+    defined_file: Path | None = None
+    defined_line: int = 0
+
+
 @dataclass
 class BuildContext:
     """Context for processing CMake commands."""
@@ -58,7 +73,9 @@ class BuildContext:
     project_name: str = ""
     variables: dict[str, str] = field(default_factory=dict)
     cache_variables: set[str] = field(default_factory=set)  # Variables from -D flags
-    cli_variables: dict[str, str] = field(default_factory=dict)  # Original -D flag values
+    cli_variables: dict[str, str] = field(
+        default_factory=dict
+    )  # Original -D flag values
     libraries: list[Library] = field(default_factory=list)
     executables: list[Executable] = field(default_factory=list)
     imported_targets: dict[str, ImportedTarget] = field(default_factory=dict)
@@ -69,6 +86,9 @@ class BuildContext:
     custom_commands: list[CustomCommand] = field(
         default_factory=list
     )  # Custom build commands
+    custom_targets: list[CustomTarget] = field(
+        default_factory=list
+    )  # Custom targets (phony)
     functions: dict[str, FunctionDef] = field(
         default_factory=dict
     )  # User-defined functions
@@ -179,7 +199,9 @@ class BuildContext:
                 if allow_undefined_empty:
                     return ""
                 if allow_undefined_warning:
-                    self.print_warning(f"undefined variable referenced: {var_name}", line)
+                    self.print_warning(
+                        f"undefined variable referenced: {var_name}", line
+                    )
                     return ""
                 level = self.print_error if strict else self.print_warning
                 level(f"undefined variable referenced: {var_name}", line)

{cja-0.2.2 → cja-0.2.3}/src/cja/find_package.py

@@ -519,4 +519,104 @@ def handle_builtin_find_package(
                 print(f"{colored('✗', 'red')} {package_name}")
         return True
 
+    if package_name == "Qt5":
+        keywords = {
+            "REQUIRED",
+            "QUIET",
+            "COMPONENTS",
+            "OPTIONAL_COMPONENTS",
+            "EXACT",
+            "MODULE",
+            "CONFIG",
+            "NO_MODULE",
+        }
+        required_components: list[str] = []
+        optional_components: list[str] = []
+        i = 1
+        while i < len(args):
+            token = args[i]
+            if token == "COMPONENTS":
+                i += 1
+                while i < len(args) and args[i] not in keywords:
+                    required_components.append(args[i])
+                    i += 1
+                continue
+            if token == "OPTIONAL_COMPONENTS":
+                i += 1
+                while i < len(args) and args[i] not in keywords:
+                    optional_components.append(args[i])
+                    i += 1
+                continue
+            i += 1
+
+        all_components = required_components + optional_components
+        if not all_components:
+            all_components = ["Core"]
+
+        found = False
+        missing_required: list[str] = []
+
+        for component in all_components:
+            pkg_name = f"Qt5{component}"
+            component_found = False
+            try:
+                result = subprocess.run(
+                    ["pkg-config", "--exists", pkg_name],
+                    capture_output=True,
+                )
+                component_found = result.returncode == 0
+            except FileNotFoundError:
+                component_found = False
+
+            if component_found:
+                found = True
+                cflags_result = subprocess.run(
+                    ["pkg-config", "--cflags", pkg_name],
+                    capture_output=True,
+                    text=True,
+                )
+                libs_result = subprocess.run(
+                    ["pkg-config", "--libs", pkg_name],
+                    capture_output=True,
+                    text=True,
+                )
+                version_result = subprocess.run(
+                    ["pkg-config", "--modversion", pkg_name],
+                    capture_output=True,
+                    text=True,
+                )
+
+                comp_cflags = cflags_result.stdout.strip()
+                comp_libs = libs_result.stdout.strip()
+                comp_version = version_result.stdout.strip()
+
+                ctx.variables[f"Qt5{component}_FOUND"] = "TRUE"
+                if comp_version:
+                    ctx.variables[f"Qt5{component}_VERSION"] = comp_version
+                    ctx.variables["Qt5_VERSION"] = comp_version
+
+                ctx.imported_targets[f"Qt5::{component}"] = ImportedTarget(
+                    cflags=comp_cflags,
+                    libs=comp_libs,
+                )
+            else:
+                ctx.variables[f"Qt5{component}_FOUND"] = "FALSE"
+                if component in required_components:
+                    missing_required.append(component)
+
+        found = found and not missing_required
+        ctx.variables["Qt5_FOUND"] = "TRUE" if found else "FALSE"
+
+        if found:
+            if not quiet:
+                print(f"{colored('✓', 'green')} {package_name}")
+        else:
+            ctx.variables["Qt5_FOUND"] = "FALSE"
+            if required:
+                ctx.print_error("could not find package: Qt5", cmd.line)
+                raise SystemExit(1)
+            if not quiet:
+                print(f"{colored('✗', 'red')} {package_name}")
+        return True
+
     return False

{cja-0.2.2 → cja-0.2.3}/src/cja/generator.py

@@ -27,6 +27,7 @@ from .syntax import (
 from .build_context import (
     BuildContext,
     CustomCommand,
+    CustomTarget,
     find_matching_endforeach,
     find_matching_endif,
 )
@@ -808,6 +809,8 @@ def process_commands(
                 add_dir(root)
         else:
             unix_defaults = ["/usr/local", "/usr"]
+            if platform.system() == "Darwin" and Path("/opt/homebrew").is_dir():
+                unix_defaults.insert(0, "/opt/homebrew")
             for root in unix_defaults:
                 if kind == "path":
                     add_dir(str(Path(root) / "include"))
@@ -996,7 +999,6 @@ def process_commands(
                     if sub_cmakelists.exists():
                         from .parser import parse_file
 
-                        ctx.record_cmake_file(sub_cmakelists)
                         ctx.record_cmake_file(sub_cmakelists)
                         sub_commands = parse_file(sub_cmakelists)
 
@@ -1327,6 +1329,7 @@ def process_commands(
                     if sub_cmakelists.exists():
                         from .parser import parse_file
 
+                        ctx.record_cmake_file(sub_cmakelists)
                         sub_commands = parse_file(sub_cmakelists)
 
                         saved_current_source_dir = ctx.current_source_dir
@@ -2235,6 +2238,64 @@ int main() {{
                         )
                     )
 
+            case "add_custom_target":
+                # Support: add_custom_target(<name> [ALL] [COMMAND cmd ...] [DEPENDS ...] [WORKING_DIRECTORY ...] [VERBATIM] [COMMENT ...])
+                if not args:
+                    break
+                target_name = ctx.expand_variables(args[0], strict, cmd.line)
+                ct_commands: list[list[str]] = []
+                ct_depends: list[str] = []
+                ct_all = False
+                ct_working_directory: str | None = None
+                ct_verbatim = False
+                ct_comment = ""
+                ct_section: str | None = None
+                ct_idx = 1
+                while ct_idx < len(args):
+                    arg = args[ct_idx]
+                    if arg == "ALL":
+                        ct_all = True
+                    elif arg in ("COMMAND", "DEPENDS", "WORKING_DIRECTORY", "COMMENT"):
+                        ct_section = arg
+                        if arg == "COMMAND":
+                            ct_commands.append([])
+                    elif arg in ("VERBATIM", "USES_TERMINAL", "COMMAND_EXPAND_LISTS"):
+                        if arg == "VERBATIM":
+                            ct_verbatim = True
+                        ct_section = None
+                    elif arg == "SOURCES":
+                        ct_section = "SOURCES"
+                    else:
+                        arg = ctx.expand_variables(arg, strict, cmd.line)
+                        if ct_section == "COMMAND":
+                            ct_commands[-1].append(arg)
+                        elif ct_section == "DEPENDS":
+                            rel = make_relative(arg, ctx.build_dir)
+                            if rel == arg:
+                                rel = ctx.resolve_path(arg)
+                            ct_depends.append(rel)
+                        elif ct_section == "WORKING_DIRECTORY":
+                            ct_working_directory = arg
+                        elif ct_section == "COMMENT":
+                            ct_comment = arg
+                        elif ct_section == "SOURCES":
+                            pass  # Ignored, only for IDE integration
+                    ct_idx += 1
+
+                ctx.custom_targets.append(
+                    CustomTarget(
+                        name=target_name,
+                        commands=ct_commands,
+                        depends=ct_depends,
+                        all=ct_all,
+                        working_directory=ct_working_directory,
+                        verbatim=ct_verbatim,
+                        comment=ct_comment,
+                        defined_file=ctx.current_list_file,
+                        defined_line=cmd.line,
+                    )
+                )
+
             case "add_test":
                 # Support: add_test(NAME <name> COMMAND <command> ...)
                 # Or: add_test(<name> <command> ...)
@@ -2370,6 +2431,12 @@ int main() {{
             case "find_path":
                 if len(args) >= 2:
                     var_name = args[0]
+                    existing = ctx.variables.get(var_name, "")
+                    if var_name in ctx.cache_variables or (
+                        existing and not existing.endswith("-NOTFOUND")
+                    ):
+                        frame.pc += 1
+                        continue
                     ctx.cache_variables.add(var_name)
                     names: list[str] = []
                     paths: list[str] = []
@@ -2478,6 +2545,12 @@ int main() {{
             case "find_library":
                 if len(args) >= 2:
                     var_name = args[0]
+                    existing = ctx.variables.get(var_name, "")
+                    if var_name in ctx.cache_variables or (
+                        existing and not existing.endswith("-NOTFOUND")
+                    ):
+                        frame.pc += 1
+                        continue
                     ctx.cache_variables.add(var_name)
                     names: list[str] = []
                     paths: list[str] = []
@@ -3519,7 +3592,17 @@ def generate_ninja(
                     return f"-D{name}="
                 return f"-D{name}={value}"
 
-            reconfigure_cmd_parts = ["cja", "--regenerate-during-build"]
+            cja_cmd = ["cja"]
+            absolute_cja_cmd = shutil.which(cja_cmd[0])
+            if absolute_cja_cmd is None:
+                # If cja is not in PATH, use the current Python executable to run it as a module
+                cja_cmd = [sys.executable, "-m", "cja"]
+            elif os.getenv("VIRTUAL_ENV") is not None:
+                # The venv might not be active when the user runs ninja (e.g. the IDE runs it)
+                cja_cmd = [absolute_cja_cmd]
+            if platform.system() == "Windows":
+                cja_cmd[0] = to_posix_path(cja_cmd[0])
+            reconfigure_cmd_parts = cja_cmd + ["--regenerate-during-build"]
             if builddir != "build":
                 reconfigure_cmd_parts += ["-B", "$builddir"]
             for var_name in sorted(ctx.cli_variables):
@@ -3583,9 +3666,24 @@ def generate_ninja(
         n.newline()
 
         # Archive rule for static libraries
+        # We must delete the old archive before creating a new one because
+        # ar rcs only adds/replaces members but never removes them.
+        if platform.system() == "Windows":
+            # On Windows, shell metacharacters (&, |, <, >, ^) cause ninja to
+            # wrap the command with cmd.exe, which corrupts pipe handles
+            # ("ReadFile: The handle is invalid"). Use a Python one-liner to
+            # avoid all shell metacharacters so ninja uses CreateProcess directly.
+            ar_command = (
+                'python -c "import os,subprocess,sys;'
+                "o=sys.argv[1];os.path.exists(o) and os.remove(o);"
+                'sys.exit(subprocess.call(sys.argv[2:]))"'
+                " $out $ar rcs $out $in"
+            )
+        else:
+            ar_command = "rm -f $out && $ar rcs $out $in"
         n.rule(
             "ar",
-            command="$ar rcs $out $in",
+            command=ar_command,
             description="\x1b[32;1mArchiving $out\x1b[0m",
             # TODO: CMake shows "Linking C static library" or "Linking C++ static library" instead.
             # "static" is redundant info here, but we should also distinguish C vs C++.
@@ -3660,6 +3758,19 @@ def generate_ninja(
         )
         n.newline()
 
+        shell_operators = (
+            ">",
+            ">>",
+            "2>",
+            "2>&1",
+            "<",
+            "|",
+            "&",
+            "&&",
+            "||",
+            ";",
+        )
+
         # Generate custom commands
         for custom_cmd in ctx.custom_commands:
             outputs = []
@@ -3673,18 +3784,6 @@ def generate_ninja(
 
             # Process multiple commands
             cmd_parts: list[str] = []
-            shell_operators = (
-                ">",
-                ">>",
-                "2>",
-                "2>&1",
-                "<",
-                "|",
-                "&",
-                "&&",
-                "||",
-                ";",
-            )
             for command in custom_cmd.commands:
                 if custom_cmd.verbatim:
                     parts = []
@@ -3728,6 +3827,52 @@ def generate_ninja(
                 register_output(out, custom_cmd.defined_file, custom_cmd.defined_line)
             n.newline()
 
+        # Generate custom targets (phony targets)
+        custom_target_all: list[str] = []
+        for ct in ctx.custom_targets:
+            ct_depends = [
+                f"$builddir/{d}"
+                if d in custom_command_outputs and not Path(d).is_absolute()
+                else d
+                for d in ct.depends
+            ]
+
+            if ct.commands:
+                # Custom target with commands: use custom_command rule
+                ct_cmd_parts: list[str] = []
+                for command in ct.commands:
+                    if ct.verbatim:
+                        parts = []
+                        for arg in command:
+                            if arg in shell_operators:
+                                parts.append(str(arg))
+                            else:
+                                parts.append(shlex.quote(str(arg)))
+                        ct_cmd_parts.append(" ".join(parts))
+                    else:
+                        ct_cmd_parts.append(" ".join(str(c) for c in command))
+
+                ct_cmd_str = " && ".join(ct_cmd_parts)
+                if ct.working_directory:
+                    ct_cmd_str = f"cd {ct.working_directory} && {ct_cmd_str}"
+
+                # Use a stamp file so ninja can track when the target last ran
+                stamp = f"$builddir/{ct.name}.stamp"
+                n.build(
+                    [stamp],
+                    "custom_command",
+                    ct_depends,
+                    variables={"cmd": f"{ct_cmd_str} && touch {stamp}"},
+                )
+                n.build([ct.name], "phony", [stamp])
+            else:
+                # No commands: purely a phony dependency aggregator
+                n.build([ct.name], "phony", ct_depends)
+
+            if ct.all:
+                custom_target_all.append(ct.name)
+            n.newline()
+
         # Helper to expand link libraries recursively
         def expand_link_libraries(
             initial: list[str], follow_private_of_static: bool
@@ -4008,6 +4153,7 @@ def generate_ninja(
 
         # Collect default targets (libraries that produce real output files)
         default_targets: list[str] = list(lib_outputs.values())
+        default_targets.extend(custom_target_all)
 
         # Generate build statements for executables