Pruner

https://pruner-formatter.github.io
Admin
Pruner is an extensible, language-agnostic, TreeSitter-powered formatter that handles embedded...
Tokens:11,340
Snippets:113
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Simple TOML Configuration Example for Pruner

Source: https://pruner-formatter.github.io/configuration

A basic TOML configuration file for Pruner, demonstrating how to specify query paths, grammar repositories, formatter commands, and language mappings. This example sets up Pruner to use a local 'queries' directory, download the tree-sitter-markdown grammar from GitHub, and configure Prettier as a formatter for Markdown.

```toml
query_paths = ["queries"]

[grammars]
markdown = "https://github.com/tree-sitter-grammars/tree-sitter-markdown"

[formatters]
prettier = { cmd = "prettier", args = [
  "--print-width=$textwidth",
  "--parser=$language",
] }

[languages]
markdown = ["prettier"]
```

--------------------------------

### Full Pruner Configuration Example (TOML)

Source: https://pruner-formatter.github.io/configuration

This TOML snippet provides a comprehensive example of a Pruner Formatter configuration file. It includes settings for query paths, grammar repositories, custom formatters, Wasm plugins, language-to-formatter mappings, and profile definitions.

```toml
# Search paths for tree-sitter injection queries
#
# This is not required if you don't care about formatting embedded languages
query_paths = ["queries"]

# Here you can define repository URLs containing tree-sitter language grammars. These repos will be cloned down,
# compiled, and loaded when formatting these languages.
#
# This is not required if you don't care about formatting embedded languages
[grammars]
clojure = "https://github.com/sogaiu/tree-sitter-clojure"
markdown = "https://github.com/tree-sitter-grammars/tree-sitter-markdown"
sql = { url = "https://github.com/derekstride/tree-sitter-sql", rev = "gh-pages" }

# Named formatters which can be executed by Pruner. The tools referenced by `cmd` will need to be installed and
# available on your $PATH
[formatters]
prettier = { cmd = "prettier", args = [
  "--prose-wrap=always",
  "--print-width=$textwidth",
  "--parser=$language",
] }

pg_format = { cmd = "pg_format", args = [
  "--spaces=2",
  "--wrap-limit=$textwidth",
  "-",
] }

# Wasm plugins to be loaded by pruner. This should be a URI pointing to a compiled .wasm binary implementing the
# pruner/plugin-api.
[plugins]
trim_newlines = "https://github.com/pruner-formatter/plugin-trim-newlines/releases/download/v0.1.0/plugin.wasm"
plugin_b = { url = "file:///path/to/plugin.wasm" }

# This section contains a mapping of language name -> formatters. When the relevant language is to be formatted, pruner
# will execute the formatters specified here in order.
#
# These can be named [formatters] or [plugins]
[languages]
markdown = ["prettier", "trim_newlines"]
sql = ["pg_format", "trim_newlines", "plugin_b"]

# Profiles are partial config overrides which can be applied selectively at runtime. More on this below.
[profiles]

```

--------------------------------

### Configure Pruner for Markdown and JavaScript Formatting with Prettier

Source: https://pruner-formatter.github.io/quickstart

This TOML configuration file sets up Pruner to use the 'prettier' formatter for Markdown and JavaScript. It specifies the tree-sitter grammar for Markdown and defines how to invoke the 'prettier' binary with specific arguments. This configuration enables Pruner to format both the Markdown structure and the embedded JavaScript code.

```toml
[grammars]
markdown = "https://github.com/tree-sitter-grammars/tree-sitter-markdown"

# Instruct pruner on how to invoke the `prettier` binary
[formatters]
prettier = { cmd = "prettier", args = [
  "--prose-wrap=always",
  "--print-width=$textwidth",
  "--parser=$language",
] }

# Instruct pruner to use the `prettier` formatter for both markdown and javascript
[languages]
markdown = ["prettier"]
javascript = ["prettier"]

```

--------------------------------

### Format Markdown with Embedded JavaScript using Pruner CLI

Source: https://pruner-formatter.github.io/quickstart

This bash script demonstrates how to use Pruner to format a Markdown file containing embedded JavaScript. It pipes the content of 'hello-world.md' to 'pruner format' specifying the language as Markdown, and redirects the output back to 'hello-world.md'. Finally, it prints the formatted content to the console.

