dprint/dprint
Dprint
dprint is a multi-language code formatter that applies consistent styling across various programming languages using a pluggable architecture. It functions as a unified project style management tool, a command-line interface for continuous integration style enforcement, and a Language Server Protocol implementation for real-time formatting in editors.
The project is distinguished by a WebAssembly-based plugin system that loads sandboxed formatting logic from URLs or file paths. It further extends its capabilities through a process-based tool integration that wraps external command-line interfaces as plugins, allowing disparate formatting engines to be managed under a single configuration schema.
The tool covers a wide range of capabilities, including incremental formatting to optimize large-scale codebases, hierarchical configuration resolution with inheritance, and recursive formatting for embedded code blocks in Markdown. It provides support for diverse languages such as Rust, Python, Go, JavaScript, TypeScript, and CSS, among others.
The command-line interface includes utilities for CI verification, configuration debugging, and automated tool version management.
Features
- Multi-Language Formatters - Implements a pluggable system that applies consistent formatting rules across multiple programming languages and embedded content.
- Multi-Language Code Formatters - Applies consistent style and layout rules to source code across various programming languages using a single tool.
- WebAssembly Plugins - Utilizes a sandboxed WebAssembly plugin system to load formatting logic from URLs or file paths.
- Style Adherence Checks - Identifies files that deviate from defined style rules without applying changes to the source code.
- CLI Code Formatters - Integrates local command-line tools to style source code using any host-machine formatter.
- Custom Formatter Connectors - Connects external command-line tools or WebAssembly modules to extend formatting support for specialized languages.
- External Process Integrations - Wraps external command-line interfaces as plugins to unify disparate formatting engines under one configuration.
- Language Server Protocol Implementations - Implements the Language Server Protocol to provide real-time formatting and diagnostics within supported editors.
- Custom Formatter Development - Allows the creation of new language formatters using WebAssembly modules or external executable processes.
- WebAssembly Sandboxing - Loads formatting logic as sandboxed WebAssembly modules from URLs or file paths.
- External CLI Formatter Integration - Enables running existing command-line formatting tools as plugins to unify disparate styling engines under one configuration.
- CI Formatting Checks - Includes a check-only mode for CI pipelines to verify that source files adhere to style rules.
- Configuration Cascade Resolutions - Implements logic to resolve final formatting rules by merging settings from hierarchical sources and override layers.
- External Process Plugins - Integrates external formatting logic through plugins and CLI wrappers to expand language support.
- Style Guide Enforcers - Verifies that source code adheres to defined formatting rules within continuous integration workflows.
- Unified Style Management - Defines and shares centralized formatting configurations and plugin settings across multiple projects and environments.
- Markdown Formatting - Provides recursive formatting for markdown documents, including the formatting of embedded code blocks.
- Incremental Formatting - Provides an incremental formatting cache that tracks modification timestamps to process only changed files.
- CLI Wrappers - Acts as a bridge that integrates existing local formatting tools into a unified configuration and execution flow.
- Editor Formatting Integrations - Implements a Language Server Protocol to provide real-time formatting capabilities directly within text editors.
- Formatting Scope - Applies consistent styling to files based on configuration rules for specific paths or staged git files.
- Configuration Inheritance - Supports extending settings from remote or local configuration files to share rules across projects.
- Developer-Intended Break Preservation - Maintains manual newlines in expressions and statements to preserve developer-intended grouping.
- Formatter Integrations - Integrates the Prettier engine as a separate process to support multiple programming languages.
- Incremental Formatting Optimizations - Reduces formatting execution time by tracking changed files and limiting resource usage.
- Language Server Protocols - Implements the Language Server Protocol to provide real-time code formatting and style enforcement for IDEs.
- Linting Workflows - Provides a command-line interface for verifying code style adherence within continuous integration pipelines.
- Remote Plugin Distribution Systems - Supports integrating external WebAssembly modules from URLs, file paths, or npm packages.
- Formatting Exclusion Markers - Supports specialized ignore comments to prevent the formatter from modifying specific blocks of code.
- Plugin-Based Style Rule Extensions - Allows adjusting plugin settings to match project-specific style guides via a flexible configuration system.
- Property Locking - Prevents users from overriding specific plugin properties to enforce a strict style guide.
- Incremental Processing Caches - Uses an incremental processing cache to skip redundant formatting operations on unchanged files.
- Code Formatters - Pluggable and configurable code formatting platform.
- Code Formatting - Pluggable and highly configurable code formatting platform.
- Prettier - Listed in the “Prettier” section of the Awesome Alternatives In Rust awesome list.
