tailwind-sorter 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82b25d2e48c760db25e242cafa14a986831e6ccaff1498ea7fbf638dc22392d9
-  data.tar.gz: dc94b034b7e7922bafc9f618a7db6f839d102eb2c38f916689f538fcfab07d2c
+  metadata.gz: a5b16162e06cb7a443fe14cb3789db5c9acc19ee0f142d6033645e52b3e54ac5
+  data.tar.gz: 2f8f31eebb9b06407e38dc0e955324c543a2f7a3bd5f0826474055322f1710d9
 SHA512:
-  metadata.gz: 95a45a46c6a5911db7bd2e48fde99b7a752f2de25bc5832b009c0fe5d840912474be6047caf2f7ecb3d2325e894c466bab4ff9f32f71fe88506448ff204bb74c
-  data.tar.gz: 98a11cdfd1bebff6fd7a8a24069326dc26776dffdcb4b37f8271374793c04133823ebd2c3375c5a6192cec5f5f68ac0b61e9322be9757658b102d32898f02358
+  metadata.gz: 0ee3992e5ef6237c10a56d44955a84f4791bbdc021238c72de8cc8a4054076486a0da17eb6626f742a59922baf83758000a5dc3cf248984da568c6113acd60f3
+  data.tar.gz: 13ac69950d1fe543a14bf32752caa323a38fa23704c6e311517307bf506d17f8e55cea0226bca03b17796911737d031dfd8fe450c2414c8ce866493b665216cd

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+### 0.5.0
+
+Restructure the gem completely:
+
+- extract `FileSorter` (that can sort classes in a file) and a new `StringSorter` (that can sort classes in a string)
+- clean up the code into their own modules / classes
+- add a DSL for running the sorters from ruby code
+- enhance the tests
+
+**BREAKING CHANGE**: if you called the file sorter from ruby like this:
+
+```ruby
+TailwindSorter::Sorter.run(file_name, warn_only: true/false, config_file: "some_config")
+```
+
+you need to change the call to the new syntax:
+
+```ruby
+TailwindSorter.sort_file(file_name, warn_only: true/false, config_file: "some_config")
+
+```
+
+### 0.4.1
+
+Add support for processing multiple files at once.
+
 ### 0.4.0
 
 - Add support for regular expressions in configuration for class ordering (#3)

data/README.md

@@ -2,12 +2,11 @@
 
 **A ruby gem to sort the [Tailwind CSS](https://tailwindcss.com) classes in your templates _the custom way_.**
 
-The gem contains a standalone executable script that can work in two ways:
+The gem contains a sorting library and a standalone executable script that can work in two ways:
 
 - it can edit the given file in place (especially useful when hooked up to a file changes watcher) or
 - it can just generate warning messages suitable for [Overcommit](https://github.com/sds/overcommit),
-  [Lefthook](https://github.com/evilmartians/lefthook) or any other similar system (or people, if that’s what you
-  prefer).
+  [Lefthook](https://github.com/evilmartians/lefthook) or any other similar system.
 
 Out of the box the script supports sorting classes in [Slim templates](http://slim-lang.com/) but can be configured for
 anything else. The script also removes duplicate classes.
@@ -163,6 +162,12 @@ The script requires the configuration file to be present in `config/tailwind_sor
 bin/tailwind_sorter -c path/to/my/config_file.yml app/views/my_template.html.slim
 ```
 
+Multiple files can be processed in a single run:
+
+```sh
+bin/tailwind_sorter app/views/my_template.html.slim app/views/another_template.html.slim
+```
+
 ## Running automatically via your IDE / editor
 
 Perhaps the best way to run the script is using your editor or IDE. Many editors provide the possibility to watch your
@@ -186,20 +191,36 @@ problems found.
 To run the sorter from ruby code, use the following line:
 
 ```ruby
-TailwindSorter::Sorter.run("app/views/my_template.html.slim")
+TailwindSorter.sort_file("app/views/my_template.html.slim")
+```
+
+You can also optionally pass in some arguments such as `warn_only: true` to only show  warning instead of overwriting the file or `config_file: "path/to/my/config_file.yml"` for custom config path.
+
+## Sorting Tailwind classes from ruby code
+
+You can also use this gem as a library and sort a single string with Tailwind classes:
+
+```ruby
+>> TailwindSorter.sort("my-4 block absolute")
+=> "absolute block my-4"
+```
+
+Optionally also with a custom config file:
+
+```ruby
+TailwindSorter.sort("my-4 block absolute", config_file: "path/to/my/config_file.yml")
 ```
 
-You can also optionally pass in ome arguments such as `warn_only: true` to only show  warning instead of overwriting the file or `config_file: "path/to/my/config_file.yml"` for custom config path.
 
 ## Running tests
 
 ```sh
 bundle install # to install the rspec gem
 bundle exec rspec
-.................
+..................................
 
-Finished in 1.08 seconds (files took 0.03424 seconds to load)
-17 examples, 0 failures
+Finished in 0.28774 seconds (files took 0.06508 seconds to load)
+34 examples, 0 failures
 ```
 
 ## Answers for the curious
@@ -209,3 +230,5 @@ Finished in 1.08 seconds (files took 0.03424 seconds to load)
 When we initially reordered CSS classes in all our templates (~900 Slim files) with the script changing nearly 4000
 lines, the whole process took less than 30 seconds. This makes the processing speed of approximately 30 files per
 second. Judge for yourself if this is fast enough for your needs or not.
+
+**Update**: this is a benchmark of an old version of the gem which supported sorting only a single file at once. Since version 0.4.1 the script can process multiple files in a single run and as this skips repeated loading of ruby it speeds up the bulk sorting process in an order of magnitude.

data/exe/tailwind_sorter

@@ -1,12 +1,12 @@
 #!/usr/bin/env ruby
 
-lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
 $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 
 require "tailwind_sorter"
 
 warn_only = false
-config_file = "config/tailwind_sorter.yml"
+config_file = TailwindSorter::Config::DEFAULT_CONFIG_FILE
 
 while (arg = ARGV.shift)
   case arg
@@ -15,13 +15,16 @@ while (arg = ARGV.shift)
   when "-c"
     config_file = ARGV.shift
   else
-    file_name = arg
+    ARGV.unshift(arg)
+    break
   end
 end
 
 begin
-  TailwindSorter::Sorter.run(file_name, warn_only: warn_only, config_file: config_file)
+  while (file_name = ARGV.shift)
+    TailwindSorter.sort_file(file_name, warn_only:, config_file:)
+  end
 rescue ArgumentError => e
-  STDERR.puts e.message
+  warn e.message
   exit 1
 end

data/lib/tailwind_sorter/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module TailwindSorter
+  class Config
+    DEFAULT_CONFIG_FILE = "config/tailwind_sorter.yml"
+
+    def initialize(config_file = DEFAULT_CONFIG_FILE)
+      unless config_file && File.exist?(config_file)
+        raise ArgumentError, "Configuration file '#{config_file}' does not exist"
+      end
+
+      @config_file = config_file
+    end
+
+    def load
+      @config = YAML.load_file(@config_file)
+      convert_class_order_regexps!
+      @config
+    end
+
+    private
+
+    def convert_class_order_regexps!
+      @config["classes_order"].each_value do |class_patterns|
+        class_patterns.map! do |class_or_pattern|
+          if (patterns = class_or_pattern.match(%r{\A/(.*)/\z}).to_a).empty?
+            class_or_pattern
+          else
+            /\A#{patterns.last}\z/
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tailwind_sorter/dsl.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "tailwind_sorter/config"
+require "tailwind_sorter/string_sorter"
+require "tailwind_sorter/file_sorter"
+
+module TailwindSorter
+  module DSL
+    def sort(classes_string, config_file: Config::DEFAULT_CONFIG_FILE)
+      TailwindSorter::StringSorter.new(config_file:).sort(classes_string)
+    end
+
+    def sort_file(file, warn_only: false, config_file: Config::DEFAULT_CONFIG_FILE)
+      TailwindSorter::FileSorter.new(warn_only:, config_file:).sort(file)
+    end
+  end
+end

data/lib/tailwind_sorter/file_sorter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "yaml"
+
+require "tailwind_sorter/config"
+require "tailwind_sorter/sortable"
+
+module TailwindSorter
+  class FileSorter
+    include Sortable
+
+    def initialize(warn_only: false, config_file: Config::DEFAULT_CONFIG_FILE)
+      @warn_only = warn_only
+      @config = Config.new(config_file).load
+
+      @sorting_keys_cache = {}
+    end
+
+    def sort(file_name)
+      raise ArgumentError, "File '#{file_name}' does not exist" unless file_name && File.exist?(file_name)
+
+      sort_classes(file_name)
+    end
+
+    private
+
+    def sort_classes(file)
+      warnings = []
+
+      infile = File.open(file)
+      outfile = Tempfile.create("#{File.basename(file)}.sorted")
+      changed = false
+
+      infile.each_line do |line|
+        line_number = infile.lineno
+
+        line_regexps_for(file).each_value do |regexp_config|
+          regexp = regexp_config["regexp"]
+          prefix = regexp_config["class_prefix"]
+          split_by = "#{regexp_config['class_splitter']}#{prefix}"
+
+          next unless (match = line.match(regexp))
+
+          classes = match["classes"]
+          classes = classes.split(split_by).map(&:strip).reject(&:empty?).uniq
+          sorted_classes = sort_classes_array(classes)
+
+          if @warn_only
+            orig_keys = classes.map { |css_class| sorting_key_lambda.call(css_class) }
+            sorted_keys = sorted_classes.map { |css_class| sorting_key_lambda.call(css_class) }
+
+            if orig_keys != sorted_keys
+              warning = "#{file}:#{line_number}:CSS classes are not sorted well. Please run 'tailwind_sorter #{file}'."
+              warnings << warning
+              puts(warning)
+            end
+          else
+            orig_line = line.dup unless changed
+            line.sub!(regexp, "\\k<before>#{prefix}#{sorted_classes.join(split_by)}")
+            changed = true if !changed && line != orig_line
+          end
+        end
+
+        outfile.puts line
+      end
+
+      success = true
+
+      warnings
+    rescue StandardError => e
+      warn "An error occurred: #{e}"
+      success = false
+    ensure
+      infile.close
+      outfile.close
+
+      success && changed ? FileUtils.mv(outfile, file) : File.unlink(outfile)
+    end
+
+    def line_regexps_for(file)
+      line_regexps = @config["regexps"].select { |_k, v| v["file_extension"] == File.extname(file) }
+      line_regexps.each_value { |v| v["regexp"] = Regexp.new(v["regexp"]) }
+      line_regexps
+    end
+  end
+end

data/lib/tailwind_sorter/sortable.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module TailwindSorter
+  module Sortable
+    private
+
+    # Returns the Tailwind classes array sorted according to the config file.
+    def sort_classes_array(classes)
+      classes = classes.map do |css_class_with_variants|
+        sort_variants(css_class_with_variants)
+      end
+
+      classes.sort_by { |css_class| sorting_key_lambda.call(css_class) }
+    end
+
+    # Lambda for sorting the Tailwind CSS classes. It is memoized to avoid repeated class groups lookups.
+    def sorting_key_lambda(default_index: 0)
+      @sorting_key_lambda ||= begin
+        class_groups = @config["classes_order"].keys
+        ->(tw_class) { sorting_key(tw_class, class_groups:, default_index:) }
+      end
+    end
+
+    # Reorders multiple variants, e.g.: "focus:sm:block" -> "sm:focus:block".
+    def sort_variants(css_class_with_variants)
+      *variants, css_class = css_class_with_variants.split(":")
+      return css_class_with_variants if variants.length <= 1
+
+      variants.sort_by! { |variant| @config["variants_order"].index(variant) }
+      "#{variants.join(':')}:#{css_class}"
+    end
+
+    # Constructs the sorting key for sorting CSS classes in the following way:
+    #
+    # group_index, variant1_index, variant2_index, class_index
+    # "sm:focus:flex" -> "01,01,11,0010"
+    # "flex"          -> "01,00,00,0010"
+    # "custom-class"  -> "00,00,00,0000"
+    def sorting_key(css_class_with_variants, class_groups:, default_index: 0)
+      return @sorting_keys_cache[css_class_with_variants] if @sorting_keys_cache[css_class_with_variants]
+
+      *variants, css_class = css_class_with_variants.split(":")
+
+      matching_index_in_group = nil
+      matching_group = class_groups.find do |group|
+        matching_index_in_group ||= @config["classes_order"][group].index { _1 === css_class }
+      end
+
+      key = [
+        format("%02d", (matching_group && class_groups.index(matching_group)) || default_index),
+        format("%02d", @config["variants_order"].index(variants[0]) || default_index),
+        format("%02d", @config["variants_order"].index(variants[1]) || default_index),
+        format("%04d", matching_index_in_group || default_index)
+      ].join(",")
+
+      @sorting_keys_cache[css_class_with_variants] = key
+    end
+  end
+end

data/lib/tailwind_sorter/string_sorter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+require "tailwind_sorter/config"
+require "tailwind_sorter/sortable"
+
+module TailwindSorter
+  class StringSorter
+    include Sortable
+
+    def initialize(config_file: Config::DEFAULT_CONFIG_FILE)
+      @config = Config.new(config_file).load
+      @sorting_keys_cache = {}
+    end
+
+    def sort(classes_string)
+      sort_classes_array(classes_string.split.map(&:strip).reject(&:empty?).uniq).join(" ")
+    end
+  end
+end

data/lib/tailwind_sorter/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TailwindSorter
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/tailwind_sorter.rb

@@ -1,5 +1,9 @@
-require "tailwind_sorter/sorter"
+# frozen_string_literal: true
+
+require "tailwind_sorter/config"
+require "tailwind_sorter/dsl"
 require "tailwind_sorter/version"
 
 module TailwindSorter
+  extend TailwindSorter::DSL
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tailwind-sorter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - NejŘemeslníci.cz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-04 00:00:00.000000000 Z
+date: 2024-08-08 00:00:00.000000000 Z
 dependencies: []
 description: Simple but customizable sorter for TailwindCSS classes
 email:
@@ -23,7 +23,11 @@ files:
 - Rakefile
 - exe/tailwind_sorter
 - lib/tailwind_sorter.rb
-- lib/tailwind_sorter/sorter.rb
+- lib/tailwind_sorter/config.rb
+- lib/tailwind_sorter/dsl.rb
+- lib/tailwind_sorter/file_sorter.rb
+- lib/tailwind_sorter/sortable.rb
+- lib/tailwind_sorter/string_sorter.rb
 - lib/tailwind_sorter/version.rb
 homepage: https://github.com/NejRemeslnici/tailwind-sorter
 licenses:

data/lib/tailwind_sorter/sorter.rb

@@ -1,148 +0,0 @@
-require "tempfile"
-require "yaml"
-
-module TailwindSorter
-  class Sorter
-    def initialize
-      @sorting_keys_cache = {}
-    end
-
-    # reorders multiple variants, e.g.: "focus:sm:block" -> "sm:focus:block"
-    def sort_variants(css_class_with_variants, variants_order:)
-      *variants, css_class = css_class_with_variants.split(":")
-      return css_class_with_variants if variants.length <= 1
-
-      variants.sort_by! { |variant| variants_order.index(variant) }
-      "#{variants.join(':')}:#{css_class}"
-    end
-
-    # Constructs the sorting key for sorting CSS classes in the following way:
-    #
-    # group_index, variant1_index, variant2_index, class_index
-    # "sm:focus:flex" -> "01,01,11,0010"
-    # "flex"          -> "01,00,00,0010"
-    # "custom-class"  -> "00,00,00,0000"
-    def sorting_key(css_class_with_variants, variants_order:, classes_order:, class_groups:, default_index: 0)
-      return @sorting_keys_cache[css_class_with_variants] if @sorting_keys_cache[css_class_with_variants]
-
-      *variants, css_class = css_class_with_variants.split(":")
-
-      matching_index_in_group = nil
-      matching_group = class_groups.find do |group|
-        matching_index_in_group ||= classes_order[group].index { _1 === css_class }
-      end
-
-      key = [
-        format("%02d", matching_group && class_groups.index(matching_group) || default_index),
-        format("%02d", variants_order.index(variants[0]) || default_index),
-        format("%02d", variants_order.index(variants[1]) || default_index),
-        format("%04d", matching_index_in_group || default_index)
-      ].join(",")
-
-      # puts "#{css_class_with_variants} #{key}"
-      @sorting_keys_cache[css_class_with_variants] = key
-    end
-
-    def convert_regexps!(classes_order)
-      classes_order.each do |group, class_patterns|
-        class_patterns.map! do |class_or_pattern|
-          if !(patterns = class_or_pattern.match(%r{\A/(.*)/\z}).to_a).empty?
-            Regexp.new(/\A#{patterns.last}\z/)
-          else
-            class_or_pattern
-          end
-        end
-      end
-
-      classes_order
-    end
-
-    def sort_classes(file, regexps:, variants_order:, classes_order:, default_index: 0, warn_only: false)
-      convert_regexps!(classes_order)
-      class_groups = classes_order.keys
-      warnings = []
-
-      infile = File.open(file)
-      outfile = Tempfile.create("#{File.basename(file)}.sorted")
-
-      calculate_sorting_key = lambda do |css_class_with_variants|
-        sorting_key(css_class_with_variants, variants_order:, classes_order:, class_groups:, default_index:)
-      end
-
-      changed = false
-      infile.each_line do |line|
-        line_number = infile.lineno
-
-        regexps.each do |_regexp_name, regexp_config|
-          regexp = regexp_config["regexp"]
-          prefix = regexp_config["class_prefix"]
-          split_by = "#{regexp_config['class_splitter']}#{prefix}"
-
-          next unless (match = line.match(regexp))
-
-          matched_classes = match["classes"]
-          # puts "#{line_number}: #{matched_classes}"
-
-          classes = matched_classes.split(split_by).map(&:strip).reject(&:empty?).uniq.map do |css_class_with_variants|
-            sort_variants(css_class_with_variants, variants_order: variants_order)
-          end
-
-          sorted_classes = classes.sort_by { |css_class| calculate_sorting_key.call(css_class) }
-          # puts sorted_classes.join('.')
-
-          if warn_only
-            orig_keys = classes.map { |css_class| calculate_sorting_key.call(css_class) }
-            sorted_keys = sorted_classes.map { |css_class| calculate_sorting_key.call(css_class) }
-            # puts orig_keys.inspect
-            # puts sorted_keys.inspect
-            if orig_keys != sorted_keys
-              warning = "#{file}:#{line_number}:CSS classes are not sorted well. Please run 'tailwind_sorter #{file}'."
-              warnings << warning
-              puts(warning)
-            end
-          else
-            orig_line = line.dup unless changed
-            line.sub!(regexp, "\\k<before>#{prefix}#{sorted_classes.join(split_by)}")
-            changed = true if !changed && line != orig_line
-          end
-        end
-
-        outfile.puts line
-      end
-
-      success = true
-
-      warnings
-
-    rescue StandardError => e
-      warn "An error occurred: #{e}"
-      success = false
-
-    ensure
-      infile.close
-      outfile.close
-
-      success && changed ? FileUtils.mv(outfile, file) : File.unlink(outfile)
-    end
-
-    def run(file_name, warn_only: false, config_file: "config/tailwind_sorter.yml")
-      raise ArgumentError, "File '#{file_name}' does not exist" unless file_name && File.exist?(file_name)
-      raise ArgumentError, "Configuration file '#{config_file}' does not exist" unless config_file && File.exist?(config_file)
-
-      config = YAML.load_file(config_file)
-      file_extension = File.extname(file_name)
-
-      regexps = config["regexps"].select { |_k, v| v["file_extension"] == file_extension }
-      regexps.each { |_k, v| v["regexp"] = Regexp.new(v["regexp"]) }
-
-      sort_classes(file_name, regexps:,
-                              classes_order: config["classes_order"],
-                              variants_order: config["variants_order"],
-                              warn_only:)
-    end
-
-    def self.run(...)
-      new.run(...)
-    end
-  end
-end