```bash
cat hello-world.md | pruner format --lang markdown > hello-world.md
cat hello-world.md
```

--------------------------------

### Format Markdown File with Pruner

Source: https://pruner-formatter.github.io/introduction

This example demonstrates how to use Pruner to format a Markdown file. It pipes the content of 'hello.md' to the 'pruner format' command, specifying the language as 'markdown', and redirects the output to 'hello.md'.

```bash
cat hello.md | pruner format --lang markdown > hello.md
```

--------------------------------

### Install Pruner on macOS using Homebrew

Source: https://pruner-formatter.github.io/installation

Installs the Pruner formatter tool on macOS using the Homebrew package manager. This command adds the necessary repository and installs the pruner package.

```bash
brew install pruner-formatter/tap/pruner
```

--------------------------------

### Rust Snippet with Embedded SQL

Source: https://pruner-formatter.github.io/language-injections/customizing-injections

An example of a Rust function that fetches user data using an embedded SQL query. This snippet serves as a reference for demonstrating Pruner's injection capabilities.

```rust
async fn get_users(pool: &PgPool) -> Result<Vec<User>> {
  let query = "SELECT
                 id,
                 name,
                 email
               FROM
                 users
               WHERE
                 active = TRUE
               ORDER BY
                 created_at DESC";
  let users = sqlx::query_as::<_, User>(query).fetch_all(pool).await?;
  Ok(users)
}
```

--------------------------------

### TOML Configuration for Query Paths in Pruner

Source: https://pruner-formatter.github.io/configuration

Example TOML snippet for configuring `query_paths` in Pruner. This setting specifies an array of filesystem paths where Pruner should look for custom injection queries. These queries are used to define how Pruner identifies and handles embedded languages within documents.

```toml
query_paths = ["queries"]
```

--------------------------------

### TOML Configuration for Grammar Download Directory in Pruner

Source: https://pruner-formatter.github.io/configuration

Example TOML snippet for setting `grammar_download_dir` in Pruner. This option specifies the directory where Pruner clones grammar git repositories. The default location is typically within the user's XDG data home.

```toml
grammar_download_dir = "./.pruner/grammars"
```

--------------------------------

### TOML Configuration for Grammar Paths in Pruner

Source: https://pruner-formatter.github.io/configuration

Example TOML snippet for configuring `grammar_paths` in Pruner. This setting defines an array of filesystem paths that contain compiled Tree-sitter grammars. Pruner uses these grammars to parse documents and identify language regions.

```toml
grammar_paths = ["grammars"]
```

--------------------------------

### TOML Configuration for Grammars in Pruner

Source: https://pruner-formatter.github.io/configuration

Example TOML snippet for configuring the `[grammars]` section in Pruner. This section maps language names to their respective Tree-sitter grammar specifications, which can be a URL or a table with a URL and an optional revision. Pruner uses these grammars for parsing and identifying embedded languages.

```toml
[grammars]
rust = "https://github.com/tree-sitter/tree-sitter-rust"
sql = { url = "https://github.com/derekstride/tree-sitter-sql", rev = "gh-pages" }
```

--------------------------------

### Basic Clojure Formatting with cljfmt

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Configures Pruner to use the cljfmt formatter for basic Clojure code formatting. This setup enables automatic fixing of common formatting issues and removal of excessive spaces.

```toml
[formatters]
cljfmt = { cmd = "cljfmt", args = [
  "fix",
  "-",
  "-q",
  "--remove-multiple-non-indenting-spaces",
] }

[languages]
clojure = ["cljfmt"]

```

--------------------------------

### TOML Configuration for Grammar Build Directory in Pruner

Source: https://pruner-formatter.github.io/configuration

Example TOML snippet for setting `grammar_build_dir` in Pruner. This option defines the directory where compiled parser artifacts from grammars are stored. The default location is usually within the user's XDG data home.

```toml
grammar_build_dir = "./.pruner/build"
```

--------------------------------

### Offset Capture Node Range with #offset! Directive

Source: https://pruner-formatter.github.io/language-injections/query-directives

