super-slim 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7c27c1a3bdc54556d0e0418a316838423719f9a0da47bba2be27b4a2812498c7
+  data.tar.gz: d5a779c6fa56691f985b3a82516769118dcb17a883eacfc6bbbe23b6afb14da0
+SHA512:
+  metadata.gz: 0d5e8d990ae3886c94cbd198f1ccfbf51722e121cf2529bfc239da0b52b6639aaf9dec2609396eef4ab43f938d9d15d0f1913085c79b23704c8373e17bac4269
+  data.tar.gz: e7eef329f3c7adef4ba9b7f53e697a35e8aec0501c72304517c590ade320641555ec7167cf6f0ff1fa8f693fe22b45bb99da3a69e6808afcc13cdfa630a5123f

data/CHANGELOG.md

@@ -0,0 +1,118 @@
+# Changelog
+
+## [Unreleased]
+
+## [3.0.0] — 2026-11-05
+
+SuperSlim is published as super-slim, the name of its command.
+
+**Breaking**
+- The gem is renamed `super-slim`: write `gem "super-slim"` in the Gemfile and `plugins: [super-slim]` in RuboCop's
+  configuration. The `SuperSlim` module, `require "super_slim"`, the `super-slim` command and `.super-slim.yml` are
+  unchanged.
+
+## [2.2.0] — 2026-11-05
+
+Six linter rules and options, `super-slim format`, and a formatter that no longer wraps a line RuboCop then refuses.
+
+**New**
+- `super-slim format` and the `format:` key of `.super-slim.yml`; `fmt` remains an alias for both.
+- Every linter rule takes `include:` and `exclude:` globs.
+- DeprecatedAttributes (`attributes: {old: new}`), and prefixes in DeprecatedClasses (`ml-*: ms-*`).
+- UnescapedOutput (`==`, `html_safe`, `raw`, `#{{}}`), EmbeddedEngines (`forbidden_engines:`) and HardcodedText, off
+  by default.
+
+**Fixed**
+- `super-slim format` keeps a line ending with an `if`, `unless`, `while`, `until` or `rescue` modifier on one line:
+  wrapped, RuboCop refused it (Style/MultilineIfModifier).
+
+## [2.1.0] — 2026-11-05
+
+Slim's doctypes are back, for email layouts.
+
+**New**
+- `doctype transitional`, `strict` and `frameset` render the HTML 4.01 doctypes again, and XML templates take `1.1`,
+  `basic`, `mobile`, `svg` and the XHTML 1.0 ones, as in Slim 5. Email layouts need `doctype transitional`:
+  `<!DOCTYPE html>` switches Apple Mail and iOS Mail to standards mode, which opens a gap under the images of table
+  cells.
+
+## [2.0.1] — 2026-11-05
+
+Two fixes to `super-slim`: braces around wrapped attributes, and `--help`.
+
+**Fixed**
+- `super-slim fmt` writes a space before `{` when it wraps attributes inside `{}` (`a.btn {`), as templates
+  usually do; `(` and `[` stay attached to the tag.
+- `super-slim --help`, `-h` and `help` print the usage on stdout and exit 0, after a command too
+  (`super-slim fmt --help`). An unknown option, such as `fmt --chek`, fails with the usage and status 64
+  instead of crashing.
+
+## [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/v3.0.0...HEAD
+[3.0.0]: https://github.com/levups/super-slim/compare/v2.2.0...v3.0.0
+[2.2.0]: https://github.com/levups/super-slim/compare/v2.1.0...v2.2.0
+[2.1.0]: https://github.com/levups/super-slim/compare/v2.0.1...v2.1.0
+[2.0.1]: https://github.com/levups/super-slim/compare/v2.0.0...v2.0.1
+[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,217 @@
+# 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, Slim's doctypes (`html`, `transitional` for email clients, their XHTML versions in XML
+templates), 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 format
+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, `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 format [--check] [PATH…]` (or `fmt`) 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 `format: max_line_length: 120` in `.super-slim.yml`, `format` 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 format` | 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}`, `old-*: new-*` for a prefix), DeprecatedAttributes (`attributes: {old: new}`) | erb_lint | on, empty |
+| UnescapedOutput (`==`, `html_safe`, `raw`, `#{{}}`) | Brakeman, erb_lint | off |
+| EmbeddedEngines (`forbidden_engines: [javascript, css]`) | slim-lint | off |
+| HardcodedText (text to translate) | erb_lint | off |
+| 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
+      ml-*: ms-*
+  InlineStyles:
+    enabled: true
+    exclude: ["app/views/*_mailer/**/*"]
+  HardcodedText:
+    enabled: true
+    include: ["app/views/shop/**/*.slim"]
+```
+
+Every rule takes `include:` and `exclude:`, lists of globs matched against paths relative to `.super-slim.yml`
+(`**/` spans directories).
+
+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 `format` 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.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Bundler requires a gem by its name: super-slim, then super/slim.
+require_relative "super_slim"

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