super_slim 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba8d431a17e14eb0624e5f6612d3c1475cd58e70ef5c01dedea459be72523d9a
+  data.tar.gz: 14e1f9dbfdf8525f134e0cf92223a55f3f0cb38990c88c0138c56c8b9cf44477
+SHA512:
+  metadata.gz: a457a4a0e06d98f6d975a7ccabfbc33421e3c98d3f7b2379f292c97f3ad7bea68ff94481a8c33c6b75153cf2df153514b1821cd02c5bfa87091a9ba15b477f67
+  data.tar.gz: bb1a7f2754771c0acf1eef3a9b204df75df8b68490cdcdd3f54c2c159db5cf08ad975da40f52d41661c8f7327df4323541d88434099e35667eca7bacf214118a

data/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+## [Unreleased]
+
+## [2.0.0] — 2026-11-05
+
+SlimX becomes SuperSlim, sheds what a Rails app doesn't need, and `super-slim fmt` wraps long lines.
+
+**Breaking**
+- The gem is renamed: `super_slim` in the Gemfile, the `SuperSlim` module, the `super-slim lint|fmt` command,
+  `.super-slim.yml` and `plugins: [super_slim]` for RuboCop. Compiled templates name their variables
+  `_super_slim1` instead of `_slimx1`.
+- No more Tilt adapter: `require "slimx/tilt"` has no replacement. Rails and `SuperSlim.compile` are unchanged.
+- No more strict mode (`SlimX.strict`, `strict: true`): run `super-slim fmt --check` in CI instead.
+- No more custom shortcuts: only `#id` and `.class`.
+- Only `doctype 5`, `doctype html` and `doctype xml` remain; HTML 4 and XHTML doctypes, such as
+  `doctype transitional`, raise `Invalid doctype`.
+
+**New**
+- `super-slim fmt` wraps lines longer than `fmt: max_line_length` in `.super-slim.yml`, off by default: a tag's
+  attributes one per line inside `fmt: attribute_delimiters` (`"()"`, `"[]"` or `"{}"`), then the arguments of
+  its Ruby code after each comma, four spaces deep when the line opens a block. A wrap is kept only when the
+  compiled Ruby differs by whitespace alone.
+
+## [1.1.0] — 2026-11-04
+
+A RuboCop plugin that lints the Ruby inside templates with SlimX's own parser, and templates compiled up to 10% faster.
+
+**New**
+- A RuboCop plugin (`plugins: [slimx]`) lints the Ruby of templates: `-` and `=` lines, code attributes, splats,
+  `#{}` interpolations and `ruby:` blocks. Offenses point at their line and column in the `.slim` file, and
+  autocorrection writes back into it. It replaces rubocop-slim, and with it slimi and Temple; unlike slimi, it
+  also reads the output of a tag with whitespace markers and attributes (`span> title="x" = name`).
+
+**Faster**
+- Templates compile 7% faster without JIT and 10% faster with YJIT, with 11% to 16% fewer allocations (6,097
+  public templates, Ruby 3.3 and 4.0). Rendering is unchanged.
+
+**Fixed**
+- `slimx lint` reports the offenses of one line in the same order on every Ruby version.
+
+## [1.0.0] — 2026-11-04
+
+First stable release: a Slim 5 engine written from scratch, without Temple. 0.1.0 and 0.1.1 were previews. It
+renders what Slim 5 renders with `format: :html, sort_attrs: false`, byte for byte; XML formats (`.xml`, `.rss`,
+`.atom`) render as XML.
+
+**New**
+- Rails through a railtie, Tilt through `require "slimx/tilt"`, and `SlimX.compile` for plain Ruby.
+- Every `-` and `=` stays on its template line, so backtraces point at the right one.
+- `slimx fmt`, which refuses any change to the compiled Ruby, and strict mode (`SlimX.strict`), which
+  refuses unformatted templates at compile time.
+- `slimx lint` with 29 rules from slim-lint, haml-lint, erb_lint, Herb and eslint-plugin-jsx-a11y,
+  configured in `.slimx.yml`.
+- `tailwind_classes`, off by default: class shortcuts read Tailwind class names.
+
+**Left out**
+- XHTML, `sort_attrs` and the other Temple options, the `coffee:`, `sass:`, `scss:`, `less:`, `erb:`,
+  `builder:` and wiki engines, conditional comments, the `logic_less`, `translator`, `include` and `smart`
+  plugins, and lambda shortcuts: each raises at compile time.
+
+**Requires**
+- Ruby 3.3 or later, every Ruby still maintained, Rails 8.0 or 8.1 for the railtie, and strscan 3.1.1 or later,
+  newer than the one Ruby 3.3 ships.
+
+[Unreleased]: https://github.com/levups/super-slim/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/levups/super-slim/compare/v1.1.0...v2.0.0
+[1.1.0]: https://github.com/next-gen-gems/slimx/compare/v1.0.0...v1.1.0
+[1.0.0]: https://github.com/next-gen-gems/slimx/releases/tag/v1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2026 Level UP Solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/LICENSE-slim

