buildgen 0.1.1__py3-none-any.whl

buildgen/__init__.py

@@ -0,0 +1,23 @@
+"""buildgen: Build system generator package.
+
+Supports generating Makefiles, CMakeLists.txt, and direct compilation.
+
+For additional components, import from submodules:
+    from buildgen.makefile.variables import Var, SVar, IVar, CVar, AVar
+    from buildgen.makefile.functions import makefile_wildcard, makefile_patsubst
+    from buildgen.cmake.variables import CMakeVar, CMakeCacheVar
+    from buildgen.common.project import TargetConfig, DependencyConfig
+"""
+
+__version__ = "0.1.1"
+
+# Core API - minimal exports for early development flexibility
+from buildgen.common.project import ProjectConfig
+from buildgen.makefile.generator import MakefileGenerator
+from buildgen.cmake.generator import CMakeListsGenerator
+
+__all__ = [
+    "ProjectConfig",
+    "MakefileGenerator",
+    "CMakeListsGenerator",
+]

buildgen/cli.py

@@ -0,0 +1,369 @@
+"""Unified CLI entry point for buildgen."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from buildgen import __version__
+from buildgen.makefile.cli import add_makefile_subparsers
+from buildgen.cmake.cli import add_cmake_subparsers
+from buildgen.common.project import ProjectConfig
+
+
+def cmd_project_generate(args: argparse.Namespace) -> None:
+    """Generate build files from project configuration."""
+    config = ProjectConfig.load(args.config)
+
+    outputs = []
+    if args.makefile or args.all:
+        makefile_path = args.makefile_output or "Makefile"
+        config.generate_makefile(makefile_path)
+        outputs.append(f"Makefile: {makefile_path}")
+
+    if args.cmake or args.all:
+        cmake_path = args.cmake_output or "CMakeLists.txt"
+        config.generate_cmake(cmake_path)
+        outputs.append(f"CMakeLists.txt: {cmake_path}")
+
+    if outputs:
+        print(f"Generated from {args.config}:")
+        for output in outputs:
+            print(f"  {output}")
+    else:
+        print("No output format specified. Use --makefile, --cmake, or --all")
+
+
+BUILD_TYPES = {
+    "executable": "Single executable (src/main.cpp)",
+    "static": "Static library (src/lib.cpp, include/)",
+    "shared": "Shared library with -fPIC",
+    "header-only": "Header-only/interface library",
+    "library-with-tests": "Static library with test executable",
+    "app-with-lib": "Executable linked to internal static library",
+    "full": "Library + app + tests with Threads dependency",
+}
+
+
+def cmd_project_types(args: argparse.Namespace) -> None:
+    """List available project build types."""
+    print("Available build types:\n")
+    for name, description in BUILD_TYPES.items():
+        print(f"  {name:<20} {description}")
+
+
+def cmd_project_init(args: argparse.Namespace) -> None:
+    """Create a sample project configuration file."""
+    from buildgen.common.project import TargetConfig, DependencyConfig
+
+    output = Path(args.output)
+    ext = output.suffix.lower()
+    name = args.name or "myproject"
+    build_type = args.type
+
+    targets: list[TargetConfig] = []
+    dependencies: list[DependencyConfig] = []
+
+    if build_type == "executable":
+        targets = [
+            TargetConfig(
+                name=name,
+                target_type="executable",
+                sources=["src/main.cpp"],
+                install=True,
+            ),
+        ]
+
+    elif build_type == "static":
+        targets = [
+            TargetConfig(
+                name=name,
+                target_type="static",
+                sources=["src/lib.cpp"],
+                include_dirs=["include"],
+                install=True,
+            ),
+        ]
+
+    elif build_type == "shared":
+        targets = [
+            TargetConfig(
+                name=name,
+                target_type="shared",
+                sources=["src/lib.cpp"],
+                include_dirs=["include"],
+                compile_options=["-fPIC"],
+                install=True,
+            ),
+        ]
+
+    elif build_type == "header-only":
+        targets = [
+            TargetConfig(
+                name=name,
+                target_type="interface",
+                sources=[],
+                include_dirs=["include"],
+                install=True,
+            ),
+        ]
+
+    elif build_type == "library-with-tests":
+        targets = [
+            TargetConfig(
+                name=name,
+                target_type="static",
+                sources=["src/lib.cpp"],
+                include_dirs=["include"],
+                install=True,
+            ),
+            TargetConfig(
+                name=f"{name}_tests",
+                target_type="executable",
+                sources=["tests/test_main.cpp"],
+                include_dirs=["include"],
+                link_libraries=[name],
+            ),
+        ]
+
+    elif build_type == "app-with-lib":
+        targets = [
+            TargetConfig(
+                name=f"{name}_lib",
+                target_type="static",
+                sources=["src/lib.cpp"],
+                include_dirs=["include"],
+            ),
+            TargetConfig(
+                name=name,
+                target_type="executable",
+                sources=["src/main.cpp"],
+                link_libraries=[f"{name}_lib"],
+                install=True,
+            ),
+        ]
+
+    elif build_type == "full":
+        dependencies = [
+            DependencyConfig(name="Threads"),
+        ]
+        targets = [
+            TargetConfig(
+                name=f"{name}_lib",
+                target_type="static",
+                sources=["src/lib.cpp"],
+                include_dirs=["include"],
+                install=True,
+            ),
+            TargetConfig(
+                name=name,
+                target_type="executable",
+                sources=["src/main.cpp"],
+                link_libraries=[f"{name}_lib", "Threads::Threads"],
+                install=True,
+            ),
+            TargetConfig(
+                name=f"{name}_tests",
+                target_type="executable",
+                sources=["tests/test_main.cpp"],
+                include_dirs=["include"],
+                link_libraries=[f"{name}_lib"],
+            ),
+        ]
+
+    sample = ProjectConfig(
+        name=name,
+        version="1.0.0",
+        description=f"A {build_type} project",
+        cxx_standard=17,
+        compile_options=["-Wall", "-Wextra"],
+        targets=targets,
+        dependencies=dependencies,
+    )
+
+    if ext in (".yaml", ".yml"):
+        sample.to_yaml(output)
+    else:
+        sample.to_json(output)
+
+    print(f"Created {build_type} project configuration: {output}")
+
+
+def add_project_subparsers(subparsers: argparse._SubParsersAction) -> None:
+    """Add project subcommand parsers."""
+    project_parser = subparsers.add_parser(
+        "project",
+        help="Generate build files from project configuration (JSON/YAML)",
+    )
+
+    project_subparsers = project_parser.add_subparsers(
+        dest="project_command", help="Project commands"
+    )
+
+    # project generate
+    gen_parser = project_subparsers.add_parser(
+        "generate",
+        help="Generate Makefile and/or CMakeLists.txt from config",
+    )
+    gen_parser.add_argument(
+        "-c",
+        "--config",
+        required=True,
+        help="Path to project configuration file (JSON or YAML)",
+    )
+    gen_parser.add_argument(
+        "--makefile",
+        action="store_true",
+        help="Generate Makefile",
+    )
+    gen_parser.add_argument(
+        "--makefile-output",
+        default=None,
+        help="Output path for Makefile (default: Makefile)",
+    )
+    gen_parser.add_argument(
+        "--cmake",
+        action="store_true",
+        help="Generate CMakeLists.txt",
+    )
+    gen_parser.add_argument(
+        "--cmake-output",
+        default=None,
+        help="Output path for CMakeLists.txt (default: CMakeLists.txt)",
+    )
+    gen_parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Generate both Makefile and CMakeLists.txt",
+    )
+    gen_parser.set_defaults(func=cmd_project_generate)
+
+    # project types
+    types_parser = project_subparsers.add_parser(
+        "types",
+        help="List available project build types",
+    )
+    types_parser.set_defaults(func=cmd_project_types)
+
+    # project init
+    init_parser = project_subparsers.add_parser(
+        "init",
+        help="Create a sample project configuration file",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Use 'buildgen project types' to list available build types.",
+    )
+    init_parser.add_argument(
+        "-o",
+        "--output",
+        default="project.json",
+        help="Output path for configuration file (default: project.json)",
+    )
+    init_parser.add_argument(
+        "-n",
+        "--name",
+        help="Project name (default: myproject)",
+    )
+    init_parser.add_argument(
+        "-t",
+        "--type",
+        choices=list(BUILD_TYPES.keys()),
+        default="executable",
+        help="Project type template (default: executable)",
+    )
+    init_parser.set_defaults(func=cmd_project_init)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the main CLI argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="buildgen",
+        description="Build system generator - Makefile, CMake, and more",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate a Makefile
+  %(prog)s makefile generate -o Makefile \\
+    --include-dirs /usr/local/include --ldlibs pthread \\
+    --targets "all:main.o:" --phony all clean
+
+  # Direct compilation (Makefile-style)
+  %(prog)s makefile build myprogram --cppfiles main.cpp utils.cpp \\
+    --include-dirs /usr/local/include --ldlibs pthread
+
+  # Generate CMakeLists.txt
+  %(prog)s cmake generate -o CMakeLists.txt --project myproject \\
+    --cxx-standard 17 --executables "myapp:main.cpp utils.cpp"
+
+  # Build with CMake
+  %(prog)s cmake build -S . -B build --build-type Release
+
+  # Generate from project config (define once, generate both)
+  %(prog)s project init -o project.json
+  %(prog)s project generate -c project.json --all
+
+Note: Escape dollar signs with backslash when passing Makefile/CMake variables via CLI.
+        """,
+    )
+
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Add makefile subcommands
+    add_makefile_subparsers(subparsers)
+
+    # Add cmake subcommands
+    add_cmake_subparsers(subparsers)
+
+    # Add project subcommands
+    add_project_subparsers(subparsers)
+
+    return parser
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Handle makefile subcommands
+    if args.command == "makefile":
+        if not hasattr(args, "makefile_command") or not args.makefile_command:
+            parser.parse_args(["makefile", "--help"])
+        elif hasattr(args, "func"):
+            try:
+                args.func(args)
+            except Exception as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+    # Handle cmake subcommands
+    elif args.command == "cmake":
+        if not hasattr(args, "cmake_command") or not args.cmake_command:
+            parser.parse_args(["cmake", "--help"])
+        elif hasattr(args, "func"):
+            try:
+                args.func(args)
+            except Exception as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+    # Handle project subcommands
+    elif args.command == "project":
+        if not hasattr(args, "project_command") or not args.project_command:
+            parser.parse_args(["project", "--help"])
+        elif hasattr(args, "func"):
+            try:
+                args.func(args)
+            except Exception as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

