slimx 0.1.0

data/lib/slimx/formatter.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module SlimX
+  # Rewrites a template in its canonical layout. Text blocks shift as a whole, so the whitespace they render is
+  # kept; and the formatted template must compile to the same Ruby as the original, or nothing is rewritten.
+  class Formatter
+    INDENT_WIDTH = 2
+    CONTROL = /\A-\s*/
+    OUTPUT = /\A(==?)([<>]*)\s*/
+    TAG_OUTPUT = /\A\s*(==?)(['<>]*)\s*/
+    REDUNDANT_DIV = /\Adiv(?=[.#][\p{Word}-])/
+
+    def self.call(source, **)
+      new(**).call(source)
+    end
+
+    def initialize(shortcuts: Shortcuts::DEFAULT, tailwind_classes: SlimX.tailwind_classes)
+      @shortcuts = shortcuts
+      @tailwind_classes = tailwind_classes
+    end
+
+    def call(source)
+      formatted = layout(source)
+      return formatted if formatted == source || compiled(formatted) == compiled(source)
+
+      raise UnsafeFormattingError, "Formatting would change how this template renders"
+    end
+
+    # The canonical layout, without checking it renders the same: what strict mode compares templates against.
+    def layout(source)
+      parser = Parser.new(shortcuts: @shortcuts, outline: true, tailwind_classes: @tailwind_classes)
+      parser.call(source)
+      lines = source.delete_prefix("").split(/\r?\n/)
+
+      formatted = []
+      indent_shift_by_lineno = {}
+      lines.each.with_index(1) do |line, lineno|
+        info = parser.outline[lineno]
+        case info.kind
+        when :blank
+          formatted << "" unless formatted.empty? || formatted.last.empty?
+        when :text_blank
+          formatted << ""
+        when :structure
+          indent = info.depth * INDENT_WIDTH
+          indent_shift_by_lineno[lineno] = indent - indent_of(line)
+          formatted << (" " * indent) + structure(line, info)
+        else
+          formatted << continuation(line, info, indent_shift_by_lineno.fetch(info.owner, 0))
+        end
+      end
+      formatted.pop while formatted.last&.empty?
+      formatted.empty? ? "" : "#{formatted.join("\n")}\n"
+    end
+
+    private
+
+    def structure(line, info)
+      content = with_output_spacing(line, info).lstrip
+      content = content.rstrip unless info.text
+      case content
+      when CONTROL then $'.empty? ? "-" : "- #{$'}"
+      when OUTPUT then "#{$1}#{$2} #{$'}"
+      when REDUNDANT_DIV then $'
+      else content
+      end
+    end
+
+    def continuation(line, info, indent_shift)
+      line = with_output_spacing(expand_tabs(line), info)
+      indent = [line[/\A */].size + indent_shift, 0].max
+      content = line.lstrip
+      content = content.rstrip unless info.kind == :text || info.text
+      (" " * indent) + content
+    end
+
+    def with_output_spacing(line, info)
+      return line unless info.output_column
+
+      before = line[0...info.output_column].rstrip
+      line[info.output_column..] =~ TAG_OUTPUT
+      $'.empty? ? "#{before} #{$1}#{$2}" : "#{before} #{$1}#{$2} #{$'}"
+    end
+
+    def indent_of(line)
+      expand_tabs(line)[/\A */].size
+    end
+
+    def expand_tabs(line)
+      line.sub(/\A[ \t]*/) { it.gsub(Parser::TAB, "\\1#{" " * Parser::TAB_SIZE}") }
+    end
+
+    def compiled(source)
+      SlimX.compile(source, shortcuts: @shortcuts, tailwind_classes: @tailwind_classes, strict: false, format: :xml).gsub(/(?:\s*[;\n]\s*)+/, ";")
+    rescue Error => exception
+      exception.message
+    end
+  end
+end

data/lib/slimx/linter/rules.rb

@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+module SlimX
+  class Linter
+    module Rules
+      def self.all
+        constants.map { const_get(it) }.select { it < Rule }
+      end
+
+      class Rule
+        DEFAULTS = { enabled: true }.freeze
+
+        def self.rule_name
+          name.split("::").last
+        end
+
+        def initialize(options)
+          @options = options
+        end
+
+        private
+
+        attr_reader :options
+
+        def offense(document, lineno, message)
+          Offense.new(document.path, lineno, self.class.rule_name, message)
+        end
+
+        def each_tag(document, name = nil)
+          document.each_tag do |tag, ancestors|
+            yield tag, ancestors if name.nil? || tag.name == name
+          end
+        end
+
+        def attribute_names(tag)
+          tag.attributes.filter_map { it.name unless it.is_a?(AST::Splat) }
+        end
+
+        def each_line(document)
+          document.lines.each.with_index(1)
+        end
+
+        def missing_attribute(document, tag_name, attribute_name, message)
+          enum_for(:each_tag, document, tag_name).filter_map do |tag,|
+            offense(document, document.line_of(tag), message) unless splat?(tag) || attribute_names(tag).include?(attribute_name)
+          end
+        end
+
+        def splat?(tag)
+          tag.attributes.any? { it.is_a?(AST::Splat) }
+        end
+
+        # The value when it is written literally, nil when it is computed.
+        def literal_value(attribute)
+          case attribute
+          when AST::StaticAttribute then attribute.value
+          when AST::QuotedAttribute then attribute.text unless attribute.text.include?('#{')
+          end
+        end
+
+        def literal_attributes(tag, name)
+          tag.attributes.select { it.respond_to?(:name) && it.name == name && literal_value(it) }
+        end
+      end
+
+      # Layout: everything `slimx fmt` rewrites.
+
+      class Indentation < Rule
+        def offenses(document, _source)
+          document.outline.each_with_index.filter_map do |info, lineno|
+            next unless info&.kind == :structure
+
+            indent = document.lines[lineno - 1][/\A */].size
+            expected = info.depth * Formatter::INDENT_WIDTH
+            offense(document, lineno, "Indent with #{expected} spaces, not #{indent}") if indent != expected
+          end
+        end
+      end
+
+      class Tab < Rule
+        def offenses(document, source)
+          return [] unless source.include?("\t")
+
+          each_line(document).filter_map { |line, lineno| offense(document, lineno, "Indent with spaces, not tabs") if line.match?(/\A *[\t ]*\t/) }
+        end
+      end
+
+      class TrailingWhitespace < Rule
+        # Matches wherever a line may end in whitespace, and a little more (a \r before \n): it only skips files.
+        ANY_TRAILING_WHITESPACE = /[ \t\r\f\v](?=\r?\n|\z)/
+
+        def offenses(document, source)
+          return [] unless source.match?(ANY_TRAILING_WHITESPACE)
+
+          each_line(document).filter_map do |line, lineno|
+            next unless line.match?(/\s\z/)
+
+            rendered = document.outline[lineno].text || document.outline[lineno].kind == :text
+            offense(document, lineno, rendered ? "Trailing whitespace renders: write it with `'` or `>` instead" : "Remove trailing whitespace")
+          end
+        end
+      end
+
+      class EmptyLines < Rule
+        def offenses(document, _source)
+          previous_blank = true
+          document.outline.each_with_index.filter_map do |info, lineno|
+            next unless info
+
+            blank = info.kind == :blank
+            extra = blank && previous_blank
+            previous_blank = blank
+            offense(document, lineno, "Remove this extra empty line") if extra
+          end
+        end
+      end
+
+      class TrailingBlankLines < Rule
+        def offenses(document, source)
+          return [] if source.empty?
+          return [offense(document, source.lines.size, "End the file with a newline")] unless source.end_with?("\n")
+
+          source.end_with?("\n\n") ? [offense(document, source.lines.size, "Remove the empty lines at the end of the file")] : []
+        end
+      end
+
+      class ControlStatementSpacing < Rule
+        TAG_OUTPUT = /\A(\s*)(==?)(['<>]*)(\s*)(?=\S)/
+
+        def offenses(document, _source)
+          document.outline.each_with_index.filter_map do |info, lineno|
+            next unless info
+
+            line = document.lines[lineno - 1]
+            if info.output_column
+              line[info.output_column..] =~ TAG_OUTPUT
+              offense(document, lineno, "Put a space before and after `#{$2}`") if $1.empty? || $4.empty?
+            elsif info.kind == :structure
+              case line.lstrip
+              when /\A-(?=\S)/ then offense(document, lineno, "Put a space after `-`")
+              when /\A((?>==?[<>]*))(?=\S)/ then offense(document, lineno, "Put a space after `#{$1}`")
+              end
+            end
+          end
+        end
+      end
+
+      class RedundantDiv < Rule
+        def offenses(document, _source)
+          document.outline.each_with_index.filter_map do |info, lineno|
+            next unless info&.kind == :structure && document.lines[lineno - 1].lstrip.match?(Formatter::REDUNDANT_DIV)
+
+            offense(document, lineno, "`div` is implied by the `.class` or `#id` shortcut")
+          end
+        end
+      end
+
+      # Slim-lint's rules on code and tags.
+
+      class LineLength < Rule
+        DEFAULTS = { enabled: true, max: 120 }.freeze
+
+        def offenses(document, _source)
+          max = options[:max]
+          each_line(document).filter_map { |line, lineno| offense(document, lineno, "Line is too long [#{line.length}/#{max}]") if line.length > max }
+        end
+      end
+
+      class CommentControlStatement < Rule
+        ALLOWED = /\A\s*#\s*(rubocop:|Template Dependency:)/
+
+        def offenses(document, _source)
+          document.enum_for(: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")
+          end
+        end
+      end
+
+      class EmptyControlStatement < Rule
+        def offenses(document, _source)
+          document.enum_for(: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
+
+        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.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") }
+          end
+        end
+
+        private
+
+        def flat_control?(node)
+          node.is_a?(AST::Control) && AST.empty?(node.children)
+        end
+      end
+
+      class TagCase < Rule
+        def offenses(document, _source)
+          return [] if document.xml?
+
+          document.enum_for(: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" }
+
+            offense(document, document.line_of(node), "Write `#{node.name.downcase}` in lowercase")
+          end
+        end
+      end
+
+      class InstanceVariables < Rule
+        INSTANCE_VARIABLE = /(?<![\w@])@[a-z_]\w*/
+
+        def offenses(document, _source)
+          return [] unless document.partial?
+
+          document.enum_for(: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
+            next unless code && (variable = code[INSTANCE_VARIABLE])
+
+            offense(document, document.line_of(node), "Pass `#{variable}` to the partial as a local")
+          end
+        end
+      end
+
+      class StrictLocals < Rule
+        DEFAULTS = { enabled: false }.freeze
+
+        def offenses(document, _source)
+          return [] if !document.partial? || document.lines.any? { it.match?(%r{\A\s*/#\s*locals:}) }
+
+          [offense(document, 1, "Declare the partial's locals: `/# locals: (name:)`")]
+        end
+      end
+
+      # HTML and accessibility, after Herb, erb_lint and eslint-plugin-jsx-a11y.
+
+      class DuplicateId < Rule
+        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) }
+            literal_attributes(tag, "id").filter_map do |attribute|
+              id = literal_value(attribute)
+              if branch_by_id.key?(id) && branch_by_id[id].equal?(branch)
+                offense(document, document.line_of(tag), "The id `#{id}` is already used in this template")
+              else
+                branch_by_id[id] = branch
+                nil
+              end
+            end
+          end.flatten
+        end
+      end
+
+      class ImageAlt < Rule
+        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
+        def offenses(document, _source)
+          missing_attribute(document, "iframe", "title", "Name the frame with `title`")
+        end
+      end
+
+      class AnchorHref < Rule
+        def offenses(document, _source)
+          missing_attribute(document, "a", "href", "A link without `href` is not a link: use a `button` for actions")
+        end
+      end
+
+      class ButtonType < Rule
+        DEFAULTS = { enabled: false }.freeze
+
+        def offenses(document, _source)
+          missing_attribute(document, "button", "type", 'Say what the button does with `type="button"` or `type="submit"`')
+        end
+      end
+
+      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" }
+
+            offense(document, document.line_of(tag), "Links cannot contain links")
+          end
+        end
+      end
+
+      class PositiveTabindex < Rule
+        def offenses(document, _source)
+          enum_for(:each_tag, document).flat_map do |tag,|
+            literal_attributes(tag, "tabindex").filter_map do |attribute|
+              next unless literal_value(attribute).to_i.positive?
+
+              offense(document, document.line_of(tag), "A positive `tabindex` breaks the reading order: use 0 or -1")
+            end
+          end
+        end
+      end
+
+      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
+
+        def offenses(document, _source)
+          enum_for(:each_tag, document).flat_map do |tag,|
+            tag.attributes.filter_map do |attribute|
+              next unless attribute.respond_to?(:name) && BOOLEAN_ATTRIBUTES.include?(attribute.name)
+              next unless ["", attribute.name].include?(literal_value(attribute))
+
+              offense(document, document.line_of(tag), "Write `#{attribute.name}=true`, or `#{attribute.name}` alone inside an attribute list")
+            end
+          end
+        end
+      end
+
+      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
+
+        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|
+                offense(document, document.line_of(tag), "`#{role}` is not an ARIA role")
+              end
+            end
+          end
+        end
+      end
+
+      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
+
+        def offenses(document, _source)
+          enum_for(:each_tag, document).flat_map do |tag,|
+            attribute_names(tag).filter_map do |name|
+              next unless name.start_with?("aria-") && !ATTRIBUTES.include?(name)
+
+              offense(document, document.line_of(tag), "`#{name}` is not an ARIA attribute")
+            end
+          end
+        end
+      end
+
+      class DeprecatedClasses < Rule
+        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|
+              next unless replacement_by_class.key?(css_class)
+
+              offense(document, document.line_of(tag), "`#{css_class}` is deprecated: use `#{replacement_by_class[css_class]}`")
+            end
+          end
+        end
+      end
+
+      class InlineStyles < Rule
+        DEFAULTS = { enabled: false }.freeze
+
+        def offenses(document, _source)
+          enum_for(:each_tag, document).filter_map do |tag,|
+            offense(document, document.line_of(tag), "Move inline styles to a stylesheet") if literal_attributes(tag, "style").any?
+          end
+        end
+      end
+
+      # Ruby that a plainer line of Slim says better, after haml-lint.
+
+      class UnnecessaryInterpolation < Rule
+        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))
+
+            texts = node.children.grep(AST::Text)
+            next unless texts.size == 1 && texts.first.text =~ LONE_INTERPOLATION
+
+            offense(document, lineno, "Write `= #{$1.strip}` instead of interpolating it alone")
+          end
+        end
+      end
+
+      class UnnecessaryStringOutput < Rule
+        PLAIN_STRING = /\A(["'])([^"'\\#&<>\s](?:[^"'\\#&<>]*[^"'\\#&<>\s])?)\1\z/
+
+        def offenses(document, _source)
+          document.enum_for(:each_node).filter_map do |node,|
+            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")
+          end
+        end
+      end
+
+      class Zwsp < Rule
+        INVISIBLE = /[\u200B-\u200D\u2060\uFEFF]/
+
+        def offenses(document, source)
+          return [] unless source.match?(INVISIBLE)
+
+          each_line(document).filter_map do |line, lineno|
+            next unless line.match?(INVISIBLE) && !(lineno == 1 && line.start_with?("\uFEFF") && !line[1..].match?(INVISIBLE))
+
+            offense(document, lineno, "Remove the invisible zero-width character")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slimx/linter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module SlimX
+  class Linter
+    Offense = Data.define(:path, :lineno, :rule, :message)
+
+    # The tree is walked once per template: every rule iterates `visits`, each node with its ancestors.
+    Document = Data.define(:path, :lines, :nodes, :outline, :line_by_node, :visits, :tag_visits) do
+      def self.visits_of(nodes, ancestors = [], visits = [])
+        nodes&.each do |node|
+          next if node == AST::NEWLINE
+
+          visits << [node, ancestors]
+          children = children_of(node)
+          visits_of(children, [*ancestors, node].freeze, visits) if children
+        end
+        visits
+      end
+
+      def partial?
+        File.basename(path.to_s).start_with?("_")
+      end
+
+      def xml?
+        path.to_s.match?(/\.(xml|rss|atom)\.slim\z/)
+      end
+
+      def line_of(node)
+        line_by_node[node]
+      end
+
+      def each_node(&) = visits.each(&)
+      def each_tag(&) = tag_visits.each(&)
+
+      def self.children_of(node)
+        case node
+        when AST::Tag then node.content
+        when AST::Control, AST::Output, AST::TextBlock, AST::Comment, AST::InlineHtml, AST::Embedded then node.children
+        end
+      end
+    end
+
+    CONFIG_FILE = ".slimx.yml"
+
+    def self.load(directory = Dir.pwd)
+      new(configuration(directory).fetch("linters", {}))
+    end
+
+    def self.configuration(directory = Dir.pwd)
+      path = File.join(directory, CONFIG_FILE)
+      File.exist?(path) ? YAML.safe_load_file(path) || {} : {}
+    end
+
+    def initialize(options_by_rule_name = {})
+      @rules = Rules.all.filter_map do |rule_class|
+        options = rule_class::DEFAULTS.merge(options_by_rule_name.fetch(rule_class.rule_name, {}).transform_keys(&:to_sym))
+        rule_class.new(options) if options[:enabled]
+      end
+    end
+
+    def call(path, source)
+      parser = Parser.new(file: path, outline: true)
+      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) }
+      # 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
+      [Offense.new(path, exception.lineno, "Syntax", exception.error)]
+    end
+  end
+end
+
+require_relative "linter/rules"

data/lib/slimx/parallel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "etc"
+
+module SlimX
+  # Maps items in forked processes, one per core, and returns the results in item order. Below
+  # minimum_per_process items per process, forking costs more than it saves, and the map stays in this process.
+  module Parallel
+    module_function
+
+    def map(items, minimum_per_process: 100, &block)
+      process_count = [Etc.nprocessors, items.size / minimum_per_process].min
+      return items.map(&block) if process_count < 2 || !Process.respond_to?(:fork)
+
+      readers = items.each_slice((items.size.to_f / process_count).ceil).map do |slice|
+        reader, writer = IO.pipe
+        fork do
+          reader.close
+          results = begin
+            slice.map(&block)
+          rescue Exception => exception # rubocop:disable Lint/RescueException -- re-raised by the parent
+            exception
+          end
+          writer.binmode.write(Marshal.dump(results))
+          exit!(0)
+        end
+        writer.close
+        reader
+      end
+      results_by_process = readers.map { Marshal.load(it.binmode.read) }
+      Process.waitall
+      results_by_process.each { raise it if it.is_a?(Exception) }
+      results_by_process.flatten(1)
+    end
+  end
+end