{"id":44028012,"url":"https://github.com/useblocks/bazel-drives-sphinx","last_synced_at":"2026-02-07T18:14:46.559Z","repository":{"id":306519497,"uuid":"1026178217","full_name":"useblocks/bazel-drives-sphinx","owner":"useblocks","description":"Let Bazel be the build system for Sphinx","archived":false,"fork":false,"pushed_at":"2025-10-08T11:29:42.000Z","size":296,"stargazers_count":0,"open_issues_count":1,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-10-08T13:27:50.276Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Starlark","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/useblocks.png","metadata":{"files":{"readme":"README.rst","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-07-25T12:46:50.000Z","updated_at":"2025-08-25T13:25:03.000Z","dependencies_parsed_at":"2025-07-26T07:20:30.956Z","dependency_job_id":"ff192658-ce82-4492-b591-c77faafde18e","html_url":"https://github.com/useblocks/bazel-drives-sphinx","commit_stats":null,"previous_names":["useblocks/bazel-drives-sphinx"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/useblocks/bazel-drives-sphinx","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/useblocks%2Fbazel-drives-sphinx","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/useblocks%2Fbazel-drives-sphinx/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/useblocks%2Fbazel-drives-sphinx/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/useblocks%2Fbazel-drives-sphinx/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/useblocks","download_url":"https://codeload.github.com/useblocks/bazel-drives-sphinx/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/useblocks%2Fbazel-drives-sphinx/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29203509,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-07T17:44:10.191Z","status":"ssl_error","status_checked_at":"2026-02-07T17:44:07.936Z","response_time":63,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-02-07T18:14:45.048Z","updated_at":"2026-02-07T18:14:46.552Z","avatar_url":"https://github.com/useblocks.png","language":"Starlark","funding_links":[],"categories":[],"sub_categories":[],"readme":"Let Bazel drive Sphinx\n======================\n\nThis project demonstrates how to use Bazel to collect reStructuredText (RST) files from various components\nand generate a Sphinx documentation project with multi-project support and cross-project traceability.\n\nThat enables modular requirement tracing with `Sphinx-Needs \u003chttps://sphinx-needs.readthedocs.io\u003e`__ in\nlarge scale build setups in which Bazel decides about the inclusion or exclusion of components to the overall build.\nBazel effectively replaces the build system part of Sphinx.\n\nGoals\n\n- Sphinx is used to generate the documentation from the collected RST files\n- Sphinx-Needs is used and works in the setup with cross-project traceability.\n- Bazel decides which single RSTs or groups of RSTs to build across multiple projects (feature flags become possible).\n- Bazel ``build`` targets are used for isolation (instead of ``run`` targets)\n- Cross-project needs.json passed using Bazel rules, not via remote URLs, so everything can be built by Bazel locally.\n- Cross-project dependencies using needs.json are managed by Bazel. Multi-step integration projects become possible.\n  Need imports are automatically generated as ``.. needimport::`` directives in separate files.\n- Bazel caches cross-project needs.json files.\n- The original Sphinx structure is preserved: project root ``index.rst`` files use ``*/docs/index`` glob patterns \n  to auto-include generated needimport directives from the ``needimports/docs/`` subdirectory.\n  No modifications of user provided ``.. toctree::`` directives.\n- Sphinx will run the build and safely complain if there are missing files or references.\n- The new schema validation feature of Sphinx-Needs is used to ensure that the documentation schema is valid.\n- Auto-generate per-project Bazel goals for the ``html``, ``needs`` and ``schema`` builders.\n- The original file structure of RSTs is kept, so that the docname variable is not affected.\n  This is helpful when needs schema validation is done based on the contained folder structure.\n\nThe solution assumes a safe subset of Sphinx/Sphinx-Needs features are used (to be documented).\nE.g. linking to a headline in a Bazel excluded file will naturally fail or linking to a need that is not included.\nBut these are all expected failures and Sphinx should be called with ``-W`` to fail on any warnings.\n\nTarget Dictionary System\n------------------------\n\nThe system uses a **targets dictionary** in each project's ``BUILD.bazel`` file to define different groups of file targets that can be built independently. Each dictionary maps group names to lists of Bazel labels:\n\n.. code-block:: starlark\n\n   targets = {\n       \"all\": [\n           \"//projects/webapp/api/docs:docs_all\",\n           \"//projects/webapp/auth/docs:docs_all\", \n           \"//projects/webapp/schema_fail/docs:docs_all\",\n       ],\n       \"trace\": [\n           \"//projects/webapp/api/docs:docs_trace\",\n           \"//projects/webapp/auth/docs:docs_trace\",\n           \"//projects/webapp/schema_fail/docs:docs_trace\", \n       ],\n   }\n\n**Automatic Target Generation:**\n\nThe ``generate_sphinx_docs()`` function automatically creates **6 build targets** from each targets dictionary:\n\nFor each group key (e.g., ``\"all\"``, ``\"trace\"``), it generates:\n\n1. ``docs_html_{group}`` - HTML documentation generation\n2. ``docs_needs_{group}`` - needs.json file generation  \n3. ``docs_schema_{group}`` - schema validation only\n\nSo a dictionary with 2 groups creates 6 total targets:\n- ``docs_html_all``, ``docs_html_trace``\n- ``docs_needs_all``, ``docs_needs_trace`` \n- ``docs_schema_all``, ``docs_schema_trace``\n\nThe names ``all`` and ``trace`` are used to distinguish between full documentation builds and trace-only artifacts.\nThis enables fast traceability validation and reports.\nProjects can decide which target keys to introduce in their targets dictionary, ``all`` and ``trace`` are just\nexamples. A project could also be split into multiple components and file groups can be selected independently\nusing ``config_setting``. Just make sure the toctree glob structure supports the exclusion of filers/folders.\n\nBehind the scenes\n-----------------\n\nSphinx itself is a build system. It has some mechanism for the inclusion and exclusion of files, but the logic\nis maintained in the Python file ``conf.py`` which does not integrate well with build systems.\nSphinx also requires all files to be part of the build root, which is not always the case in large projects.\n\nThe idea of this demo is to delegate the dependency management inside a Sphinx project to Bazel.\nThat includes the collection of RST files and other assets from different components,\nwhich are organized in a Bazel workspace or Bazel module.\nThat way documentation and requirements can be selected the same way features are selected for code\ncomponents.\nIn this approach Bazel can also pass on tags to the Sphinx ``sphinx-build`` CLI which can be used for\nvariant management or other dynamic behavior in Sphinx-Needs.\n\nThe original file/folder structure of the docs sources is kept,\nas authors still want to maintain a documentation structure and also because RST docnames might be examined by Sphinx extensions.\n\n.. figure:: architecture.drawio.png\n   \n   Architecture overview of the Bazel-driven Sphinx documentation system for example projects and components.\n\nGetting Started\n---------------\n\nTo get started with this project, ensure you have `Bazelisk \u003chttps://github.com/bazelbuild/bazelisk\u003e`__ installed.\nIt will get the correct version of Bazel. It also install a symlink ``bazel`` to the ``bazelisk`` binary which\ncan be used as a drop-in replacement for ``bazel``.\n\nYou can then build the documentation by running the appropriate Bazel commands.\n\nProject Structure\n-----------------\n\nThe project is organized to demonstrate modular documentation management with Bazel across multiple projects::\n\n  bazel-drives-sphinx/\n  ├── MODULE.bazel                    # Bazel module configuration\n  ├── BUILD.bazel                     # Root build file (includes git_infos target)\n  ├── README.rst                      # This file\n  ├── cfg_bazel/                      # Bazel config\n  │   ├── BUILD.bazel                 # Make it a package\n  │   └── config.bzl                  # Bazel rules for Sphinx target generation\n  ├── projects/                       # Multi-project structure\n  │   ├── acdc/                       # ACDC project (AC/DC components)\n  │   │   ├── BUILD.bazel             # Project build configuration (targets dictionary)\n  │   │   ├── conf.py                 # Sphinx configuration\n  │   │   ├── index.rst               # Project root with */docs/index glob pattern\n  │   │   ├── schemas.json            # Project-specific schema definitions\n  │   │   ├── ubproject.toml          # Sphinx-Needs project configuration (+CodeLinks config)\n  │   │   ├── ac/                     # AC component\n  │   │   │   ├── BUILD.bazel         # Component build with CodeLinks rules\n  │   │   │   ├── codelinks.toml      # CodeLinks component configuration\n  │   │   │   ├── src/                # Source code with need ID markers\n  │   │   │   │   └── ac.c            # C source file with @need-ids: markers\n  │   │   │   └── docs/               # AC documentation\n  │   │   │       ├── BUILD.bazel     # Component docs filegroups\n  │   │   │       ├── index.rst       # Component entry point\n  │   │   │       └── lots_of_ac.rst\n  │   │   └── dc/                     # DC component\n  │   │       └── docs/               # DC documentation\n  │   │           ├── BUILD.bazel     # Component docs filegroups\n  │   │           ├── index.rst       # Component entry point\n  │   │           └── lots_of_dc.rst\n  │   ├── webapp/                     # Web application project\n  │   │   ├── BUILD.bazel             # Project build configuration (targets dictionary)\n  │   │   ├── conf.py                 # Sphinx configuration\n  │   │   ├── index.rst               # Project root with */docs/index glob pattern\n  │   │   ├── schemas.json            # Project-specific schema definitions\n  │   │   ├── ubproject.toml          # Sphinx-Needs project configuration\n  │   │   ├── api/                    # API component\n  │   │   │   └── docs/               # API documentation\n  │   │   │       ├── BUILD.bazel     # Component docs filegroups\n  │   │   │       ├── index.rst       # Component entry point\n  │   │   │       ├── responses.rst\n  │   │   │       └── endpoints/\n  │   │   │           └── index.rst\n  │   │   ├── auth/                   # Authentication component\n  │   │   │   └── docs/               # Auth documentation\n  │   │   │       ├── BUILD.bazel     # Component docs filegroups\n  │   │   │       ├── index.rst       # Component entry point\n  │   │   │       ├── intro.rst\n  │   │   │       └── trace/          # Traceability artifacts\n  │   │   │           ├── authentication.rst\n  │   │   │           └── authorization.rst\n  │   │   └── schema_fail/            # Example with validation errors\n  │   │       └── docs/\n  │   │           ├── BUILD.bazel\n  │   │           └── index.rst       # Component entry point\n  │   └── integration/                # Integration project\n  │       ├── BUILD.bazel             # Cross-project integration (targets dictionary)\n  │       ├── conf.py                 # Sphinx configuration\n  │       ├── index.rst               # Project root with */docs/index glob pattern\n  │       ├── schemas.json            # Integration schema definitions\n  │       ├── ubproject.toml          # Sphinx-Needs project configuration\n  │       └── overall/                # Overall integration component\n  │           └── docs/\n  │               ├── BUILD.bazel\n  │               ├── index.rst       # Component entry point\n  │               ├── int_reqs_fail.rst\n  │               ├── int_reqs.rst\n  │               └── analytics/\n  │                   └── index.rst\n  └── tools/                          # Build tooling\n      └── sphinx/                     # Sphinx build configuration\n          ├── BUILD.bazel             # Sphinx build binary and requirements\n          ├── requirements.in         # Python dependencies specification\n          ├── requirements.txt        # Locked Python dependencies\n          ├── dynamic_needimports/    # Needimport directive generation\n          │   ├── BUILD.bazel         # Generator targets\n          │   ├── generate.bzl        # Bazel rule for needimport generation\n          │   └── generator.py        # Python script for needimport assembly\n          ├── codelinks/              # CodeLinks integration rules\n          │   ├── analyse.bzl         # Bazel rule for codelinks_analyse\n          │   └── needextend.bzl      # Bazel rule for codelinks_needextend\n          └── dynamic_project/        # Dynamic Sphinx project generation (currently unused)\n              ├── BUILD.bazel         # Generator targets\n              ├── generate.bzl        # Custom Bazel rule for project generation\n              ├── generator.py        # Python script for project assembly\n              └── index.rst.template  # Index template with toctree and needimport placeholders\n\n**Key Components:**\n\n- **Targets Dictionary System**: Each project's ``BUILD.bazel`` file defines a ``targets`` dictionary that maps \n  target group names (like ``\"all\"`` and ``\"trace\"``) to lists of file group labels. This dictionary is passed \n  to the ``generate_sphinx_docs()`` function which automatically creates 6 build targets for each group:\n  \n  * ``docs_html_{group}`` - HTML documentation generation\n  * ``docs_needs_{group}`` - needs.json file generation  \n  * ``docs_schema_{group}`` - schema validation only\n\n  Example targets dictionary::\n\n    targets = {\n        \"all\": [\n            \"//projects/webapp/api/docs:docs_all\",\n            \"//projects/webapp/auth/docs:docs_all\",\n        ],\n        \"trace\": [\n            \"//projects/webapp/api/docs:docs_trace\", \n            \"//projects/webapp/auth/docs:docs_trace\",\n        ],\n    }\n\n  This generates 6 targets: ``docs_html_all``, ``docs_needs_all``, ``docs_schema_all``, \n  ``docs_html_trace``, ``docs_needs_trace``, ``docs_schema_trace``.\n\n- **Preserved Sphinx Structure**: Project root ``index.rst`` files use ``.. toctree::`` with ``:glob:`` and \n  ``*/docs/index`` patterns to automatically include component documentation and generated needimport directives.\n  This preserves the original Sphinx directory structure while allowing Bazel to manage component selection.\n\n- **Auto-Generated Needimports**: Cross-project imports are handled by automatically generating \n  ``.. needimport::`` directives in a ``needimports/docs/`` subdirectory. Each needs.json file gets its own \n  ``.rst`` file with appropriate needimport directives, and these are included via the glob pattern.\n\n- **Multi-Project Architecture**: Each project (``acdc``, ``webapp``, ``integration``) has its own Sphinx configuration,\n  schema definitions, and component structure with the targets dictionary system\n- **Cross-Project Traceability**: The integration project demonstrates importing needs.json files from other projects\n  using the ``needs_json_labels`` attribute in the ``generate_sphinx_docs()`` function call\n- **Build Variants**: Each target group supports multiple build formats (``docs_html``, ``docs_schema``, ``docs_needs``)\n  for different validation and output requirements\n- **Modular Dependencies**: Each component has separate ``docs_all`` and ``docs_trace`` filegroups, allowing\n  selective inclusion of full documentation or trace-only artifacts\n- **Schema Validation**: Project-specific `schemas.json`_ files define validation rules for Sphinx-Needs\n- **CodeLinks Integration**: Automated source code analysis and traceability link generation using\n  `sphinx-codelinks \u003chttps://codelinks.useblocks.com/\u003e`__\n  with need ID reference markers in source code and automatic needextend directive generation\n\n**CodeLinks Source Code Traceability:**\n\nThe system integrates `sphinx-codelinks \u003chttps://github.com/useblocks/sphinx-codelinks\u003e`__ for automated source code analysis and traceability:\n\n1. **Source Code Analysis**: Each component can analyze source files for need ID references using ``codelinks_analyse`` targets\n2. **Need ID Markers**: Source code files contain special markers like ``@need-ids: REQ_001, REQ_002`` to reference documentation needs\n3. **Automatic Needextend Generation**: The ``codelinks_needextend`` rule automatically generates ``.. needextend::`` directives \n   from analyzed source code markers\n4. **Cross-Project Integration**: Generated needextend directives are collected and included in projects via the \n   ``needextends_labels`` attribute in ``generate_sphinx_docs()``\n\n**CodeLinks Configuration:**\n\nEach component that participates in source code traceability requires two configuration files:\n\n1. **Component CodeLinks Config** (``codelinks.toml``):\n\n   .. code-block:: toml\n\n      [codelinks.projects.code.analyse]\n      get_need_id_refs = true\n      get_oneline_needs = false\n      get_rst = false\n\n      [codelinks.projects.code.source_discover]\n      src_dir = \"./src\"\n      gitignore = true\n\n      [codelinks.projects.code.analyse.need_id_refs]\n      markers = [\"@need-ids:\"]\n\n   The project name ``code`` can be adjusted per component. If there is just one project,\n   the name does not matter.\n   sphinx-codelinks will pick up all configured projects in case it is not constrained using ``--project`` on the CLI.\n\n2. **Project Sphinx-Needs Config** (``ubproject.toml``):\n\n   .. code-block:: toml\n\n      [needs.string_links.codelinks]\n      regex = \"^(?P\u003cprefix\u003e[^/]+//[^/]+/[^/]+/[^/]+/[^/]+/[^/]+/)(?P\u003cremains\u003e.*)?\"\n      link_url = \"{{ prefix }}{{ remains }}\"\n      link_name = \"{{ remains }}\"\n      options = [\"src_trace\"]\n\n      [[needs.extra_options]]\n      name = \"src_trace\"\n      description = \"CodeLinks marker for remote URL\"\n      schema.type = \"string\"\n\n   This ensures short source code references on requirements with a full reference to the remote Github source file\n   and line.\n\n**CodeLinks Bazel Integration:**\n\nComponents integrate CodeLinks through Bazel rules in their ``BUILD.bazel`` files:\n\n.. code-block:: starlark\n\n   load(\"//tools/sphinx/codelinks:analyse.bzl\", \"codelinks_analyse\")\n   load(\"//tools/sphinx/codelinks:needextend.bzl\", \"codelinks_needextend\")\n\n   filegroup(\n       name = \"sources\",\n       srcs = [\"src/component.c\"],\n   )\n\n   codelinks_analyse(\n       name = \"codelinks_analyse\",\n       config = \":codelinks.toml\",\n       srcs = [\":sources\", \"//:git_infos\"],\n       visibility = [\"//visibility:public\"],\n   )\n\n   codelinks_needextend(\n       name = \"codelinks_needextend\", \n       json_markers = \":codelinks_analyse\",\n       visibility = [\"//visibility:public\"],\n   )\n\nThe ``//:git_infos`` target provides Git repository metadata to CodeLinks for generating accurate source code links.\nIt contains information about the current Git repository state (commit hash, remote URL, etc.) that enables\nCodeLinks to generate proper URLs pointing to the exact source code location in the remote repository.\n\n**Git Repository Information:**\n\nThe ``//:git_infos`` target is defined in the root ``BUILD.bazel`` file and extracts Git metadata needed for\ngenerating accurate source code URLs in the CodeLinks integration. This target provides:\n\n- Current Git commit hash\n- Remote repository URL (e.g., GitHub repository)\n- Branch information\n- Repository state metadata\n\nThis information allows CodeLinks to generate URLs that point to the exact line and commit of source code\nin the remote repository, ensuring that traceability links remain accurate even as the codebase evolves.\n\n**Usage of codelinks_needextend in projects**\n\nProjects reference these needextend targets in their documentation configuration:\n\n.. code-block:: starlark\n\n   generate_sphinx_docs(\n       name = \"project_docs\",\n       targets = targets,\n       needextends_labels = [\n           \"//projects/webapp/auth:codelinks_needextend\",\n           \"//projects/webapp/api:codelinks_needextend\",\n       ],\n   )\n\n**Needs.json Integration:**\n\nThe system supports cross-project need imports through an automated needimport generation mechanism:\n\n1. **Generation**: Each project can generate a ``needs.json`` file using target group suffixes (e.g., ``//projects/webapp:docs_needs_all``)\n2. **Auto-Import Generation**: The ``generate_sphinx_docs()`` function automatically creates a ``needimports/docs/`` \n   subdirectory containing separate ``.rst`` files for each imported needs.json file with appropriate \n   ``.. needimport::`` directives\n3. **Glob Integration**: Project root ``index.rst`` files use ``.. toctree::`` with ``:glob: */docs/index`` \n   patterns to automatically include both component documentation and the generated needimport directives\n4. **Cross-Project References**: Projects can specify ``needs_json_labels`` in their ``generate_sphinx_docs()`` \n   call to import needs.json files from other projects\n\nExample integration project configuration::\n\n    generate_sphinx_docs(\n        name = \"integration_docs\", \n        targets = targets,\n        needs_json_labels = [\n            \"//projects/webapp:docs_needs_all\",\n            \"//projects/acdc:docs_needs_all\", \n        ],\n        needextends_labels = [\n            \"//projects/integration/overall:codelinks_needextend\",\n        ],\n    )\n\nThis enables integration projects like `projects/integration/BUILD.bazel`_ to import and display needs from multiple source projects,\ncreating comprehensive traceability matrices and cross-project validation without manual needimport directive management.\n\nThis structure enables selective documentation builds where Bazel determines which components to include, while Sphinx handles the actual documentation generation with full markup, validation and cross-referencing capabilities across multiple projects.\n\n**Source Code Traceability Workflow:**\n\n1. **Source Code Markers**: Developers add need ID reference markers in source code:\n\n   .. code-block:: c\n\n      // @need-ids: REQ_AUTH_001, REQ_AUTH_002\n      int authenticate_user(const char* username, const char* password) {\n          // Implementation\n      }\n\n2. **Analysis**: Bazel runs CodeLinks analysis on source files to extract need references as JSON\n3. **Needextend Generation**: Automatic generation of ``.. needextend::`` directives linking source code to documentation needs\n4. **Integration**: Generated needextend directives are included in project documentation via ``needextends_labels``\n5. **Validation**: Sphinx-Needs validates that all referenced need IDs exist and creates traceability links\n\nBuilding Documentation\n----------------------\n\n**Single Project Builds:**\n\nBuild the ACDC project documentation (all components)::\n\n  bazel build //projects/acdc:docs_html_all\n\nBuild the webapp project documentation (all components)::\n\n  bazel build //projects/webapp:docs_html_all\n\nBuild the integration project (with cross-project imports)::\n\n  bazel build //projects/integration:docs_html_all\n\nBuild with trace-only artifacts for faster validation::\n\n  bazel build //projects/webapp:docs_html_trace\n\nSee schema validation failing for the webapp project:\n\n1. In `projects/webapp/BUILD.bazel`_ uncomment the ``schema_fail`` component.\n2. Run the schema validation command::\n\n     bazel build //projects/webapp:docs_schema_all\n\nObserve how the build fails as validation errors are present.\nSphinx runs with ``-W`` which makes the build fail on each warning.\n\n**Trace-Only Builds:**\n\nBuild only traceability artifacts using the trace target group (faster for validation)::\n\n  bazel build //projects/webapp:docs_html_trace\n  bazel build //projects/acdc:docs_html_trace\n\n**Schema Validation:**\n\nRun fast schema validation without generating HTML using schema targets::\n\n  bazel build //projects/webapp:docs_schema_all\n  bazel build //projects/acdc:docs_schema_all\n  bazel build //projects/webapp:docs_schema_trace\n\n**Needs.json Generation:**\n\nGenerate needs.json files for cross-project import using needs targets::\n\n  bazel build //projects/webapp:docs_needs_all\n  bazel build //projects/acdc:docs_needs_all\n  bazel build //projects/webapp:docs_needs_trace\n\nUpdating dependencies\n---------------------\n\n1. Modify tools/sphinx/requirements.in\n2. Run ``bazel run //tools/sphinx:requirements.update``\n\n.. _cfg_bazel/config.bzl: cfg_bazel/config.bzl\n.. _projects/integration/BUILD.bazel: projects/integration/BUILD.bazel\n.. _projects/webapp/BUILD.bazel: projects/webapp/BUILD.bazel\n.. _schemas.json: projects/webapp/schemas.json\n.. _tools/sphinx/dynamic_needimports/generate.bzl: tools/sphinx/dynamic_needimports/generate.bzl\n.. _tools/sphinx/dynamic_needimports/generator.py: tools/sphinx/dynamic_needimports/generator.py\n.. _tools/sphinx/dynamic_project/generate.bzl: tools/sphinx/dynamic_project/generate.bzl\n.. _tools/sphinx/dynamic_project/generator.py: tools/sphinx/dynamic_project/generator.py\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fuseblocks%2Fbazel-drives-sphinx","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fuseblocks%2Fbazel-drives-sphinx","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fuseblocks%2Fbazel-drives-sphinx/lists"}