clsx-ruby 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a68c03880d32a04dc1c721e0ee3009ac8a276f906da830e4866e2afae6ce92
-  data.tar.gz: 24155294bbdca977a8358ef7f6296febfdc86c2ca61d4faaf5b7e49b7f6d0d2a
+  metadata.gz: 043652e6d2bc00c77d0409b45cb15f361cd1fb417af14db62892be42ed2a1815
+  data.tar.gz: dbacda2ec82ed045800345914fec73339d1dfee64df87e33305a5a8b5cf7c118
 SHA512:
-  metadata.gz: 34de1db1360cae0f43ac95c1c5e1cb65d53294a313d5ad232afd79fe2b785e9ffab14f5b6bec527058f0cacc13354a000db1ea3479f43f0f6e17e5240a245c90
-  data.tar.gz: 4236efda398f4977ebb215ef492fd3965eff434efe9a8bccb9da4fb06023bd0bf8f32c02fabc962129a0fce7cbae34950c7936e0b3334e5da48219ddb15dc7ea
+  metadata.gz: 26c9443192380c6b8415923df85df04d78add5cead6a676d78739410261cbeb277f8e6c4856b15761355dd61becfc09ad6aec7870d530f78bb5d3fcfbd358893
+  data.tar.gz: 919462b5126de045d8a2b1d63ef5e3da4fb04156ef62c9c3e4985922d05dd041997fcbc473f1aab7495d61914e87b09cdf88b2f1448f0fb80b8c3c3006115763

data/CHANGELOG.md

@@ -1,7 +1,49 @@
 # Changelog
 
+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).
+
+## Unreleased
+
+## v1.1.1
+
+### Added
+
+- YARD documentation to all public and private methods
+- Rails 8.1.2 `class_names` as a third benchmark competitor
+- ViewComponent and Phlex examples in README
+- Memory and profiling benchmark scripts (`benchmark/memory.rb`, `benchmark/profile.rb`, `benchmark/stackprof_run.rb`)
+
+### Changed
+
+- Replaced `class ==` type checks with idiomatic `is_a?` early returns
+- Extracted `clsx_single` method for clearer single-argument dispatch
+- Simplified `Cn` alias from wrapper module to `Cn = Clsx`
+- Removed redundant `seen.key?` guards in `clsx_process`
+- Reduced allocations in `clsx_single`: pass arrays directly to `clsx_process` instead of wrapping, handle edge types inline
+- Moved inline rubocop disables to `.rubocop.yml` config
+- Updated benchmark baseline to compare against previous version, not ancient one
+- Rewrote README with benchmark numbers and feature comparison table
+- Process hash keys inline in `clsx_process` instead of deferring to a second pass (+23% mixed, +13% complex). Hash keys now appear in declaration order, matching JS clsx behavior.
+
+## v1.1.0
+
+### Added
+
+- New fast path for `clsx('base', active: cond)` string + hash pattern (+69%)
+- `string + hash` benchmark scenario
+
+### Changed
+
+- Optimized hash-only path: skip dedup Hash since hash keys are unique by definition (+8%)
+- Use `str.dup` instead of `String.new(str)` for buffer init (+12-18% on hash paths)
+
 ## v1.0.0
 
+### Added
+
 - Initial release as standalone framework-agnostic gem
 - Extracted from clsx-rails v2.0.0
 - API: `Clsx['foo', bar: true]`, `Cn['foo', bar: true]`, `include Clsx::Helper`

data/CLAUDE.md

