clsx-rails 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ac79817d0d2f653dbc76e4f3d044c6d599f342acecc1c6d6c6639dbbdec1ecf
-  data.tar.gz: ce38f0509202614f8aeab6f16f0079eb93d686e6c5c42d48170af8d50ccd801b
+  metadata.gz: 2da83a9921c3d24cf5c9743bcaf1a11a63bae43f38f7ba197116436f8b2471d5
+  data.tar.gz: 280c9dfc3fc501ce352d755d620f49ec4e58b8c6de7e976487cd80ccf358e700
 SHA512:
-  metadata.gz: 0c8e9e1d7100c07f7336b9a8ac4fd699b4a1a90f78bd4c2fa51cdd931583948913d9622e901a17f3fa03104fbebca4f92ac07df50287a1f4209bb531cf4886fe
-  data.tar.gz: 155e24fb75550a7a12e050fc20089fc9677e0435d7b08f0412d65b19a727f7fbca2cb86cbb0d7cf6df44b037e4e515efa947c42d2da9f020805ac8c4461d7e58
+  metadata.gz: 33c8950cb1a10e94b22fc4a442dba3181dab708f7d1d6abec2bbd0b42aae009832aebcbd1c963c6050fa0ba397f4e4f960743675679d7ad46c507a3b2d9efb52
+  data.tar.gz: 47bb02df172c9c3d98251234112eaaef97b150d39b49c1e51a1fc5caf6d41c310719af75de32be86a15e7cb3a6062dd67fdbbe90e2c9765d9f3907f51399737f

data/CHANGELOG.md

@@ -4,54 +4,54 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and to [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/).
 
-## Unreleased changes
+## Unreleased
 
-## v2.0.0 (2025-01-11)
+## v3.0.0 (2026-02-13)
+
+### Added
+- Codecov badge and configuration
 
-### Breaking Changes
-- Drop Rails 6.1 and 7.0 support, require Rails 7.1+
+### Changed
+- BREAKING: Use clsx-ruby gem as core engine instead of bundled implementation
+- BREAKING: Require Ruby 3.2+ (was 3.1+) and Rails 7.2+ (was 7.1+)
+- Version constant moved from `Clsx::VERSION` to `Clsx::Rails::VERSION`
+- Benchmarks now compare against Rails `class_names` instead of internal versions
 
-### Features
-- Add Ruby 3.4 support
-- Add Rails 8.0, 8.1, and edge support
+### Removed
+- Bundled clsx algorithm (now provided by clsx-ruby dependency)
 
-### Performance Improvements
+## v2.0.0 (2025-01-11)
+
+### Changed
+- BREAKING: Drop Rails 6.1 and 7.0 support, require Rails 7.1+
 - Rewrite algorithm for 2-5x performance improvement
 - Add fast-paths for single string, string array, and simple hash
 - Use Hash-based deduplication instead of Array + `uniq!`
 - Use `Symbol#name` instead of `to_s` for faster symbol conversion
 - Use direct class comparison for type checking
 - Remove unused `require 'set'`
-
-### Chore
 - Refactor benchmark infrastructure (data.rb, original.rb, quick.rb, run.rb)
-- Add CLAUDE.md for AI coding assistants
+
+### Added
+- Ruby 3.4 support
+- Rails 8.0, 8.1, and edge support
+- CLAUDE.md for AI coding assistants
+
+### Tests
+- Improve test coverage to 100% line and 100% branch coverage
 
 ## v1.0.1 (2024-03-04)
 
