slimx 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee525fd8483ce0a207faa8ea7a61dc5f17a13720b130e6b819420afe8a6452c2
-  data.tar.gz: 0c902f495a605426f96ec1da183c48d3d7b316e6992eb9dd8f095c3bfbb8502d
+  metadata.gz: 1226be0f289b66fcf4b695e789913b7a94df07468e7db6471f5e82cd5a58d05f
+  data.tar.gz: ceaca10aa563fcbf70bafa180f140495e640622f1809bb119027c35a868e9281
 SHA512:
-  metadata.gz: 05ab88358c968355515af67ffe3a5cb87359bb7dfa88232f4f553809c4fa6268e522a228fff8930e3c2c390adfffbf13f151842429462606e0b9f84e1da1ee66
-  data.tar.gz: 409b2ddcc6fb27168758f05e8908cada7a8c72f28870484683a893b30fe522bf8c1197735e541c11459a88107a905f03b4aef666816d55771cd3e11fdccdf7dd
+  metadata.gz: d66c62e8a22d996b0a822f981a34cc8c2648d1cdf18cec491d5995c4c4acb96d8feeef85044313415888e0463c01dd58c3d6a4010de3b9455a12471dce13ea54
+  data.tar.gz: a5184ee72fcd2df6d2755b4baf35aca285bf2f05b7e2ab8a40928ee1ecd92bb902759ba9a8f906899a0576b424bb92eceafa793b2aae844403966ea7d522ec30

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+## [Unreleased]
+
+## [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/next-gen-gems/slimx/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/next-gen-gems/slimx/releases/tag/v1.0.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2026 Clément Joubert
+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

data/README.md

@@ -0,0 +1,180 @@
+# SlimX
+
+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://next-gen-gems.github.io/slimx/
+
+## Installation
+
+```ruby
+# Gemfile
+gem "slimx" # instead of slim-rails
+```
+
+## Usage
+
+Rails picks it up through its railtie. Outside Rails, `require "slimx/tilt"` registers it with Tilt
+(Sinatra, Hanami, Roda…), and `SlimX.compile(source)` returns the Ruby code.
+
+## What SlimX 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, custom 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`, 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
+SlimX.tailwind_classes = true # config/initializers/slimx.rb, or tailwind_classes: true per compile
+```
+
+```yaml
+# .slimx.yml, for slimx lint and slimx 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 SlimX 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 SlimX 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 lambda shortcuts.
+
+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 SlimX gives. Then swap
+`slim-rails` for `slimx`, and drop any `Slim::Engine.set_options`/`with_options` call.
+
+## Formatter, strict mode and linter
+
+One parser serves the compiler, the formatter and the linter, so all three read templates the same way.
+
+`slimx 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.
+
+Strict mode (`SlimX.strict = true`, or `strict: true` per compile) refuses any template that `slimx fmt` would
+change, pointing at the first line and what it should be: `gofmt` discipline at compile time.
+
+`slimx lint [PATH…]` reads `.slimx.yml` and checks, in about half the time slim-lint takes:
+
+| Rule | From | Default |
+|---|---|---|
+| Indentation, Tab, TrailingWhitespace, EmptyLines, TrailingBlankLines, ControlStatementSpacing, RedundantDiv | slim-lint, fixed by `slimx 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
+# .slimx.yml
+linters:
+  LineLength:
+    max: 150
+  ButtonType:
+    enabled: true
+  DeprecatedClasses:
+    classes:
+      text-muted: text-body-secondary
+```
+
+## How it is tested
+
+- Slim's own test suite and its literate specification (`TESTS.md`) run against SlimX: every template renders
+  through Slim and SlimX, 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 `SLIMX_CORPUS`.
+
+## Benchmarks
+
+`bench/compare.rb` renders the same blog page with SlimX, 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
+SLIMX_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 `slimx 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                                # SlimX'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
+
+Changes go under `## [Unreleased]` in `CHANGELOG.md` as they land. To release them, refresh the website's
+numbers on a quiet machine (`SLIMX_CORPUS=path/to/app/views bundle exec rake bench`) and commit them, 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
+```
+
+`bin/release` dates the Unreleased section, bumps the version, commits, and pushes the commit with a signed tag
+`vX.Y.Z`. 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/lib/slimx/ast.rb

@@ -23,7 +23,7 @@ module SlimX
     Splat = Struct.new(:code)
 
     def self.empty?(nodes)
-      nodes.all? { |node| node == NEWLINE }
+      nodes.all?(NEWLINE)
     end
 
     # Once compiled, a text block with no text leaves nothing behind: Slim then closes a void tag holding one.

data/lib/slimx/cli.rb

@@ -30,8 +30,8 @@ module SlimX
 
     def lint(paths, configuration)
       linter = Linter.new(configuration.fetch("linters", {}))
-      offenses = Parallel.map(templates(paths)) { linter.call(it, File.read(it)) }.flatten
-      offenses.each { puts "#{it.path}:#{it.lineno}: [#{it.rule}] #{it.message}" }
+      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
 
@@ -47,8 +47,8 @@ module SlimX
       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
+      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)
@@ -56,7 +56,7 @@ module SlimX
       paths.flat_map do |path|
         next [path] unless File.directory?(path)
 
-        Dir.glob("**/*.slim", base: path).reject { it.match?(SKIPPED_DIRECTORIES) }.map { File.join(path, it) }
+        Dir.glob("**/*.slim", base: path).filter_map { |template| File.join(path, template) unless template.match?(SKIPPED_DIRECTORIES) }
       end.sort
     end
   end

data/lib/slimx/compiler.rb

@@ -4,7 +4,7 @@ module SlimX
   class Compiler
     include AST
 
-    VOID_ELEMENTS = %w[area base br col embed hr img input keygen link menuitem meta param source track wbr].to_h { [it, true] }.freeze
+    VOID_ELEMENTS = %w[area base br col embed hr img input keygen link menuitem meta param source track wbr].to_h { [_1, true] }.freeze
     HYPHENATED_ATTRIBUTES = %w[data aria].freeze
     DOCTYPES = {
       html: {
@@ -12,7 +12,7 @@ module SlimX
         "html" => "<!DOCTYPE html>",
         "strict" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
         "frameset" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
-        "transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">',
+        "transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
       },
       xml: {
         "1.1" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
@@ -23,8 +23,8 @@ module SlimX
         "mobile" => '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
         "basic" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
         "transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
-        "svg" => '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">',
-      },
+        "svg" => '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'
+      }
     }.freeze
 
     BLOCK_SELF_OPENING = /(\A(if|unless|else|elsif|when|in|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^|]*\|\s*)?\z/
@@ -36,7 +36,7 @@ module SlimX
     ESCAPED_INTERPOLATION = /\A\\#\{/
     INTERPOLATION = /\A#\{((?>[^{}]|(\{(?>[^{}]|\g<1>)*\}))*)\}/
     UNESCAPED_INTERPOLATION_CODE = /\A\{.*\}\Z/
-    INTERPOLATION_FREE_TEXT = /\A([#\\]?[^#\\]*([#\\][^\\#\{][^#\\]*)*)/
+    INTERPOLATION_FREE_TEXT = /\A([#\\]?[^#\\]*([#\\][^\\#\{][^#\\]*)*)/ # rubocop:disable Style/RedundantRegexpEscape -- `#{` would open an interpolation
 
     def initialize(format: :html, rails: false, html_safe: String.method_defined?(:html_safe?), preamble: nil, postamble: nil)
       raise ArgumentError, "Invalid format #{format.inspect}" unless DOCTYPES.key?(format)
