clsx-ruby 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f20a56982120e4142d5932688887cc7f4b38a3596e01ce8aacf1f7b5b15f8d4
-  data.tar.gz: ebbd199c2d2ad139c2dda52680953778092b21708e01aef7b09d4619d932333a
+  metadata.gz: 7af7dbc1bf63dae86a10afc293087f0528b82d479e0f4cc2e82a6944c79c8ed4
+  data.tar.gz: 2ed149e30e3da918e403697ea511ca597c6bece1bbb2965ae6dd02e0d054a4b8
 SHA512:
-  metadata.gz: 5ed8a104aac715ac054d3399f6cf0c6e15a1b5a2df6307218c5f31172ebe7c1aca261d24b8b7ed23e3a06974002c2c1b9af7f857b4a4ebf4e90eea3694e75050
-  data.tar.gz: 83a0ea7711cab8e01b9eb8f71376af34e51d21bbbbd7da6091e1abe323d4145228c6e8ed44ec13f6421670ad1685a7857c531e198c100e553f77771d4183db45
+  metadata.gz: 37be556d78cb762df769303b6143e7872fd0bc67f26110720e31cf34238d3c657cab2f09b39f899163babcd7086c044d281d157261cb73736e7fcf4fe81d6b05
+  data.tar.gz: 6c5af47dba54f7d17fa5ba00a8f9bd2e96f34581cdd3f3544702b93699ec9bb0f5068147e294b5cff976341f64aa56353f2713b90929dbdfd443a5d83a62560e

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## v1.1.3
+
+### Fixed
+
+- Normalize whitespace in class strings: tabs, newlines, leading/trailing spaces, and consecutive spaces are collapsed to single spaces (e.g., `clsx("foo\tbar")` returns `"foo bar"`)
+- Whitespace-only strings now correctly return `nil` (e.g., `clsx("   ")` returns `nil`)
+- Deduplicate class names across multi-token strings (e.g., `clsx("foo bar", "foo")` now returns `"foo bar"`)
+
 ## v1.1.2
 
 ### Changed

data/README.md

