htmlformatter 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5ebc277c83a5ccab865848d6aeb362fc75d2f79e873521840c11bb279462a9e
+  data.tar.gz: 5068a689fedc3844836affa11eb2fa2afb0018073be7802f22f7fa5b1068f4bf
+SHA512:
+  metadata.gz: 578e632d90a7c13840b0f195e0eba4f983f9f4ddd4d3ce7c63e6f1197d5cb88765a8496af8057e33c69037806a45d0b57cd54cf765ed78c504b61bb241d9c8ab
+  data.tar.gz: 4a88997ed83e8086e696ccd053c9af830bca8ac8f6d0377ab612aa5a6d9812df2b0951312e74caf8849d1478c16e9d0604d5bc6952f1433b2518e1830590f360

data/README.md

@@ -0,0 +1,71 @@
+# HTML Formatter
+
+A normaliser/formatter for HTML that also understands embedded Ruby and Elixir.
+Ideal for tidying up Rails and Phoenix templates.
+
+## What it does
+
+* Normalises hard tabs to spaces (or vice versa)
+* Removes trailing spaces
+* Indents after opening HTML elements
+* Outdents before closing elements
+* Collapses multiple whitespace
+* Indents after block-opening embedded Ruby or Elixir (if, do etc.)
+* Outdents before closing Ruby or Elixir blocks
+* Outdents elsif and then indents again
+* Indents the left-hand margin of JavaScript and CSS blocks to match the
+  indentation level of the code
+
+## Usage
+
+### From the command line
+
+To update files in-place:
+
+``` sh
+$ htmlformatter file1 [file2 ...]
+```
+
+or to operate on standard input and output:
+
+``` sh
+$ htmlformatter < input > output
+```
+
+### In your code
+
+```ruby
+require 'htmlformatter'
+
+formatted = HtmlFormatter.format(messy)
+```
+
+You can also specify how to indent (the default is two spaces):
+
+```ruby
+formatted = HtmlFormatter.format(messy, indent: "\t")
+```
+
+## Installation
+
+This is a Ruby gem.
+To install the command-line tool (you may need `sudo`):
+
+```sh
+$ gem install htmlformatter
+```
+
+To use the gem with Bundler, add to your `Gemfile`:
+
+```ruby
+gem 'htmlformatter'
+```
+
+## Contributing
+
+1. Follow [these guidelines][git-commit] when writing commit messages (briefly,
+   the first line should begin with a capital letter, use the imperative mood,
+   be no more than 50 characters, and not end with a period).
+2. Include tests.
+
+[git-commit]:http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html

data/Rakefile

@@ -0,0 +1,16 @@
+require "rspec/core/rake_task"
+
+desc "Run the specs."
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = false
+end
+
+task :default => [:spec]
+
+if Gem.loaded_specs.key?('rubocop')
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+
+  task(:default).prerequisites << task(:rubocop)
+end

data/bin/htmlformatter

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+require "htmlformatter"
+require "optparse"
+require "fileutils"
+
+def format(name, input, output, options)
+  output.puts HtmlFormatter.format(input, options)
+rescue => e
+  raise "Error parsing #{name}: #{e}"
+end
+
+executable = File.basename(__FILE__)
+
+options = { indent: "  " }
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{executable} [options] [file ...]"
+  opts.separator <<END
+
+#{executable} has two modes of operation:
+
+1. If no files are listed, it will read from standard input and write to
+   standard output.
+2. If files are listed, it will modify each file in place, overwriting it
+   with the formatted output.
+
+The following options are available:
+
+END
+  opts.on(
+    "-t", "--tab-stops NUMBER", Integer,
+    "Set number of spaces per indent (default #{options[:tab_stops]})"
+  ) do |num|
+    options[:indent] = " " * num
+  end
+  opts.on(
+    "-T", "--tab",
+    "Indent using tabs"
+  ) do
+    options[:indent] = "\t"
+  end
+  opts.on(
+    "-i", "--indent-by NUMBER", Integer,
+    "Indent the output by NUMBER steps (default 0)."
+  ) do |num|
+    options[:initial_level] = num
+  end
+  opts.on(
+    "-e", "--stop-on-errors",
+    "Stop when invalid nesting is encountered in the input"
+  ) do |num|
+    options[:stop_on_errors] = num
+  end
+  opts.on(
+    "-b", "--keep-blank-lines NUMBER", Integer,
+    "Set number of consecutive blank lines"
+  ) do |num|
+    options[:keep_blank_lines] = num
+  end
+  opts.on(
+    "-n", "--engine STRING", String,
+    "Use engine STRING (default erb, allowed: eex)."
+  ) do |eng|
+    options[:engine] = eng
+  end
+  opts.on(
+    "-h", "--help",
+    "Display this help message and exit"
+  ) do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+if ARGV.any?
+  ARGV.each do |path|
+    input = File.read(path)
+    temppath = path + ".tmp"
+    File.open(temppath, "w") do |output|
+      format path, input, output, options
+    end
+    FileUtils.mv temppath, path
+  end
+else
+  format "standard input", $stdin.read, $stdout, options
+end

