super-slim 3.0.0

data/lib/super_slim/rubocop.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+require "strscan"
+require_relative "../super_slim"
+require_relative "linter"
+
+module SuperSlim
+  # Loaded by RuboCop from `plugins: [super_slim]`: lints the Ruby of each template, offenses at their place in the `.slim` file.
+  module RuboCop
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(name: "super_slim", version: VERSION, homepage: "https://github.com/levups/super-slim",
+          description: "Lints the Ruby of Slim templates, read by SuperSlim's parser")
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        ::RuboCop::Runner.ruby_extractors.unshift(RubyExtractor)
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: File.expand_path("../../config/rubocop.yml", __dir__))
+      end
+    end
+
+    # Hands RuboCop each piece of Ruby with its offset: a piece is a slice of the template, so autocorrection
+    # writes back into the template.
+    class RubyExtractor
+      Fragment = Struct.new(:code, :offset)
+
+      # Slim reads a control line as the head of a block: its keyword and `do` belong to the indented lines.
+      LEADING_KEYWORD = /\A(?:begin|case|else|elsif|ensure|if|rescue|unless|until|when|while|for[ \t]+\w+[ \t]+in)\b[ \t]*/
+      TRAILING_DO = /(?:\b[ \t]*|[ \t])do[ \t]*(\|[^|]*\|)?[ \t]*(#.*)?\z/
+      WHEN = /\A\s*when[ \t]/
+      THEN = /[ \t]then(?:[ \t].*)?\z/m
+      INTERPOLATION = /#\{((?>[^{}]|(\{(?>[^{}]|\g<1>)*\}))*)\}/
+      ESCAPED_INTERPOLATION = /\\#\{/
+      UNESCAPED_INTERPOLATION_CODE = /\A\{.*\}\z/m
+      TEXT_WITHOUT_INTERPOLATION = /[^#\\]+|./m
+
+      def self.call(processed_source)
+        new(processed_source).call if processed_source.path&.end_with?(".slim")
+      end
+
+      def initialize(processed_source)
+        @processed_source = processed_source
+        @source = processed_source.raw_source
+      end
+
+      def call
+        fragments.filter_map do |fragment|
+          next if fragment.code.strip.empty?
+
+          {offset: fragment.offset, processed_source: processed_source_of(fragment.code)}
+        end
+      end
+
+      private
+
+      def fragments
+        parser = Parser.new(file: @processed_source.path, outline: true, tailwind_classes: tailwind_classes?)
+        parser.call(@source)
+        parser.ruby_ranges.flat_map do |kind, first, last|
+          # From the start of its first line, so that the indentation of a `ruby:` block is the same on every line.
+          first = (@source.rindex("\n", first - 1) || -1) + 1 if kind == :embedded_ruby
+          fragment = Fragment.new(@source[first...last], first)
+          case kind
+          when :text then interpolations(fragment)
+          when :code then without_block_syntax(fragment)
+          when :embedded_ruby then [fragment]
+          end
+        end
+      rescue SyntaxError
+        []
+      end
+
+      def tailwind_classes?
+        configuration = Linter.configuration
+        configuration.key?("tailwind_classes") ? configuration["tailwind_classes"] : SuperSlim.tailwind_classes
+      end
+
+      def interpolations(text)
+        scanner = StringScanner.new(text.code)
+        fragments = []
+        until scanner.eos?
+          next if scanner.skip(ESCAPED_INTERPOLATION)
+
+          if scanner.scan(INTERPOLATION)
+            code = scanner[1]
+            offset = text.offset + scanner.charpos - code.size - 1
+            fragments << (code.match?(UNESCAPED_INTERPOLATION_CODE) ? Fragment.new(code[1..-2], offset + 1) : Fragment.new(code, offset))
+          else
+            scanner.skip(TEXT_WITHOUT_INTERPOLATION)
+          end
+        end
+        fragments
+      end
+
+      def without_block_syntax(fragment)
+        whens(fragment).map do |clause|
+          keyword = clause.code[LEADING_KEYWORD].to_s
+          Fragment.new(clause.code[keyword.size..].sub(TRAILING_DO, ""), clause.offset + keyword.size)
+        end
+      end
+
+      # `when a, b` holds two expressions, which RuboCop reads as an array: each one becomes a fragment.
+      def whens(fragment)
+        keyword = fragment.code[WHEN] or return [fragment]
+        conditions = fragment.code[keyword.size..].sub(THEN, "")
+        array = processed_source_of("[#{conditions}]").ast
+        return [fragment] unless array&.array_type?
+
+        array.children.map do |condition|
+          Fragment.new(condition.source, fragment.offset + keyword.size + condition.source_range.begin_pos - 1)
+        end
+      end
+
+      def processed_source_of(code)
+        processed_source = ::RuboCop::ProcessedSource.new(code, @processed_source.ruby_version, @processed_source.path,
+          parser_engine: @processed_source.parser_engine)
+        processed_source.config = @processed_source.config
+        processed_source.registry = @processed_source.registry
+        processed_source
+      end
+    end
+  end
+end

data/lib/super_slim/runtime.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "erb/escape"
+
+module SuperSlim
+  module Runtime
+    module_function
+
+    def escape_html(value)
+      ERB::Escape.html_escape(value.to_s)
+    end
+
+    def escape_html_safe(value)
+      string = value.to_s
+      (string.html_safe? || value.html_safe?) ? string : ERB::Escape.html_escape(string)
+    end
+
+    def class_value(value, escape, html_safe)
+      if value.is_a?(Array)
+        value = value.flatten.filter_map do |element|
+          string = element.to_s
+          string unless string.empty?
+        end.join(" ")
+      end
+      return value.to_s unless escape
+
+      html_safe ? escape_html_safe(value) : escape_html(value)
+    end
+
+    def join_classes(*values)
+      values.reject(&:empty?).join(" ")
+    end
+
+    # Attributes only known at render time: splats (`*hash`), `data=`/`aria=` hashes and dynamic tags (`*{tag: "a"}`).
+    class Attributes
+      INVALID_NAME = /[ \0"'>\/=]/
+      HYPHENATED = %w[data aria].freeze
+
+      def initialize(html_safe)
+        @html_safe = html_safe
+        @value_by_name = {}
+      end
+
+      def code_attr(name, escape, value)
+        if name == "class"
+          value = value.is_a?(Array) ? value.join(" ") : value.to_s
+          attr(name, escape(escape, value)) unless value.empty?
+        elsif HYPHENATED.include?(name) && value.is_a?(Hash)
+          hyphenated_attr(name, escape, value)
+        elsif value != false && !value.nil?
+          attr(name, escape(escape, value))
+        end
+      end
+
+      def splat_attrs(splat)
+        splat.each { |name, value| code_attr(name.is_a?(Symbol) ? name.name : name.to_s, true, value) }
+      end
+
+      def attr(name, value)
+        raise InvalidAttributeNameError, "Invalid attribute name '#{name}' was rendered" if name.match?(INVALID_NAME)
+
+        if !@value_by_name.key?(name)
+          @value_by_name[name] = value
+        elsif name == "class"
+          @value_by_name[name] = "#{@value_by_name[name]} #{value}"
+        else
+          raise "Multiple #{name} attributes specified"
+        end
+      end
+
+      def build_tag(content = nil)
+        tag = @value_by_name.delete("tag").to_s
+        tag = "div" if tag.empty?
+        content ? "<#{tag}#{self}>#{content}</#{tag}>" : "<#{tag}#{self} />"
+      end
+
+      def to_s
+        html = +""
+        @value_by_name.each do |name, value|
+          html << " " << name
+          html << %(=") << value.to_s << %(") unless value == true
+        end
+        html
+      end
+
+      private
+
+      def hyphenated_attr(name, escape, value)
+        if value.is_a?(Hash)
+          value.each { |key, nested_value| hyphenated_attr("#{name}-#{key}", escape, nested_value) }
+        else
+          attr(name, escape(escape, value))
+        end
+      end
+
+      def escape(escape, value)
+        return value if !escape || value == true
+
+        @html_safe ? Runtime.escape_html_safe(value) : Runtime.escape_html(value)
+      end
+    end
+  end
+end

data/lib/super_slim/shortcuts.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SuperSlim
+  # `#name` sets the id and `.name` a class, on a div unless a tag name comes first.
+  module Shortcuts
+    ATTRIBUTE_BY_SHORTCUT = {"#" => "id", "." => "class"}.freeze
+    DEFAULT_TAG = "div"
+
+    SLIM_NAME_PART = /\p{Word}|-|\/\d+|:(?:\w|-)+/
+    # Tailwind class names: arbitrary values in brackets (one level of nesting, no whitespace), CSS variables in
+    # parentheses after a dash, variants joined by `:` (`: ` with a space still nests a tag), `!` and `@`,
+    # `*:` child variants, fractions and opacities after `/` (a final `/` still closes the tag), and decimals
+    # such as `py-1.5`, where a dot between two digits does not start a new class.
+    # Tailwind never puts a bracket right after a letter or a digit: `.btn[href="/"]` stays an attribute list.
+    TAILWIND_NAME_PART = %r{
+      \p{Word} | - | ! | @ | \*(?=:)
+      | :(?=[\p{Word}\[(!@*-])
+      | /(?=[\p{Word}\[(])
+      | (?<=\d)\.(?=\d)
+      | (?<![\p{Word}\])]) \[ (?:[^\[\]\s] | \[[^\[\]\s]*\])+ \]
+      | (?<=-)\( (?:[^()\s] | \([^()\s]*\))+ \)
+    }x
+
+    ATTRIBUTE_PATTERN = /\A([#.]+)((?:#{SLIM_NAME_PART})*)/
+    TAILWIND_ATTRIBUTE_PATTERN = /\A([#.]+)((?:#{TAILWIND_NAME_PART})*)/
+    TAG_PATTERN = /\A(?:[#.]|\*(?=[^\s]+)|(\p{Word}(?:\p{Word}|:|-)*\p{Word}|\p{Word}+))/
+  end
+end

data/lib/super_slim/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SuperSlim
+  VERSION = "3.0.0"
+end

data/lib/super_slim.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "super_slim/version"
+require_relative "super_slim/ast"
+require_relative "super_slim/shortcuts"
+require_relative "super_slim/parser"
+require_relative "super_slim/compiler"
+require_relative "super_slim/runtime"
+
+module SuperSlim
+  autoload :Formatter, "super_slim/formatter"
+  autoload :RuboCop, "super_slim/rubocop"
+
+  class Error < StandardError; end
+  class InvalidAttributeNameError < Error; end
+  class UnsafeFormattingError < Error; end
+
+  class SyntaxError < Error
+    attr_reader :error, :file, :line, :lineno, :column
+
+    def initialize(error, file, line, lineno, column)
+      @error = error
+      @file = file || "(__TEMPLATE__)"
+      @line = line.to_s
+      @lineno = lineno
+      @column = column
+      super(to_s)
+    end
+
+    def to_s
+      line = @line.lstrip
+      column = @column + line.size - @line.size
+      <<~MESSAGE
+        #{error}
+          #{file}, Line #{lineno}, Column #{@column}
+            #{line}
+            #{" " * column}^
+      MESSAGE
+    end
+  end
+
+  class << self
+    # Shortcuts also read Tailwind class names, such as `.rounded-b-[3px]` or `.lg:hover:underline`. Off by
+    # default so that switching from Slim changes no template: Slim renders `.size-2.5` as two classes.
+    attr_accessor :tailwind_classes
+
+    def compile(source, file: nil, tailwind_classes: self.tailwind_classes, **compiler_options)
+      Compiler.new(**compiler_options).call(Parser.new(file:, tailwind_classes:).call(source))
+    end
+  end
+end
+
+require_relative "super_slim/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: super-slim
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Level UP Solutions
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: strscan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+description: 'A Slim template engine rewritten from scratch, without Temple: same
+  HTML as Slim 5, faster compilation and rendering with fewer allocations, a formatter
+  that cannot change a page, a linter with HTML and accessibility rules, and a RuboCop
+  plugin for the Ruby inside templates.'
+executables:
+- super-slim
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- LICENSE-slim
+- README.md
+- config/rubocop.yml
+- exe/super-slim
+- lib/super-slim.rb
+- lib/super_slim.rb
+- lib/super_slim/ast.rb
+- lib/super_slim/cli.rb
+- lib/super_slim/compiler.rb
+- lib/super_slim/formatter.rb
+- lib/super_slim/formatter/line_wrapper.rb
+- lib/super_slim/linter.rb
+- lib/super_slim/linter/rules.rb
+- lib/super_slim/parallel.rb
+- lib/super_slim/parser.rb
+- lib/super_slim/rails_handler.rb
+- lib/super_slim/railtie.rb
+- lib/super_slim/rubocop.rb
+- lib/super_slim/runtime.rb
+- lib/super_slim/shortcuts.rb
+- lib/super_slim/version.rb
+homepage: https://github.com/levups/super-slim
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/levups/super-slim
+  changelog_uri: https://github.com/levups/super-slim/blob/main/CHANGELOG.md
+  documentation_uri: https://levups.github.io/super-slim/
+  bug_tracker_uri: https://github.com/levups/super-slim/issues
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: SuperSlim::RuboCop::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.24
+specification_version: 4
+summary: 'Slim templates, rewritten: faster to compile and render, with a formatter
+  and a linter'
+test_files: []