clsx-ruby 1.1.0 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49ae33f9c65cab86b628e1ed9cb764242f13397135caafa48a9a431f5f3d0a78
-  data.tar.gz: a59da0c73f12ed098f411777c14986f807dccb635ea6055ecece2a08c6845f00
+  metadata.gz: 3f20a56982120e4142d5932688887cc7f4b38a3596e01ce8aacf1f7b5b15f8d4
+  data.tar.gz: ebbd199c2d2ad139c2dda52680953778092b21708e01aef7b09d4619d932333a
 SHA512:
-  metadata.gz: 5cbb6c36d0920943123f9e19c978a8ef4914669ca6b71666f770883c865ca4c2dd6d3f089ced1612d62532b881c3492df656d4381bb85533dd635c7af4009c0c
-  data.tar.gz: d6ac365bce6825166fdf51303a87398f20997075535babf65a28686dea562f46586bc0c6e9418bfac77b9307e8820b377f4b5ce2265b21d7360c405928cd524f
+  metadata.gz: 5ed8a104aac715ac054d3399f6cf0c6e15a1b5a2df6307218c5f31172ebe7c1aca261d24b8b7ed23e3a06974002c2c1b9af7f857b4a4ebf4e90eea3694e75050
+  data.tar.gz: 83a0ea7711cab8e01b9eb8f71376af34e51d21bbbbd7da6091e1abe323d4145228c6e8ed44ec13f6421670ad1685a7857c531e198c100e553f77771d4183db45

data/CHANGELOG.md

@@ -1,14 +1,56 @@
 # 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.2
+
+### Changed
+
+- Improved gemspec description and README marketing copy
+- Switched gemspec to whitelist approach for included files
+
+## 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
 
-- Optimized hash-only path: skip dedup Hash since hash keys are unique by definition (+8%)
+### Added
+
 - New fast path for `clsx('base', active: cond)` string + hash pattern (+69%)
-- Added `string + hash` benchmark scenario
+- `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/README.md

@@ -1,16 +1,11 @@
-# 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, framework-agnostic conditional CSS class builder for Ruby.  
+> Perfect for ViewComponent, Phlex, Tailwind CSS or just standalone.
 
-Ruby port of the JavaScript [clsx](https://github.com/lukeed/clsx) package. Works with Rails, Sinatra, Hanami, or plain Ruby.
+Inspired by the JavaScript [clsx](https://github.com/lukeed/clsx) package. Works with any Ruby codebase.
 
-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 +14,55 @@ 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)
 ```
 
+## Rails Integration
+
+For Rails integration (adds `clsx` and `cn` helpers to all views), see [clsx-rails](https://github.com/svyatov/clsx-rails).
+
+## 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 +134,127 @@ 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`.
-
-## Conventional Commits
-
-This project uses [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) for commit messages.
-
-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,71 +1,82 @@
 # 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
-      elsif args.size == 2
-        return clsx_string_hash(args[0], args[1]) if args[0].class == String && args[1].class == Hash # rubocop:disable Style/ClassEqualityComparison
-      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
 
-    # Hash-only path — no dedup hash needed (hash keys are unique by definition).
-    # Builds result string directly with <<.
-    # 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?
 
@@ -73,11 +84,10 @@ module Clsx
       hash.each do |key, value|
         next unless value
 
-        klass = key.class
-        if klass == Symbol
+        if key.is_a?(Symbol)
           str = key.name
           buf ? (buf << ' ' << str) : (buf = str.dup)
-        elsif klass == String
+        elsif key.is_a?(String)
           next if key.empty?
 
           buf ? (buf << ' ' << key) : (buf = key.dup)
@@ -89,11 +99,14 @@ module Clsx
       end
       buf
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-    # String + Hash fast path: clsx('base', active: cond).
-    # Builds result string directly, dedup only against base string.
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # 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?
 
@@ -101,11 +114,10 @@ module Clsx
       hash.each do |key, value|
         next unless value
 
-        klass = key.class
-        if klass == Symbol
+        if key.is_a?(Symbol)
           s = key.name
           buf << ' ' << s unless s == str
-        elsif klass == String
+        elsif key.is_a?(String)
           buf << ' ' << key unless key.empty? || key == str
         else
           seen = { str => true }
@@ -115,37 +127,43 @@ module Clsx
       end
       buf
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-    # rubocop:disable Style/MultipleComparison, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # 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.1.0'
+  VERSION = '1.1.2'
 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,15 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: clsx-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - Leonid Svyatov
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A tiny utility for constructing CSS class strings conditionally
+description: Build CSS class strings from conditional expressions, hashes, arrays,
+  or nested structures. Framework-agnostic. Perfect for ViewComponent, Phlex, and
+  Tailwind CSS. Works with any Ruby codebase.
 email:
 - leonid@svyatov.com
 executables: []
@@ -17,7 +19,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CLAUDE.md
 - LICENSE.txt
 - README.md
 - lib/clsx.rb
@@ -46,5 +47,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: clsx / classnames for Ruby
+summary: The fastest conditional CSS class builder for Ruby
 test_files: []

data/CLAUDE.md

@@ -1,66 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-clsx-ruby is a Ruby gem that provides a utility (`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 Ruby conventions. Framework-agnostic — works with Rails, Sinatra, Hanami, or plain Ruby.
-
-## 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
-
-# Release a new version (update version.rb first)
-# Builds gem, creates git tag, pushes to rubygems.org
-# OTP is fetched automatically from 1Password
-bundle exec rake release
-```
-
-## Architecture
-
-The gem has a minimal structure:
-
-- `lib/clsx.rb` - Entry point; extends `Clsx` with `Helper`, defines `Clsx[]` and `Cn[]` shortcuts
-- `lib/clsx/helper.rb` - Core implementation with `clsx` method and `cn` alias
-- `lib/clsx/version.rb` - Version constant
-
-### API
-
-- **`Clsx['foo', bar: true]`** — primary bracket API via `self.[]`
-- **`Cn['foo', bar: true]`** — short alias (defined only if `Cn` constant is not taken)
-- **`Clsx.clsx(...)`** / **`Clsx.cn(...)`** — module methods
-- **`include Clsx::Helper`** — mixin giving `clsx()` and `cn()` instance methods
-
-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 — prevents 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`