The #offset! directive, inspired by Neovim, allows for adjusting the start and end rows/columns of a captured node's range. It takes the capture ID and the desired row/column offsets as parameters.

```tree-sitter query
(#offset! @injection.content 0 1 0 -1)
```

--------------------------------

### Define SQL Injection Query for Clojure Strings

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This Treesitter injection query identifies SQL code embedded within Clojure strings. It matches strings starting with common SQL keywords and sets the injection language to 'sql' for formatting.

```scm
;; queries/clojure/injections.scm

((str_lit) @injection.content
  (#match? @injection.content "^\"(SET|TRUNCATE|SELECT|CREATE|DELETE|ALTER|UPDATE|DROP|INSERT|WITH)")
  (#offset! @injection.content 0 1 0 -1)
  (#escape! @injection.content "\"")
  (#set! injection.language "sql"))
```

--------------------------------

### Configure Conform with Multiple Pruner Profiles

Source: https://pruner-formatter.github.io/guides/neovim-integration

Demonstrates how to set up conform.nvim to use multiple Pruner formatter instances, each potentially with a different profile. This allows for fine-grained control over formatting based on filetype or specific needs, such as using a 'trim' profile for Rust code.

```lua
...

require("conform").setup({
  formatters_by_ft = {
    markdown = { "pruner" },
    -- Use the LSP server for formatting, but run some other pruner profile afterwards
    rust = { lsp_format = "first", "pruner_trim" },
  },

  formatters = {
    pruner = pruner(),
    pruner_trim = pruner({ profile = "trim" }),
  },
})

```

--------------------------------

### Define Language Formatters with Profiles (TOML)

Source: https://pruner-formatter.github.io/configuration

This TOML snippet demonstrates how to define language-specific formatters and apply them using profiles. Profiles allow for partial configuration overlays that can be conditionally applied during runtime. Later profiles override earlier ones in case of conflicts.

```toml
# Basic language formatter configuration
[languages]
markdown = ["prettier", "trim_newlines"]

# Profile to override markdown formatters
[profiles.trim]
languages.markdown = ["trim_newlines"]

```

--------------------------------

### Complete Pruner Configuration (TOML)

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This TOML configuration file outlines all available settings for the Pruner formatter. It specifies query paths, grammars for different languages, formatter commands and arguments, plugin Wasm files, and language-specific formatter and plugin assignments.

```toml
query_paths = ["queries"]

[grammars]
clojure = "https://github.com/sogaiu/tree-sitter-clojure"
markdown = "https://github.com/tree-sitter-grammars/tree-sitter-markdown"

[formatters]
cljfmt = { cmd = "cljfmt", args = [
  "fix",
  "-",
  "-q",
  "--remove-multiple-non-indenting-spaces",
] }

prettier = { cmd = "prettier", args = [
  "--prose-wrap=always",
  "--print-width=$textwidth",
  "--parser=$language",
] }

pg_format = { cmd = "pg_format", args = [
  "--spaces=2",
  "--wrap-limit=$textwidth",
  "-",
] }

[plugins]
trim_newlines = "https://github.com/pruner-formatter/plugin-trim-newlines/releases/download/v0.1.1/plugin.wasm"
align_comments = "https://github.com/pruner-formatter/plugin-clojure-comment-formatter/releases/download/v0.1.0/plugin.wasm"

[languages]
clojure = ["cljfmt", "align_comments", "trim_newlines"]
markdown = ["prettier", "trim_newlines"]
sql = ["pg_format", "trim_newlines"]

```

--------------------------------

### Pruner Configuration for Rust and SQL Formatting

Source: https://pruner-formatter.github.io/language-injections/customizing-injections

A TOML configuration file for Pruner. It sets the query search path, specifies the Rust treesitter grammar URL, defines formatters for Rust and SQL (pg_format), and maps languages to their respective formatters.

```toml
query_paths = ["queries"]

[grammars]
rust = "https://github.com/tree-sitter/tree-sitter-rust"

[formatters]
rustfmt = { cmd = "rustfmt", args = ["--emit=stdout", "--edition=2024"] }

pg_format = { cmd = "pg_format", args = [
  "--spaces=2",
  "--wrap-limit=$textwidth",
  "-"
]
}

[languages]sql = ["pg_format"]
ust = ["rustfmt"]
```