data/lib/htmlformatter.rb

@@ -0,0 +1,29 @@
+require "htmlformatter/builder"
+require "htmlformatter/html_parser"
+require "htmlformatter/version"
+
+module HtmlFormatter
+  #
+  # Returns a formatted HTML/HTML+EEX document as a String.
+  # html must be an object that responds to +#to_s+.
+  #
+  # Available options are:
+  # tab_stops - an integer for the number of spaces to indent, default 2.
+  # Deprecated: see indent.
+  # indent - what to indent with ("  ", "\t" etc.), default "  "
+  # stop_on_errors - raise an exception on a badly-formed document. Default
+  # is false, i.e. continue to process the rest of the document.
+  # initial_level - The entire output will be indented by this number of steps.
+  # Default is 0.
+  # keep_blank_lines - an integer for the number of consecutive empty lines
+  # to keep in output.
+  #
+  def self.format(html, options = {})
+    if options[:tab_stops]
+      options[:indent] = " " * options[:tab_stops]
+    end
+    "".tap { |output|
+      HtmlParser.new.scan html.to_s, Builder.new(output, options)
+    }
+  end
+end

data/lib/htmlformatter/builder.rb

@@ -0,0 +1,147 @@
+require "htmlformatter/parser"
+require "htmlformatter/ruby_indenter"
+require "htmlformatter/elixir_indenter"
+
+module HtmlFormatter
+  class Builder
+    DEFAULT_OPTIONS = {
+      indent: "  ",
+      initial_level: 0,
+      stop_on_errors: false,
+      keep_blank_lines: 0
+    }
+
+    def initialize(output, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      @tab = options[:indent]
+      @stop_on_errors = options[:stop_on_errors]
+      @level = options[:initial_level]
+      @keep_blank_lines = options[:keep_blank_lines]
+      @new_line = false
+      @empty = true
+      @ie_cc_levels = []
+      @output = output
+
+      if options[:engine] == "eex"
+        @embedded_indenter = ElixirIndenter.new
+      else
+        @embedded_indenter = RubyIndenter.new
+      end
+    end
+
+  private
+
+    def error(text)
+      return unless @stop_on_errors
+      raise text
+    end
+
+    def indent
+      @level += 1
+    end
+
+    def outdent
+      error "Extraneous closing tag" if @level == 0
+      @level = [@level - 1, 0].max
+    end
+
+    def emit(*strings)
+      @output << "\n" if @new_line && !@empty
+      @output << (@tab * @level) if @new_line
+      @output << strings.join("")
+      @new_line = false
+      @empty = false
+    end
+
+    def new_line
+      @new_line = true
+    end
+
+    def embed(opening, code, closing)
+      lines = code.split(%r{\n}).map(&:strip)
+      outdent if @embedded_indenter.outdent?(lines)
+      emit opening, code, closing
+      indent if @embedded_indenter.indent?(lines)
+    end
+
+    def foreign_block(opening, code, closing)
+      emit opening
+      emit_reindented_block_content code unless code.strip.empty?
+      emit closing
+    end
+
+    def emit_reindented_block_content(code)
+      lines = code.strip.split(%r{\n})
+      indentation = foreign_block_indentation(code)
+
+      indent
+      new_line
+      lines.each do |line|
+        emit line.rstrip.sub(%r{^#{indentation}}, "")
+        new_line
+      end
+      outdent
+    end
+
+    def foreign_block_indentation(code)
+      code.split(%r{\n}).find { |ln| !ln.strip.empty? }[%r{^\s+}]
+    end
+
+    def preformatted_block(opening, content, closing)
+      new_line
+      emit opening, content, closing
+      new_line
+    end
+
+    def standalone_element(e)
+      emit e
+      new_line if e =~ %r{^<br[^\w]}
+    end
+
+    def close_element(e)
+      outdent
+      emit e
+    end
+
+    def close_block_element(e)
+      close_element e
+      new_line
+    end
+
+    def open_element(e)
+      emit e
+      indent
+    end
+
+    def open_block_element(e)
+      new_line
+      open_element e
+    end
+
+    def close_ie_cc(e)
+      if @ie_cc_levels.empty?
+        error "Unclosed conditional comment"
+      else
+        @level = @ie_cc_levels.pop
+      end
+      emit e
+    end
+
+    def open_ie_cc(e)
+      emit e
+      @ie_cc_levels.push @level
+      indent
+    end
+
+    def new_lines(*content)
+      blank_lines = content.first.scan(%r{\n}).count - 1
+      blank_lines = [blank_lines, @keep_blank_lines].min
+      @output << "\n" * blank_lines
+      new_line
+    end
+
+    def text(t)
+      emit t
+    end
+  end
+end

data/lib/htmlformatter/elixir_indenter.rb

@@ -0,0 +1,19 @@
+module HtmlFormatter
+  class ElixirIndenter
+    INDENT_KEYWORDS = %w[ else ]
+    OUTDENT_KEYWORDS = %w[ else end ]
+    ELIXIR_INDENT  = %r{
+      ^ ( #{INDENT_KEYWORDS.join("|")} )\b
+      | ( -\> | do ) $
+    }xo
+    ELIXIR_OUTDENT = %r{ ^ ( #{OUTDENT_KEYWORDS.join("|")} | \} ) \b }xo
+
+    def outdent?(lines)
+      lines.first =~ ELIXIR_OUTDENT
+    end
+
+    def indent?(lines)
+      lines.last =~ ELIXIR_INDENT
+    end
+  end
+end

data/lib/htmlformatter/html_parser.rb

@@ -0,0 +1,61 @@
+require "htmlformatter/parser"
+
+module HtmlFormatter
+  class HtmlParser < Parser
+    ELEMENT_CONTENT = %r{ (?:<%.*?%>|[^>])* }mx
+    HTML_VOID_ELEMENTS = %r{(?:
+      area | base | br | col | command | embed | hr | img | input | keygen |
+      link | meta | param | source | track | wbr
+    )}mix
+    HTML_BLOCK_ELEMENTS = %r{(?:
+      address | article | aside | audio | blockquote | canvas | dd | dir | div |
+      dl | dt | fieldset | figcaption | figure | footer | form | h1 | h2 | h3 |
+      h4 | h5 | h6 | header | hr | li | menu | noframes | noscript | ol | p |
+      pre | section | table | tbody | td | tfoot | th | thead | tr | ul | video
+    )}mix
+
+    MAPPINGS = [
+      [%r{(<%-?=?)(.*?)(-?%>)}om,
+       :embed],
+      [%r{<!--\[.*?\]>}om,
+       :open_ie_cc],
+      [%r{<!\[.*?\]-->}om,
+       :close_ie_cc],
+      [%r{<!--.*?-->}om,
+       :standalone_element],
+      [%r{<!.*?>}om,
+       :standalone_element],
+      [%r{(<script#{ELEMENT_CONTENT}>)(.*?)(</script>)}omi,
+       :foreign_block],
+      [%r{(<style#{ELEMENT_CONTENT}>)(.*?)(</style>)}omi,
+       :foreign_block],
+      [%r{(<pre#{ELEMENT_CONTENT}>)(.*?)(</pre>)}omi,
+       :preformatted_block],
+      [%r{(<textarea#{ELEMENT_CONTENT}>)(.*?)(</textarea>)}omi,
+       :preformatted_block],
+      [%r{<#{HTML_VOID_ELEMENTS}(?: #{ELEMENT_CONTENT})?/?>}om,
+       :standalone_element],
+      [%r{<\w+(?: #{ELEMENT_CONTENT})?/>}om,
+       :standalone_element],
+      [%r{</#{HTML_BLOCK_ELEMENTS}>}om,
+       :close_block_element],
+      [%r{<#{HTML_BLOCK_ELEMENTS}(?: #{ELEMENT_CONTENT})?>}om,
+       :open_block_element],
+      [%r{</#{ELEMENT_CONTENT}>}om,
+       :close_element],
+      [%r{<#{ELEMENT_CONTENT}>}om,
+       :open_element],
+      [%r{(\s*\r?\n\s*)+}om,
+       :new_lines],
+      [%r{[^<\n]+},
+       :text]]
+
+    def initialize
+      super do |p|
+        MAPPINGS.each do |regexp, method|
+          p.map regexp, method
+        end
+      end
+    end
+  end
+end

data/lib/htmlformatter/parser.rb

@@ -0,0 +1,48 @@
+require "strscan"
+
+module HtmlFormatter
+  class Parser
+    def initialize
+      @maps = []
+      yield self if block_given?
+    end
+
+    def map(pattern, method)
+      @maps << [pattern, method]
+    end
+
+    def scan(subject, receiver)
+      @scanner = StringScanner.new(subject)
+      dispatch(receiver) until @scanner.eos?
+    end
+
+    def source_so_far
+      @scanner.string[0...@scanner.pos]
+    end
+
+    def source_line_number
+      [source_so_far.chomp.split(%r{\n}).count, 1].max
+    end
+
+  private
+
+    def dispatch(receiver)
+      _, method = @maps.find { |pattern, _| @scanner.scan(pattern) }
+      raise "Unmatched sequence" unless method
+      receiver.__send__(method, *extract_params(@scanner))
+    rescue => ex
+      raise "#{ex.message} on line #{source_line_number}"
+    end
+
+    def extract_params(scanner)
+      return [scanner[0]] unless scanner[1]
+      params = []
+      i = 1
+      while scanner[i]
+        params << scanner[i]
+        i += 1
+      end
+      params
+    end
+  end
+end

data/lib/htmlformatter/ruby_indenter.rb

@@ -0,0 +1,19 @@
+module HtmlFormatter
+  class RubyIndenter
+    INDENT_KEYWORDS = %w[ if elsif else unless while until begin for ]
+    OUTDENT_KEYWORDS = %w[ elsif else end ]
+    RUBY_INDENT  = %r{
+      ^ ( #{INDENT_KEYWORDS.join("|")} )\b
+      | \b ( do | \{ ) ( \s* \| [^\|]+ \| )? $
+    }xo
+    RUBY_OUTDENT = %r{ ^ ( #{OUTDENT_KEYWORDS.join("|")} | \} ) \b }xo
+
+    def outdent?(lines)
+      lines.first =~ RUBY_OUTDENT
+    end
+
+    def indent?(lines)
+      lines.last =~ RUBY_INDENT
+    end
+  end
+end

data/lib/htmlformatter/version.rb

@@ -0,0 +1,9 @@
+module HtmlFormatter #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 5
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join(".")
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: htmlformatter
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+platform: ruby
+authors:
+- Paul Battley
+- Bartosz Kalinowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+description: A normaliser/formatter for HTML that also understands embedded Ruby and
+  Elixir.
+email: kelostrada@gmail.com
+executables:
+- htmlformatter
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/htmlformatter
+- lib/htmlformatter.rb
+- lib/htmlformatter/builder.rb
+- lib/htmlformatter/elixir_indenter.rb
+- lib/htmlformatter/html_parser.rb
+- lib/htmlformatter/parser.rb
+- lib/htmlformatter/ruby_indenter.rb
+- lib/htmlformatter/version.rb
+homepage: http://github.com/kelostrada/htmlformatter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: HTML/ERB/EEX formatter
+test_files: []