@@ -130,7 +130,7 @@ module SlimX
     end
 
     def with_do(code, children)
-      code.match?(BLOCK_SELF_OPENING) || AST.empty?(children) ? code : "#{code} do"
+      (code.match?(BLOCK_SELF_OPENING) || AST.empty?(children)) ? code : "#{code} do"
     end
 
     def compile_tag(tag)
@@ -139,7 +139,7 @@ module SlimX
       closed = tag.content.nil? || (AST.renders_nothing?(tag.content) && (@xml || VOID_ELEMENTS.key?(tag.name)))
       emit_static("<#{tag.name}")
       compile_attributes(tag.attributes)
-      emit_static(closed && @xml ? " />" : ">")
+      emit_static((closed && @xml) ? " />" : ">")
       return if closed && tag.content.nil?
 
       compile_children(tag.content)
@@ -162,7 +162,7 @@ module SlimX
 
     def compile_attributes(attributes)
       return if attributes.empty?
-      return emit_output(compile_runtime_attributes(attributes), false) if attributes.any? { runtime_attribute?(it) }
+      return emit_output(compile_runtime_attributes(attributes), false) if attributes.any? { runtime_attribute?(_1) }
 
       if attributes.size > 1
         seen_names = {}
@@ -180,8 +180,8 @@ module SlimX
         next compile_attribute(attribute) unless attribute.name == "class"
         next if class_attributes
 
-        class_attributes = attributes.select { it.name == "class" }
-        compile_class_attribute(class_attributes.map { attribute_parts(it) })
+        class_attributes = attributes.select { _1.name == "class" }
+        compile_class_attribute(class_attributes.map { attribute_parts(_1) })
       end
     end
 
@@ -227,8 +227,8 @@ module SlimX
         emit_static('"')
       else
         classes = new_variable
-        expressions = values.map { string_expression(it) }
-        emit_code(values.size == 1 ? "#{classes} = #{expressions.first}" : "#{classes} = ::SlimX::Runtime.join_classes(#{expressions.join(", ")})")
+        expressions = values.map { string_expression(_1) }
+        emit_code((values.size == 1) ? "#{classes} = #{expressions.first}" : "#{classes} = ::SlimX::Runtime.join_classes(#{expressions.join(", ")})")
         emit_code("unless #{classes}.empty?")
         emit_attribute("class", [[:raw, classes]])
         emit_code("end")