--------------------------------

### Configure Pruner for Embedded SQL Formatting

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This configuration sets up the `pg_format` formatter for SQL and defines a language pipeline for SQL files. It specifies formatter command-line arguments for indentation and wrap limits.

```toml
[formatters]
pg_format = { cmd = "pg_format", args = [
  "--spaces=2",
  "--wrap-limit=$textwidth",
  "-"
] }

[languages]sql = ["pg_format"]
```

--------------------------------

### Configure Rust Language Pipeline

Source: https://pruner-formatter.github.io/configuration

Defines the formatting pipeline for 'rust' files. It uses 'rustfmt' but specifically avoids running it in injected code regions.

```toml
rust = [{ formatter = "rustfmt", run_in_injections = false }]
```

--------------------------------

### Apply Pruner Profile via CLI (Bash)

Source: https://pruner-formatter.github.io/configuration

This bash command shows how to use the Pruner Formatter with a defined profile. It pipes content to `pruner format`, specifying the language and the profile to be applied. This allows for dynamic configuration of the formatting process.

```bash
cat README.md | pruner format --lang markdown --profile trim
```

--------------------------------

### Configure Pruner as a Conform Formatter in Neovim

Source: https://pruner-formatter.github.io/guides/neovim-integration

Sets up Pruner as a formatter for markdown, mdx, and clojure filetypes within conform.nvim. It dynamically passes the buffer's textwidth and filetype as arguments to the Pruner command, allowing for customized formatting based on Neovim's settings.

```lua
require("conform").setup({
  formatters_by_ft = {
    markdown = { "pruner" },
    mdx = { "pruner" },
    clojure = { "pruner" },
  },

  formatters = {
    pruner = {
      command = "pruner",
      args = function(_, ctx) 
        local args = { "format" }

        local textwidth = vim.api.nvim_get_option_value("textwidth", { buf = ctx.buf })
        if textwidth and textwidth > 0 then
          table.insert(args, "--print-width=" .. textwidth)
        end

        local filetype = vim.api.nvim_get_option_value("filetype", { buf = ctx.buf })
        if filetype then
          table.insert(args, "--lang=" .. filetype)
        end

        return args
      end,
    },
  },
})

```

--------------------------------

### Configure Stylua Formatter

Source: https://pruner-formatter.github.io/configuration

Defines a 'stylua' formatter that expects a filename instead of stdin. It uses the 'stylua' executable and passes the temporary file path as an argument.

```toml
# Tools like stylua generally expect a filename.
stylua = { cmd = "stylua", args = ["$file"], stdin = false }
```

--------------------------------

### Set Keybinding to Format Current Buffer with Conform

Source: https://pruner-formatter.github.io/guides/neovim-integration

Defines a keybinding (<localleader>f) in Neovim to trigger the formatting of the current buffer using conform.nvim. This allows for quick and easy code formatting directly from the editor.

```lua
vim.keymap.set("", "<localleader>f", function()
  require("conform").format({ async = true })
end, { desc = "Format current buffer" })

```

--------------------------------

### Neovim Injection Queries for Syntax Highlighting (SCM)

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This SCM (Source Code Map) file defines injection queries for Neovim. It allows specific code blocks within a language (e.g., Markdown in Clojure docstrings, SQL in strings) to be highlighted using their respective grammars.

```scm
;; ~/.config/nvim/queries/clojure/injections.scm
;; Example: Highlight Markdown in docstrings and SQL in strings
[
  [ "docstring" ] @markdown
  [ "string" ] @sql
]

```

--------------------------------

### Configure Prettier Formatter

Source: https://pruner-formatter.github.io/configuration

Defines a 'prettier' formatter that reads from stdin, utilizing region-aware width and language settings. It uses the 'prettier' executable with dynamic arguments for print width and parser.

```toml
[formatters]
# Reads from stdin; uses region-aware width and language.
prettier = { cmd = "prettier", args = [
  "--print-width=$textwidth",
  "--parser=$language",
] }
```

--------------------------------

### Create a Pruner Formatter Factory Function for Conform