@@ -0,0 +1,22 @@
+SuperSlim's parser follows the grammar and the parsing algorithm of Slim
+(https://github.com/slim-template/slim), released under the MIT License:
+
+Copyright (c) 2010 - 2026 Slim Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,203 @@
+# SuperSlim
+
+A Slim template engine rewritten from scratch: no Temple, no filter pipeline, a single-pass compiler and a
+render-time runtime of a few methods. Templates written for [Slim](https://github.com/slim-template/slim) 5
+render byte for byte the same, faster, with fewer allocations.
+
+https://levups.github.io/super-slim/
+
+## Installation
+
+```ruby
+# Gemfile
+gem "super_slim" # instead of slim-rails
+```
+
+## Usage
+
+Rails picks it up through its railtie. Outside Rails, `SuperSlim.compile(source)` returns the Ruby code.
+
+## What SuperSlim renders
+
+HTML5, with attributes in the order you write them — what Slim renders with
+`format: :html, sort_attrs: false`. Templates whose format is XML (`.xml`, `.rss`, `.atom`) render as XML
+(`<link />`, `doctype xml`) from their format alone.
+
+The whole Slim 5 grammar is supported: tags and `#id`/`.class` shortcuts, attributes with
+any delimiter, boolean attributes, `*splat`, `data`/`aria` hashes, `class` merging, `<`/`>` whitespace
+markers, `|` and `'` text, inline HTML, `/` and `/!` comments, `-` control code, `=`/`==` output, `#{}` and
+`#{{}}` interpolation, `doctype 5`/`html`/`xml`, and the `ruby:`, `javascript:`, `css:` and `markdown:` (through
+[Markly](https://github.com/ioquatix/markly)) embedded engines.
+
+## Tailwind class names
+
+Slim cuts `.rounded-b-[3px]` at the bracket, and refuses `.lg:[&:nth-child(3)]:hover:underline`. Turn on
+`tailwind_classes` and the `.` shortcut takes any Tailwind class name:
+
+```slim
+.p-1.rounded-b-[3px].lg:[&:nth-child(3)]:hover:underline
+.font-['Open_Sans'].bg-(--brand).mx-0.5.w-1/2.!font-bold.@lg:flex
+ul.*:p-2
+```
+
+```ruby
+SuperSlim.tailwind_classes = true # config/initializers/super_slim.rb, or tailwind_classes: true per compile
+```
+
+```yaml
+# .super-slim.yml, for super-slim lint and super-slim fmt
+tailwind_classes: true
+```
+
+Attribute lists keep their meaning: Tailwind never puts a bracket right after a letter or a digit, so
+`a.btn[href="/"]` is still a link with a class and an `href`. A colon followed by a space still nests a tag
+(`li.item: a`), and a final `/` still closes one. What changes is what Slim mangles: it renders `.size-2.5` as
+`class="size-2 5"`, the option as `class="size-2.5"`. On 7,505 templates from 31 apps, 16 compile differently
+with the option, all of them Tailwind classes Slim breaks. It stays off by default all the same, so that
+turning SuperSlim on changes nothing.
+
+The option only changes how templates are read: compiling 1,408 templates takes the same time (+0.5%, within
+noise), and the compiled Ruby, so the time it takes to render, is the same.
+
+## What SuperSlim leaves out
+
+Each fails at compile time with a clear error instead of being silently ignored:
+
+- the XHTML format and its doctypes, the HTML 4 doctypes, `sort_attrs`, `attr_quote`, `pretty`, `js_wrapper` and every Temple option;
+- the `coffee:`, `sass:`, `scss:`, `less:`, `erb:`, `builder:`, `textile:`, `rdoc:`, `asciidoc:` and wiki
+  engines, and `/[if IE]` conditional comments;
+- the `logic_less`, `translator`, `include` and `smart` plugins, and custom shortcuts: only `#id` and `.class`.
+
+They can come back if people ask, as long as they cost nothing at render time.
+
+## Migrating from Slim
+
+Slim's defaults are `format: :xhtml` and `sort_attrs: true`. If you never changed them, first switch Slim
+to `format: :html, sort_attrs: false` and check your test suite: that is the output SuperSlim gives. Then swap
+`slim-rails` for `super_slim`, and drop any `Slim::Engine.set_options`/`with_options` call.
+
+## Formatter and linter
+
+One parser serves the compiler, the formatter and the linter, so all three read templates the same way.
+
+`super-slim fmt [--check] [PATH…]` rewrites templates in their canonical layout: two spaces per level, `- code`,
+`= output` and `p = output` spacing, no redundant `div`, no trailing whitespace, single blank lines, one final
+newline. Text blocks move as a whole, so the whitespace they render stays put — and before writing anything,
+the formatter compiles both versions and refuses if the Ruby differs. Formatting cannot change a page.
+
+With `fmt: max_line_length: 120` in `.super-slim.yml`, `fmt` also wraps longer lines: a tag's attributes one
+per line inside `attribute_delimiters` (`"()"` by default, `"[]"` or `"{}"`), then the arguments of its Ruby code after each comma, four spaces deep when the line opens a block. It keeps a wrap only
+when the compiled Ruby differs by whitespace alone, and leaves lines already spread over several lines alone.
+
+`super-slim lint [PATH…]` reads `.super-slim.yml` and checks, with about a third of the CPU time slim-lint takes:
+
+| Rule | From | Default |
+|---|---|---|
+| Indentation, Tab, TrailingWhitespace, EmptyLines, TrailingBlankLines, ControlStatementSpacing, RedundantDiv | slim-lint, fixed by `super-slim fmt` | on |
+| LineLength (`max: 120`), CommentControlStatement, EmptyControlStatement, ConsecutiveControlStatements (`max: 2`), TagCase | slim-lint | on |
+| InstanceVariables (in partials) | haml-lint, Rails conventions | on |
+| StrictLocals (partials declare `/# locals:`) | Rails 7.1 strict locals | off |
+| DuplicateId, ImageAlt, IframeTitle, AnchorHref, NestedLinks, PositiveTabindex, BooleanAttributeValue, AriaRole, AriaAttribute | Herb, eslint-plugin-jsx-a11y | on |
+| ButtonType, InlineStyles | eslint-plugin-react, haml-lint | off |
+| DeprecatedClasses (`classes: {old: new}`) | erb_lint | on, empty |
+| UnnecessaryInterpolation, UnnecessaryStringOutput | haml-lint | on |
+| Zwsp (invisible characters) | slim-lint | on |
+
+```yaml
+# .super-slim.yml
+linters:
+  LineLength:
+    max: 150
+  ButtonType:
+    enabled: true
+  DeprecatedClasses:
+    classes:
+      text-muted: text-body-secondary
+```
+
+The Ruby inside templates is RuboCop's job: SuperSlim ships a RuboCop plugin that hands it each `-` and `=` line,
+code attribute, splat, `#{}` interpolation and `ruby:` block, read by SuperSlim's own parser. Offenses point at their
+line and column in the `.slim` file, and autocorrection writes back into it. It replaces rubocop-slim, and with
+it slimi and Temple:
+
+```yaml
+# .rubocop-slim.yml, run with rubocop -c .rubocop-slim.yml
+inherit_from: .rubocop.yml
+plugins:
+  - super_slim
+AllCops:
+  Include:
+    - "**/*.slim"
+```
+
+The cops that cannot hold in a template — indentation and alignment across lines, frozen string comments,
+`Lint/UselessAssignment` on a variable a later line reads — are turned off for `.slim` files, as rubocop-slim
+does. Unlike slimi, SuperSlim also reads the output of a tag with whitespace markers and attributes
+(`span> title="x" = name`), so a few offenses appear when switching.
+
+## How it is tested
+
+- Slim's own test suite and its literate specification (`TESTS.md`) run against SuperSlim: every template renders
+  through Slim and SuperSlim, and both outputs must match.
+- A seeded fuzzer generates thousands of random templates from the grammar and compares both engines; CI adds
+  10,000 from a new seed on every run.
+- Golden snapshots (`test/golden`) hold the rendered HTML, compiled Ruby, formatting and lint offenses of
+  templates covering the grammar, its errors and Tailwind class names: `UPDATE_GOLDEN=1` rewrites them.
+- `bench/compiled_digests.rb` proves a refactoring leaves the compiled Ruby of a whole corpus unchanged.
+
+Real templates come from 30 public apps pinned in `corpus/manifest.yml`: `rake corpus:fetch` downloads only
+their `.slim` files into the ignored `corpus/cache`, `rake corpus:check` compiles, formats and lints each one
+against Slim, and `rake corpus:diff BASE=rev` reports what changes between a revision and the working tree:
+compiled Ruby, formatting, lint offenses. Downloaded templates are never rendered, as rendering runs their
+Ruby; directories you trust, such as your own app, render too when passed in `SUPER_SLIM_CORPUS`.
+
+## Benchmarks
+
+`bench/compare.rb` renders the same blog page with SuperSlim, Slim, Haml, Erubi and Herb, checks that they all
+produce the same HTML, and writes compile and render speed and allocations to `docs/benchmarks.json`, which
+the website reads. Run it before each release, on a quiet machine:
+
+```sh
+bundle exec rake bench                                  # YJIT, 5 seconds per measurement
+SUPER_SLIM_CORPUS=path/to/app/views bundle exec rake bench   # adds the compile time of a whole app against Slim
+BENCH_LOCK=path/to/.bench.lock bundle exec rake bench   # waits for other benchmarks holding that lock
+```
+
+With `corpus/cache` fetched, it also times the open-source corpus, and `super-slim lint` and `fmt` there against
+slim-lint when it is installed. `bundle exec rake docs` rewrites the linter rules on the website
+(`docs/tools.html`), after checking every example against the linter.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake test                                # SuperSlim's tests, then Slim's own suites
+BUNDLE_GEMFILE=gemfiles/rails_8_0.gemfile bundle exec rake test  # the same on Rails 8.0
+bundle exec rubocop
+FUZZ_SEED=42 FUZZ_CASES=20000 bundle exec ruby -Ilib test/fuzz_test.rb
+bundle exec ruby -Ilib bench/corpus.rb path/to/app   # compile time and allocations against Slim
+bundle exec ruby --yjit -Ilib bench/render.rb        # render speed and allocations against Slim
+```
+
+### Releasing
+
+Pull requests leave `CHANGELOG.md` alone: a release starts by writing its notes under `## [Unreleased]`, from the
+pull requests merged since the last tag, without committing them. Refresh the website's numbers on a quiet machine
+(`SUPER_SLIM_CORPUS=path/to/app/views bundle exec rake bench`) and merge them through a pull request, then, from an
+up-to-date `main` whose CI is green:
+
+```sh
+bin/release minor --dry-run   # the notes and the changes, nothing written
+bin/release minor             # or patch, major, or an exact version such as 1.2.0
+```
+
+`main` takes no direct push, so `bin/release` dates the Unreleased section and bumps the version on a branch
+`release/vX.Y.Z`, opens its pull request, which merges itself once CI is green, and waits for it. It then pushes a
+signed tag `vX.Y.Z` on the merge commit (`bin/release --tag X.Y.Z` does it if you stopped waiting). The tag starts
+the Release workflow, which publishes the gem to RubyGems through trusted publishing and creates the GitHub release
+with the version's notes and the `.gem`.
+
+## License
+
+MIT, by Level UP Solutions, part of [Next Gen Gems](https://github.com/next-gen-gems). The parser follows the
+grammar and parsing algorithm of [Slim](https://github.com/slim-template/slim), by the Slim Team (MIT).

data/config/rubocop.yml

@@ -0,0 +1,212 @@
+inherit_mode:
+  merge:
+    - Exclude
+    - Include
+
+AllCops:
+  Include:
+    - "**/*.slim"
+
+Layout/ArgumentAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/ArrayAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/BlockAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/ClosingParenthesisIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/EmptyLineAfterGuardClause:
+  Exclude:
+    - "**/*.slim"
+
+Layout/EndAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstArgumentIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstArrayElementIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstArrayElementLineBreak:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstHashElementIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstHashElementLineBreak:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstMethodArgumentLineBreak:
+  Exclude:
+    - "**/*.slim"
+
+Layout/FirstParameterIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/HashAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/InitialIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/IndentationConsistency:
+  Exclude:
+    - "**/*.slim"
+
+Layout/IndentationWidth:
+  Exclude:
+    - "**/*.slim"
+
+Layout/LineEndStringConcatenationIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/LineLength:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineArrayBraceLayout:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineAssignmentLayout:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineHashBraceLayout:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineMethodCallBraceLayout:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineMethodCallIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineMethodDefinitionBraceLayout:
+  Exclude:
+    - "**/*.slim"
+
+Layout/MultilineOperationIndentation:
+  Exclude:
+    - "**/*.slim"
+
+Layout/ParameterAlignment:
+  Exclude:
+    - "**/*.slim"
+
+Layout/TrailingEmptyLines:
+  Exclude:
+    - "**/*.slim"
+
+Layout/TrailingWhitespace:
+  Exclude:
+    - "**/*.slim"
+
+Lint/EmptyFile:
+  Exclude:
+    - "**/*.slim"
+
+Lint/Syntax:
+  Exclude:
+    - "**/*.slim"
+
+Lint/UselessAssignment:
+  Exclude:
+    - "**/*.slim"
+
+Lint/Void:
+  Exclude:
+    - "**/*.slim"
+
+Metrics/BlockLength:
+  Exclude:
+    - "**/*.slim"
+
+Metrics/BlockNesting:
+  Exclude:
+    - "**/*.slim"
+
+Naming/FileName:
+  Exclude:
+    - "**/*.slim"
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - "**/*.slim"
+
+Style/IdenticalConditionalBranches:
+  Exclude:
+    - "**/*.slim"
+
+Style/IfUnlessModifier:
+  Exclude:
+    - "**/*.slim"
+
+Style/MultilineTernaryOperator:
+  Exclude:
+    - "**/*.slim"
+
+Style/NestedTernaryOperator:
+  Exclude:
+    - "**/*.slim"
+
+Style/Next:
+  Exclude:
+    - "**/*.slim"
+
+Style/ParallelAssignment:
+  Exclude:
+    - "**/*.slim"
+
+Style/RedundantParentheses:
+  Exclude:
+    - "**/*.slim"
+
+Style/RescueModifier:
+  Exclude:
+    - "**/*.slim"
+
+Style/Semicolon:
+  Exclude:
+    - "**/*.slim"
+
+Style/TrailingCommaInArguments:
+  Exclude:
+    - "**/*.slim"
+
+Style/TrailingCommaInArrayLiteral:
+  Exclude:
+    - "**/*.slim"
+
+Style/TrailingCommaInHashLiteral:
+  Exclude:
+    - "**/*.slim"
+
+Style/WhileUntilDo:
+  Exclude:
+    - "**/*.slim"
+
+Style/WhileUntilModifier:
+  Exclude:
+    - "**/*.slim"

data/exe/super-slim

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/super_slim/cli"
+
+exit SuperSlim::CLI.new.call(ARGV)

data/lib/super_slim/ast.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SuperSlim
+  module AST
+    NEWLINE = :newline
+
+    # Structs, not Data: Data.new allocates two more objects per node and is 2.8x slower, on every template line.
+    Static = Struct.new(:text)
+    Text = Struct.new(:text)
+    TextBlock = Struct.new(:children)
+    InlineHtml = Struct.new(:text, :children)
+    Tag = Struct.new(:name, :attributes, :content)
+    Control = Struct.new(:code, :children)
+    Output = Struct.new(:code, :escape, :children)
+    Comment = Struct.new(:children)
+    Doctype = Struct.new(:type)
+    Embedded = Struct.new(:engine, :children, :attributes)
+
+    StaticAttribute = Struct.new(:name, :value)
+    QuotedAttribute = Struct.new(:name, :escape, :text)
+    CodeAttribute = Struct.new(:name, :escape, :code)
+    BooleanAttribute = Struct.new(:name)
+    Splat = Struct.new(:code)
+
+    def self.empty?(nodes)
+      nodes.all?(NEWLINE)
+    end
+
+    # Once compiled, a text block with no text leaves nothing behind: Slim then closes a void tag holding one.
+    def self.renders_nothing?(nodes)
+      nodes.all? { |node| node == NEWLINE || (node.is_a?(TextBlock) && renders_nothing?(node.children)) }
+    end
+  end
+end

data/lib/super_slim/cli.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../super_slim"
+require_relative "linter"
+require_relative "parallel"
+
+module SuperSlim
+  class CLI
+    USAGE = <<~TEXT
+      Usage: super-slim lint [PATH…]             report what breaks the rules of .super-slim.yml
+             super-slim fmt [--check] [PATH…]    rewrite templates in their canonical layout
+             super-slim version
+    TEXT
+    SKIPPED_DIRECTORIES = %r{(\A|/)(\.git|node_modules|tmp|vendor)/}
+    EX_USAGE = 64
+
+    def call(arguments)
+      command, *arguments = arguments
+      configuration = Linter.configuration
+      SuperSlim.tailwind_classes = configuration["tailwind_classes"] if configuration.key?("tailwind_classes")
+      case command
+      when "lint" then lint(arguments, configuration)
+      when "fmt" then format(arguments, configuration.fetch("fmt", {}))
+      when "version", "--version" then puts(VERSION) || 0
+      else warn(USAGE) || EX_USAGE
+      end
+    end
+
+    private
+
+    def lint(paths, configuration)
+      linter = Linter.new(configuration.fetch("linters", {}))
+      offenses = Parallel.map(templates(paths)) { |path| linter.call(path, File.read(path)) }.flatten
+      offenses.each { |offense| puts "#{offense.path}:#{offense.lineno}: [#{offense.rule}] #{offense.message}" }
+      offenses.empty? ? 0 : 1
+    end
+
+    def format(arguments, options)
+      check = arguments.delete("--check")
+      formatter = Formatter.new(max_line_length: options["max_line_length"], attribute_delimiters: options.fetch("attribute_delimiters", "()"))
+      outcomes = Parallel.map(templates(arguments)) do |path|
+        source = File.read(path)
+        formatted = formatter.call(source)
+        next if formatted == source
+
+        File.write(path, formatted) unless check
+        [:reformatted, path]
+      rescue Error => exception
+        [:refused, "#{path}: #{exception.message.lines.first.strip}"]
+      end
+      outcomes.compact.each { |outcome, text| (outcome == :reformatted) ? puts(text) : warn(text) }
+      (outcomes.any? { |outcome,| outcome == :refused || (outcome == :reformatted && check) }) ? 1 : 0
+    end
+
+    def templates(paths)
+      paths = ["."] if paths.empty?
+      paths.flat_map do |path|
+        next [path] unless File.directory?(path)
+
+        Dir.glob("**/*.slim", base: path).filter_map { |template| File.join(path, template) unless template.match?(SKIPPED_DIRECTORIES) }
+      end.sort
+    end
+  end
+end