@@ -61,6 +61,78 @@ The helper uses an optimized algorithm with fast-paths for common cases (single
 - Ignores `Proc`/lambda objects and boolean `true` values
 - Supports complex hash keys like `{ %w[foo bar] => true }` which resolve recursively
 
+## Benchmarking
+
+`benchmark/original.rb` contains the **previous version** of the algorithm for comparison. It must always reflect the last committed version from the main branch — not some ancient baseline.
+
+**Rule:** Before making any algorithm or performance change to `lib/clsx/helper.rb`, copy the current main-branch implementation into `benchmark/original.rb` (wrapping in `module ClsxOriginal` — method names stay the same, no renaming needed). This ensures `bundle exec ruby benchmark/run.rb` compares the new code against its immediate predecessor, giving meaningful before/after numbers.
+
 ## Commit Convention
 
-Uses [Conventional Commits](https://www.conventionalcommits.org/): `feat`, `fix`, `perf`, `chore`, `docs`, `refactor`
+This project follows [Conventional Commits v1.0.0](https://www.conventionalcommits.org/en/v1.0.0/).
+
+Format: `<type>[optional scope]: <description>`
+
+### Types
+
+| Type | Description | Version bump |
+|------|-------------|--------------|
+| `feat` | New feature | MINOR |
+| `fix` | Bug fix | PATCH |
+| `docs` | Documentation only | — |
+| `style` | Formatting, whitespace | — |
+| `refactor` | Code change (no feature/fix) | — |
+| `perf` | Performance improvement | — |
+| `test` | Adding/fixing tests | — |
+| `build` | Build system or dependencies | — |
+| `ci` | CI configuration | — |
+| `chore` | Maintenance tasks | — |
+
+### Breaking Changes
+
+Use `!` after type or add `BREAKING CHANGE:` footer. Breaking changes trigger a MAJOR version bump.
+
+## Changelog Format
+
+This project follows [Keep a Changelog v1.1.0](https://keepachangelog.com/en/1.1.0/).
+
+Allowed categories in **required order**:
+
+1. **Added** — new features
+2. **Changed** — changes to existing functionality
+3. **Deprecated** — soon-to-be removed features
+4. **Removed** — removed features
+5. **Fixed** — bug fixes
+6. **Security** — vulnerability fixes
+
+Rules:
+- Categories must appear in the order listed above within each release section
+- Each category must appear **at most once** per release section — always append to an existing category rather than creating a duplicate
+- Do NOT use non-standard categories like "Updated", "Internal", or "Breaking changes"
+- Breaking changes should be prefixed with **BREAKING:** within the relevant category (typically Changed or Removed)
+
+`CHANGELOG.md` must stay current on every feature branch. After each commit, ensure the `## Unreleased` section at the top accurately reflects all user-facing changes on the branch. Add the section if it doesn't exist. Keep entries concise — one bullet per logical change. On release, the `## Unreleased` heading gets replaced with the version number.
+
+The unreleased section describes the **net result** compared to the last release, not a history of intermediate steps. When a later change supersedes an earlier one, update or remove the stale bullet — don't accumulate entries that no longer reflect reality.
+
+## Documentation Style
+
+All classes and methods must have YARD documentation. Follow these conventions:
+
+- Always leave a **blank line** between the main description and `@` attributes (params, return, etc.)
+- Document all public methods with description, params, and return types
+- Document all private methods with params and return types, add description for complex logic
+- Include `@example` blocks for non-obvious usage patterns
+- **Omit descriptions that just repeat the code** — if the method name and signature make it obvious, only include `@param`, `@return` tags without a description
+
+## Releasing a New Version
+
+This project follows [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html):
+- **MAJOR** — breaking changes (incompatible API changes)
+- **MINOR** — new features (backwards-compatible)
+- **PATCH** — bug fixes (backwards-compatible)
+
+1. Update `lib/clsx/version.rb` with the new version number
+2. Update `CHANGELOG.md`: change `## Unreleased` to `## vX.Y.Z` and add new empty `## Unreleased` section
+3. Commit changes: `chore: bump version to X.Y.Z`
+4. Release: `bundle exec rake release`

data/README.md

@@ -1,16 +1,10 @@
-# clsx-ruby [![Gem Version](https://img.shields.io/gem/v/clsx-ruby)](https://rubygems.org/gems/clsx-ruby) [![CI](https://github.com/svyatov/clsx-ruby/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/clsx-ruby/actions?query=workflow%3ACI) [![GitHub License](https://img.shields.io/github/license/svyatov/clsx-ruby)](LICENSE.txt)
+# clsx-ruby [![Gem Version](https://img.shields.io/gem/v/clsx-ruby)](https://rubygems.org/gems/clsx-ruby) [![Codecov](https://img.shields.io/codecov/c/github/svyatov/clsx-ruby)](https://app.codecov.io/gh/svyatov/clsx-ruby) [![CI](https://github.com/svyatov/clsx-ruby/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/svyatov/clsx-ruby/actions?query=workflow%3ACI) [![GitHub License](https://img.shields.io/github/license/svyatov/clsx-ruby)](LICENSE.txt)
 
-> A tiny, framework-agnostic utility for constructing CSS class strings conditionally.
+> The fastest Ruby utility for constructing CSS class strings conditionally. Perfect for Tailwind CSS utility classes. Zero dependencies.
 
-Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package. Works with Rails, Sinatra, Hanami, or plain Ruby.
+Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package — a faster, smarter alternative to Rails `class_names`. Works with Rails, Sinatra, Hanami, or plain Ruby.
 
-For automatic Rails view helper integration, see [clsx-rails](https://github.com/svyatov/clsx-rails).
-
-## Requirements
-
-Ruby 3.2+. No runtime dependencies.
-
-## Installation
+## Quick Start
 
 ```bash
 bundle add clsx-ruby
@@ -19,9 +13,51 @@ bundle add clsx-ruby
 Or add it manually to the Gemfile:
 
 ```ruby
-gem 'clsx-ruby', '~> 1.0'
+gem 'clsx-ruby', '~> 1.1'
+```
+
+Then use it:
+
+```ruby
+require 'clsx'
+
+Clsx['btn', 'btn-primary', active: is_active, disabled: is_disabled]
+# => "btn btn-primary active" (when is_active is truthy, is_disabled is falsy)
 ```
 
+## Why clsx-ruby?
+
+### Blazing fast
+
+**3–8x faster** than Rails `class_names` across every scenario:
+
+| Scenario | clsx-ruby | 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** |
+
+<sup>Ruby 4.0.1, Apple M1 Pro. Reproduce: `bundle exec ruby benchmark/run.rb`</sup>
+
+### More feature-rich than `class_names`
+
+| Feature | clsx-ruby | Rails `class_names` |
+|---|---|---|
+| Conditional classes | ✅ | ✅ |
+| Auto-deduplication | ✅ | ✅ |
+| 3–8× faster | ✅ | ❌ |
+| Returns `nil` when empty | ✅ | ❌ (returns `""`) |
+| Complex hash keys | ✅ | ❌ |
+| Framework-agnostic | ✅ | ❌ |
+| Zero dependencies | ✅ | ❌ |
+
+### Tiny footprint
+
+~100 lines of code. Zero runtime dependencies. Ruby 3.2+.
+
 ## Usage
 
 ### Bracket API (recommended)
@@ -93,63 +129,131 @@ Clsx[['foo', nil, false, 'bar']]
 Clsx[['foo'], ['', nil, false, 'bar'], [['baz', [['hello'], 'there']]]]
 # => 'foo bar baz hello there'
 
+# Symbols
+Clsx[:foo, :'bar-baz']
+# => 'foo bar-baz'
+
+# Numbers
+Clsx[1, 2, 3]
+# => '1 2 3'
+
 # Kitchen sink (with nesting)
 Clsx['foo', ['bar', { baz: false, bat: nil }, ['hello', ['world']]], 'cya']
 # => 'foo bar hello world cya'
 ```
 
-### Framework examples
+## Framework Examples
+
+### Rails
 
 ```erb
-<%# Rails %>
 <%= tag.div class: Clsx['foo', 'baz', 'is-active': @active] do %>
   Hello, world!
 <% end %>
 ```
 
+### Sinatra
+
 ```ruby
-# Sinatra
 erb :"<div class='#{Clsx['nav', active: @active]}'>...</div>"
 ```
 
+### ViewComponent
+
+```ruby
+class AlertComponent < ViewComponent::Base
+  include Clsx::Helper
+
+  def initialize(variant: :info, dismissible: false)
+    @variant = variant
+    @dismissible = dismissible
+  end
+
+  def classes
+    clsx("alert", "alert-#{@variant}", dismissible: @dismissible)
+  end
+end
+```
+
+```erb
+<div class="<%= classes %>">...</div>
+```
+
+### Tailwind CSS
+
+```ruby
+class NavLink < ViewComponent::Base
+  include Clsx::Helper
+
+  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
+```
+
+### Phlex
+
+```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
+```
+
 ## Differences from JavaScript clsx
 
-1. **Falsy values** — In Ruby only `false` and `nil` are falsy, so `0`, `''`, `[]`, `{}` are all truthy:
+1. **Returns `nil`** when no classes apply (not an empty string). This prevents rendering empty `class=""` attributes in template engines that skip `nil`:
    ```ruby
-   Clsx['foo' => 0, bar: []] # => 'foo bar'
+   Clsx[nil, false] # => nil
    ```
 
-2. **Complex hash keys** — Any valid `clsx` input works as a hash key:
+2. **Deduplication** — Duplicate classes are automatically removed:
    ```ruby
-   Clsx[[{ foo: true }, 'bar'] => true] # => 'foo bar'
+   Clsx['foo', 'foo'] # => 'foo'
    ```
 
-3. **Ignored values** — Boolean `true` and `Proc`/lambda objects are silently ignored:
+3. **Falsy values** — In Ruby only `false` and `nil` are falsy, so `0`, `''`, `[]`, `{}` are all truthy:
    ```ruby
-   Clsx['', proc {}, -> {}, nil, false, true] # => nil
+   Clsx['foo' => 0, bar: []] # => 'foo bar'
    ```
 
-4. **Returns `nil`** when no classes apply (not an empty string). This prevents rendering empty `class=""` attributes in template engines that skip `nil`:
+4. **Complex hash keys** — Any valid `clsx` input works as a hash key:
    ```ruby
-   Clsx[nil, false] # => nil
+   Clsx[[{ foo: true }, 'bar'] => true] # => 'foo bar'
    ```
 
-5. **Deduplication** — Duplicate classes are automatically removed:
+5. **Ignored values** — Boolean `true` and `Proc`/lambda objects are silently ignored:
    ```ruby
-   Clsx['foo', 'foo'] # => 'foo'
+   Clsx['', proc {}, -> {}, nil, false, true] # => nil
    ```
 
-## Development
-
-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.
-
-There is a benchmark suite in the `benchmark` directory. Run it with `bundle exec ruby benchmark/run.rb`.
+## Rails Integration
 
-## Conventional Commits
+For automatic Rails view helper integration (adds `clsx` and `cn` helpers to all views), see [clsx-rails](https://github.com/svyatov/clsx-rails).
 
-This project uses [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) for commit messages.
+## Development
 
-Types: `feat`, `fix`, `perf`, `chore`, `docs`, `refactor`
+```bash
+bin/setup                             # install dependencies
+bundle exec rake test                 # run tests
+bundle exec ruby benchmark/run.rb    # run benchmarks
+```
 
 ## Contributing
 

data/lib/clsx/helper.rb

@@ -1,120 +1,169 @@
 # frozen_string_literal: true
 
-# :nodoc:
 module Clsx
-  # :nodoc:
+  # Mixin providing {#clsx} and {#cn} instance methods.
+  #
+  # @example
+  #   include Clsx::Helper
+  #   clsx('btn', active: @active)  # => "btn active"
   module Helper
-    # The clsx function can take any number of arguments,
-    # each of which can be Hash, Array, Boolean, String, or Symbol.
+    # Build a CSS class string from an arbitrary mix of arguments.
     #
-    # **Important**
-    # Any falsy values are discarded! Standalone Boolean values are discarded as well.
+    # Falsy values (+nil+, +false+) and standalone +true+ are discarded.
+    # Duplicates are eliminated. Returns +nil+ (not +""+) when no classes apply.
     #
-    # @param [Mixed] args
+    # @param args [String, Symbol, Hash, Array, Numeric, nil, false] class descriptors
+    #   to merge into a single space-separated string
+    # @return [String] space-joined class string
+    # @return [nil] when no classes apply
     #
-    # @return [String] the joined class names
+    # @example Strings and hashes
+    #   clsx('foo', 'bar')                      # => "foo bar"
+    #   clsx(foo: true, bar: false, baz: true)  # => "foo baz"
     #
-    # @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
+    # @example Nested arrays
+    #   clsx('a', ['b', nil, ['c']])            # => "a b c"
+    #   clsx(%w[foo bar], hidden: true)         # => "foo bar hidden"
     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
+      return clsx_single(args[0]) if args.size == 1
+      return clsx_string_hash(args[0], args[1]) if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(Hash)
 
       seen = {}
       clsx_process(args, seen)
       seen.empty? ? nil : seen.keys.join(' ')
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
+    # (see #clsx)
     alias cn clsx
 
     private
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # Single-argument fast path — dispatches by type to avoid allocating
+    # a +seen+ hash when possible.
+    #
+    # @param arg [String, Symbol, Hash, Array] single class descriptor
+    # @return [String] resolved class string
+    # @return [nil] when the argument produces no classes
+    def clsx_single(arg)
+      return (arg.empty? ? nil : arg) if arg.is_a?(String)
+      return arg.name if arg.is_a?(Symbol)
+      return clsx_simple_hash(arg) if arg.is_a?(Hash)
+
+      if arg.is_a?(Array)
+        return nil if arg.empty?
+
+        if arg.all?(String)
+          seen = {}
+          arg.each { |s| seen[s] = true unless s.empty? }
+          return seen.empty? ? nil : seen.keys.join(' ')
+        end
+
+        seen = {}
+        clsx_process(arg, seen)
+        return seen.empty? ? nil : seen.keys.join(' ')
+      end
+
+      return arg.to_s if arg.is_a?(Numeric)
+      return nil if !arg || arg == true || arg.is_a?(Proc)
+
+      str = arg.to_s
+      str.empty? ? nil : str
+    end
+
+    # Hash-only fast path — no dedup needed since hash keys are unique.
+    # Falls back to {#clsx_process} on non-String/Symbol keys.
+    #
+    # @param hash [Hash{String, Symbol => Boolean}] class-name => condition pairs
+    # @return [String] resolved class string
+    # @return [nil] when no hash values are truthy
     def clsx_simple_hash(hash)
       return nil if hash.empty?
 
-      seen = {}
+      buf = nil
       hash.each do |key, value|
         next unless value
 
-        klass = key.class
+        if key.is_a?(Symbol)
+          str = key.name
+          buf ? (buf << ' ' << str) : (buf = str.dup)
+        elsif key.is_a?(String)
+          next if key.empty?
 
-        if klass == Symbol
-          seen[key.name] = true
-        elsif klass == String
-          seen[key] = true unless key.empty?
+          buf ? (buf << ' ' << key) : (buf = key.dup)
         else
-          # Complex key - fall back to full processing
           seen = {}
           clsx_process([hash], seen)
           return seen.empty? ? nil : seen.keys.join(' ')
         end
       end
+      buf
+    end
 
-      seen.empty? ? nil : seen.keys.join(' ')
+    # Fast path for +clsx('base', active: cond)+ — deduplicates only against
+    # the base string. Falls back to {#clsx_process} on non-String/Symbol keys.
+    #
+    # @param str [String] base class name
+    # @param hash [Hash{String, Symbol => Boolean}] class-name => condition pairs
+    # @return [String] resolved class string
+    # @return [nil] when no classes apply
+    def clsx_string_hash(str, hash)
+      return clsx_simple_hash(hash) if str.empty?
+
+      buf = str.dup
+      hash.each do |key, value|
+        next unless value
+
+        if key.is_a?(Symbol)
+          s = key.name
+          buf << ' ' << s unless s == str
+        elsif key.is_a?(String)
+          buf << ' ' << key unless key.empty? || key == str
+        else
+          seen = { str => true }
+          clsx_process([hash], seen)
+          return seen.size == 1 ? str : seen.keys.join(' ')
+        end
+      end
+      buf
     end
 
-    # rubocop:disable Style/MultipleComparison
+    # General-purpose recursive walker. Processes hash keys inline for simple
+    # types (String/Symbol) to avoid deferred-array allocation. Only complex
+    # keys (Array, nested Hash) recurse.
+    #
+    # @param args [Array<String, Symbol, Hash, Array, Numeric, nil, false>] nested arguments
+    # @param seen [Hash{String => true}] accumulator for deduplication
+    # @return [void]
     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
+        if arg.is_a?(String)
+          seen[arg] = true unless arg.empty?
+        elsif arg.is_a?(Symbol)
+          seen[arg.name] = true
+        elsif arg.is_a?(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
+        elsif arg.is_a?(Hash)
+          arg.each do |key, value|
+            next unless value
+
+            if key.is_a?(Symbol)
+              seen[key.name] = true
+            elsif key.is_a?(String)
+              seen[key] = true unless key.empty?
+            else
+              clsx_process([key], seen)
+            end
+          end
+        elsif arg.is_a?(Numeric)
+          seen[arg.to_s] = true
+        elsif !arg || arg == true || arg.is_a?(Proc)
           next
         else
           str = arg.to_s
-          seen[str] = true unless str.empty? || seen.key?(str)
+          seen[str] = true unless str.empty?
         end
       end
-
-      clsx_process(deferred, seen) if deferred
     end
-    # rubocop:enable Style/MultipleComparison, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
   end
 end

data/lib/clsx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clsx
-  VERSION = '1.0.0'
+  VERSION = '1.1.1'
 end

data/lib/clsx.rb

@@ -3,21 +3,21 @@
 require_relative 'clsx/version'
 require_relative 'clsx/helper'
 
-# :nodoc:
+# Construct CSS class strings conditionally.
+# Ruby port of the JavaScript {https://github.com/lukeed/clsx clsx} package.
+#
+# @example
+#   Clsx['foo', 'bar']                  # => "foo bar"
+#   Clsx['btn', active: true]           # => "btn active"
+#   Cn['hidden', visible: false]        # => "hidden"
 module Clsx
   extend Helper
 
+  # (see Helper#clsx)
   def self.[](*)
     clsx(*)
   end
 end
 
-# Short alias — only defined if `Cn` is not already taken
-unless Object.const_defined?(:Cn)
-  # :nodoc:
-  module Cn
-    def self.[](*)
-      Clsx[*]
-    end
-  end
-end
+# Short alias — only defined if +Cn+ is not already taken.
+Cn = Clsx unless Object.const_defined?(:Cn)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clsx-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -44,7 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.6
 specification_version: 4
 summary: clsx / classnames for Ruby
 test_files: []