Source: https://pruner-formatter.github.io/guides/neovim-integration

A factory function that generates Pruner formatter configurations for conform.nvim. This function allows for dynamic configuration, including the ability to specify a Pruner profile, which is useful for applying different formatting rules based on context.

```lua
local function pruner(config)
  config = config or {}

  return {
    command = "pruner",
    args = function(_, ctx) 
      local args = { "format" }

      local textwidth = vim.api.nvim_get_option_value("textwidth", { buf = ctx.buf })
      if textwidth and textwidth > 0 then
        table.insert(args, "--print-width=" .. textwidth)
      end

      local filetype = vim.api.nvim_get_option_value("filetype", { buf = ctx.buf })
      if filetype then
        table.insert(args, "--lang=" .. filetype)
      end

      if config.profile then
        table.insert(args, "--profile=" .. config.profile)
      end

      return args
    end,
  }
end

```

--------------------------------

### Pruner Configuration for LSP Integration (TOML)

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This TOML snippet demonstrates how to configure Pruner to work with LSP formatters by controlling where formatters are applied. It uses `run_in_root` and `run_in_injections` to specify if a formatter should run on the main document or injected code blocks.

```toml
[languages]
clojure = [
  { formatter = "cljfmt", run_in_root = false, run_in_injections = true },
  "align_comments",
  "trim_newlines",
]

```

--------------------------------

### Configure Markdown Language Pipeline

Source: https://pruner-formatter.github.io/configuration

Defines the formatting pipeline for 'markdown' files. It uses 'prettier' followed by the 'trim_newlines' plugin for formatting.

```toml
[languages]
markdown = ["prettier", "trim_newlines"]
```

--------------------------------

### Run Pruner with Debug Logging (Bash)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Executes the Pruner command to format a Markdown file while enabling debug logging. This command pipes the content of 'README.md' to 'pruner format' and displays detailed logs, useful for verifying plugin loading and execution.

```bash
cat README.md | pruner format --lang markdown --log-level debug

```

--------------------------------

### Compile Rust Plugin for Pruner (Bash)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Compiles a Rust project into a WebAssembly component suitable for Pruner plugins. The command targets 'wasm32-wasip2' for compatibility and builds the project in release mode for optimization.

```bash
cargo build --release --target wasm32-wasip2

```

--------------------------------

### Configure Local WASM Plugin

Source: https://pruner-formatter.github.io/configuration

Registers a local WASM plugin using a file URL. Pruner will compile and cache this plugin from the specified absolute path.

```toml
local_plugin = { url = "file:///absolute/path/to/plugin.wasm" }
```

--------------------------------

### Implement Basic Plugin Structure in Rust (lib.rs)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Provides the initial structure for a Pruner plugin in Rust. It defines a 'Component' struct that implements the 'PluginApi' trait and exports the component using 'pruner_plugin_api::bindings::export!'. The initial 'format' function returns the source unchanged.

```rust
use pruner_plugin_api::{FormatError, FormatOpts, PluginApi};

struct Component;

impl PluginApi for Component {
    fn format(source: Vec<u8>, _opts: FormatOpts) -> Result<Vec<u8>, FormatError> {
        Ok(source)
    }
}

pruner_plugin_api::bindings::export!(Component);

```

--------------------------------

### Configure Pruner with Rust Plugin (pruner.toml)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Configures Pruner to load and use a compiled Rust WASM plugin. It maps a plugin name ('trim_newlines') to its file path and assigns the plugin to a language pipeline (e.g., 'markdown').

```toml
[plugins]
trim_newlines = "file:///path/to/target/wasm32-wasip2/release/trim_newlines.wasm"

[languages]
markdown = ["trim_newlines"]

```

--------------------------------

### Format Embedded SQL in Clojure String (Before)

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Shows a simple SQL query embedded within a Clojure string before any formatting is applied. This illustrates the raw, unformatted state.

```clojure
(def query 
  "SELECT id, name, email FROM users WHERE active = true ORDER BY created_at DESC")
```

--------------------------------

### Formatting Clojure Docstrings as Markdown with Prettier

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Enhances Clojure formatting by enabling Pruner to format docstrings as Markdown using prettier. This requires configuring grammar repositories for Clojure and Markdown, and setting up prettier with specific arguments for prose wrapping and print width.