@@ -279,7 +279,7 @@ module SlimX
         [[:raw, "::SlimX::Runtime.class_value(#{value}, #{attribute.escape}, #{@html_safe})"]]
       when QuotedAttribute
         interpolation_parts(attribute.text).map do |kind, value, escape|
-          kind == :static && attribute.escape ? [:static, ERB::Escape.html_escape(value)] : [kind, value, escape]
+          (kind == :static && attribute.escape) ? [:static, ERB::Escape.html_escape(value)] : [kind, value, escape]
         end
       end
     end
@@ -373,7 +373,7 @@ module SlimX
 
       placeholder = "%#{object_id.abs.to_s(36)}%"
       dynamic_parts = []
-      markdown = children.grep(Text).flat_map { interpolation_parts(it.text) }.map do |part|
+      markdown = children.grep(Text).flat_map { interpolation_parts(_1.text) }.map do |part|
         next part[1] if part.first == :static
 
         dynamic_parts << part

data/lib/slimx/formatter.rb

@@ -87,7 +87,7 @@ module SlimX
     end
 
     def expand_tabs(line)
-      line.sub(/\A[ \t]*/) { it.gsub(Parser::TAB, "\\1#{" " * Parser::TAB_SIZE}") }
+      line.sub(/\A[ \t]*/) { _1.gsub(Parser::TAB, "\\1#{" " * Parser::TAB_SIZE}") }
     end
 
     def compiled(source)

data/lib/slimx/linter/rules.rb

@@ -4,11 +4,14 @@ module SlimX
   class Linter
     module Rules
       def self.all
-        constants.map { const_get(it) }.select { it < Rule }
+        constants.filter_map do |constant_name|
+          rule = const_get(constant_name)
+          rule if rule < Rule
+        end
       end
 
       class Rule
-        DEFAULTS = { enabled: true }.freeze
+        DEFAULTS = {enabled: true}.freeze
 
         def self.rule_name
           name.split("::").last
@@ -33,7 +36,7 @@ module SlimX
         end
 
         def attribute_names(tag)
-          tag.attributes.filter_map { it.name unless it.is_a?(AST::Splat) }
+          tag.attributes.filter_map { |attribute| attribute.name unless attribute.is_a?(AST::Splat) }
         end
 
         def each_line(document)
@@ -47,7 +50,7 @@ module SlimX
         end
 
         def splat?(tag)
-          tag.attributes.any? { it.is_a?(AST::Splat) }
+          tag.attributes.any? { _1.is_a?(AST::Splat) }
         end
 
         # The value when it is written literally, nil when it is computed.
@@ -59,7 +62,7 @@ module SlimX
         end
 
         def literal_attributes(tag, name)
-          tag.attributes.select { it.respond_to?(:name) && it.name == name && literal_value(it) }
+          tag.attributes.select { |attribute| attribute.respond_to?(:name) && attribute.name == name && literal_value(attribute) }
         end
       end
 
@@ -158,7 +161,7 @@ module SlimX
       # Slim-lint's rules on code and tags.
 
       class LineLength < Rule
-        DEFAULTS = { enabled: true, max: 120 }.freeze
+        DEFAULTS = {enabled: true, max: 120}.freeze
 
         def offenses(document, _source)
           max = options[:max]
@@ -170,7 +173,7 @@ module SlimX
         ALLOWED = /\A\s*#\s*(rubocop:|Template Dependency:)/
 
         def offenses(document, _source)
