erbf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fa38a8ddf489f16a90c48c63039d9509210f13764d1cbe7590f8b094de30d9c8
+  data.tar.gz: ec92348e114992ffef85120d0467cb53df0cd55fe7b55eff8e2fd9446e37abee
+SHA512:
+  metadata.gz: c14b1941af80e13905fea704dace9d92f633370ba5d18e8c3ab5a2159b8139120681aa9bc239018d7bb1b327c9cb2b686b367ac8716012963f41cdad79dadc6d
+  data.tar.gz: 061c828ee94a80c20ff91a2944924a4e73bb884490c1653f21a58727f7bb5bc0e08192c364b9fbbad324534d09e29a3e80b97a850f953a400ccbac7569c4f823

data/.rubocop.yml

@@ -0,0 +1,40 @@
+inherit_gem:
+  syntax_tree: config/rubocop.yml
+
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  NewCops: enable
+  SuggestExtensions: false
+  TargetRubyVersion: 3.0
+
+Metrics:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Naming/MethodName:
+  Enabled: false
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/DocumentDynamicEvalDefinition:
+  Exclude:
+    - test/fixtures/**/*.rb
+
+Style/FormatString:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact

data/.streerc

@@ -0,0 +1 @@
+--print-width=100

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Tomasz Szczęśniak-Szlagowski
+
+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,118 @@
+# erbf
+
+A formatter for your `.html.erb` files.
+
+> [!CAUTION]
+> erbf is still in alpha stages of development. Use at your own risk.
+
+## Features
+
+#### Style similar to Prettier's
+
+Many teams use prettier and it'd be strange if `.html.erb` files were formatted
+differently than `.html` files in the same project.
+
+If some HTML (without ERB tags) gets formatted differently than Prettier with
+default settings would have done it, that's a bug.
+
+Support for `--html-whitespace-sensitivity` may be added in the future.
+
+#### Formats Ruby code
+
+SyntaxTree will be used if it's available. If you don't want your Ruby code
+reformatted, you can disable it in the config file.
+
+#### Formats other embedded languages
+
+The code within `<script>` and `<style>` tags will be formatted if `prettier`
+is installed under the `node_modules` directory.
+
+You can also specify any other formatter that has a CLI which can format STDIN.
+
+#### CLI
+
+Format/check/write specified files (or STDIN)
+
+#### Planned
+
+- Some kind of "no-format" comment support
+- Support for any other Ruby formatter
+- Ruby LSP Plugin
+- SyntaxTree Plugin
+- Rake tasks
+- Website with examples of: formatting, configuration, integration with other tools and IDEs
+
+## Installation
+
+Install the gem, either as your project's dependency or globally:
+
+```sh
+bundle add erbf --group "development, test"
+# or
+gem install erbf
+```
+
+## Usage
+
+```sh
+# format all *.html.erb files in a directory
+erbf directory
+
+# check if all files are formatted
+erbf -c directory
+
+# auto-format all files
+erbf -w directory
+
+# auto-format files with a different extension
+erbf 'directory/**/*.erb'
+
+# format stdin
+erbf < file.erb
+```
+
+You can configure it via a config file in your repo:
+
+```yaml
+# .erbf.yml or config/erbf.yml
+line_length: 80
+ruby:
+  formatter: syntax_tree
+  syntax_tree_plugins:
+    - plugin/single_quotes
+embedded:
+  - types:
+      - text/javascript
+      - module
+    command: prettier --stdin-filepath file.js --print-width %<line_length>d
+  - types:
+      - text/css
+    command: prettier --stdin-filepath file.css --print-width %<line_length>d
+```
+
+## Development
+
+```sh
+# Install dependencies
+bin/setup
+
+# Run the linter, formatter and tests
+bundle exec rake
+
+# Run a REPL
+bin/console
+
+# Install the gem locally
+bundle exec rake install
+
+# Release a new version (after updating version.rb)
+bundle exec rake release
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/spect88/erbf.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/erbf

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/erbf"
+require_relative "../lib/erbf/cli"
+
+exit(Erbf::CLI.call(ARGV, $stdin))

data/lib/erbf/cli.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+class Erbf::CLI
+  class Error < StandardError
+  end
+
+  def self.call(...)
+    new.call(...)
+  end
+
+  def initialize
+    @command = :format
+    @files = []
+    @input = nil
+    @config_path = nil
+  end
+
+  def parse!(argv, stdin)
+    argv_left = argv.dup
+
+    begin
+      options.parse!(argv_left)
+    rescue OptionParser::MissingArgument, OptionParser::InvalidOption => e
+      raise Error, e.message
+    end
+
+    if @command == :format
+      @input = stdin.read if (argv_left.empty? && !stdin.tty?) || argv_left.include?("-")
+      argv_left -= ["-"]
+    end
+
+    @files =
+      argv_left
+        .flat_map do |path|
+          paths = Dir[path]
+          raise Error, "invalid file/directory/glob: #{path}" if paths.empty?
+
+          dirs, files = paths.partition { |p| File.directory?(p) }
+          files + dirs.flat_map { |d| Dir["#{d}/**/*.html.erb"] }
+        end
+        .uniq
+
+    if @input.nil? && @files.empty? && %i[format check write].include?(@command)
+      raise Error, "no file/directory/glob specified"
+    end
+  end
+
+  def execute(stdout = $stdout, stderr = $stderr)
+    erbf = Erbf.new(config_file: @config_path)
+    case @command
+    when :help
+      stdout.puts options
+      true
+    when :version
+      stdout.puts Erbf::VERSION
+      true
+    when :format
+      @files.each do |path|
+        content = File.read(path)
+        stdout.puts erbf.format_code(content)
+      end
+      stdout.puts erbf.format_code(@input) if @input
+      true
+    when :check
+      success = true
+      @files.each do |path|
+        original = File.read(path)
+        formatted = erbf.format_code(original)
+        formatted = "#{formatted}\n"
+        next if original == formatted
+
+        stderr.puts "#{path} needs to be formatted"
+        success = false
+      end
+      success
+    when :write
+      @files.each do |path|
+        original = File.read(path)
+        formatted = erbf.format_code(original)
+        formatted = "#{formatted}\n"
+        next if original == formatted
+
+        File.write(path, formatted)
+        stdout.puts "Formatted: #{path}"
+      end
+      true
+    end
+  end
+
+  def call(argv, stdin, stdout = $stdout, stderr = $stderr)
+    parse!(argv, stdin)
+    execute(stdout, stderr) ? 0 : 1
+  rescue Error => e
+    stderr.puts "#{e.message}\n\n"
+    stderr.puts options
+    1
+  end
+
+  def options
+    @options ||=
+      OptionParser.new do |opts|
+        opts.banner = <<~USAGE
+          Usage: erbf [options] [files/directories/glob]
+
+          By default the output is written to stdout
+
+          Output options:
+
+        USAGE
+        opts.on("-c", "--check", "Check if the files are formatted") do
+          raise Error, "incompatible options: --#{@command} and --check" if @command != :format
+          @command = :check
+        end
+        opts.on("-w", "--write", "Format the files in-place") do
+          raise Error, "incompatible options: --#{@command} and --write" if @command != :format
+          @command = :write
+        end
+        opts.separator <<~USAGE
+
+          Other options:
+
+        USAGE
+        opts.on("--config PATH", String, "Use a config file at a different location") do |path|
+          @config_path = path
+        end
+        opts.on("-h", "--help", "Show this help") do
+          raise Error, "incompatible options: --#{@command} and --help" if @command != :format
+          @command = :help
+        end
+        opts.on("-v", "--version", "Show erbf version") do
+          raise Error, "incompatible options: --#{@command} and --version" if @command != :format
+          @command = :version
+        end
+        opts.separator ""
+      end
+  end
+end

data/lib/erbf/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "logger"
+require "yaml"
+
+class Erbf::Config
+  DEFAULT_FILEPATHS = %w[config/erbf.yml .erbf.yml].freeze
+
+  attr_reader :line_length, :logger, :embedded, :ruby
+
+  def initialize(line_length:, logger:, debug:, embedded:, ruby:)
+    @line_length = line_length
+    @logger = logger
+    @debug = debug
+    @embedded = embedded
+    @ruby = ruby
+  end
+
+  def debug? = @debug
+
+  class << self
+    def load(config_file: nil, **options)
+      opts =
+        default_options.merge(
+          config_file.nil? ? options_from_default_file : options_from_file(config_file),
+          options
+        )
+      new(**opts)
+    end
+
+    def default_embedded
+      prettier = "node_modules/.bin/prettier"
+      if File.exist?(prettier)
+        [
+          {
+            types: %w[text/javascript module],
+            command: "#{prettier} --stdin-filepath file.js --print-width %<line_length>d"
+          },
+          {
+            types: ["text/css"],
+            command: "#{prettier} --stdin-filepath file.css --print-width %<line_length>d"
+          },
+          {
+            types: %w[importmap application/json application/ld+json],
+            command: "#{prettier} --stdin-filepath file.json --print-width %<line_length>d"
+          }
+        ]
+      else
+        []
+      end
+    end
+
+    def default_ruby
+      { formatter: "syntax_tree", syntax_tree_plugins: [] }
+    end
+
+    def default_options
+      {
+        line_length: 80,
+        logger: Logger.new($stderr, level: Logger::WARN),
+        debug: false,
+        embedded: default_embedded,
+        ruby: default_ruby
+      }
+    end
+
+    def options_from_file(path)
+      yaml = YAML.safe_load_file(path, symbolize_names: true)
+      { line_length: yaml[:line_length], embedded: yaml[:embedded], ruby: yaml[:ruby] }.compact
+    end
+
+    def options_from_default_file
+      DEFAULT_FILEPATHS.each do |path|
+        next unless File.exist?(path)
+
+        return options_from_file(path)
+      end
+      {}
+    end
+  end
+end

data/lib/erbf/formatter/embedded_language_formatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Erbf::Formatter::EmbeddedLanguageFormatter
+  def initialize(config)
+    @config = config
+  end
+
+  def supported?(type)
+    !find(type).nil?
+  end
+
+  def format(type, content, line_length)
+    formatter = find(type)
+    return content.chomp if formatter.nil?
+
+    command = sprintf(formatter[:command], line_length: line_length)
+
+    logger.debug(self.class.to_s) { "Formatting #{type}: #{command}" }
+    stdout, stderr, status = Open3.capture3({}, command, { stdin_data: content })
+
+    if status.exitstatus != 0
+      logger.error(self.class.to_s) { "[#{command}] exit status: #{status.exitstatus}" }
+      logger.warn(self.class.to_s) { "[#{command}] stderr output:\n#{stderr}" } unless stderr.empty?
+      logger.debug(self.class.to_s) { "[#{command}] input was:\n#{content}" }
+    end
+
+    status.exitstatus.zero? ? stdout.chomp : content.chomp
+  end
+
+  private
+
+  def find(type)
+    @config.embedded.find { |e| e[:types].include?(type) }
+  end
+
+  def logger
+    @config.logger
+  end
+end

data/lib/erbf/formatter/html_helper.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Erbf::Formatter::HtmlHelper
+  CASE_INSENSITIVE_ATTRIBUTES = %w[id class].to_set.freeze
+  INLINE_TAGS = %w[
+    a
+    abbr
+    acronym
+    b
+    bdo
+    big
+    br
+    button
+    cite
+    code
+    dfn
+    em
+    i
+    img
+    input
+    kbd
+    label
+    map
+    object
+    output
+    q
+    samp
+    select
+    small
+    span
+    strong
+    sub
+    sup
+    textarea
+    time
+    tt
+    var
+  ].to_set.freeze
+
+  private
+
+  def inline?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) || inline_tag?(node)
+  end
+
+  def inline_tag?(node)
+    node.is_a?(Herb::AST::HTMLElementNode) &&
+      INLINE_TAGS.include?(node.open_tag.tag_name.value.downcase)
+  end
+
+  def pre_tag?(node)
+    node.is_a?(Herb::AST::HTMLElementNode) && node.open_tag.tag_name.value.downcase == "pre"
+  end
+
+  def tag_attribute(node, name)
+    attribute =
+      node.open_tag.children.find do |child|
+        child.is_a?(Herb::AST::HTMLAttributeNode) && child.name.name.value.downcase == name.downcase
+      end
+    return nil if attribute.nil?
+
+    value_children = attribute.value.children
+
+    if value_children.size == 1 && value_children.first.is_a?(Herb::AST::LiteralNode)
+      value_children.first.content
+    else
+      :dynamic
+    end
+  end
+
+  def case_insensitive_attribute_name?(node)
+    CASE_INSENSITIVE_ATTRIBUTES.include?(node.name.value.downcase)
+  end
+
+  def br_tag?(node)
+    node.is_a?(Herb::AST::HTMLElementNode) && node.open_tag.tag_name.value.downcase == "br"
+  end
+
+  def starts_with_whitespace?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\A\s/
+  end
+
+  def ends_with_whitespace?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\s\z/
+  end
+
+  def ends_with_double_newline?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\n\s*\n\z/
+  end
+
+  def ends_with_newline?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\n\z/
+  end
+
+  def begins_with_double_newline?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\A\n\s*\n/
+  end
+
+  def begins_with_newline?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\A\n/
+  end
+
+  def blank_node?(node)
+    node.is_a?(Herb::AST::HTMLTextNode) && node.content =~ /\A\s+\z/
+  end
+
+  def text_node?(node)
+    node.is_a?(Herb::AST::HTMLTextNode)
+  end
+end

data/lib/erbf/formatter/prettier_print_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Erbf::Formatter::PrettierPrintHelper
+  private
+
+  def current_indent_level
+    queue = [[0, q.groups.first]]
+    while (indent, node = queue.shift)
+      next_indent = indent
+
+      case node
+      when PrettierPrint::Indent
+        next_indent += 2
+      when PrettierPrint::Align
+        next_indent += node.indent
+      end
+
+      case node
+      when PrettierPrint::Indent, PrettierPrint::Align, PrettierPrint::Group,
+           PrettierPrint::LineSuffix
+        return indent if node.contents.equal?(q.target)
+
+        queue += node.contents.map { |child| [next_indent, child] }
+      when PrettierPrint::IfBreak
+        return indent if node.flat_contents.equal?(q.target) || node.break_contents.equal?(q.target)
+
+        queue += (node.flat_contents + node.break_contents).map { |child| [next_indent, child] }
+      end
+    end
+
+    nil
+  end
+end

data/lib/erbf/formatter/ruby_formatter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class Erbf::Formatter::RubyFormatter
+  def initialize(config)
+    @config = config
+    @loaded = false
+  end
+
+  def format(code, line_length)
+    formatter.call(code, line_length)
+  end
+
+  def format_incomplete(code, line_length)
+    code = code.strip
+    keyword = code[/\A[a-z]+/]
+    case keyword
+    when "if", "unless", "while", "until", "for", "begin"
+      format([code, "end"].join("\n"), line_length).delete_suffix("end").rstrip
+    when "elsif"
+      format(["if a", code, "end"].join("\n"), line_length)
+        .delete_prefix("if a")
+        .delete_suffix("end")
+        .strip
+    when "case"
+      format([code, "when true", "end"].join("\n"), line_length)
+        .delete_suffix("end")
+        .rstrip
+        .delete_suffix("when true")
+        .rstrip
+    when "when", "in"
+      format(["case a", code, "end"].join("\n"), line_length)
+        .delete_prefix("case a")
+        .delete_suffix("end")
+        .strip
+    when "rescue", "ensure"
+      format(["begin", code, "end"].join("\n"), line_length)
+        .delete_prefix("begin")
+        .delete_suffix("end")
+        .strip
+    else
+      if code =~ /(do|{)\s*(\|[\s,()\w-]+\|)?\z/
+        if Regexp.last_match(1) == "{"
+          format([code, "}"].join("\n"), line_length).delete_suffix("}").rstrip
+        else
+          # Formatter may convert short `do end` into `{}`, so let's add content
+          format([code, "a" * line_length, "end"].join("\n"), line_length)
+            .delete_suffix("end")
+            .rstrip
+            .delete_suffix("a" * line_length)
+            .rstrip
+        end
+      else
+        @config.logger.warn(self.class.to_s) { "Can't handle incomplete ruby: #{code}" }
+        code
+      end
+    end
+  end
+
+  private
+
+  def formatter
+    @formatter ||=
+      case @config.ruby[:formatter]
+      when nil
+        @config.logger.debug(self.class.to_s) { "Using null formatter" }
+        method(:null_format)
+      when "syntax_tree"
+        begin
+          require "syntax_tree"
+          (@config.ruby[:syntax_tree_plugins] || []).each do |plugin|
+            require "syntax_tree/#{plugin}"
+          end
+          @config.logger.debug(self.class.to_s) { "Using syntax_tree formatter" }
+          method(:syntax_tree_format)
+        rescue LoadError => e
+          @config.logger.error(self.class.to_s) { e.to_s }
+          method(:null_format)
+        end
+      else
+        @config
+          .logger
+          .error(self.class.to_s) { "Unsupported Ruby formatter: #{@config.ruby[:formatter]}" }
+        method(:null_format)
+      end
+  end
+
+  def null_format(code, _line_length)
+    code.strip
+  end
+
+  def syntax_tree_format(code, line_length)
+    SyntaxTree.format(code, line_length).chomp
+  end
+end

data/lib/erbf/formatter.rb

@@ -0,0 +1,537 @@
+# frozen_string_literal: true
+
+class Erbf::Formatter
+  autoload :HtmlHelper, "erbf/formatter/html_helper"
+  autoload :PrettierPrintHelper, "erbf/formatter/prettier_print_helper"
+  autoload :EmbeddedLanguageFormatter, "erbf/formatter/embedded_language_formatter"
+  autoload :RubyFormatter, "erbf/formatter/ruby_formatter"
+
+  include HtmlHelper
+  include PrettierPrintHelper
+
+  def initialize(q, config)
+    @q = q
+    @context = []
+    @config = config
+    @embedded_language = EmbeddedLanguageFormatter.new(config)
+    @ruby = RubyFormatter.new(config)
+  end
+
+  def visit(node)
+    debug { "visiting #{node.class}" }
+    case node
+    when Herb::AST::DocumentNode
+      visit_document(node)
+    when Herb::AST::WhitespaceNode
+      visit_whitespace(node)
+    when Herb::AST::LiteralNode
+      visit_literal(node)
+    when Herb::AST::HTMLDoctypeNode
+      visit_html_doctype(node)
+    when Herb::AST::HTMLCommentNode
+      visit_html_comment(node)
+    when Herb::AST::HTMLElementNode
+      visit_html_element(node)
+    when Herb::AST::HTMLOpenTagNode
+      visit_html_open_tag(node)
+    when Herb::AST::HTMLCloseTagNode
+      visit_html_close_tag(node)
+    when Herb::AST::HTMLSelfCloseTagNode
+      visit_html_self_close_tag(node)
+    when Herb::AST::HTMLAttributeNode
+      visit_html_attribute(node)
+    when Herb::AST::HTMLAttributeNameNode
+      visit_html_attribute_name(node)
+    when Herb::AST::HTMLAttributeValueNode
+      visit_html_attribute_value(node)
+    when Herb::AST::HTMLTextNode
+      visit_html_text(node)
+    when Herb::AST::ERBIfNode
+      visit_erb_if(node)
+    when Herb::AST::ERBUnlessNode
+      visit_erb_unless(node)
+    when Herb::AST::ERBElseNode
+      visit_erb_else(node)
+    when Herb::AST::ERBCaseNode
+      visit_erb_case(node)
+    when Herb::AST::ERBWhenNode
+      visit_erb_when(node)
+    when Herb::AST::ERBWhileNode
+      visit_erb_while(node)
+    when Herb::AST::ERBUntilNode
+      visit_erb_until(node)
+    when Herb::AST::ERBBlockNode
+      visit_erb_block(node)
+    when Herb::AST::ERBForNode
+      visit_erb_for(node)
+    when Herb::AST::ERBRescueNode
+      visit_erb_rescue(node)
+    when Herb::AST::ERBBeginNode
+      visit_erb_begin(node)
+    when Herb::AST::ERBEnsureNode
+      visit_erb_ensure(node)
+    when Herb::AST::ERBContentNode
+      visit_erb_content(node)
+    when Herb::AST::ERBEndNode
+      visit_erb_end(node)
+    end
+  end
+
+  private
+
+  attr_reader :q
+
+  def visit_document(node)
+    visit_elements(node.children)
+  end
+
+  def visit_html_doctype(node)
+    q.text(node.tag_opening.value.downcase)
+    node.children.each(&method(:visit))
+    q.text(node.tag_closing.value)
+  end
+
+  def visit_html_element(node)
+    if node.is_void
+      debug { "<#{node.open_tag.tag_name.value}> void" }
+      q.group do
+        visit(node.open_tag)
+        q.breakable(" ")
+        q.text("/>")
+      end
+    elsif inline_tag?(node)
+      debug { "<#{node.open_tag.tag_name.value}> inline" }
+      q.group do
+        visit(node.open_tag)
+        q.indent do
+          q.breakable("")
+          q.text(">")
+          visit_elements(node.body)
+          visit(node.close_tag) if node.close_tag
+        end
+        if node.close_tag
+          q.breakable("")
+          q.text(">")
+        end
+      end
+    else
+      debug { "<#{node.open_tag.tag_name.value}> block" }
+      q.group do
+        q.group do
+          visit(node.open_tag)
+          q.breakable("") if node.body.any?
+          q.text(">")
+        end
+        if node.body.any?
+          if pre_tag?(node)
+            debug { "pre" }
+            q.breakable("", indent: false)
+            with_context(:preserve_whitespace) { node.body.each { |child| visit(child) } }
+          elsif (language = embedded_language(node))
+            debug { "embedded language: #{language}" }
+            if @embedded_language.supported?(language) && node.body.size == 1 &&
+                 text_node?(node.body.first)
+              debug { "formatting" }
+              q.indent do
+                q.breakable("")
+                lines =
+                  @embedded_language.format(
+                    language,
+                    node.body.first.content,
+                    [@config.line_length - current_indent_level, 1].max
+                  ).lines
+                print_formatted_lines(lines)
+              end
+            else
+              debug { "unsupported or more than 1 child node" }
+              q.indent do
+                q.breakable("")
+                with_context(:preserve_whitespace) { node.body.each { |child| visit(child) } }
+              end
+            end
+          else
+            debug { "normal block" }
+            q.indent do
+              q.breakable("")
+              visit_elements(node.body)
+            end
+          end
+        end
+        if node.close_tag
+          q.breakable("") unless pre_tag?(node)
+          visit(node.close_tag)
+          q.text(">")
+        end
+      end
+    end
+  end
+
+  def visit_html_open_tag(node)
+    q.group do
+      q.text("<")
+      q.text(node.tag_name.value.downcase)
+      if node.children.any?
+        q.indent do
+          q.breakable(" ")
+          q.seplist(node.children, -> { q.breakable(" ") }) { |child| visit(child) }
+        end
+      end
+    end
+    # The > is handled in #visit_html_element
+  end
+
+  def visit_html_close_tag(node)
+    q.text("</")
+    q.text(node.tag_name.value.downcase)
+    # The > is handled in #visit_html_element
+  end
+
+  def visit_html_attribute(node)
+    visit(node.name)
+    q.text("=") if node.value
+    visit(node.value)
+  end
+
+  def visit_html_attribute_name(node)
+    q.text(case_insensitive_attribute_name?(node) ? node.name.value.downcase : node.name.value)
+  end
+
+  def visit_html_attribute_value(node)
+    if node.children.size == 1 && node.children.first.is_a?(Herb::AST::LiteralNode)
+      # The value is a literal, so we can process it to find the optimal way to quote it
+      value = node.children.first.content
+      quotes_count = value.scan(/"|&quot;|&#34;/i).count
+      apostrophes_count = value.scan(/'|&apos;|&#39;/i).count
+      if quotes_count > apostrophes_count
+        q.text("'")
+        q.text(value.gsub(/"|&quot;|&#34/i, '"').gsub(/'|&apos;|&#39;/i, "&apos;"))
+        q.text("'")
+      else
+        q.text('"')
+        q.text(value.gsub(/"|&quot;|&#34/i, "&quot;").gsub(/'|&apos;|&#39;/i, "'"))
+        q.text('"')
+      end
+    else
+      q.text(node.open_quote.value) if node.quoted
+      node.children.each(&method(:visit))
+      q.text(node.close_quote.value) if node.quoted
+    end
+  end
+
+  def visit_literal(node)
+    q.text(node.content)
+  end
+
+  def visit_html_text(node)
+    if context?(:preserve_whitespace)
+      q.group { q.text(node.content) }
+      return
+    end
+
+    content = node.content.gsub(/\s+/, " ").strip
+
+    q.group do
+      content.split.each.with_index do |word, index|
+        q.fill_breakable(" ") if index.positive?
+        q.text(word)
+      end
+    end
+  end
+
+  def visit_html_comment(node)
+    q.text("<!--")
+    node.children.each(&method(:visit))
+    q.text("-->")
+  end
+
+  def visit_erb_content(node)
+    q.text(node.tag_opening.value)
+
+    # Don't format comments
+    if node.tag_opening.value == "<%#"
+      q.text(node.content.value)
+      q.text(node.tag_closing.value)
+      return
+    end
+
+    q.indent do
+      q.breakable(" ")
+
+      lines = format_ruby(node.content.value)
+      print_formatted_lines(lines)
+    end
+
+    q.breakable(" ")
+    q.text(node.tag_closing.value)
+  end
+
+  def visit_erb_if(node)
+    visit_erb_keyword(node) do
+      if node.subsequent
+        q.breakable("")
+        visit(node.subsequent)
+      end
+    end
+  end
+
+  def visit_erb_unless(node)
+    visit_erb_keyword(node) do
+      if node.else_clause
+        q.breakable("")
+        visit(node.else_clause)
+      end
+    end
+  end
+
+  def visit_erb_case(node)
+    visit_erb_keyword(node, can_have_statements: false) do
+      # "children" are the thing between "case condition" and "when value"
+      # Valid values are basically whitespace and ERB comments
+      if node.children.any?
+        q.breakable("")
+        visit_elements(node.children)
+      end
+
+      if node.conditions.any?
+        q.breakable("")
+        visit_elements(node.conditions)
+      end
+
+      if node.else_clause
+        q.breakable("")
+        visit(node.else_clause)
+      end
+    end
+  end
+
+  def visit_erb_when(node)
+    visit_erb_keyword(node, can_have_end: false)
+  end
+
+  def visit_erb_else(node)
+    q.group do
+      q.text(node.tag_opening.value)
+      q.breakable(" ")
+      q.text(node.content.value.strip)
+      q.breakable(" ")
+      q.text(node.tag_closing.value)
+    end
+
+    if node.statements.any?
+      q.indent do
+        q.breakable("")
+        visit_elements(node.statements)
+      end
+    end
+  end
+
+  def visit_erb_while(node)
+    visit_erb_keyword(node)
+  end
+
+  def visit_erb_until(node)
+    visit_erb_keyword(node)
+  end
+
+  def visit_erb_for(node)
+    visit_erb_keyword(node)
+  end
+
+  def visit_erb_begin(node)
+    visit_erb_keyword(node) do
+      if node.rescue_clause
+        q.breakable("")
+        visit(node.rescue_clause)
+      end
+
+      if node.else_clause
+        q.breakable("")
+        visit(node.else_clause)
+      end
+
+      if node.ensure_clause
+        q.breakable("")
+        visit(node.ensure_clause)
+      end
+    end
+  end
+
+  def visit_erb_rescue(node)
+    visit_erb_keyword(node, can_have_end: false) do
+      if node.subsequent
+        q.breakable("")
+        visit(node.subsequent)
+      end
+    end
+  end
+
+  def visit_erb_ensure(node)
+    visit_erb_keyword(node, can_have_end: false)
+  end
+
+  def visit_erb_block(node)
+    visit_erb_keyword(node, can_have_statements: false) do
+      if node.body.any?
+        q.indent do
+          q.breakable("")
+          visit_elements(node.body)
+        end
+      end
+    end
+  end
+
+  def visit_erb_end(node)
+    q.group do
+      q.text(node.tag_opening.value)
+      q.breakable(" ")
+      q.text(node.content.value.strip)
+      q.breakable(" ")
+      q.text(node.tag_closing.value)
+    end
+  end
+
+  def visit_erb_keyword(node, can_have_statements: true, can_have_end: true, &block)
+    q.group do
+      q.text(node.tag_opening.value)
+
+      q.indent do
+        q.breakable(" ")
+
+        lines = format_incomplete_ruby(node.content.value)
+        print_formatted_lines(lines)
+      end
+
+      q.breakable(" ")
+      q.text(node.tag_closing.value)
+    end
+
+    if can_have_statements && node.statements.any?
+      q.indent do
+        q.breakable("")
+        visit_elements(node.statements)
+      end
+    end
+
+    block.call if block_given?
+
+    if can_have_end && node.end_node
+      q.breakable("")
+      visit(node.end_node)
+    end
+  end
+
+  def visit_elements(children)
+    if children.size == 1
+      visit(children.first)
+      return
+    end
+
+    groups =
+      children
+        .slice_when do |prev_child, next_child|
+          ends_with_double_newline?(prev_child) || begins_with_double_newline?(next_child)
+        end
+        .map do |group|
+          group.drop_while(&method(:blank_node?)).reverse.drop_while(&method(:blank_node?)).reverse
+        end
+        .reject(&:empty?)
+
+    break_next = false
+
+    (groups + [nil]).each_cons(2) do |group, next_group|
+      q.group do
+        (group + [nil]).each_cons(2) do |child, next_child|
+          next if blank_node?(child)
+
+          if break_next
+            q.group do
+              q.breakable(" ")
+              visit(child)
+            end
+            break_next = false
+          else
+            visit(child)
+          end
+
+          next if next_child.nil?
+
+          if br_tag?(child) && starts_with_whitespace?(next_child)
+            debug { "breakable(force) after <br> tag" }
+            q.breakable(force: true)
+          elsif inline?(child) && inline?(next_child)
+            if starts_with_whitespace?(next_child)
+              debug { "adding a break before whitespace" }
+              q.with_target(q.target.last.contents) { q.breakable(" ") }
+            elsif ends_with_whitespace?(child)
+              debug { "will add a break after whitespace" }
+              break_next = true
+            else
+              debug { "fill_breakable('') between inline/text without separating whitespace" }
+              q.fill_breakable("")
+            end
+          else
+            q.breakable(force: true)
+          end
+        end
+      end
+      next if next_group.nil?
+
+      q.breakable(force: true)
+      q.breakable(force: true)
+    end
+  end
+
+  def with_context(context)
+    @context.push(context)
+    yield
+  ensure
+    @context.pop
+  end
+
+  def context?(value)
+    @context.last == value
+  end
+
+  def embedded_language(node)
+    return nil unless node.is_a?(Herb::AST::HTMLElementNode)
+
+    case node.open_tag.tag_name.value.downcase
+    when "script"
+      normalize_type(tag_attribute(node, "type"), "text/javascript")
+    when "style"
+      normalize_type(tag_attribute(node, "type"), "text/css")
+    end
+  end
+
+  def normalize_type(value, default)
+    case value
+    when String
+      value.downcase
+    when :dynamic
+      "unknown"
+    else
+      default
+    end
+  end
+
+  def format_ruby(code)
+    @ruby.format(code, [@config.line_length - current_indent_level, 1].max).lines
+  end
+
+  def format_incomplete_ruby(code)
+    @ruby.format_incomplete(code, [@config.line_length - current_indent_level, 1].max).lines
+  end
+
+  def print_formatted_lines(lines)
+    (lines + [nil]).each_cons(2) do |line, next_line|
+      break if line.nil?
+
+      q.text(line.chomp)
+      q.breakable(force: true) unless next_line.nil?
+    end
+  end
+
+  def debug(&block)
+    @config.logger.debug(self.class.to_s, &block)
+  end
+end

data/lib/erbf/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Erbf
+  VERSION = "0.1.0"
+end

data/lib/erbf.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "herb"
+require "prettier_print"
+require "pp"
+
+class Erbf
+  autoload :Config, "erbf/config"
+  autoload :Formatter, "erbf/formatter"
+  autoload :CLI, "erbf/cli"
+  autoload :VERSION, "erbf/version"
+
+  def initialize(config_or_options = {})
+    @config =
+      (config_or_options.is_a?(Config) ? config_or_options : Config.load(**config_or_options))
+    @logger = @config.logger
+    @logger.debug! if @config.debug?
+  end
+
+  def format_code(input)
+    result = Herb.parse(input)
+    # TODO: Handle errors
+    format_ast(result.value)
+  end
+
+  def format_ast(ast_node)
+    PrettierPrint.format(+"", @config.line_length) do |q|
+      @logger.debug(to_s) { "AST:\n#{PP.pp(ast_node, +"", 80)}" }
+      # TODO: Use Herb::Visitor
+      Formatter.new(q, @config).visit(ast_node)
+      @logger.debug(to_s) { "Formatted:\n#{PP.pp(q.target, +"", 80)}" }
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: erbf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomasz Szczęśniak-Szlagowski
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: herb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: prettier_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: It breaks longs lines and integrates with Ruby and JS/CSS formatters
+email:
+- spect88@gmail.com
+executables:
+- erbf
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".streerc"
+- LICENSE.txt
+- README.md
+- exe/erbf
+- lib/erbf.rb
+- lib/erbf/cli.rb
+- lib/erbf/config.rb
+- lib/erbf/formatter.rb
+- lib/erbf/formatter/embedded_language_formatter.rb
+- lib/erbf/formatter/html_helper.rb
+- lib/erbf/formatter/prettier_print_helper.rb
+- lib/erbf/formatter/ruby_formatter.rb
+- lib/erbf/version.rb
+homepage: https://github.com/spect88/erbf
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/spect88/erbf
+  source_code_uri: https://github.com/spect88/erbf
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A formatter for .html.erb files
+test_files: []