@@ -34,16 +34,16 @@ For Rails integration (adds `clsx` and `cn` helpers to all views), see [clsx-rai
 
 ### Blazing fast
 
-**3-8x faster** than Rails `class_names` across every scenario:
+**2-3x 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** |
+| String array | 1.3M i/s | 369K i/s | **3.4x** |
+| Multiple strings | 1.3M i/s | 408K i/s | **3.3x** |
+| Single string | 2.4M i/s | 893K i/s | **2.7x** |
+| Mixed types | 912K i/s | 358K i/s | **2.5x** |
+| Hash | 1.7M i/s | 672K i/s | **2.5x** |
+| String + hash | 1.2M i/s | 565K i/s | **2.1x** |
 
 <sup>Ruby 4.0.1, Apple M1 Pro. Reproduce: `bundle exec ruby benchmark/run.rb`</sup>
 
@@ -53,7 +53,7 @@ For Rails integration (adds `clsx` and `cn` helpers to all views), see [clsx-rai
 |---|---|---|
 | Conditional classes | ✅ | ✅ |
 | Auto-deduplication | ✅ | ✅ |
-| 3–8× faster | ✅ | ❌ |
+| 2–3× faster | ✅ | ❌ |
 | Returns `nil` when empty | ✅ | ❌ (returns `""`) |
 | Complex hash keys | ✅ | ❌ |
 | Framework-agnostic | ✅ | ❌ |
@@ -228,9 +228,10 @@ end
    Clsx[nil, false] # => nil
    ```
 
-2. **Deduplication** — Duplicate classes are automatically removed:
+2. **Deduplication** — Duplicate classes are automatically removed, even across multi-token strings:
    ```ruby
-   Clsx['foo', 'foo'] # => 'foo'
+   Clsx['foo', 'foo']      # => 'foo'
+   Clsx['foo bar', 'foo']  # => 'foo bar'
    ```
 
 3. **Falsy values** — In Ruby only `false` and `nil` are falsy, so `0`, `''`, `[]`, `{}` are all truthy:

data/lib/clsx/helper.rb

@@ -26,12 +26,18 @@ module Clsx
     #   clsx(%w[foo bar], hidden: true)         # => "foo bar hidden"
     def clsx(*args)
       return nil if args.empty?
-      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)
+      return clsx_one(args[0]) if args.size == 1
+
+      if args.size == 2 && args[0].is_a?(String) && args[1].is_a?(Hash)
+        str = args[0]
+        return clsx_hash(args[1]) if str.empty?
+        return clsx_str_hash_full(str, args[1]) if str.include?(' ') || str.include?("\t") || str.include?("\n") # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return clsx_str_hash(str, args[1])
+      end
 
       seen = {}
-      clsx_process(args, seen)
-      seen.empty? ? nil : seen.keys.join(' ')
+      clsx_walk(args, seen)
+      clsx_join(seen)
     end
 
     # (see #clsx)
@@ -39,131 +45,283 @@ module Clsx
 
     private
 
-    # Single-argument fast path — dispatches by type to avoid allocating
-    # a +seen+ hash when possible.
+    # Single-argument fast path — dispatches by type, handles multi-token
+    # string dedup without allocating a walker Hash for simple cases.
     #
-    # @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)
+    # @param arg [Object] single class descriptor
+    # @return [String, nil]
+    def clsx_one(arg)
+      if arg.is_a?(String)
+        return nil if arg.empty?
+        return arg unless arg.include?(' ') || arg.include?("\t") || arg.include?("\n")
+
+        parts = arg.split
+        return nil if parts.empty?
+        return parts[0] if parts.length == 1
+        return arg if !parts.uniq! && parts.length == arg.count(' ') + 1 # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return parts.join(' ')
+      end
+
+      if arg.is_a?(Symbol)
+        s = arg.name
+        return s unless s.include?(' ') || s.include?("\t") || s.include?("\n") # rubocop:disable Layout/EmptyLineAfterGuardClause
+        return clsx_dedup_str(s)
+      end
+
+      return clsx_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(' ')
+        clsx_walk(arg, seen)
+        return clsx_join(seen)
       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
+      s = arg.to_s
+      s.empty? ? nil : s
     end
 
-    # Hash-only fast path — no dedup needed since hash keys are unique.
-    # Falls back to {#clsx_process} on non-String/Symbol keys.
+    # Dedup and normalize a multi-token string. Handles whitespace-only
+    # input, leading/trailing whitespace, tabs, newlines, and duplicates.
     #
-    # @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)
+    # @param str [String] space-separated class string
+    # @return [String, nil]
+    def clsx_dedup_str(str)
+      parts = str.split
+      return nil if parts.empty?
+      return parts[0] if parts.length == 1
+      return str if !parts.uniq! && parts.length == str.count(' ') + 1
+
+      parts.join(' ')
+    end
+
+    # Hash-only fast path using string buffer. Falls back to Hash dedup
+    # on mixed key types, multi-token keys, or complex keys.
+    #
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_hash(hash)
       return nil if hash.empty?
 
       buf = nil
+      key_type = nil
+
       hash.each do |key, value|
         next unless value
 
         if key.is_a?(Symbol)
-          str = key.name
-          buf ? (buf << ' ' << str) : (buf = str.dup)
+          return clsx_hash_full(hash) if key_type == :string
+
+          key_type = :symbol
+          s = key.name
+          return clsx_hash_full(hash) if s.include?(' ')
+
+          buf ? (buf << ' ' << s) : (buf = s.dup)
         elsif key.is_a?(String)
           next if key.empty?
 
+          return clsx_hash_full(hash) if key_type == :symbol
+          return clsx_hash_full(hash) if key.include?(' ')
+
+          key_type = :string
           buf ? (buf << ' ' << key) : (buf = key.dup)
         else
-          seen = {}
-          clsx_process([hash], seen)
-          return seen.empty? ? nil : seen.keys.join(' ')
+          return clsx_hash_full(hash)
         end
       end
+
+      return nil unless buf
+      return clsx_dedup_str(buf) if buf.include?("\t") || buf.include?("\n")
+
       buf
     end
 
-    # Fast path for +clsx('base', active: cond)+ — deduplicates only against
-    # the base string. Falls back to {#clsx_process} on non-String/Symbol keys.
+    # Hash fallback with full dedup via walker.
     #
-    # @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?
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_hash_full(hash)
+      seen = {}
+      clsx_walk_hash(hash, seen)
+      clsx_join(seen)
+    end
 
+    # Fast path for +clsx('base', active: cond)+ pattern where base is a
+    # single token. Deduplicates via direct string comparison.
+    #
+    # @param str [String] base class name
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash(str, hash)
       buf = str.dup
+      key_type = nil
+
+      hash.each do |key, value|
+        next unless value
+
+        if key.is_a?(Symbol)
+          return clsx_str_hash_full(str, hash) if key_type == :string
+
+          key_type = :symbol
+          s = key.name
+          return clsx_str_hash_full(str, hash) if s.include?(' ')
+
+          next if s == str
+
+          buf << ' ' << s
+        elsif key.is_a?(String)
+          return clsx_str_hash_full(str, hash) if key_type == :symbol
+
+          key_type = :string
+          next if key.empty?
+
+          return clsx_str_hash_full(str, hash) if key.include?(' ')
+
+          next if key == str
+
+          buf << ' ' << key
+        else
+          return clsx_str_hash_full(str, hash)
+        end
+      end
+
+      return clsx_dedup_str(buf) if buf.include?("\t") || buf.include?("\n")
+
+      buf
+    end
+
+    # Full str+hash dedup using array lookup. Splits the base string once,
+    # then checks hash keys against the parts array via linear search.
+    # Falls back to Hash dedup on mixed key types or complex keys.
+    #
+    # @param str [String] base class name (contains spaces)
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash_full(str, hash)
+      parts = str.split
+      return clsx_hash(hash) if parts.empty?
+      return clsx_str_hash_full_walk(parts, hash) if parts.length == 1
+
+      buf = if parts.uniq! || parts.length != str.count(' ') + 1
+              parts.join(' ')
+            else
+              str.dup
+            end
+
+      key_type = nil
+
       hash.each do |key, value|
         next unless value
 
         if key.is_a?(Symbol)
+          return clsx_str_hash_full_walk(parts, hash) if key_type == :string
+
+          key_type = :symbol
           s = key.name
-          buf << ' ' << s unless s == str
+          return clsx_str_hash_full_walk(parts, hash) if s.include?(' ') || s.include?("\t") || s.include?("\n")
+
+          next if parts.include?(s)
+
+          buf << ' ' << s
         elsif key.is_a?(String)
-          buf << ' ' << key unless key.empty? || key == str
+          return clsx_str_hash_full_walk(parts, hash) if key_type == :symbol
+
+          key_type = :string
+          next if key.empty?
+          return clsx_str_hash_full_walk(parts, hash) if key.include?(' ') || key.include?("\t") || key.include?("\n")
+
+          next if parts.include?(key)
+
+          buf << ' ' << key
         else
-          seen = { str => true }
-          clsx_process([hash], seen)
-          return seen.size == 1 ? str : seen.keys.join(' ')
+          return clsx_str_hash_full_walk(parts, hash)
         end
       end
+
       buf
     end
 
-    # 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.
+    # Hash-based fallback for str+hash when array lookup can't handle it.
+    #
+    # @param parts [Array<String>] pre-split base tokens
+    # @param hash [Hash] class-name => condition pairs
+    # @return [String, nil]
+    def clsx_str_hash_full_walk(parts, hash)
+      seen = {}
+      parts.each { |s| seen[s] = true }
+      clsx_walk_hash(hash, seen)
+      clsx_join(seen)
+    end
+
+    # General-purpose recursive walker. Stores strings as-is; normalization
+    # and dedup are handled by {#clsx_join} after walking.
     #
-    # @param args [Array<String, Symbol, Hash, Array, Numeric, nil, false>] nested arguments
+    # @param args [Array] nested arguments to walk
     # @param seen [Hash{String => true}] accumulator for deduplication
     # @return [void]
-    def clsx_process(args, seen)
+    def clsx_walk(args, seen)
       args.each do |arg|
         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)
+          clsx_walk(arg, seen)
         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
+          clsx_walk_hash(arg, seen)
         elsif !arg || arg == true || arg.is_a?(Proc)
           next
         else
-          str = arg.to_s
-          seen[str] = true unless str.empty?
+          s = arg.to_s
+          seen[s] = true unless s.empty?
+        end
+      end
+    end
+
+    # Hash-specific walker — avoids wrapping hash in an array for recursion.
+    #
+    # @param hash [Hash] hash to walk
+    # @param seen [Hash{String => true}] accumulator
+    # @return [void]
+    def clsx_walk_hash(hash, seen)
+      return if hash.empty?
+
+      hash.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?
+        elsif key.is_a?(Array)
+          clsx_walk(key, seen)
+        elsif key.is_a?(Hash)
+          clsx_walk_hash(key, seen)
+        elsif !key || key == true || key.is_a?(Proc)
+          next
+        else
+          s = key.to_s
+          seen[s] = true unless s.empty?
         end
       end
     end
+
+    # Post-join dedup and normalization: detects multi-token entries via
+    # space count mismatch or tab/newline presence, then splits and rebuilds.
+    #
+    # @param seen [Hash{String => true}] token accumulator
+    # @return [String, nil] space-joined class string
+    def clsx_join(seen)
+      return nil if seen.empty?
+
+      result = seen.keys.join(' ')
+      return result if result.count(' ') + 1 == seen.size && !result.include?("\t") && !result.include?("\n")
+
+      normalized = result.split.uniq.join(' ')
+      normalized.empty? ? nil : normalized
+    end
   end
 end

data/lib/clsx/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clsx-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Leonid Svyatov