erb-formatter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e92985fbdbf82a7b1fd9908e54a4363ef74458b354edd71f5c1d4bb89fb99c3
+  data.tar.gz: 549bb67e76b412780c7b5eed871d630b204659b0857d8393ba10ee5312603583
+SHA512:
+  metadata.gz: 313b11be7a997560cb6e925b35b5ce9b574baaaba8d7d837e676a6d31737e1c2f672925f15210ac63d7aac7ae1c35fe77cc9007c833cfd2d889334a8b8782013
+  data.tar.gz: cd71d740571e141b4c748e13b28306b189b1a3833649f87cbc611c2e2837fb5993be9b357bc110bb840d25d58be9778c77f503e96e6df2b85dadd361bd4cae2f

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-03-11
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in erb-formatter.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    erb-formatter (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.15.0)
+    rake (13.0.6)
+    rufo (0.13.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  erb-formatter!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rufo
+
+BUNDLED WITH
+   2.3.7

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Elia Schito
+
+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,120 @@
+# ERB::Formatter 🪜
+
+Format ERB files with speed and precision.
+
+Features:
+
+- very fast
+- attempts to limit length (configurable)
+- tries to have an ouput similar to prettier for HTML
+- indents correctly ruby blocks (e.g. `if`/`elsif`/`do`/`end`)
+- designed to be integrated into editors and commit hooks
+- gives meaningful output in case of errors (most of the time)
+- will use multiline values for `class` and `data-action` attributes
+
+Roadmap:
+
+- extensive unit testing
+- more configuration options
+- more ruby reformatting capabilities
+- JavaScript and CSS formatting
+- VSCode plugin
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'erb-formatter'
+gem 'rufo' # for enabling minimal ruby re-formatting
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install erb-formatter
+
+## Usage
+
+### From the command line
+
+    $ echo "<div       > asdf  <% if 123%> <%='foobar'%> <%end-%>  </div>" | erb-format --stdin
+    <div>
+      asdf
+      <% if 123 %>
+        <%= 'foobar' %>
+      <% end -%>
+    </div>
+
+
+Check out `erb-format --help` for more options.
+
+### From Ruby
+
+```ruby
+require 'erb/formatter'
+
+formatted = ERB::Formatter.format <<-ERB
+<div        >
+            asdf
+                  <% if 123%>
+                      <%='foobar'%> <%end-%>
+           </div>
+ERB
+
+# => "<div>\n  asdf\n  <% if 123 %>\n    <%= 'foobar' %>\n  <% end -%>\n</div>\n"
+#
+# Same as:
+#
+#   <div>
+#     asdf
+#     <% if 123 %>
+#       <%= 'foobar' %>
+#     <% end -%>
+#   </div>
+```
+
+### With `lint-staged`
+
+Add the gem to your gemfile and the following to your `package.json`:
+
+```js
+"lint-staged": {
+  // …
+  "*.html.erb": "bundle exec erb-format --write"
+}
+```
+
+### As a TextMate plugin
+
+Create a command with the following settings:
+
+- **Scope selector:** `text.html.erb`
+- **Semantic class:** `callback.document.will-save`
+- **Input:** `document` → `text`
+- **Output:** `replace document` → `text`
+- **Caret placement:** `line-interpolation`
+
+```bash
+#!/usr/bin/env bash
+
+cd "$TM_PROJECT_DIRECTORY"
+bundle exec erb-format --stdin-filename "$TM_FILEPATH" < /dev/stdin 2> /dev/stdout
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/elia/erb-formatter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/erb-formatter.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "lib/erb/formatter"
+
+Gem::Specification.new do |spec|
+  spec.name = "erb-formatter"
+  spec.version = ERB::Formatter::VERSION
+  spec.authors = ["Elia Schito"]
+  spec.email = ["elia@schito.me"]
+
+  spec.summary = "Format ERB files with speed and precision."
+  spec.homepage = "https://github.com/nebulab/erb-formatter#readme"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/nebulab/erb-formatter"
+  spec.metadata["changelog_uri"] = "https://github.com/nebulab/erb-formatter/releases"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rufo"
+end

data/exe/erb-format

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+write, filename, read_stdin, code = nil
+
+OptionParser.new do |parser|
+  parser.banner = "Usage: #{$0} FILENAME... --write"
+
+  parser.on("-w", "--[no-]write", "Write file") do |value|
+    write = value
+  end
+
+  parser.on("--stdin-filename FILEPATH", "Set the stdin filename (implies --stdin)") do |value|
+    filename = value
+    read_stdin = true
+  end
+
+  parser.on("--[no-]stdin", "Read the file from stdin") do |value|
+    if read_stdin == true && value == false
+      abort "Can't set stdin filename and not use stdin at the same time"
+    end
+
+    read_stdin = value
+    filename ||= '-'
+  end
+
+  parser.on("-h", "--help", "Prints this help") do
+    puts parser
+    exit
+  end
+end.parse!(ARGV)
+
+abort "Can't read both stdin and a list of files" if read_stdin && !ARGV.empty?
+
+# If multiple files are provided assume `--write` and
+# execute on each of them.
+if ARGV.size > 1
+  ARGV.each do
+    warn "==> Formatting #{_1}..."
+    system __FILE__, _1, *[
+      ('--write' if write)
+    ].compact or exit(1)
+  end
+  exit
+end
+
+require 'erb/formatter'
+
+filename ||= ARGV.first
+code = read_stdin ? $stdin.read : File.read(filename)
+ignore = ERB::Formatter::IgnoreList.new
+
+if ignore.should_ignore_file? filename
+  print code unless write
+else
+  html = ERB::Formatter.format(code, filename: filename)
+
+  if write
+    File.write(filename, html)
+  else
+    puts html
+  end
+end
+

data/lib/erb/formatter/ignore_list.rb

@@ -0,0 +1,15 @@
+class ERB::Formatter::IgnoreList
+  def initialize(contents: nil, base_dir: Dir.pwd)
+    ignore_list_path = "#{base_dir}/.format-erb-ignore"
+    @contents = contents || (File.exists?(ignore_list_path) ? File.read(ignore_list_path) : '')
+    @ignore_list = @contents.lines
+  end
+
+  def should_ignore_file?(path)
+    path = File.expand_path(path, @base_dir)
+    @ignore_list.any? do
+      File.fnmatch? File.expand_path(_1.chomp, @base_dir), path
+    end
+  end
+end
+

data/lib/erb/formatter/version.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'erb/formatter'

data/lib/erb/formatter.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+# $DEBUG = true
+require "erb"
+require "cgi"
+require "ripper"
+require 'securerandom'
+require 'strscan'
+require 'pp'
+require 'stringio'
+
+class ERB::Formatter
+  VERSION = "0.1.0"
+  autoload :IgnoreList, 'erb/formatter/ignore_list'
+
+  class Error < StandardError; end
+
+  # https://stackoverflow.com/a/317081
+  ATTR_NAME = %r{[^\r\n\t\f\v= '"<>]*[^\r\n\t\f\v= '"<>/]} # not ending with a slash
+  UNQUOTED_VALUE = ATTR_NAME
+  UNQUOTED_ATTR = %r{#{ATTR_NAME}=#{UNQUOTED_VALUE}}
+  SINGLE_QUOTE_ATTR = %r{(?:#{ATTR_NAME}='[^']*?')}m
+  DOUBLE_QUOTE_ATTR = %r{(?:#{ATTR_NAME}="[^"]*?")}m
+  BAD_ATTR = %r{#{ATTR_NAME}=\s+}
+  QUOTED_ATTR = Regexp.union(SINGLE_QUOTE_ATTR, DOUBLE_QUOTE_ATTR)
+  ATTR = Regexp.union(SINGLE_QUOTE_ATTR, DOUBLE_QUOTE_ATTR, UNQUOTED_ATTR, UNQUOTED_VALUE)
+  MULTILINE_ATTR_NAMES = %w[class data-action]
+
+  ERB_TAG = %r{(<%(?:==|=|-|))\s*(.*?)\s*(-?%>)}m
+  ERB_PLACEHOLDER = %r{erb[a-z0-9]+tag}
+  ERB_END = %r{(<%-?)\s*(end)\s*(-?%>)}
+  ERB_ELSE = %r{(<%-?)\s*(else|elsif\b.*)\s*(-?%>)}
+
+  HTML_ATTR = %r{\s+#{SINGLE_QUOTE_ATTR}|\s+#{DOUBLE_QUOTE_ATTR}|\s+#{UNQUOTED_ATTR}|\s+#{ATTR_NAME}}m
+  HTML_TAG_OPEN = %r{<(\w+)((?:#{HTML_ATTR})*)(\s*?)(/>|>)}m
+  HTML_TAG_CLOSE = %r{</\s*(\w+)\s*>}
+
+  SELF_CLOSING_TAG = /\A(area|base|br|col|command|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)\z/i
+
+  ERB_OPEN_BLOCK = ->(code) do
+    # is nil when the parsing is broken, meaning it's an open expression
+    Ripper.sexp(code).nil?
+  end.freeze
+
+  RUBOCOP_STDIN_MARKER = "===================="
+
+  # Override the max line length to account from already indented ERB
+  module RubocopForcedMaxLineLength
+    def max
+      Thread.current['RuboCop::Cop::Layout::LineLength#max'] || super
+    end
+  end
+
+  module DebugShovel
+    def <<(string)
+      puts "ADDING: #{string.inspect} FROM:\n  #{caller(1, 5).join("\n  ")}"
+      super
+    end
+  end
+
+  def self.format(source, filename: nil)
+    new(source, filename: filename).html
+  end
+
+  def initialize(source, line_width: 80, filename: nil)
+    @original_source = source
+    @filename = filename || '(erb)'
+    @line_width = line_width
+    @source = source.dup
+    @html = +""
+
+    html.extend DebugShovel if $DEBUG
+
+    @tag_stack = []
+    @pre_pos = 0
+
+    build_uid = -> { ['erb', SecureRandom.uuid, 'tag'].join.delete('-') }
+
+    @pre_placeholders = {}
+    @erb_tags = {}
+
+    @source.gsub!(ERB_PLACEHOLDER) { |tag| build_uid[].tap { |uid| pre_placeholders[uid] = tag } }
+    @source.gsub!(ERB_TAG) { |tag| build_uid[].tap { |uid| erb_tags[uid] = tag } }
+
+    @erb_tags_regexp = /(#{Regexp.union(erb_tags.keys)})/
+    @pre_placeholders_regexp = /(#{Regexp.union(pre_placeholders.keys)})/
+    @tags_regexp = Regexp.union(HTML_TAG_CLOSE, HTML_TAG_OPEN)
+
+    format
+    freeze
+  end
+
+  attr_accessor \
+    :source, :html, :tag_stack, :pre_pos, :pre_placeholders, :erb_tags, :erb_tags_regexp,
+    :pre_placeholders_regexp, :tags_regexp, :line_width
+
+  alias to_s html
+
+  def format_attributes(tag_name, attrs, tag_closing)
+    return "" if attrs.strip.empty?
+
+    plain_attrs = attrs.tr("\n", " ").squeeze(" ").gsub(erb_tags_regexp, erb_tags)
+    return " #{plain_attrs}" if "<#{tag_name} #{plain_attrs}#{tag_closing}".size <= line_width
+
+    attr_html = ""
+    tag_stack_push(['attr='], attrs)
+    attrs.scan(ATTR).flatten.each do |attr|
+      attr.strip!
+      full_attr = indented(attr)
+      name, value = attr.split('=', 2)
+
+      if full_attr.size > line_width && MULTILINE_ATTR_NAMES.include?(name) && attr.match?(QUOTED_ATTR)
+        attr_html << indented("#{name}=#{value[0]}")
+        tag_stack_push('attr"', value)
+        value[1...-1].strip.split(/\s+/).each do |value_part|
+          attr_html << indented(value_part)
+        end
+        tag_stack_pop('attr"', value)
+        attr_html << indented(value[-1])
+      else
+        attr_html << full_attr
+      end
+    end
+    tag_stack_pop(['attr='], attrs)
+    attr_html << indented("")
+    attr_html
+  end
+
+  def format_erb_attributes(string)
+    erb_scanner = StringScanner.new(string.to_s)
+    erb_pre_pos = 0
+    until erb_scanner.eos?
+      if erb_scanner.scan_until(erb_tags_regexp)
+        erb_pre_match = erb_scanner.pre_match
+        erb_pre_match = erb_pre_match[erb_pre_pos..]
+        erb_pre_pos = erb_scanner.pos
+
+        erb_code = erb_tags[erb_scanner.captures.first]
+
+        format_attributes(erb_pre_match)
+
+        erb_open, ruby_code, erb_close = ERB_TAG.match(erb_code).captures
+        full_erb_tag = "#{erb_open} #{ruby_code} #{erb_close}"
+
+        case ruby_code
+        when /\Aend\z/
+          tag_stack_pop('%erb%', ruby_code)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+        when /\A(else|elsif\b(.*))\z/
+          tag_stack_pop('%erb%', ruby_code)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+          tag_stack_push('%erb%', ruby_code)
+        when ERB_OPEN_BLOCK
+          ruby_code = format_ruby(ruby_code, autoclose: true)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+          tag_stack_push('%erb%', ruby_code)
+        else
+          ruby_code = format_ruby(ruby_code, autoclose: false)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+        end
+      else
+        rest = erb_scanner.rest.to_s
+        format_erb_attributes(rest)
+        erb_scanner.terminate
+      end
+    end
+  end
+
+  def tag_stack_push(tag_name, code)
+    tag_stack << [tag_name, code]
+    p PUSH: tag_stack if $DEBUG
+  end
+
+  def tag_stack_pop(tag_name, code)
+    if tag_name == tag_stack.last&.first
+      tag_stack.pop
+      p POP_: tag_stack if $DEBUG
+    else
+      raise "Unmatched close tag, tried with #{[tag_name, code]}, but #{tag_stack.last} was on the stack"
+    end
+  end
+
+  def raise(message)
+    line = @original_source[0..pre_pos].count("\n")
+    location = "#{@filename}:#{line}:in `#{tag_stack.last&.first}'"
+    error = RuntimeError.new([
+      nil,
+      "==> FORMATTED:",
+      html,
+      "==> STACK:",
+      tag_stack.pretty_inspect,
+      "==> ERROR: #{message}",
+    ].join("\n"))
+    error.set_backtrace caller.to_a + [location]
+    super error
+  end
+
+  def indented(string)
+    indent = "  " * tag_stack.size
+    "\n#{indent}#{string.strip}"
+  end
+
+  def format_text(text)
+    starting_space = text.match?(/\A\s/)
+
+    final_newlines_count = text.match(/(\s*)\z/m).captures.last.count("\n")
+    html << "\n" if final_newlines_count > 1
+
+    return if text.match?(/\A\s*\z/m) # empty
+
+    text = text.gsub(/\s+/m, ' ').strip
+
+    offset = (starting_space ? indented("") : "").size
+    lines = []
+
+    until text.empty?
+      lines << text.slice!(0..text.rindex(' ', -(line_width - offset)))
+      offset = 0
+    end
+
+    html << lines.shift.strip unless starting_space
+    lines.each do |line|
+      html << indented(line)
+    end
+  end
+
+  def format_code_with_rubocop(code, line_width)
+    stdin, stdout = $stdin, $stdout
+    $stdin = StringIO.new(code)
+    $stdout = StringIO.new
+
+    Thread.current['RuboCop::Cop::Layout::LineLength#max'] = line_width
+
+    @rubocop_cli ||= begin
+      RuboCop::Cop::Layout::LineLength.prepend self
+      RuboCop::CLI.new
+    end
+
+    @rubocop_cli.run([
+      '--auto-correct',
+      '--stdin', @filename,
+      '-f', 'quiet',
+    ])
+
+    $stdout.string.split(RUBOCOP_STDIN_MARKER, 2).last
+  ensure
+    $stdin, $stdout = stdin, stdout
+    Thread.current['RuboCop::Cop::Layout::LineLength#max'] = nil
+  end
+
+  def format_ruby(code, autoclose: false)
+    if autoclose
+      code += "\nend" unless ERB_OPEN_BLOCK["#{code}\nend"]
+      code += "\n}" unless ERB_OPEN_BLOCK["#{code}\n}"]
+    end
+    p RUBY_IN_: code if $DEBUG
+
+    offset = tag_stack.size * 2
+    if defined? Rubocop
+      code = format_code_with_rubocop(code, line_width - offset) if (offset + code.size) > line_width
+    elsif defined?(Rufo)
+      code = Rufo.format(code) rescue code
+    end
+
+    lines = code.strip.lines
+    lines = lines[0...-1] if autoclose
+    code = lines.map { indented(_1) }.join.strip
+    p RUBY_OUT: code if $DEBUG
+    code
+  end
+
+  def format_erb_tags(string)
+    if %w[style script].include?(tag_stack.last&.first)
+      html << string.rstrip
+      return
+    end
+
+    erb_scanner = StringScanner.new(string.to_s)
+    erb_pre_pos = 0
+    until erb_scanner.eos?
+      if erb_scanner.scan_until(erb_tags_regexp)
+        erb_pre_match = erb_scanner.pre_match
+        erb_pre_match = erb_pre_match[erb_pre_pos..]
+        erb_pre_pos = erb_scanner.pos
+
+        erb_code = erb_tags[erb_scanner.captures.first]
+
+        format_text(erb_pre_match)
+
+        erb_open, ruby_code, erb_close = ERB_TAG.match(erb_code).captures
+        erb_open << ' ' unless ruby_code.start_with?('#')
+        full_erb_tag = "#{erb_open}#{ruby_code} #{erb_close}"
+
+        case ruby_code
+        when /\Aend\z/
+          tag_stack_pop('%erb%', ruby_code)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+        when /\A(else|elsif\b(.*))\z/
+          tag_stack_pop('%erb%', ruby_code)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+          tag_stack_push('%erb%', ruby_code)
+        when ERB_OPEN_BLOCK
+          ruby_code = format_ruby(ruby_code, autoclose: true)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+          tag_stack_push('%erb%', ruby_code)
+        else
+          ruby_code = format_ruby(ruby_code, autoclose: false)
+          html << (erb_pre_match.match?(/\s+\z/) ? indented(full_erb_tag) : full_erb_tag)
+        end
+      else
+        rest = erb_scanner.rest.to_s
+        format_text(rest)
+        erb_scanner.terminate
+      end
+    end
+  end
+
+  def format
+    scanner = StringScanner.new(source)
+
+    until scanner.eos?
+
+      if matched = scanner.scan_until(tags_regexp)
+        pre_match = scanner.pre_match[pre_pos..]
+        self.pre_pos = scanner.pos
+
+        # Don't accept `name= "value"` attributes
+        raise "Bad attribute, please fix spaces after the equal sign." if BAD_ATTR.match? pre_match
+
+        format_erb_tags(pre_match) if pre_match
+
+        if matched.match?(HTML_TAG_CLOSE)
+          tag_name = scanner.captures.first
+
+          full_tag = "</#{tag_name}>"
+          tag_stack_pop(tag_name, full_tag)
+          html << (scanner.pre_match.match?(/\s+\z/) ? indented(full_tag) : full_tag)
+
+        elsif matched.match(HTML_TAG_OPEN)
+          _, tag_name, tag_attrs, _, tag_closing = *scanner.captures
+
+          raise "Unknown tag #{tag_name.inspect}" unless tag_name.match?(/\A[a-z0-9]+\z/)
+
+          tag_self_closing = tag_closing == '/>' || SELF_CLOSING_TAG.match?(tag_name)
+          tag_attrs.strip!
+          formatted_tag_name = format_attributes(tag_name, tag_attrs.strip, tag_closing).gsub(erb_tags_regexp, erb_tags)
+          full_tag = "<#{tag_name}#{formatted_tag_name}#{tag_closing}"
+          html << (scanner.pre_match.match?(/\s+\z/) ? indented(full_tag) : full_tag)
+
+          tag_stack_push(tag_name, full_tag) unless tag_self_closing
+        else
+          raise "Unrecognized content: #{matched.inspect}"
+        end
+      else
+        format_erb_tags(scanner.rest.to_s)
+        scanner.terminate
+      end
+    end
+
+    html.gsub!(erb_tags_regexp, erb_tags)
+    html.gsub!(pre_placeholders_regexp, pre_placeholders)
+    html.strip!
+    html << "\n"
+  end
+end

data/sig/erb/formatter.rbs

@@ -0,0 +1,7 @@
+# See the writing guide of rbs: https://github.com/ruby/rbs#guides
+class ERB::Formatter
+  VERSION: String
+
+  def initialize: (String, line_width: ?Integer, filename: ?String) -> void
+  def self.format(String, filename: ?String) -> String
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: erb-formatter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Elia Schito
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rufo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- elia@schito.me
+executables:
+- erb-format
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- erb-formatter.gemspec
+- exe/erb-format
+- lib/erb/formatter.rb
+- lib/erb/formatter/ignore_list.rb
+- lib/erb/formatter/version.rb
+- sig/erb/formatter.rbs
+homepage: https://github.com/nebulab/erb-formatter#readme
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nebulab/erb-formatter#readme
+  source_code_uri: https://github.com/nebulab/erb-formatter
+  changelog_uri: https://github.com/nebulab/erb-formatter/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Format ERB files with speed and precision.
+test_files: []