-          document.enum_for(:each_node).filter_map do |node,|
+          document.each_node.filter_map do |node,|
             next unless node.is_a?(AST::Control) && node.code.match?(/\A\s*#/) && !node.code.match?(ALLOWED)
 
             offense(document, document.line_of(node), "Write comments with `/`, not `- #`: they cost nothing at render time")
@@ -180,22 +183,25 @@ module SlimX
 
       class EmptyControlStatement < Rule
         def offenses(document, _source)
-          document.enum_for(:each_node).filter_map do |node,|
+          document.each_node.filter_map do |node,|
             offense(document, document.line_of(node), "Remove this empty `-`") if node.is_a?(AST::Control) && node.code.strip.empty?
           end
         end
       end
 
       class ConsecutiveControlStatements < Rule
-        DEFAULTS = { enabled: true, max: 2 }.freeze
+        DEFAULTS = {enabled: true, max: 2}.freeze
 
         def offenses(document, _source)
           sibling_lists = [document.nodes, *document.visits.filter_map { |node,| Document.children_of(node) }]
-          sibling_lists.select! { |siblings| siblings.count { flat_control?(it) } > options[:max] }
+          sibling_lists.select! { |siblings| siblings.count { flat_control?(_1) } > options[:max] }
           sibling_lists.flat_map do |siblings|
             siblings.chunk_while { |control, following| flat_control?(control) && flat_control?(following) }
-              .select { it.size > options[:max] && flat_control?(it.first) }
-              .map { offense(document, document.line_of(it.first), "Merge these #{it.size} lines of Ruby into a `ruby:` block") }
+              .filter_map do |controls|
+                next unless controls.size > options[:max] && flat_control?(controls.first)
+
+                offense(document, document.line_of(controls.first), "Merge these #{controls.size} lines of Ruby into a `ruby:` block")
+              end
           end
         end
 
@@ -210,9 +216,9 @@ module SlimX
         def offenses(document, _source)
           return [] if document.xml?
 
-          document.enum_for(:each_node).filter_map do |node, ancestors|
+          document.each_node.filter_map do |node, ancestors|
             next unless node.is_a?(AST::Tag) && node.name.match?(/[A-Z]/)
-            next if ancestors.any? { it.is_a?(AST::Tag) && it.name == "svg" }
+            next if ancestors.any? { |ancestor| ancestor.is_a?(AST::Tag) && ancestor.name == "svg" }
 
             offense(document, document.line_of(node), "Write `#{node.name.downcase}` in lowercase")
           end
@@ -225,11 +231,11 @@ module SlimX
         def offenses(document, _source)
           return [] unless document.partial?
 
-          document.enum_for(:each_node).filter_map do |node,|
+          document.each_node.filter_map do |node,|
             code = case node
-                   when AST::Control, AST::Output then node.code
-                   when AST::Tag then node.attributes.filter_map { it.code if it.respond_to?(:code) }.join(" ")
-                   end
+            when AST::Control, AST::Output then node.code
+            when AST::Tag then node.attributes.filter_map { |attribute| attribute.code if attribute.respond_to?(:code) }.join(" ")
+            end
             next unless code && (variable = code[INSTANCE_VARIABLE])
 
             offense(document, document.line_of(node), "Pass `#{variable}` to the partial as a local")
@@ -238,10 +244,10 @@ module SlimX
       end
 
       class StrictLocals < Rule
-        DEFAULTS = { enabled: false }.freeze
+        DEFAULTS = {enabled: false}.freeze
 
         def offenses(document, _source)
-          return [] if !document.partial? || document.lines.any? { it.match?(%r{\A\s*/#\s*locals:}) }
+          return [] if !document.partial? || document.lines.any? { _1.match?(%r{\A\s*/#\s*locals:}) }
 
           [offense(document, 1, "Declare the partial's locals: `/# locals: (name:)`")]
         end
@@ -253,7 +259,7 @@ module SlimX
         def offenses(document, _source)
           branch_by_id = {}
           enum_for(:each_tag, document).filter_map do |tag, ancestors|
-            branch = ancestors.reverse.find { it.is_a?(AST::Control) }
+            branch = ancestors.reverse.find { _1.is_a?(AST::Control) }
             literal_attributes(tag, "id").filter_map do |attribute|
               id = literal_value(attribute)
               if branch_by_id.key?(id) && branch_by_id[id].equal?(branch)
@@ -271,7 +277,6 @@ module SlimX
         def offenses(document, _source)
           missing_attribute(document, "img", "alt", 'Describe the image with `alt`, or mark it decorative with `alt=""`')
         end
-
       end
 
       class IframeTitle < Rule
@@ -287,7 +292,7 @@ module SlimX
       end
 
       class ButtonType < Rule
-        DEFAULTS = { enabled: false }.freeze
+        DEFAULTS = {enabled: false}.freeze
 
         def offenses(document, _source)
           missing_attribute(document, "button", "type", 'Say what the button does with `type="button"` or `type="submit"`')
@@ -297,7 +302,7 @@ module SlimX
       class NestedLinks < Rule
         def offenses(document, _source)
           enum_for(:each_tag, document, "a").filter_map do |tag, ancestors|
-            next unless ancestors.any? { it.is_a?(AST::Tag) && it.name == "a" }
+            next unless ancestors.any? { |ancestor| ancestor.is_a?(AST::Tag) && ancestor.name == "a" }
 
             offense(document, document.line_of(tag), "Links cannot contain links")
           end
@@ -318,8 +323,8 @@ module SlimX
 
       class BooleanAttributeValue < Rule
         BOOLEAN_ATTRIBUTES = %w[allowfullscreen async autofocus autoplay checked controls default defer disabled formnovalidate
-                                hidden inert ismap loop multiple muted nomodule novalidate open playsinline readonly required
-                                reversed selected].freeze
+          hidden inert ismap loop multiple muted nomodule novalidate open playsinline readonly required
+          reversed selected].freeze
 
         def offenses(document, _source)
           enum_for(:each_tag, document).flat_map do |tag,|
@@ -335,17 +340,19 @@ module SlimX
 
       class AriaRole < Rule
         ROLES = %w[alert alertdialog application article banner blockquote button caption cell checkbox code columnheader
-                   combobox complementary contentinfo definition deletion dialog document emphasis feed figure form generic
-                   grid gridcell group heading img insertion link list listbox listitem log main marquee math menu menubar
-                   menuitem menuitemcheckbox menuitemradio meter navigation none note option paragraph presentation
-                   progressbar radio radiogroup region row rowgroup rowheader scrollbar search searchbox separator slider
-                   spinbutton status strong subscript superscript switch tab table tablist tabpanel term textbox time timer
-                   toolbar tooltip tree treegrid treeitem].freeze
+          combobox complementary contentinfo definition deletion dialog document emphasis feed figure form generic
+          grid gridcell group heading img insertion link list listbox listitem log main marquee math menu menubar
+          menuitem menuitemcheckbox menuitemradio meter navigation none note option paragraph presentation
+          progressbar radio radiogroup region row rowgroup rowheader scrollbar search searchbox separator slider
+          spinbutton status strong subscript superscript switch tab table tablist tabpanel term textbox time timer
+          toolbar tooltip tree treegrid treeitem].freeze
 
         def offenses(document, _source)
           enum_for(:each_tag, document).flat_map do |tag,|
             literal_attributes(tag, "role").flat_map do |attribute|
-              literal_value(attribute).split.reject { ROLES.include?(it) || it.start_with?("doc-", "graphics-") }.map do |role|
+              literal_value(attribute).split.filter_map do |role|
+                next if ROLES.include?(role) || role.start_with?("doc-", "graphics-")
+
                 offense(document, document.line_of(tag), "`#{role}` is not an ARIA role")
               end
             end
@@ -355,11 +362,11 @@ module SlimX
 
       class AriaAttribute < Rule
         ATTRIBUTES = %w[activedescendant atomic autocomplete braillelabel brailleroledescription busy checked colcount
-                        colindex colindextext colspan controls current describedby description details disabled
-                        dropeffect errormessage expanded flowto grabbed haspopup hidden invalid keyshortcuts label
-                        labelledby level live modal multiline multiselectable orientation owns placeholder posinset
-                        pressed readonly relevant required roledescription rowcount rowindex rowindextext rowspan selected
-                        setsize sort valuemax valuemin valuenow valuetext].map { "aria-#{it}" }.freeze
+          colindex colindextext colspan controls current describedby description details disabled
+          dropeffect errormessage expanded flowto grabbed haspopup hidden invalid keyshortcuts label
+          labelledby level live modal multiline multiselectable orientation owns placeholder posinset
+          pressed readonly relevant required roledescription rowcount rowindex rowindextext rowspan selected
+          setsize sort valuemax valuemin valuenow valuetext].map { "aria-#{_1}" }.freeze
 
         def offenses(document, _source)
           enum_for(:each_tag, document).flat_map do |tag,|
@@ -373,14 +380,14 @@ module SlimX
       end
 
       class DeprecatedClasses < Rule
-        DEFAULTS = { enabled: true, classes: {} }.freeze
+        DEFAULTS = {enabled: true, classes: {}}.freeze
 
         def offenses(document, _source)
           replacement_by_class = options[:classes]
           return [] if replacement_by_class.empty?
 
           enum_for(:each_tag, document).flat_map do |tag,|
-            literal_attributes(tag, "class").flat_map { literal_value(it).split }.filter_map do |css_class|
+            literal_attributes(tag, "class").flat_map { literal_value(_1).split }.filter_map do |css_class|
               next unless replacement_by_class.key?(css_class)
 
               offense(document, document.line_of(tag), "`#{css_class}` is deprecated: use `#{replacement_by_class[css_class]}`")
@@ -390,7 +397,7 @@ module SlimX
       end
 
       class InlineStyles < Rule
-        DEFAULTS = { enabled: false }.freeze
+        DEFAULTS = {enabled: false}.freeze
 
         def offenses(document, _source)
           enum_for(:each_tag, document).filter_map do |tag,|
@@ -405,8 +412,9 @@ module SlimX
         LONE_INTERPOLATION = /\A#\{([^{}]+)\}\z/
 
         def offenses(document, _source)
-          document.enum_for(:each_node).filter_map do |node, ancestors|
-            next unless node.is_a?(AST::TextBlock) && (lineno = document.line_of(node) || document.line_of(ancestors.last))
+          document.each_node.filter_map do |node, ancestors|
+            next unless node.is_a?(AST::TextBlock)
+            next unless (lineno = document.line_of(node) || document.line_of(ancestors.last))
 
             texts = node.children.grep(AST::Text)
             next unless texts.size == 1 && texts.first.text =~ LONE_INTERPOLATION
@@ -418,12 +426,21 @@ module SlimX
 
       class UnnecessaryStringOutput < Rule
         PLAIN_STRING = /\A(["'])([^"'\\#&<>\s](?:[^"'\\#&<>]*[^"'\\#&<>\s])?)\1\z/
+        # Text starting with one of these, written inline after a tag, reads as attributes or output: `span (note)`.
+        READ_AS_SYNTAX_AFTER_TAG = /\A[(\[{=*\/]/
 
         def offenses(document, _source)
-          document.enum_for(:each_node).filter_map do |node,|
+          document.each_node.filter_map do |node, ancestors|
             next unless node.is_a?(AST::Output) && AST.empty?(node.children) && node.code =~ PLAIN_STRING
 
-            offense(document, document.line_of(node), "Write the text `| #{$2}` instead of outputting a string")
+            text = $2
+            lineno = document.line_of(node)
+            message = if text.match?(READ_AS_SYNTAX_AFTER_TAG) && ancestors.any? && document.line_of(ancestors.last) == lineno
+              "Write the text `| #{text}` on its own line, under the tag: inline, it would read as attributes"
+            else
+              "Write the text `| #{text}` instead of outputting a string"
+            end
+            offense(document, lineno, message)
           end
         end
       end

data/lib/slimx/linter.rb

@@ -65,8 +65,8 @@ module SlimX
       nodes = parser.call(source)
       visits = Document.visits_of(nodes)
       document = Document.new(path:, lines: source.split(/\r?\n/), nodes:, outline: parser.outline, line_by_node: parser.line_by_node,
-                              visits:, tag_visits: visits.select { |node,| node.is_a?(AST::Tag) })
-      offenses = @rules.flat_map { it.offenses(document, source) }
+        visits:, tag_visits: visits.select { |node,| node.is_a?(AST::Tag) })
+      offenses = @rules.flat_map { _1.offenses(document, source) }
       # sort_by is not stable: the index keeps offenses of one line in rule order.
       offenses.each_with_index.sort_by { |offense, index| [offense.lineno, index] }.map(&:first)
     rescue SyntaxError => exception

data/lib/slimx/parallel.rb

@@ -27,9 +27,9 @@ module SlimX
         writer.close
         reader
       end
-      results_by_process = readers.map { Marshal.load(it.binmode.read) }
+      results_by_process = readers.map { |reader| Marshal.load(reader.binmode.read) }
       Process.waitall
-      results_by_process.each { raise it if it.is_a?(Exception) }
+      results_by_process.each { |results| raise results if results.is_a?(Exception) }
       results_by_process.flatten(1)
     end
   end

data/lib/slimx/parser.rb

@@ -10,7 +10,7 @@ module SlimX
 
     TAB_SIZE = 4
     TAB = /\G((?: {#{TAB_SIZE}})*) {0,#{TAB_SIZE - 1}}\t/
-    DELIMITERS = { "(" => ")", "[" => "]", "{" => "}" }.freeze
+    DELIMITERS = {"(" => ")", "[" => "]", "{" => "}"}.freeze
     SUPPORTED_ENGINES = %w[javascript css ruby markdown].freeze
     # Engines Slim ships that SlimX deliberately refuses, so they fail loudly instead of parsing as a tag.
     UNSUPPORTED_ENGINES = %w[asciidoc textile rdoc coffee sass scss less erb builder creole wiki org].freeze
@@ -39,15 +39,15 @@ module SlimX
     CLOSED_TAG = /\s*\/\s*/
     SHORTCUT_VALUE_TO_ESCAPE = /[&<>"']/
     # Runs of characters the scanners would otherwise copy one by one: no delimiter, no line continuation.
-    CODE_CHUNK_BY_CLOSING = [nil, *DELIMITERS.values].to_h { [it, /(?:[^\s(\[{,\\#{Regexp.escape(it.to_s)}]|[,\\](?!\z))+/] }.freeze
+    CODE_CHUNK_BY_CLOSING = [nil, *DELIMITERS.values].to_h { |closing| [closing, /(?:[^\s(\[{,\\#{Regexp.escape(closing.to_s)}]|[,\\](?!\z))+/] }.freeze
     NESTED_CODE_CHUNK_BY_OPENING = DELIMITERS.to_h { |opening, closing| [opening, /(?:[^,\\#{Regexp.escape(opening + closing)}]|[,\\](?!\z))+/] }.freeze
-    QUOTED_CHUNK_BY_QUOTE = %w[" '].to_h { [it, /(?:[^{}\\#{it}]|\\(?!\z))+/] }.freeze
+    QUOTED_CHUNK_BY_QUOTE = %w[" '].to_h { |quote| [quote, /(?:[^{}\\#{quote}]|\\(?!\z))+/] }.freeze
     SLASH, PIPE, APOSTROPHE, LESS_THAN, GREATER_THAN, DASH, EQUALS = "/|'<>-=".bytes
     OPENING_BRACE, CLOSING_BRACE = "{}".bytes
     WHITESPACE_MARKER_BYTES = "<>'".bytes.freeze
-    BOOLEAN_ATTRIBUTE_BY_CLOSING = DELIMITERS.values.to_h { [it, /#{ATTRIBUTE_NAME}(?=(\s|#{Regexp.escape(it)}|\z))/] }.freeze
-    ATTRIBUTE_LIST_END_BY_CLOSING = DELIMITERS.values.to_h { [it, /\s*#{Regexp.escape(it)}/] }.freeze
-    CODE_END_BY_CLOSING = [nil, *DELIMITERS.values].to_h { [it, /[\s#{Regexp.escape(it.to_s)}]/] }.freeze
+    BOOLEAN_ATTRIBUTE_BY_CLOSING = DELIMITERS.values.to_h { |closing| [closing, /#{ATTRIBUTE_NAME}(?=(\s|#{Regexp.escape(closing)}|\z))/] }.freeze
+    ATTRIBUTE_LIST_END_BY_CLOSING = DELIMITERS.values.to_h { |closing| [closing, /\s*#{Regexp.escape(closing)}/] }.freeze
+    CODE_END_BY_CLOSING = [nil, *DELIMITERS.values].to_h { |closing| [closing, /[\s#{Regexp.escape(closing.to_s)}]/] }.freeze
 
     # What the formatter and the linter need to know about each source line, indexed by line number.
     LineInfo = Struct.new(:kind, :depth, :owner, :text, :output_column)
@@ -297,7 +297,7 @@ module SlimX
           end
 
           if @outline
-            rendered_blank_linenos.each { @outline[it].kind = :text_blank }
+            rendered_blank_linenos.each { @outline[_1].kind = :text_blank }
             rendered_blank_linenos.clear
           end
           next_line
@@ -312,7 +312,7 @@ module SlimX
           text_indent ||= indent
         end
       end
-      rendered_blank_linenos.each { @outline[it].kind = :blank } if @outline
+      rendered_blank_linenos.each { @outline[_1].kind = :blank } if @outline
       nodes
     end
 
@@ -341,7 +341,7 @@ module SlimX
 
         # Tailwind arbitrary values may hold quotes and ampersands, which Slim names never do.
         value = ERB::Escape.html_escape(value) if value.match?(SHORTCUT_VALUE_TO_ESCAPE)
-        names.each { attributes << StaticAttribute.new(it, value) }
+        names.each { |name| attributes << StaticAttribute.new(name, value) }
         @shortcuts.additional_attributes_by_shortcut[shortcut]&.each { |name, value| attributes << StaticAttribute.new(name.to_s, value) }
         @scanner.pos += shortcut_length
       end
@@ -447,12 +447,12 @@ module SlimX
         if @scanner.match?(LINE_CONTINUATION)
           code << @scanner.getch << "\n"
           expect_next_line
-        elsif (chunk = @scanner.scan(depth == 0 ? CODE_CHUNK_BY_CLOSING[outer_closing] : NESTED_CODE_CHUNK_BY_OPENING[opening]))
+        elsif (chunk = @scanner.scan((depth == 0) ? CODE_CHUNK_BY_CLOSING[outer_closing] : NESTED_CODE_CHUNK_BY_OPENING[opening]))
           code << chunk
         else
           character = @scanner.getch
           if depth > 0
-            depth += character == opening ? 1 : -1
+            depth += (character == opening) ? 1 : -1
           else
             depth = 1
             opening = character
@@ -490,7 +490,7 @@ module SlimX
     end
 
     def syntax_error!(message)
-      error = SyntaxError.new(message, @file, @line, @lineno, @line && @scanner ? column : 0)
+      error = SyntaxError.new(message, @file, @line, @lineno, (@line && @scanner) ? column : 0)
       error.set_backtrace(["#{@file}:#{@lineno}", *caller])
       raise error
     end

data/lib/slimx/rails_handler.rb

@@ -8,7 +8,7 @@ module SlimX
         file: template.identifier,
         format: xml?(template) ? :xml : :html,
         rails: true,
-        **annotations(template),
+        **annotations(template)
       )
     end
 
@@ -25,7 +25,7 @@ module SlimX
     def annotations(template)
       return {} unless ActionView::Base.annotate_rendered_view_with_filenames && template.format == :html
 
-      { preamble: "<!-- BEGIN #{template.short_identifier} -->\n", postamble: "<!-- END #{template.short_identifier} -->\n" }
+      {preamble: "<!-- BEGIN #{template.short_identifier} -->\n", postamble: "<!-- END #{template.short_identifier} -->\n"}
     end
   end
 end

data/lib/slimx/runtime.rb

@@ -12,11 +12,16 @@ module SlimX
 
     def escape_html_safe(value)
       string = value.to_s
-      string.html_safe? || value.html_safe? ? string : ERB::Escape.html_escape(string)
+      (string.html_safe? || value.html_safe?) ? string : ERB::Escape.html_escape(string)
     end
 
     def class_value(value, escape, html_safe)
-      value = value.flatten.map(&:to_s).reject(&:empty?).join(" ") if value.is_a?(Array)
+      if value.is_a?(Array)
+        value = value.flatten.filter_map do |element|
+          string = element.to_s
+          string unless string.empty?
+        end.join(" ")
+      end
       return value.to_s unless escape
 
       html_safe ? escape_html_safe(value) : escape_html(value)

data/lib/slimx/shortcuts.rb

@@ -2,7 +2,7 @@
 
 module SlimX
   class Shortcuts
-    DEFAULT = { "#" => { attr: "id" }, "." => { attr: "class" } }.freeze
+    DEFAULT = {"#" => {attr: "id"}, "." => {attr: "class"}}.freeze
     DEFAULT_TAG = "div"
 
     attr_reader :tag_by_shortcut, :attributes_by_shortcut, :additional_attributes_by_shortcut, :attribute_pattern, :tag_pattern
@@ -34,19 +34,18 @@ module SlimX
       @additional_attributes_by_shortcut = {}
       definitions.each { |shortcut, definition| register(shortcut, definition) }
 
-      attribute_keys = Regexp.union(@attributes_by_shortcut.keys.sort_by { -it.size })
+      attribute_keys = Regexp.union(@attributes_by_shortcut.keys.sort_by { -_1.size })
       name_part = tailwind_classes ? TAILWIND_NAME_PART : SLIM_NAME_PART
       @attribute_pattern = /\A(#{attribute_keys}+)((?:#{name_part})*)/
-      tag_keys = Regexp.union(@tag_by_shortcut.keys.sort_by { -it.size })
+      tag_keys = Regexp.union(@tag_by_shortcut.keys.sort_by { -_1.size })
       @tag_pattern = /\A(?:#{tag_keys}|\*(?=[^\s]+)|(\p{Word}(?:\p{Word}|:|-)*\p{Word}|\p{Word}+))/
     end
 
     private
 
     def register(shortcut, definition)
-      unless (definition[:attr] || definition[:tag]) && (definition.keys - %i[attr tag additional_attrs]).empty?
-        raise ArgumentError, "Shortcut requires :tag and/or :attr"
-      end
+      valid = (definition[:attr] || definition[:tag]) && (definition.keys - %i[attr tag additional_attrs]).empty?
+      raise ArgumentError, "Shortcut requires :tag and/or :attr" unless valid
 
       raise ArgumentError, "Lambda shortcuts are not supported" if definition[:attr].is_a?(Proc)
 

data/lib/slimx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SlimX
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/slimx.rb

@@ -46,7 +46,7 @@ module SlimX
     attr_accessor :tailwind_classes
 
     def compile(source, file: nil, shortcuts: Shortcuts::DEFAULT, strict: self.strict, tailwind_classes: self.tailwind_classes,
-                **compiler_options)
+      **compiler_options)
       ensure_formatted!(source, file, shortcuts, tailwind_classes) if strict
       Compiler.new(**compiler_options).call(Parser.new(file:, shortcuts:, tailwind_classes:).call(source))
     end
@@ -59,7 +59,7 @@ module SlimX
 
       lines = source.split("\n", -1)
       expected_lines = formatted.split("\n", -1)
-      index = lines.each_index.find { lines[it] != expected_lines[it] } || lines.size
+      index = lines.each_index.find { |line_index| lines[line_index] != expected_lines[line_index] } || lines.size
       raise SyntaxError.new("Not formatted, `slimx fmt` writes: #{expected_lines[index].inspect}", file, lines[index], index + 1, lines[index].to_s[/\A\s*/].size)
     end
   end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: slimx
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
-- Clément Joubert
+- Level UP Solutions
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: strscan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
 description: 'A Slim template engine rewritten from scratch, without Temple: same
   HTML as Slim 5, faster compilation and rendering with fewer allocations, a formatter
   that cannot change a page, a strict mode, and a linter with HTML and accessibility
@@ -18,7 +32,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
+- README.md
 - exe/slimx
 - lib/slimx.rb
 - lib/slimx/ast.rb
@@ -35,9 +51,14 @@ files:
 - lib/slimx/shortcuts.rb
 - lib/slimx/tilt.rb
 - lib/slimx/version.rb
+homepage: https://github.com/next-gen-gems/slimx
 licenses:
 - MIT
 metadata:
+  source_code_uri: https://github.com/next-gen-gems/slimx
+  changelog_uri: https://github.com/next-gen-gems/slimx/blob/main/CHANGELOG.md
+  documentation_uri: https://next-gen-gems.github.io/slimx/
+  bug_tracker_uri: https://github.com/next-gen-gems/slimx/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -46,14 +67,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.4'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.23
+rubygems_version: 4.0.20
 specification_version: 4
 summary: 'Slim templates, rewritten: faster to compile and render, with a formatter
   and a linter'