syntax_tree-tailwindcss 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4b9561bf73bff9b6e6a4c31fae7d4ff8d287625512a657baf29fd5ffe15a73cd
+  data.tar.gz: 3211cff998a98e08555fd66e19570e4f3ec5f0ce3064d33cd4088195adc11d3f
+SHA512:
+  metadata.gz: d1153927f9f76770ab2453c88761534d7c653df77afafd460e8db289734f04936c58b1406a0789b429428f3211b1e2bdd95ca89fbf167e3f4e7880b11610501e
+  data.tar.gz: 38ec5cf289bd018651f8f5efb64e0b0877edc193b9998d7bfba3d4024ff96b1132859207ead2f193874e13683ba6f5ebbdd921f8f7f0eb37193d07fb6f662915

data/.rubocop.yml

@@ -0,0 +1,31 @@
+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/DocumentDynamicEvalDefinition:
+  Exclude:
+    - test/fixture/**/*.rb

data/.streerc

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 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,38 @@
+# SyntaxTree plugin: tailwindcss
+
+SyntaxTree can be used to format:
+
+- `.rb` files that render HTML, e.g. Rails helpers
+- `.haml` files (using the [haml](https://github.com/ruby-syntax-tree/syntax_tree-haml)
+  plugin)
+- `.html.erb` files (using the [erb](https://github.com/davidwessman/syntax_tree-erb)
+  plugin)
+
+All of these can contain TailwindCSS classes and this plugin will help you keep
+them in order, just like
+[the official prettier plugin](https://github.com/tailwindlabs/prettier-plugin-tailwindcss)
+would.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add syntax_tree-tailwindcss
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install syntax_tree-tailwindcss
+
+## Usage
+
+Example:
+
+    $ stree write --plugins=erb,tailwindcss app/helpers/**/*.rb app/views/**/*.html.erb
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/spect88/syntax_tree-tailwindcss.
+
+## 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,23 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+require "syntax_tree/rake_tasks"
+require "rubocop/rake_task"
+
+Minitest::TestTask.create
+
+stree_config =
+  proc { |t| t.source_files = FileList[%w[Gemfile Rakefile lib/**/*.rb test/**/*.rb *.gemspec]] }
+SyntaxTree::Rake::CheckTask.new(&stree_config)
+SyntaxTree::Rake::WriteTask.new(&stree_config)
+
+RuboCop::RakeTask.new
+
+desc "Run all code checks"
+task check: %i[rubocop stree:check test]
+
+desc "Run all automated fixes"
+task fix: %i[stree:write rubocop:autocorrect_all]
+
+task default: :check

data/lib/syntax_tree/complete_mutation_visitor.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # This is a fix for SyntaxTree::MutationVisitor not traversing the entire tree
+  class CompleteMutationVisitor < SyntaxTree::BasicVisitor
+    def initialize
+      super
+      @mutations = []
+    end
+
+    def mutate(query, &block)
+      @mutations << [Pattern.new(query).compile, block]
+    end
+
+    def visit(node)
+      return unless node
+
+      result = node.accept(self)
+      @mutations.each do |(pattern, mutation)|
+        result = mutation.call(result) if pattern.call(result)
+      end
+
+      result
+    end
+
+    def copy_and_visit_children(node)
+      node.dup.tap do |clone|
+        clone.instance_variables.each do |name|
+          next if %i[@location @comments].include?(name)
+
+          var = clone.instance_variable_get(name)
+          clone.instance_variable_set(name, visit_child(var))
+        end
+      end
+    end
+
+    def visit_child(child)
+      case child
+      when Array
+        child.map { |node| visit_child(node) }
+      when SyntaxTree::Node
+        visit(child)
+      else
+        child
+      end
+    end
+
+    alias visit_aref copy_and_visit_children
+    alias visit_aref_field copy_and_visit_children
+    alias visit_alias copy_and_visit_children
+    alias visit_arg_block copy_and_visit_children
+    alias visit_arg_paren copy_and_visit_children
+    alias visit_arg_star copy_and_visit_children
+    alias visit_args copy_and_visit_children
+    alias visit_args_forward copy_and_visit_children
+    alias visit_array copy_and_visit_children
+    alias visit_aryptn copy_and_visit_children
+    alias visit_assign copy_and_visit_children
+    alias visit_assoc copy_and_visit_children
+    alias visit_assoc_splat copy_and_visit_children
+    alias visit_backref copy_and_visit_children
+    alias visit_backtick copy_and_visit_children
+    alias visit_bare_assoc_hash copy_and_visit_children
+    alias visit_BEGIN copy_and_visit_children
+    alias visit_begin copy_and_visit_children
+    alias visit_binary copy_and_visit_children
+    alias visit_block copy_and_visit_children
+    alias visit_blockarg copy_and_visit_children
+    alias visit_block_var copy_and_visit_children
+    alias visit_bodystmt copy_and_visit_children
+    alias visit_break copy_and_visit_children
+    alias visit_call copy_and_visit_children
+    alias visit_case copy_and_visit_children
+    alias visit_CHAR copy_and_visit_children
+    alias visit_class copy_and_visit_children
+    alias visit_comma copy_and_visit_children
+    alias visit_command copy_and_visit_children
+    alias visit_command_call copy_and_visit_children
+    alias visit_comment copy_and_visit_children
+    alias visit_const copy_and_visit_children
+    alias visit_const_path_field copy_and_visit_children
+    alias visit_const_path_ref copy_and_visit_children
+    alias visit_const_ref copy_and_visit_children
+    alias visit_cvar copy_and_visit_children
+    alias visit_def copy_and_visit_children
+    alias visit_defined copy_and_visit_children
+    alias visit_dyna_symbol copy_and_visit_children
+    alias visit_END copy_and_visit_children
+    alias visit_else copy_and_visit_children
+    alias visit_elsif copy_and_visit_children
+    alias visit_embdoc copy_and_visit_children
+    alias visit_embexpr_beg copy_and_visit_children
+    alias visit_embexpr_end copy_and_visit_children
+    alias visit_embvar copy_and_visit_children
+    alias visit_ensure copy_and_visit_children
+    alias visit_excessed_comma copy_and_visit_children
+    alias visit_field copy_and_visit_children
+    alias visit_float copy_and_visit_children
+    alias visit_fndptn copy_and_visit_children
+    alias visit_for copy_and_visit_children
+    alias visit_gvar copy_and_visit_children
+    alias visit_hash copy_and_visit_children
+    alias visit_heredoc copy_and_visit_children
+    alias visit_heredoc_beg copy_and_visit_children
+    alias visit_heredoc_end copy_and_visit_children
+    alias visit_hshptn copy_and_visit_children
+    alias visit_ident copy_and_visit_children
+    alias visit_if copy_and_visit_children
+    alias visit_if_op copy_and_visit_children
+    alias visit_imaginary copy_and_visit_children
+    alias visit_in copy_and_visit_children
+    alias visit_int copy_and_visit_children
+    alias visit_ivar copy_and_visit_children
+    alias visit_kw copy_and_visit_children
+    alias visit_kwrest_param copy_and_visit_children
+    alias visit_label copy_and_visit_children
+    alias visit_label_end copy_and_visit_children
+    alias visit_lambda copy_and_visit_children
+    alias visit_lambda_var copy_and_visit_children
+    alias visit_lbrace copy_and_visit_children
+    alias visit_lbracket copy_and_visit_children
+    alias visit_lparen copy_and_visit_children
+    alias visit_massign copy_and_visit_children
+    alias visit_method_add_block copy_and_visit_children
+    alias visit_mlhs copy_and_visit_children
+    alias visit_mlhs_paren copy_and_visit_children
+    alias visit_module copy_and_visit_children
+    alias visit_mrhs copy_and_visit_children
+    alias visit_next copy_and_visit_children
+    alias visit_not copy_and_visit_children
+    alias visit_op copy_and_visit_children
+    alias visit_opassign copy_and_visit_children
+    alias visit_params copy_and_visit_children
+    alias visit_paren copy_and_visit_children
+    alias visit_period copy_and_visit_children
+    alias visit_pinned_begin copy_and_visit_children
+    alias visit_pinned_var_ref copy_and_visit_children
+    alias visit_program copy_and_visit_children
+    alias visit_qsymbols copy_and_visit_children
+    alias visit_qsymbols_beg copy_and_visit_children
+    alias visit_qwords copy_and_visit_children
+    alias visit_qwords_beg copy_and_visit_children
+    alias visit_range copy_and_visit_children
+    alias visit_rassign copy_and_visit_children
+    alias visit_rational copy_and_visit_children
+    alias visit_rbrace copy_and_visit_children
+    alias visit_rbracket copy_and_visit_children
+    alias visit_redo copy_and_visit_children
+    alias visit_regexp_beg copy_and_visit_children
+    alias visit_regexp_content copy_and_visit_children
+    alias visit_regexp_end copy_and_visit_children
+    alias visit_regexp_literal copy_and_visit_children
+    alias visit_rescue copy_and_visit_children
+    alias visit_rescue_ex copy_and_visit_children
+    alias visit_rescue_mod copy_and_visit_children
+    alias visit_rest_param copy_and_visit_children
+    alias visit_retry copy_and_visit_children
+    alias visit_return copy_and_visit_children
+    alias visit_rparen copy_and_visit_children
+    alias visit_sclass copy_and_visit_children
+    alias visit_statements copy_and_visit_children
+    alias visit_string_concat copy_and_visit_children
+    alias visit_string_content copy_and_visit_children
+    alias visit_string_dvar copy_and_visit_children
+    alias visit_string_embexpr copy_and_visit_children
+    alias visit_string_literal copy_and_visit_children
+    alias visit_super copy_and_visit_children
+    alias visit_symbeg copy_and_visit_children
+    alias visit_symbol_content copy_and_visit_children
+    alias visit_symbol_literal copy_and_visit_children
+    alias visit_symbols copy_and_visit_children
+    alias visit_symbols_beg copy_and_visit_children
+    alias visit_tlambda copy_and_visit_children
+    alias visit_tlambeg copy_and_visit_children
+    alias visit_top_const_field copy_and_visit_children
+    alias visit_top_const_ref copy_and_visit_children
+    alias visit_tstring_beg copy_and_visit_children
+    alias visit_tstring_content copy_and_visit_children
+    alias visit_tstring_end copy_and_visit_children
+    alias visit_unary copy_and_visit_children
+    alias visit_undef copy_and_visit_children
+    alias visit_unless copy_and_visit_children
+    alias visit_until copy_and_visit_children
+    alias visit_var_field copy_and_visit_children
+    alias visit_var_ref copy_and_visit_children
+    alias visit_vcall copy_and_visit_children
+    alias visit_void_stmt copy_and_visit_children
+    alias visit_when copy_and_visit_children
+    alias visit_while copy_and_visit_children
+    alias visit_word copy_and_visit_children
+    alias visit_words copy_and_visit_children
+    alias visit_words_beg copy_and_visit_children
+    alias visit_xstring copy_and_visit_children
+    alias visit_xstring_literal copy_and_visit_children
+    alias visit_yield copy_and_visit_children
+    alias visit_zsuper copy_and_visit_children
+    alias visit___end__ copy_and_visit_children
+  end
+end

data/lib/syntax_tree/erb/mutation_visitor.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module ERB
+    # A base ERB Visitor class that returns a deep copy of the AST.
+    # It can be subclassed to mutate some parts of the AST and keep everything
+    # else as it was.
+    #
+    # Ideally this class (or equivalent) would exist within SyntaxTree::ERB gem.
+    class MutationVisitor
+      def visit(node)
+        node&.accept(self)
+      end
+
+      def copy_and_visit_children(node)
+        node.dup.tap do |clone|
+          clone.instance_variables.each do |name|
+            var = clone.instance_variable_get(name)
+            clone.instance_variable_set(
+              name,
+              case var
+              when Array
+                var.map { |child| visit(child) }
+              when SyntaxTree::ERB::Node
+                visit(var)
+              else
+                var
+              end
+            )
+          end
+        end
+      end
+
+      alias visit_attribute copy_and_visit_children
+      alias visit_block copy_and_visit_children
+      alias visit_char_data copy_and_visit_children
+      alias visit_closing_tag copy_and_visit_children
+      alias visit_doctype copy_and_visit_children
+      alias visit_document copy_and_visit_children
+      alias visit_erb copy_and_visit_children
+      alias visit_erb_block copy_and_visit_children
+      alias visit_erb_case copy_and_visit_children
+      alias visit_erb_case_when copy_and_visit_children
+      alias visit_erb_close copy_and_visit_children
+      alias visit_erb_comment copy_and_visit_children
+      alias visit_erb_content copy_and_visit_children
+      alias visit_erb_do_close copy_and_visit_children
+      alias visit_erb_else copy_and_visit_children
+      alias visit_erb_end copy_and_visit_children
+      alias visit_erb_if copy_and_visit_children
+      alias visit_erb_yield copy_and_visit_children
+      alias visit_html copy_and_visit_children
+      alias visit_html_comment copy_and_visit_children
+      alias visit_html_string copy_and_visit_children
+      alias visit_new_line copy_and_visit_children
+      alias visit_opening_tag copy_and_visit_children
+      alias visit_token copy_and_visit_children
+    end
+  end
+end

data/lib/syntax_tree/haml/mutation_visitor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Haml
+    class MutationVisitor
+      # A base Haml Visitor class that returns a deep copy of the AST.
+      # It can be subclassed to mutate some parts of the AST and keep everything
+      # else as it was.
+      #
+      # Ideally this class (or equivalent) would existing within SyntaxTree::Haml gem.
+      def visit(node)
+        node&.accept(self)
+      end
+
+      def copy_and_visit_children(node)
+        # Haml::Parser::ParseNode has these main attributes
+        # - value: nil | Hash
+        # - children: [ParseNode]
+        # - parent: ParseNode
+        node.dup.tap do |clone|
+          clone.value = node.value.dup unless node.value.nil?
+          clone.children =
+            node.children.map do |child|
+              visit(child).tap { |child_copy| child_copy.parent = clone }
+            end
+        end
+      end
+
+      alias visit_comment copy_and_visit_children
+      alias visit_doctype copy_and_visit_children
+      alias visit_filter copy_and_visit_children
+      alias visit_haml_comment copy_and_visit_children
+      alias visit_plain copy_and_visit_children
+      alias visit_root copy_and_visit_children
+      alias visit_script copy_and_visit_children
+      alias visit_silent_script copy_and_visit_children
+      alias visit_tag copy_and_visit_children
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/erb_mutation_visitor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "syntax_tree/erb/mutation_visitor"
+
+module SyntaxTree
+  module Tailwindcss
+    class ErbMutationVisitor < SyntaxTree::ERB::MutationVisitor
+      def initialize(sorter)
+        super()
+        @sorter = sorter
+        @ruby_visitor = SyntaxTree::Tailwindcss::RubyMutationVisitor.new(sorter)
+      end
+
+      # Rewrite `<%= tag.span class: 'foo bar' %>`
+      def visit_erb_content(node)
+        node.dup.tap do |clone|
+          clone.instance_variable_set(:@value, clone.value.accept(@ruby_visitor))
+        end
+      end
+
+      # Rewrite `class="foo <%= something %> bar"`
+      def visit_attribute(node)
+        clone = super
+        return clone unless node.key.value == "class"
+        return clone unless node.value.is_a?(SyntaxTree::ERB::HtmlString)
+
+        contents =
+          clone.value.contents.reject do |content|
+            content.is_a?(SyntaxTree::ERB::Token) && content.type == :whitespace
+          end
+
+        clone.value.instance_variable_set(
+          :@contents,
+          contents.map.with_index do |content, index|
+            next content unless content.is_a?(SyntaxTree::ERB::Token)
+
+            # It's already a clone, so it's OK to mutate it
+            new_value = @sorter.sort(content.value.split).join(" ")
+            new_value = " #{new_value}" if index.positive? && erb_node?(contents[index - 1])
+            new_value = "#{new_value} " if index < contents.size - 1 &&
+              erb_node?(contents[index + 1])
+            content.instance_variable_set(:@value, new_value)
+            content
+          end
+        )
+
+        clone
+      end
+
+      private
+
+      def erb_node?(node)
+        node.is_a?(SyntaxTree::ERB::ErbNode)
+      end
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/haml_mutation_visitor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "syntax_tree/haml/mutation_visitor"
+
+module SyntaxTree
+  module Tailwindcss
+    class HamlMutationVisitor < SyntaxTree::Haml::MutationVisitor
+      def initialize(sorter)
+        super()
+        @sorter = sorter
+        @ruby_visitor = SyntaxTree::Tailwindcss::RubyMutationVisitor.new(@sorter)
+      end
+
+      def visit_tag(node)
+        super.tap do |clone|
+          next unless node.value
+
+          # Rewrite `.foo.bar`
+          if node.value[:attributes].key?("class")
+            clone.value[:attributes]["class"] = @sorter.sort(
+              node.value[:attributes]["class"].split
+            ).join(" ")
+          end
+
+          # Rewrite `(class="foo #{something} bar")`
+          if node.value[:dynamic_attributes].new&.include?('"class"')
+            clone.value[:dynamic_attributes] = node.value[:dynamic_attributes].dup.tap do |attrs|
+              attrs.new = rewrite_html_attributes(attrs.new)
+            end
+          end
+        end
+      end
+
+      # Rewrites `(class="foo #{something} bar")`
+      def rewrite_html_attributes(string)
+        new_string = string.dup
+
+        pattern = <<~PATTERN
+          Assoc[
+            key: StringLiteral[parts: [TStringContent[value: "class"]]],
+            value: StringLiteral
+          ]
+        PATTERN
+
+        SyntaxTree.search(string, pattern) do |assoc_node|
+          location = assoc_node.value.location
+          rewritten = @ruby_visitor.rewrite_string_literal(assoc_node.value)
+
+          formatter = SyntaxTree::Formatter.new(string, [], 10_000)
+          rewritten.format(formatter)
+          formatter.flush(0)
+          formatted = formatter.output.join
+
+          new_string[location.start_char...location.end_char] = formatted
+        end
+
+        new_string
+      end
+
+      def haml_attributes_mutation_visitor
+        @haml_attributes_mutation_visitor ||=
+          SyntaxTree.mutation do |visitor|
+            # Rewrite `class: ["foo", "bar"]` and `class: "foo bar"`
+            visitor.mutate(<<~PATTERN) do |node|
+                Assoc[
+                  key: Label[value: 'class:'] | SymbolLiteral[value: Kw[value: 'class']],
+                  value: ArrayLiteral[contents: Args] | StringLiteral
+                ]
+              PATTERN
+              case node.value
+              when ArrayLiteral
+                args = @ruby_visitor.rewrite_args(node.value.contents)
+                node.copy(value: node.value.copy(contents: args))
+              when StringLiteral
+                new_value = @ruby_visitor.rewrite_string_literal(node.value)
+                node.copy(value: new_value)
+              else
+                node
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/patches.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Tailwindcss
+    module Patches
+      module SyntaxTree
+        def format_node(source, node, ...)
+          modified_node = node.accept(Tailwindcss.ruby_mutation_visitor)
+          super(source, modified_node, ...)
+        end
+      end
+
+      module ERB
+        def parse(source)
+          node = ::SyntaxTree::ERB::Parser.new(source).parse
+          node.accept(Tailwindcss.erb_mutation_visitor)
+        end
+      end
+
+      module Haml
+        def parse(source)
+          node = ::Haml::Parser.new({}).call(source)
+          node.accept(Tailwindcss.haml_mutation_visitor)
+        end
+      end
+
+      module HamlFormat
+        def parse_attributes_hash(source, node, ...)
+          modified_node =
+            node.accept(Tailwindcss.haml_mutation_visitor.haml_attributes_mutation_visitor)
+          super(source, modified_node, ...)
+        end
+      end
+    end
+  end
+
+  class << self
+    prepend Tailwindcss::Patches::SyntaxTree
+  end
+
+  # This should only be done if ERB plugin is already loaded
+  if const_defined?("ERB")
+    module ERB
+      class << self
+        prepend Tailwindcss::Patches::ERB
+      end
+    end
+  end
+
+  # This should only be done if Haml plugin is already loaded
+  if const_defined?("Haml")
+    module Haml
+      class << self
+        prepend Tailwindcss::Patches::Haml
+      end
+      Format.prepend(Tailwindcss::Patches::HamlFormat)
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/ruby_mutation_visitor.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "syntax_tree/complete_mutation_visitor"
+
+module SyntaxTree
+  module Tailwindcss
+    class RubyMutationVisitor < SyntaxTree::CompleteMutationVisitor
+      def initialize(sorter)
+        super()
+        @sorter = sorter
+
+        # Rewrite `class: "foo bar"` and `:class => "foo bar"`
+        pattern = <<~PATTERN
+          Assoc[
+            key: Label[value: 'class:'] | SymbolLiteral[value: Kw[value: 'class']],
+            value: StringLiteral
+          ]
+        PATTERN
+        mutate(pattern) { |node| node.copy(value: rewrite_string_literal(node.value)) }
+
+        # Rewrite `class_names("foo bar", "lorem ipsum")`
+        mutate("CallNode[message: Ident[value: 'class_names']]") do |node|
+          next node unless node.arguments.is_a?(ArgParen)
+          next node unless node.arguments.arguments.is_a?(Args)
+
+          args = node.arguments.arguments
+          node.copy(arguments: node.arguments.copy(arguments: rewrite_args(args)))
+        end
+
+        # Rewrite `class_names "foo bar", "lorem ipsum"`
+        mutate("Command[message: Ident[value: 'class_names']]") do |node|
+          next node unless node.arguments.is_a?(Args)
+
+          node.copy(arguments: rewrite_args(node.arguments))
+        end
+      end
+
+      def rewrite_string_literal(string_literal)
+        return string_literal unless string_literal.is_a?(StringLiteral)
+
+        string_parts =
+          string_literal.parts.map do |string_part|
+            next string_part unless string_part.is_a?(TStringContent)
+
+            value = string_part.value
+            new_value = @sorter.sort(value.split).join(" ")
+            new_value = " #{new_value}" if value.match?(/\A\s/)
+            new_value = "#{new_value} " if value.match?(/\s\z/)
+            string_part.copy(value: new_value)
+          end
+        string_literal.copy(parts: string_parts)
+      end
+
+      def rewrite_args(args)
+        return args unless args.is_a?(Args)
+
+        # Rewrite each string literal separately, e.g. 'mb-4 text-2xl'
+        rewritten_parts = args.parts.map { |part| rewrite_string_literal(part) }
+
+        # Reorder subsequent single-class strings, e.g. 'mb-4', 'text-2xl'
+        reordered_parts =
+          rewritten_parts
+            .slice_when { |a, b| single_class_string_literal?(a) ^ single_class_string_literal?(b) }
+            .map do |segment|
+              next segment if segment.size == 1 || !single_class_string_literal?(segment.first)
+
+              segment
+                .uniq { |node| node.parts.first.value }
+                .sort_by { |node| @sorter.sort_order(node.parts.first.value) }
+            end
+            .flatten
+
+        args.copy(parts: reordered_parts)
+      end
+
+      def single_class_string_literal?(string_literal)
+        string_literal.is_a?(StringLiteral) && string_literal.parts.size == 1 &&
+          string_literal.parts.first.is_a?(TStringContent) &&
+          string_literal.parts.first.value.match?(/\A\S+\z/)
+      end
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/sorter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Tailwindcss
+    class Sorter
+      def initialize(classes_in_order)
+        @classes_order = classes_in_order.to_enum.with_index.to_h
+      end
+
+      def sort(classes)
+        classes.uniq.sort_by { |cls| @classes_order[cls] || -1 }
+      end
+
+      def sort_order(cls)
+        @classes_order[cls] || -1
+      end
+
+      class << self
+        def load_cached
+          return new(SyntaxTree::Tailwindcss.custom_order) if SyntaxTree::Tailwindcss.custom_order
+
+          mtime = File.mtime(tailwind_output_path)
+          return @cached_sorter if @cached_mtime == mtime
+
+          @cached_sorter = load!
+          @cached_mtime = mtime
+          @cached_sorter
+        rescue Errno::ENOENT
+          warn do
+            "Couldn't find TailwindCSS output (#{tailwind_output_path}). Classes won't be sorted."
+          end
+          new([])
+        end
+
+        def load!
+          tailwind_output = File.read(tailwind_output_path)
+          classes = parse_tailwind_output(tailwind_output)
+          new(classes)
+        end
+
+        def tailwind_output_path
+          if SyntaxTree::Tailwindcss.output_path
+            SyntaxTree::Tailwindcss.output_path
+          elsif ENV["TAILWIND_OUTPUT_PATH"]
+            ENV["TAILWIND_OUTPUT_PATH"]
+          else
+            "app/assets/builds/application.css"
+          end
+        end
+
+        def parse_tailwind_output(output)
+          # We could use a real CSS parser, but that'd be slow and we only need to know valid classes
+          output
+            .gsub(%r{/\*.+?\*/}, "")
+            .gsub(/\\(.)/) { "-ESCAPED-#{Regexp.last_match[1].ord}-" }
+            .scan(/(?<=\.)[^0-9][^. {:>),\[]*/)
+            .uniq
+            .join(" ")
+            .gsub(/-ESCAPED-(\d+)-/) { Regexp.last_match[1].to_i.chr(Encoding::UTF_8) }
+            .split
+        end
+      end
+    end
+  end
+end

data/lib/syntax_tree/tailwindcss/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module Tailwindcss
+    VERSION = "0.1.0"
+  end
+end

data/lib/syntax_tree/tailwindcss.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "tailwindcss/version"
+require_relative "tailwindcss/patches"
+
+module SyntaxTree
+  module Tailwindcss
+    autoload :Sorter, "syntax_tree/tailwindcss/sorter"
+    autoload :RubyMutationVisitor, "syntax_tree/tailwindcss/ruby_mutation_visitor"
+    autoload :ErbMutationVisitor, "syntax_tree/tailwindcss/erb_mutation_visitor"
+    autoload :HamlMutationVisitor, "syntax_tree/tailwindcss/haml_mutation_visitor"
+
+    class << self
+      attr_accessor :output_path, :custom_order
+
+      def ruby_mutation_visitor
+        sorter = Sorter.load_cached
+        RubyMutationVisitor.new(sorter)
+      end
+
+      def erb_mutation_visitor
+        sorter = Sorter.load_cached
+        ErbMutationVisitor.new(sorter)
+      end
+
+      def haml_mutation_visitor
+        sorter = Sorter.load_cached
+        HamlMutationVisitor.new(sorter)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: syntax_tree-tailwindcss
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomasz Szczęśniak-Szlagowski
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+description: It sorts Tailwind classes in your helpers and ERB files and sorts them
+email:
+- spect88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".streerc"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/syntax_tree/complete_mutation_visitor.rb
+- lib/syntax_tree/erb/mutation_visitor.rb
+- lib/syntax_tree/haml/mutation_visitor.rb
+- lib/syntax_tree/tailwindcss.rb
+- lib/syntax_tree/tailwindcss/erb_mutation_visitor.rb
+- lib/syntax_tree/tailwindcss/haml_mutation_visitor.rb
+- lib/syntax_tree/tailwindcss/patches.rb
+- lib/syntax_tree/tailwindcss/ruby_mutation_visitor.rb
+- lib/syntax_tree/tailwindcss/sorter.rb
+- lib/syntax_tree/tailwindcss/version.rb
+homepage: https://github.com/spect88/syntax_tree-tailwindcss
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/spect88/syntax_tree-tailwindcss
+  source_code_uri: https://github.com/spect88/syntax_tree-tailwindcss
+  rubygems_mfa_required: 'true'
+post_install_message:
+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.3.7
+signing_key:
+specification_version: 4
+summary: A Syntax Tree plugin for sorting TailwindCSS classes
+test_files: []