-### Performance Improvements
+### Changed
 - Speeds up the performance by 2x [`32236ed`](https://github.com/svyatov/clsx-rails/commit/32236ed)
-
-### Chore
 - Fixes CI action [`f1b948c`](https://github.com/svyatov/clsx-rails/commit/f1b948c)
 - Upload code coverage to CodeCov for the latest combination of Ruby and ActionView only [`4e5d768`](https://github.com/svyatov/clsx-rails/commit/4e5d768)
 
-### Documentation
-- Changelog update + version bump [`13b408d`](https://github.com/svyatov/clsx-rails/commit/13b408d)
+### Added
 - Adds information about supported Ruby and Rails version [skip ci] [`2e6483f`](https://github.com/svyatov/clsx-rails/commit/2e6483f)
 - Adds link to the CodeCov badge, switch to Conventional Commits [`b48cc84`](https://github.com/svyatov/clsx-rails/commit/b48cc84)
-
-### Other
-- Updates CI badge [skip ci] [`a829613`](https://github.com/svyatov/clsx-rails/commit/a829613)
 - Adds code coverage tracking [`0c5d34c`](https://github.com/svyatov/clsx-rails/commit/0c5d34c)
-- Ignore ruby-head in the CI matrix [`f3ab4df`](https://github.com/svyatov/clsx-rails/commit/f3ab4df)
-- Better name for the GitHub Action job [`a28adb7`](https://github.com/svyatov/clsx-rails/commit/a28adb7)
-- Adds badges, fixes rubocop configuration for CI [`56fab44`](https://github.com/svyatov/clsx-rails/commit/56fab44)
-- Create dependabot.yml [`ed1e0eb`](https://github.com/svyatov/clsx-rails/commit/ed1e0eb)
-- Fixes GitHub Actions [`f58a4b2`](https://github.com/svyatov/clsx-rails/commit/f58a4b2)
 
 ## v1.0.0 (2024-03-03)
 
-### Other
 - Initial commit [`f65b9b8`](https://github.com/svyatov/clsx-rails/commit/f65b9b8)
-

data/README.md

@@ -1,18 +1,10 @@
 # clsx-rails [![Gem Version](https://img.shields.io/gem/v/clsx-rails)](https://rubygems.org/gems/clsx-rails) [![Codecov](https://img.shields.io/codecov/c/github/svyatov/clsx-rails)](https://app.codecov.io/gh/svyatov/clsx-rails) [![CI](https://github.com/svyatov/clsx-rails/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/clsx-rails/actions?query=workflow%3ACI) [![GitHub License](https://img.shields.io/github/license/svyatov/clsx-rails)](LICENSE.txt)
 
-> A tiny Rails view helper for constructing CSS class strings conditionally.
+> Rails view helper for constructing CSS class strings conditionally. Powered by [clsx-ruby](https://github.com/svyatov/clsx-ruby).
 
-This gem is essentially a clone if the [clsx](https://github.com/lukeed/clsx) npm package.
-It provides a simple way to conditionally apply classes to HTML elements in Rails views.
-It is especially useful when you have a lot of conditional classes and you want to keep your views clean and readable.
+Automatically adds `clsx` and `cn` helpers to all Rails views. The fastest alternative to Rails `class_names`.
 
-## Supported Ruby and Rails versions
-
-Ruby 3.1+ and Rails 7.1+ are supported.
-
-## Installation
-
-Install the gem and add to the application's Gemfile by executing:
+## Quick Start
 
 ```bash
 bundle add clsx-rails
@@ -21,14 +13,46 @@ bundle add clsx-rails
 Or add it manually to the Gemfile:
 
 ```ruby
-gem 'clsx-rails', '~> 1.0'
+gem 'clsx-rails', '~> 3.0'
 ```
 
-## Usage
+That's it — `clsx` and `cn` are now available in all your views:
+
+```erb
+<%= tag.div class: clsx('btn', 'btn-primary', active: @active) do %>
+  Click me
+<% end %>
+```
+
+## Why clsx-rails over Rails `class_names`?
+
+### Faster
+
+**3-8x faster** than Rails `class_names` across every scenario:
+
+| Scenario | clsx | Rails `class_names` | Speedup |
+|---|---|---|---|
+| Single string | 7.6M i/s | 911K i/s | **8.5x** |
+| String + hash | 2.4M i/s | 580K i/s | **4.1x** |
+| String array | 1.4M i/s | 357K i/s | **4.0x** |
+| Multiple strings | 1.5M i/s | 414K i/s | **3.7x** |
+| Hash | 2.2M i/s | 670K i/s | **3.3x** |
+| Mixed types | 852K i/s | 367K i/s | **2.3x** |
 
-The `clsx` helper method can be used in views to conditionally apply classes to HTML elements.
-You can also use a slightly more conise `cn` alias.
-It accepts a variety of arguments and returns a string of unique classes.
+<sup>Ruby 4.0.1, Apple M1 Pro. Reproduce: `bundle exec ruby benchmark/run.rb`</sup>
+
+### More features
+
+| Feature | clsx-rails | Rails `class_names` |
+|---|---|---|
+| Conditional classes | yes | yes |
+| Auto-deduplication | yes | yes |
+| 3-8x faster | yes | no |
+| Returns `nil` when empty | yes | no (returns `""`) |
+| Complex hash keys | yes | no |
+| Short `cn` alias | yes | no |
+
+## Usage
 
 ```ruby
 # Strings (variadic)
@@ -36,7 +60,7 @@ clsx('foo', true && 'bar', 'baz')
 # => 'foo bar baz'
 
 # Hashes
-cn({ foo: true, bar: false, baz: a_method_that_returns_true })
+cn(foo: true, bar: false, baz: a_method_that_returns_true)
 # => 'foo baz'
 
 # Hashes (variadic)
@@ -52,124 +76,130 @@ clsx(['foo'], ['', nil, false, 'bar'], [['baz', [['hello'], 'there']]])
 # => 'foo bar baz hello there'
 
 # Kitchen sink (with nesting)
-cn('foo', ['bar', { baz: false, bat: nil }, ['hello', ['world']]], 'cya');
+cn('foo', ['bar', { baz: false, bat: nil }, ['hello', ['world']]], 'cya')
 # => 'foo bar hello world cya'
 ```
 
+### ERB
+
 ```erb
-<%= tag.div class: clsx('foo', 'baz', 'is-active' => @active) do %>
+<%= tag.div class: clsx('foo', 'baz', 'is-active': @active) do %>
   Hello, world!
 <% end %>
 
-<div class="<%= clsx('foo', 'baz', 'is-active' => @active) %>">
+<div class="<%= clsx('foo', 'baz', 'is-active': @active) %>">
   Hello, world!
 </div>
 ```
 
+### HAML
+
 ```haml
-%div{class: clsx('foo', 'baz', 'is-active' => @active)}
+%div{class: clsx('foo', 'baz', 'is-active': @active)}
   Hello, world!
 ```
 
+### Slim
+
 ```slim
-div class=clsx('foo', 'baz', 'is-active' => @active)
+div class=clsx('foo', 'baz', 'is-active': @active)
   | Hello, world!
 ```
 
-So the basic idea is to get rid of constructions like this in your views:
+## Framework Examples
 
-```erb
-<% classes = ['foo', 'baz'] %>
-<% classes << 'is-active' if @active %>
+### ViewComponent
 
-<div class="<%= classes.join(' ') %>">
-  Hello, world!
-</div>
+```ruby
+class AlertComponent < ViewComponent::Base
+  def initialize(variant: :info, dismissible: false)
+    @variant = variant
+    @dismissible = dismissible
+  end
+
+  def classes
+    clsx("alert", "alert-#{@variant}", dismissible: @dismissible)
+  end
+end
 ```
 
-or like this:
+### Phlex
 
-```erb
-<div class="<%= ['foo', 'baz', @active ? 'is-active' : nil].compact.join(' ') %>">
-  Hello, world!
-</div>
+```ruby
+class Badge < Phlex::HTML
+  include Clsx::Helper
+
+  def initialize(color: :blue, pill: false)
+    @color = color
+    @pill = pill
+  end
+
+  def view_template
+    span(class: clsx("badge", "badge-#{@color}", pill: @pill)) { yield }
+  end
+end
 ```
 
-or like this:
+### Tailwind CSS
 
-```erb
-<div class="foo bar <%= 'is-active' if @active %>">
-  Hello, world!
-</div>
+```ruby
+class NavLink < ViewComponent::Base
+  def initialize(active: false)
+    @active = active
+  end
+
+  def classes
+    clsx(
+      'px-3 py-2 rounded-md text-sm font-medium transition-colors',
+      'text-white bg-indigo-600': @active,
+      'text-gray-300 hover:text-white hover:bg-gray-700': !@active
+    )
+  end
+end
 ```
 
-## Differences from the original `clsx` package
-
-This gem reproduces the functionality of the original `clsx` package, but with nuances of Ruby and Rails in mind.
+## Differences from JavaScript clsx
 
-The main differences are:
-
-1. falsy values in Ruby are only `false` and `nil`, so the `clsx` method will not accept `0`, `''`, `[]`, `{}`, etc. as falsy values.
-   ```ruby
-    clsx('foo' => 0, bar: []) # => 'foo bar'
-   ``` 
- 
-2. `clsx-rails` supports complex hash keys, like `{ %[foo bar] => true }`, which will be converted to `foo bar` in the resulting string.
-   Meaning, if it's a valid input for the `clsx-rails`, it's a valid hash key.
+1. **Returns `nil`** when no classes apply (not an empty string). Rails tag helpers skip `nil`, preventing empty `class=""` attributes:
    ```ruby
-    clsx([{ foo: true }, 'bar'] => true) # => 'foo bar'
-   ``` 
- 
-3. `clsx-rails` will ignore objects that are `blank?`, boolean (`true` or `false`), or an instance of `Proc` (so, procs and lambdas).
-    ```ruby
-     clsx('', [], {}, proc {}, -> {}, nil, false, true) # => nil
-    ```
- 
-4. `clsx-rails` returns `nil` if there are no classes to apply, instead of an empty string.
-   The reason for that is not to pollute the HTML with empty `class` attributes when using Rails tag helpers: Rails will not render the `class` attribute if it's `nil`.
+   clsx(nil, false) # => nil
+   ```
+
+2. **Deduplication** — duplicate classes are automatically removed:
    ```ruby
-     clsx(nil, false) # => nil
+   clsx('foo', 'foo') # => 'foo'
    ```
-   Although, it won't help if you're using it directly in erb:
-   ```erb
-    <div class="<%= clsx(nil, false) %>">
-      Hello, world!
-    </div>
+
+3. **Falsy values** — in Ruby only `false` and `nil` are falsy, so `0`, `''`, `[]`, `{}` are all truthy:
+   ```ruby
+   clsx('foo' => 0, bar: []) # => 'foo bar'
    ```
-   This code will render `<div class="">Hello, world!</div>` anyway.
- 
-5. `clsx-rails` eliminates duplicate classes:
+
+4. **Complex hash keys** — any valid `clsx` input works as a hash key:
    ```ruby
-    clsx('foo', 'foo') # => 'foo'
+   clsx([{ foo: true }, 'bar'] => true) # => 'foo bar'
    ```
 
-## Development
+5. **Ignored values** — boolean `true` and `Proc`/lambda objects are silently ignored:
+   ```ruby
+   clsx('', proc {}, -> {}, nil, false, true) # => nil
+   ```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run
-`rake test` to run the tests. You can also run `bin/console` for an interactive
-prompt that will allow you to experiment.
+## Looking for a framework-agnostic version?
 
-To install this gem onto your local machine, run `bundle exec rake install`. To
-release a new version, update the version number in `version.rb`, and then run
-`bundle exec rake release`, which will create a git tag for the version, push
-git commits and the created tag, and push the `.gem` file to
-[rubygems.org](https://rubygems.org).
+See [clsx-ruby](https://github.com/svyatov/clsx-ruby) — works with Rails, Sinatra, Hanami, or plain Ruby.
 
-There is a simple benchmark script in the `benchmark` directory.
-You can run it with `bundle exec ruby benchmark/run.rb`.
-I've added it for easier performance testing when making changes to the gem.
+## Supported Versions
 
-## Conventional Commits
+Ruby 3.2+ and Rails 7.2+.
 
-This project uses [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) for commit messages.
+## Development
 
-Types of commits are:
-- `feat`: a new feature
-- `fix`: a bug fix
-- `perf`: code that improves performance
-- `chore`: updating build tasks, configs, formatting etc; no code change
-- `docs`: changes to documentation
-- `refactor`: refactoring code
+```bash
+bin/setup                            # install dependencies
+bundle exec rake test                # run tests
+bundle exec ruby benchmark/run.rb   # run benchmarks
+```
 
 ## Contributing
 

data/lib/clsx/{version.rb → rails/version.rb}

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module Clsx
-  VERSION = '2.0.0'
+  module Rails
+    VERSION = '3.0.0'
+  end
 end

data/lib/clsx-rails.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require 'clsx'
 require 'active_support'
 require 'action_view'
 
-require_relative 'clsx/version'
-require_relative 'clsx/helper'
+require_relative 'clsx/rails/version'
 
 # :nodoc:
 module Clsx
-  ActiveSupport.on_load(:action_view) { include Helper }
+  module Rails; end # :nodoc:
+  ActiveSupport.on_load(:action_view) { include Clsx::Helper }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clsx-rails
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -15,15 +15,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
-description: A tiny Rails view helper for constructing CSS class strings conditionally
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: clsx-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Adds clsx and cn helpers to all Rails views for constructing CSS class
+  strings conditionally
 email:
 - leonid@svyatov.com
 executables: []
@@ -31,12 +46,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CLAUDE.md
 - LICENSE.txt
 - README.md
 - lib/clsx-rails.rb
-- lib/clsx/helper.rb
-- lib/clsx/version.rb
+- lib/clsx/rails/version.rb
 homepage: https://github.com/svyatov/clsx-rails
 licenses:
 - MIT
@@ -52,14 +65,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
-summary: clsx / classnames for Rails views
+summary: Rails view helper integration for clsx-ruby
 test_files: []

data/CLAUDE.md

@@ -1,54 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-clsx-rails is a Ruby gem that provides a Rails view helper (`clsx`/`cn`) for constructing CSS class strings conditionally. It's a Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package, adapted for Rails conventions.
-
-## Common Commands
-
-```bash
-# Run all tests and linting (default rake task)
-bundle exec rake
-
-# Run tests only
-bundle exec rake test
-
-# Run a single test file
-bundle exec ruby -Itest test/clsx/helper_test.rb
-
-# Run a specific test method
-bundle exec ruby -Itest test/clsx/helper_test.rb -n test_with_strings
-
-# Run linter
-bundle exec rake rubocop
-
-# Run benchmark
-bundle exec ruby benchmark/run.rb
-
-# Install dependencies
-bin/setup
-```
-
-## Architecture
-
-The gem has a minimal structure:
-
-- `lib/clsx-rails.rb` - Entry point that auto-includes the helper into ActionView via `ActiveSupport.on_load`
-- `lib/clsx/helper.rb` - Core implementation with `clsx` method and `cn` alias
-- `lib/clsx/version.rb` - Version constant
-
-The helper uses an optimized algorithm with fast-paths for common cases (single string, string array, simple hash) and Hash-based deduplication for complex inputs.
-
-## Key Behaviors
-
-- Returns `nil` (not empty string) when no classes apply - this prevents Rails from rendering empty `class=""` attributes
-- Eliminates duplicate classes automatically
-- Ruby falsy values are only `false` and `nil` (unlike JS, `0`, `''`, `[]`, `{}` are truthy)
-- Ignores `Proc`/lambda objects and boolean `true` values
-- Supports complex hash keys like `{ %w[foo bar] => true }` which resolve recursively
-
-## Commit Convention
-
-Uses [Conventional Commits](https://www.conventionalcommits.org/): `feat`, `fix`, `perf`, `chore`, `docs`, `refactor`

data/lib/clsx/helper.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-# :nodoc:
-module Clsx
-  # :nodoc:
-  module Helper
-    # The clsx function can take any number of arguments,
-    # each of which can be Hash, Array, Boolean, String, or Symbol.
-    #
-    # **Important**
-    # Any falsy values are discarded! Standalone Boolean values are discarded as well.
-    #
-    # @param [Mixed] args
-    #
-    # @return [String] the joined class names
-    #
-    # @example
-    #   clsx('foo', 'bar') # => 'foo bar'
-    #   clsx(true, { bar: true }) # => 'bar'
-    #   clsx('foo', { bar: false }) # => 'foo'
-    #   clsx({ bar: true }, 'baz', { bat: false }) # => 'bar baz'
-    #
-    # @example within a view
-    #   <div class="<%= clsx('foo', 'bar') %>">
-    #   <div class="<%= clsx('foo', active: @is_active, 'another-class' => @condition) %>">
-    #   <%= tag.div class: clsx(%w[foo bar], hidden: @condition) do ... end %>
-    #
-    # @note Implementation prioritizes performance over readability.
-    #   Direct class comparisons and explicit conditionals are used
-    #   instead of more idiomatic Ruby patterns for speed.
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-    def clsx(*args)
-      return nil if args.empty?
-
-      # Fast path: single argument (most common cases)
-      if args.size == 1
-        arg = args[0]
-        klass = arg.class
-
-        if klass == String
-          return arg.empty? ? nil : arg
-        elsif klass == Symbol
-          return arg.name
-        elsif klass == Array && arg.all?(String)
-          seen = {}
-          arg.each { |s| seen[s] = true unless s.empty? || seen.key?(s) }
-          return seen.empty? ? nil : seen.keys.join(' ')
-        elsif klass == Hash
-          return clsx_simple_hash(arg)
-        end
-      end
-
-      seen = {}
-      clsx_process(args, seen)
-      seen.empty? ? nil : seen.keys.join(' ')
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
-    alias cn clsx
-
-    private
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-    def clsx_simple_hash(hash)
-      return nil if hash.empty?
-
-      seen = {}
-      hash.each do |key, value|
-        next unless value
-
-        klass = key.class
-
-        if klass == Symbol
-          seen[key.name] = true
-        elsif klass == String
-          seen[key] = true unless key.empty?
-        else
-          # Complex key - fall back to full processing
-          seen = {}
-          clsx_process([hash], seen)
-          return seen.empty? ? nil : seen.keys.join(' ')
-        end
-      end
-
-      seen.empty? ? nil : seen.keys.join(' ')
-    end
-
-    # rubocop:disable Style/MultipleComparison
-    def clsx_process(args, seen)
-      deferred = nil
-
-      args.each do |arg|
-        klass = arg.class
-
-        if klass == String
-          seen[arg] = true unless arg.empty? || seen.key?(arg)
-        elsif klass == Symbol
-          str = arg.name
-          seen[str] = true unless seen.key?(str)
-        elsif klass == Array
-          clsx_process(arg, seen)
-        elsif klass == Hash
-          arg.each { |key, value| (deferred ||= []) << key if value }
-        elsif klass == Integer || klass == Float
-          str = arg.to_s
-          seen[str] = true unless seen.key?(str)
-        elsif klass == NilClass || klass == FalseClass || klass == TrueClass || klass == Proc
-          next
-        else
-          str = arg.to_s
-          seen[str] = true unless str.empty? || seen.key?(str)
-        end
-      end
-
-      clsx_process(deferred, seen) if deferred
-    end
-    # rubocop:enable Style/MultipleComparison, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-  end
-end