buildgen/cmake/__init__.py

@@ -0,0 +1,33 @@
+"""CMake generation and building support."""
+
+from buildgen.cmake.variables import (
+    CMakeVar,
+    CMakeCacheVar,
+    CMakeOption,
+    CMakeEnvVar,
+    cmake_var,
+    cmake_env_var,
+    cmake_cache_var,
+    cmake_bool,
+)
+from buildgen.cmake.generator import CMakeListsGenerator, CMakeWriter
+from buildgen.cmake.builder import CMakeBuilder
+from buildgen.cmake.functions import Cm
+
+__all__ = [
+    # Variables
+    "CMakeVar",
+    "CMakeCacheVar",
+    "CMakeOption",
+    "CMakeEnvVar",
+    "cmake_var",
+    "cmake_env_var",
+    "cmake_cache_var",
+    "cmake_bool",
+    # Generator
+    "CMakeListsGenerator",
+    "CMakeWriter",
+    "CMakeBuilder",
+    # Functions
+    "Cm",
+]

buildgen/cmake/builder.py

@@ -0,0 +1,247 @@
+"""CMake builder class for configuring and building with CMake."""
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional, Union
+
+from buildgen.common.utils import UniqueList, PathLike
+from buildgen.common.base import BaseBuilder
+
+
+def cmake_bool(value: bool) -> str:
+    """Convert Python bool to CMake ON/OFF."""
+    return "ON" if value else "OFF"
+
+
+class CMakeBuilder(BaseBuilder):
+    """Configure and build projects using CMake."""
+
+    def __init__(
+        self,
+        source_dir: PathLike = ".",
+        build_dir: PathLike = "build",
+        target: Optional[str] = None,
+        strict: bool = False,
+    ):
+        """Initialize CMakeBuilder.
+
+        Args:
+            source_dir: Directory containing CMakeLists.txt
+            build_dir: Build output directory
+            target: Optional target name (for BaseBuilder compatibility)
+            strict: If True, raise errors on duplicate entries
+        """
+        super().__init__(target or str(build_dir), strict)
+        self.source_dir = Path(source_dir)
+        self.build_dir = Path(build_dir)
+
+        # CMake options
+        self.generator: Optional[str] = None
+        self.cmake_options: dict[str, Union[str, bool, int]] = {}
+        self.cache_scripts: UniqueList = UniqueList()
+        self.build_config: str = "Release"
+        self.parallel_jobs: Optional[int] = None
+        self.build_targets: UniqueList = UniqueList()
+        self.install_prefix: Optional[str] = None
+
+        # Environment
+        self.env_vars: dict[str, str] = {}
+
+    def set_generator(self, generator: str) -> None:
+        """Set CMake generator (e.g., 'Ninja', 'Unix Makefiles')."""
+        self.generator = generator
+
+    def set_option(self, name: str, value: Union[str, bool, int]) -> None:
+        """Set a CMake option (-D)."""
+        self.cmake_options[name] = value
+
+    def set_build_type(self, build_type: str) -> None:
+        """Set CMAKE_BUILD_TYPE (Debug, Release, RelWithDebInfo, MinSizeRel)."""
+        self.cmake_options["CMAKE_BUILD_TYPE"] = build_type
+        self.build_config = build_type
+
+    def set_install_prefix(self, prefix: str) -> None:
+        """Set CMAKE_INSTALL_PREFIX."""
+        self.cmake_options["CMAKE_INSTALL_PREFIX"] = prefix
+        self.install_prefix = prefix
+
+    def add_cache_script(self, script_path: str) -> None:
+        """Add a cache initialization script (-C)."""
+        self.cache_scripts.add(script_path)
+
+    def add_build_target(self, target: str) -> None:
+        """Add a specific target to build."""
+        self.build_targets.add(target)
+
+    def set_parallel_jobs(self, jobs: int) -> None:
+        """Set number of parallel build jobs."""
+        self.parallel_jobs = jobs
+
+    def set_env(self, name: str, value: str) -> None:
+        """Set environment variable for CMake commands."""
+        self.env_vars[name] = value
+
+    # BaseBuilder interface implementation
+    def add_include_dirs(self, *entries) -> None:
+        """Add include directories via CMAKE_INCLUDE_PATH."""
+        current = self.cmake_options.get("CMAKE_INCLUDE_PATH", "")
+        new_dirs = ";".join(entries)
+        if current:
+            self.cmake_options["CMAKE_INCLUDE_PATH"] = f"{current};{new_dirs}"
+        else:
+            self.cmake_options["CMAKE_INCLUDE_PATH"] = new_dirs
+
+    def add_link_dirs(self, *entries) -> None:
+        """Add link directories via CMAKE_LIBRARY_PATH."""
+        current = self.cmake_options.get("CMAKE_LIBRARY_PATH", "")
+        new_dirs = ";".join(entries)
+        if current:
+            self.cmake_options["CMAKE_LIBRARY_PATH"] = f"{current};{new_dirs}"
+        else:
+            self.cmake_options["CMAKE_LIBRARY_PATH"] = new_dirs
+
+    def add_cxxflags(self, *entries) -> None:
+        """Add C++ flags via CMAKE_CXX_FLAGS."""
+        current = self.cmake_options.get("CMAKE_CXX_FLAGS", "")
+        new_flags = " ".join(entries)
+        if current:
+            self.cmake_options["CMAKE_CXX_FLAGS"] = f"{current} {new_flags}"
+        else:
+            self.cmake_options["CMAKE_CXX_FLAGS"] = new_flags
+
+    def add_cflags(self, *entries) -> None:
+        """Add C flags via CMAKE_C_FLAGS."""
+        current = self.cmake_options.get("CMAKE_C_FLAGS", "")
+        new_flags = " ".join(entries)
+        if current:
+            self.cmake_options["CMAKE_C_FLAGS"] = f"{current} {new_flags}"
+        else:
+            self.cmake_options["CMAKE_C_FLAGS"] = new_flags
+
+    def add_ldflags(self, *entries) -> None:
+        """Add linker flags via CMAKE_EXE_LINKER_FLAGS."""
+        current = self.cmake_options.get("CMAKE_EXE_LINKER_FLAGS", "")
+        new_flags = " ".join(entries)
+        if current:
+            self.cmake_options["CMAKE_EXE_LINKER_FLAGS"] = f"{current} {new_flags}"
+        else:
+            self.cmake_options["CMAKE_EXE_LINKER_FLAGS"] = new_flags
+
+    def _get_env(self) -> dict:
+        """Get environment for subprocess calls."""
+        env = os.environ.copy()
+        env.update(self.env_vars)
+        return env
+
+    def _format_cmake_value(self, value: Union[str, bool, int]) -> str:
+        """Format a value for CMake command line."""
+        if isinstance(value, bool):
+            return cmake_bool(value)
+        return str(value)
+
+    def get_configure_cmd(self) -> list[str]:
+        """Get the cmake configure command."""
+        cmd = ["cmake"]
+
+        # Source and build directories
+        cmd.extend(["-S", str(self.source_dir), "-B", str(self.build_dir)])
+
+        # Generator
+        if self.generator:
+            cmd.extend(["-G", self.generator])
+
+        # Cache scripts
+        for script in self.cache_scripts:
+            cmd.extend(["-C", script])
+
+        # Options
+        for key, value in self.cmake_options.items():
+            cmd.append(f"-D{key}={self._format_cmake_value(value)}")
+
+        return cmd
+
+    def get_build_cmd(self) -> list[str]:
+        """Get the cmake --build command."""
+        cmd = ["cmake", "--build", str(self.build_dir)]
+
+        # Config (for multi-config generators)
+        cmd.extend(["--config", self.build_config])
+
+        # Parallel jobs
+        if self.parallel_jobs:
+            cmd.extend(["--parallel", str(self.parallel_jobs)])
+
+        # Specific targets
+        for target in self.build_targets:
+            cmd.extend(["--target", target])
+
+        return cmd
+
+    def get_install_cmd(self) -> list[str]:
+        """Get the cmake --install command."""
+        cmd = ["cmake", "--install", str(self.build_dir)]
+
+        if self.install_prefix:
+            cmd.extend(["--prefix", self.install_prefix])
+
+        return cmd
+
+    def configure(self, dry_run: bool = False) -> None:
+        """Run CMake configuration step."""
+        cmd = self.get_configure_cmd()
+        cmd_str = " ".join(cmd)
+
+        if dry_run:
+            print(cmd_str)
+            return
+
+        print(f"Configuring: {cmd_str}")
+        self.build_dir.mkdir(parents=True, exist_ok=True)
+        subprocess.check_call(cmd, env=self._get_env())
+
+    def build(self, dry_run: bool = False) -> None:
+        """Run CMake build step."""
+        cmd = self.get_build_cmd()
+        cmd_str = " ".join(cmd)
+
+        if dry_run:
+            print(cmd_str)
+            return
+
+        print(f"Building: {cmd_str}")
+        subprocess.check_call(cmd, env=self._get_env())
+
+    def install(self, dry_run: bool = False) -> None:
+        """Run CMake install step."""
+        cmd = self.get_install_cmd()
+        cmd_str = " ".join(cmd)
+
+        if dry_run:
+            print(cmd_str)
+            return
+
+        print(f"Installing: {cmd_str}")
+        subprocess.check_call(cmd, env=self._get_env())
+
+    def configure_and_build(self, dry_run: bool = False) -> None:
+        """Run configure followed by build."""
+        self.configure(dry_run=dry_run)
+        if not dry_run:
+            self.build(dry_run=dry_run)
+
+    def full_build(self, dry_run: bool = False) -> None:
+        """Run configure, build, and install."""
+        self.configure(dry_run=dry_run)
+        if not dry_run:
+            self.build(dry_run=dry_run)
+            if self.install_prefix:
+                self.install(dry_run=dry_run)
+
+    def clean(self) -> None:
+        """Clean build directory."""
+        if self.build_dir.exists():
+            import shutil
+
+            shutil.rmtree(self.build_dir)
+            print(f"Removed: {self.build_dir}")