DOCSEARCHbyAlgolia
Submit Docs

Pants Build System

repository·main·Indexed 11 days ago

https://github.com/pantsbuild/pants

A scalable build system optimized for monorepos, providing a unified interface for managing multiple languages and tools. It features fine-grained invalidation, shared result caching, and support for concurrent and remote execution. The system is extensible via a plugin API and includes a native Rust-based engine for high-performance execution.

Tokens
287.6K
Snippets
954
Records
1.7K
Agent score
87%

What's inside Pants

  1. What is the Pants Build System

    main

    Pants is a scalable build system designed specifically for monorepos—large codebases that contain multiple projects, often utilizing different programming languages and frameworks within a single unified repository.

    Key capabilities include:

    • Explicit dependency modeling: Clearly defining how different parts of the codebase relate to one another.
    • Fine-grained invalidation: Only re-running tasks when the specific inputs they depend on have changed.
    • Shared result caching: Reusing previous build outputs to speed up execution.
    • Concurrent and Remote execution: Running tasks in parallel or offloading them to remote workers.
    • Unified interface: A single way to interact with various tools and languages.
    • Extensibility: A plugin API that allows for custom build logic and tool integration.

  2. Overview of TypeScript Test Resource Project Structures

    main

    The test_resources directory contains various TypeScript project structures used for backend integration testing. These structures are categorized by their complexity and package manager compatibility:

    1. basic_project/: A simple single-package project compatible with npm, pnpm, and yarn. It includes React/TSX support and is used for testing core TypeScript compilation and named targets.
    2. complex_project/: A multi-package workspace with scoped dependencies and TypeScript project references. It is compatible with npm and yarn and is used to test workspace dependency resolution.
    3. pnpm_link/: A project specifically designed for pnpm to test the link: protocol and hoisted node linking for local dependencies.

  3. What is Pants and what does it do?

    main

    Pants is a fast, scalable, and user-friendly build and developer workflow system designed for codebases of all sizes. It orchestrates and runs standard underlying tools—such as compilers, code generators, dependency resolvers, test runners, linters, formatters, and packagers—into a single stable, hermetic toolchain.

    Key capabilities include:

    • Workflow Speedup: Uses caching and concurrency to accelerate development.
    • Low Overhead: Designed to be easy to adopt without requiring massive amounts of build metadata or codebase refactoring. You can invoke Pants directly on source files and directories.
    • Unified Interface: Provides a consistent way to interact with various tools and languages.

  4. Key changes in Pants 1.5.0 stable release

    main

    The 1.5.0 stable release introduced several significant architectural changes and feature updates compared to the 1.4.x branch:

    • Engine Changes: The V1 engine has been removed.
    • Thrift Support: A new Thrift binary tool subsystem was introduced.
    • JavaScript Linting: The JavaScript Style Checker was redesigned to use ESLint directly.
    • Python Pipeline: The old Python pipeline was removed.
    • Build Configuration: workdir-max-build-entries is now enabled by default.

  5. New features in Pants 2.9.x

    main

    The 2.9.x release series introduced several significant features across different backends:

    JVM

    • JVM Resources support: Added support for JVM resources.
    • Scalatest support: Added support for running Scalatest.
    • JUnit support for Scala: Ability to run JUnit tests written in Scala.
    • Protobuf codegen: Added protobuf codegen support via scalapb for Scala.
    • Global scalac plugins: Support for global scalac plugins.
    • JVM Artifacts: Added a jar field to jvm_artifact.

    Docker

    • Docker build target stage: Support for specifying build stages in Docker targets.
    • Docker run arguments: Added the --docker-run-args option to support docker run [args] <image>.
    • Docker secrets: Added a new secrets field to docker_image.
    • Docker context troubleshooting: Added a troubleshooter for Docker contexts.

    Scala

    • Scalafmt support: Added scalafmt support for the fmt and lint goals.

  6. Understand the Google APIs proto dump

    main
    This directory contains a selective dump of .proto files sourced from the official googleapis/googleapis repository (specifically from git sha e17dbfb19652240490cae8adeb89991d13cf9df7). It is not a complete mirror of the Google APIs repository, but rather a curated subset of the protocol buffer definitions required by the Pants build system.

  7. Javascript and NodeJS support in Pants

    main

    Pants provides support for the Javascript and NodeJS ecosystem by wrapping existing package managers with a thin caching layer. This allows you to integrate Javascript workflows into the unified Pants interface.

    Supported Package Managers:

    • npm
    • pnpm
    • yarn

    Key Features:

    • Caching: Caches results of test scripts and build scripts, making them available as resources or package artifacts.
    • Unified Interface: Use standard Pants commands like pants fmt, lint, check, test, and package across your entire repository.
    • Remote Capabilities: Supports remote execution and remote caching.
    • Introspection: Enables advanced project introspection, such as identifying all code that transitively depends on a specific package.

    :::caution Javascript support is beta stage Pants's Javascript support is currently in the beta stage. While most core functionality is implemented, some edge cases may not yet be handled. :::

  9. Key features and changes in Pants 1.3.0

    main

    The 1.3.0 stable release introduced several major architectural and functional improvements:

    • Python Backend Overhaul: Modernized to support caching and reduced latency for re-running tests after code edits.
    • Native Rust Engine: Introduced a native-code engine implemented in Rust to unlock significant performance improvements.
    • Pants Daemon: A daemon for caching BUILD file parsing and file fingerprinting (available for alpha testing via pants.daemon.ini).
    • Implicit Sources: A default set of implicit_sources can be manually enabled to reduce BUILD file boilerplate.
    • New Goals:
      • lint: A new goal for style-related tasks (moved from compile).
      • fmt: A new goal supporting scalafmt, gofmt, and Python isort.
    • Scala Improvements: Zinc incremental Scala compiler updated to 1.0.0 with improved incremental behavior.
    • Node.js Support: Added support for yarnpkg in the node contrib module.
    • JVM/Scala Support:
      • Direct support for scalatest tests in the JVM test runner.
      • Support for relative jar declarations to allow committing jars in the repository.
    • Other: Added a contrib module for errorprone.

  12. New features in Pants 1.19.0rc0

    main

    The 1.19.0rc0 release introduced several new capabilities:

    • Scoverage support: Added support for code coverage using scoverage.
    • Scoverage report generator: Includes a generator for scoverage reports.
    • fs_util subcommand: A new subcommand to list known directories.
    • Zinc native-images: A script is available to generate zinc native-images.