```toml
[grammars]
clojure = "https://github.com/sogaiu/tree-sitter-clojure"
markdown = "https://github.com/tree-sitter-grammars/tree-sitter-markdown"

[formatters]
cljfmt = { cmd = "cljfmt", args = [
  "fix",
  "-",
  "-q",
  "--remove-multiple-non-indenting-spaces",
] }

prettier = { cmd = "prettier", args = [
  "--prose-wrap=always",
  "--print-width=$textwidth",
  "--parser=$language",
] }

[languages]
clojure = ["cljfmt"]
markdown = ["prettier"]

```

--------------------------------

### Define Pruner Plugin Crate in Rust (Cargo.toml)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Sets up a Rust project to be compiled as a WASM component for Pruner plugins. It specifies the package details, dependencies on 'pruner-plugin-api', and configures the library type as 'cdylib'.

```toml
[package]
name = "trim-newlines"
version = "0.0.1"
edition = "2024"
resolver = "2"

[dependencies]
pruner-plugin-api = "1"

[lib]
crate-type = ["cdylib"]

```

--------------------------------

### Treesitter Injection Query for SQL in Rust

Source: https://pruner-formatter.github.io/language-injections/customizing-injections

A treesitter query file that instructs Pruner to identify and label string content within Rust code as SQL. It uses a regex to match SQL keywords and specifies quote escaping.

```scm
;; queries/rust/injections.scm
((string_content) @injection.content
  ;; Regex match for a string containing text that looks like a SQL query
  (#match? @injection.content "^(SET|TRUNCATE|SELECT|CREATE|DELETE|ALTER|UPDATE|DROP|INSERT|WITH)")
  ;; Inform Pruner that any '"' characters should be escaped.
  (#escape! @injection.content "\"")
  ;; Label this region as SQL
  (#set! injection.language "sql"))
```

--------------------------------

### Configure Remote WASM Plugin

Source: https://pruner-formatter.github.io/configuration

Registers a remote WASM plugin named 'trim_newlines' from a GitHub release URL. Pruner will download and cache this plugin.

```toml
[plugins]
trim_newlines = "https://github.com/pruner-formatter/plugin-trim-newlines/releases/download/v0.1.0/plugin.wasm"
```

--------------------------------

### Format Embedded SQL in Clojure String (After)

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Displays the same SQL query after being formatted using Pruner and the `pg_format` configuration. The SQL is now nicely indented and readable.

```clojure
(def query
  "SELECT
     id,
     name,
     email
   FROM
     users
   WHERE
     active = TRUE
   ORDER BY
     created_at DESC")
```

--------------------------------

### Format Misaligned Clojure Comments

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Demonstrates how comments in Clojure code are misaligned before formatting. This highlights the problem that the `clojure-comment-formatter` plugin aims to solve by aligning comments.

```clojure
(defn create-user [params]
      ;; Validate the user params and insert a new
      ;; record into the database.
  (let [validated (validate params)]
   ;; Also wasn't aligned
    (db/insert! validated)))
```

--------------------------------

### Configure Pruner for Trimming Newlines

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This configuration adds the `trim-newlines` WASM plugin to Pruner. It's included in the `[plugins]` section and added to the Clojure language pipeline to ensure files end with a single newline and have leading/trailing whitespace removed.

```toml
[plugins]
align_comments = "https://github.com/pruner-formatter/plugin-clojure-comment-formatter/releases/download/v0.1.0/plugin.wasm"
trim_newlines = "https://github.com/pruner-formatter/plugin-trim-newlines/releases/download/v0.1.1/plugin.wasm"

[languages]
clojure = ["cljfmt", "align_comments", "trim_newlines"]
```

--------------------------------

### Format Aligned Clojure Comments

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

Shows the same Clojure code after applying the `clojure-comment-formatter` plugin, where the comments are now correctly aligned with the surrounding code's indentation.

```clojure
(defn create-user [params]
  ;; Validate the user params and insert a new
  ;; record into the database.
  (let [validated (validate params)]
    ;; Also wasn't aligned
    (db/insert! validated)))
```

--------------------------------

### Format Clojure Comments with Pruner WASM Plugin

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

This configuration enables the `clojure-comment-formatter` WASM plugin to align `;;` comment blocks with surrounding Clojure code. It's added to the Pruner configuration under `[plugins]` and extended to the Clojure language pipeline.

```toml
[plugins]
align_comments = "https://github.com/pruner-formatter/plugin-clojure-comment-formatter/releases/download/v0.1.0/plugin.wasm"

[languages]
# This will run `cljfmt`, and then `align_comments` on the result
clojure = ["cljfmt", "align_comments"]
```

--------------------------------

### Define Clojure Docstring Injection Queries for Markdown

Source: https://pruner-formatter.github.io/guides/improved-clojure-formatting

These Treesitter injection queries identify Markdown regions within Clojure docstrings for various forms like `def`, `defn`, `ns`, and `defprotocol`. It uses Pruner-specific directives like `#offset!` and `#escape!` to correctly parse the embedded content.

```scm
;; queries/clojure/injections.scm

;; Match def and defprotocol with docstrings
((list_lit
  ((sym_lit) @def-type
   (sym_lit) @def-name
   (str_lit) @injection.content)
   (map_lit)?
   (_)+)

  (#match? @def-type "^(def|defprotocol)$")
  (#offset! @injection.content 0 1 0 -1)
  (#escape! @injection.content "\"")
  (#set! injection.language "markdown"))

;; Match defn, defn-, and defmacro with docstrings
((list_lit
  ((sym_lit) @def-type
   (sym_lit) @def-name
   (str_lit)? @injection.content)
   (map_lit)?

   [
    (vec_lit)
    (list_lit (vec_lit))+
   ])

  (#match? @def-type "^(defn-?|defmacro)$")
  (#offset! @injection.content 0 1 0 -1)
  (#escape! @injection.content "\"")
  (#set! injection.language "markdown"))

;; Match ns with docstrings
((list_lit
  ((sym_lit) @fn-type
   (sym_lit) @ns-name
   (#eq? @fn-type "ns")

   (str_lit)? @injection.content)
   (map_lit)?)

  (_)*

  (#offset! @injection.content 0 1 0 -1)
  (#escape! @injection.content "\"")
  (#set! injection.language "markdown"))

;; Match protocol method docstrings
(list_lit
  ((sym_lit) @fn-name
   (#eq? @fn-name "defprotocol")
   (sym_lit) @protocol-name

   (str_lit)?)

  (list_lit
    (sym_lit)
    (vec_lit)+
    (str_lit) @injection.content)

  (#offset! @injection.content 0 1 0 -1)
  (#escape! @injection.content "\"")
  (#set! injection.language "markdown"))
```

--------------------------------

### Add Functionality to Pruner Plugin in Rust (lib.rs)

Source: https://pruner-formatter.github.io/guides/writing-a-plugin-in-rust

Enhances the Pruner plugin's 'format' function in Rust to strip leading and trailing newline characters and ensure a single trailing newline. This modifies the input byte vector before returning it.

```rust
use pruner_plugin_api::{FormatError, FormatOpts, PluginApi};

struct Component;

impl PluginApi for Component {
    fn format(source: Vec<u8>, _opts: FormatOpts) -> Result<Vec<u8>, FormatError> {
        let mut start = 0;
        let mut end = source.len();

        while start < end && (source[start] == b'\n' || source[start] == b'\r') {
            start += 1;
        }

        while end > start && (source[end - 1] == b'\n' || source[end - 1] == b'\r') {
            end -= 1;
        }

        let mut result = source[start..end].to_vec();
        result.push(b'\n');
        Ok(result)
    }
}

pruner_plugin_api::bindings::export!(Component);

```

--------------------------------

### Escape Characters in Embedded Languages with #escape! Directive

Source: https://pruner-formatter.github.io/language-injections/query-directives

The #escape! directive instructs Pruner to escape specific characters within the content of an embedded language. This is useful when the embedded language's syntax conflicts with the host language's string delimiters, such as escaping double quotes within a Rust string containing SQL.

```tree-sitter query
(#escape! @injection.content "/")
```
Tokens:
Raw