keycase 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9cd4f359e0bdcfad518f08a8bbb845060cb4d66d2d8a3738b68aa46c53f183e
-  data.tar.gz: d0c79c9129587e65c2588efff8a969c5877ac802d1e1b818c2f9eaf2ff8bb114
+  metadata.gz: 39ff511337d13fc2e2c0118ee5f3d439f3f0be41eb83c86ead9fdee519454588
+  data.tar.gz: e13af5511466486ea3146f9f10c82b815b0879b0565e4590b84162e49cc73f52
 SHA512:
-  metadata.gz: 606ecc4d4358942e9b5e00c4f5ac1c6dfda3fc0b548948b69c3d3fb30dfe935c6382c3964cb7ca4a737d8cad755c2d2db8ca55d0f40291faff1d3ab60072d2d6
-  data.tar.gz: 376edfd2e6bc64564adb3b11ef63e658cc540d0c7759b6388bf84973e0fcee55b056b5d21ed01577c6346a0cdf01e13fdb2270ed195efced6e3e8d9436f048ae
+  metadata.gz: f9aba9bd010e999f6230da576f3785beac87369e83a8ddcda0b7ae6deb7aa32529f90cee48bf50fb7d5f18b81b195e8e9fdbc0bde1cb57ce926dce9843a9f4f1
+  data.tar.gz: b6782695576a300f13702c0a21be89b89631a35247d8628444b7f60c7fa8f74c14d3daa91224d9d22e709b373eec32b12c91cdd060fbb1c59746835e967fdab7

data/README.md

@@ -1,7 +1,7 @@
 # Keycase
 
 This gem converts the case of strings, symbols, and keys of hash recursively.
-The convertible cases are camelCase, PascalCase, snake_case, etc.
+The convertible cases are camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, kebab-case, and Train-Case.
 
 ## Installation
 
@@ -21,6 +21,43 @@ Or install it yourself as:
 
 ## Usage
 
+### Module functions (no `using`)
+
+Call methods on `Keycase` when refinements are awkward (Rails, other gems, shared libraries).
+
+```rb
+require "keycase"
+
+Keycase.camel_case("user_id")          # => "userId"
+Keycase.camel_case(:user_id)          # => :userId
+Keycase.camel_case(42)                 # => 42
+
+Keycase.camel_case("APIResponse", acronyms: %w[API HTTP ID])
+# => "APIResponse"
+
+Keycase.camel_case("user_id", capitalize: true)
+# => "UserId"
+
+Keycase.snake_case("userID", upcase: true)
+# => "USER_ID"
+
+Keycase.kebab_case("user_id", capitalize: true)
+# => "User-Id"
+
+Keycase.with_camel_case_keys({ "user_id" => 1, nested: { "item_count" => 2 } })
+# => { "userId" => 1, :nested => { "itemCount" => 2 } }
+
+Keycase.with_camel_case_keys(
+  { "API-Key" => 1, nested: { "http_status" => 200 } },
+  acronyms: %w[API HTTP],
+)
+# => { "APIKey" => 1, :nested => { "httpStatus" => 200 } }
+```
+
+See [Interface](#interface) for the full list of `Keycase.*` methods and their refinement equivalents.
+
+### Refinements
+
 ```sh
 irb --context-mode=1
 ```
@@ -66,22 +103,32 @@ irb --context-mode=1
 
 ## Interface
 
-Keycase is provided as Ruby refinements. Enable the case conversion you want with `using`.
+Keycase offers **module functions** on `Keycase` (no `using` required) and the same behavior as **refinements** when you `using Keycase::CamelCase` (and similarly for other case modules).
 
-| Refinement | String/Symbol conversion | Hash/Array key conversion |
-| --- | --- | --- |
-| `Keycase::CamelCase` | `to_camel_case` | `with_camel_case_keys` |
-| `Keycase::PascalCase` | `to_pascal_case` | `with_pascal_case_keys` |
-| `Keycase::SnakeCase` | `to_snake_case` | `with_snake_case_keys` |
-| `Keycase::ScreamingSnakeCase` | `to_screaming_snake_case` | `with_screaming_snake_case_keys` |
-| `Keycase::KebabCase` | `to_kebab_case` | `with_kebab_case_keys` |
-| `Keycase::TrainCase` | `to_train_case` | `with_train_case_keys` |
+| Refinement | `Keycase` module function (scalar) | `Keycase` module function (Hash/Array keys) | Refinement instance methods |
+| --- | --- | --- | --- |
+| `Keycase::CamelCase` | `Keycase.camel_case` | `Keycase.with_camel_case_keys` | `to_camel_case` / `with_camel_case_keys` |
+| `Keycase::SnakeCase` | `Keycase.snake_case` | `Keycase.with_snake_case_keys` | `to_snake_case` / `with_snake_case_keys` |
+| `Keycase::KebabCase` | `Keycase.kebab_case` | `Keycase.with_kebab_case_keys` | `to_kebab_case` / `with_kebab_case_keys` |
+
+`Keycase.camel_case` (and the other `Keycase.*` scalar methods) behave like refinement `to_*` for strings and symbols, and leave other objects unchanged.
+
+Use options to select the former paired case variants:
+
+-   `Keycase.camel_case(..., capitalize: true)` converts to PascalCase.
+-   `Keycase.snake_case(..., upcase: true)` converts to SCREAMING_SNAKE_CASE.
+-   `Keycase.kebab_case(..., capitalize: true)` converts to Train-Case.
+
+For **camelCase**, **PascalCase**, and **Train-Case** you can pass [`acronyms`](#acronyms-initialisms) so tokens such as `API`, `HTTP`, or `ID` keep the spelling you configure instead of being title-cased (for example `Api`, `Http`). Other case styles are unchanged by this option.
+
+`Keycase.with_camel_case_keys` (and siblings) behave like `Hash#with_*_keys` and `Array#with_*_keys` after the matching `using`.
 
-`String#to_*` returns a converted string. `Symbol#to_*` returns a converted symbol. Other objects respond to these methods and return themselves unchanged.
+`String#to_*` returns a converted string. `Symbol#to_*` returns a converted symbol. Other objects respond to these refinement-only methods by returning themselves unchanged.
 
-`Hash#with_*_keys` and `Array#with_*_keys` recursively convert only Hash keys.
-Arrays are traversed so hashes inside arrays are converted. Values that are not Hash or Array objects are returned unchanged.
+`Hash#with_*_keys`, `Array#with_*_keys`, and `Struct#with_*_keys` recursively convert keys by default.
+Arrays are traversed so hashes and structs inside arrays are converted. Other values are returned unchanged.
 Key type is preserved: string keys remain strings, and symbol keys remain symbols.
+Optional [`recursive`](#traversal-scope-recursive-arrays), [`arrays`](#traversal-scope-recursive-arrays), and [`only`](#key-types-only) narrow **what** is traversed and **which** keys are converted.
 
 ```rb
 using Keycase::SnakeCase
@@ -104,13 +151,20 @@ using Keycase::SnakeCase
 
 ## Options
 
-All `with_*_keys` methods accept an options hash.
+All structure key conversion methods (`Keycase.with_*_keys`, and `Hash#with_*_keys` / `Array#with_*_keys` after `using`) accept an options hash.
 
 | Option | Default | Description |
 | --- | --- | --- |
-| `max_depth` | `nil` | Maximum nested Hash/Array depth to traverse. `nil` means no depth limit. |
-
-Depth starts at `0` for the receiver itself. Each nested Hash or Array increases
+| `max_depth` | `nil` | Maximum nested Hash/Array/Struct depth to traverse. `nil` means no depth limit. |
+| `on_collision` | `:raise` | How to handle multiple source keys that convert to the same destination key in one Hash. See [Key collisions (`on_collision`)](#key-collisions-on_collision). |
+| `recursive` | `true` | When `false`, hashes nested **under another hash** are not converted (see [Traversal scope](#traversal-scope-recursive-arrays)). |
+| `arrays` | `true` | When `false`, array elements are not traversed (see [Traversal scope](#traversal-scope-recursive-arrays)). |
+| `only` | `nil` | Restrict conversion to certain key types (`:string`, `:symbol`, or `String` / `Symbol`). See [Key types (`only`)](#key-types-only). |
+| `acronyms` | `nil` | For `camel_case` and capitalized `kebab_case` key conversion only: list of strings treated as initialisms. See [Acronyms](#acronyms-initialisms). |
+| `capitalize` | `false` | For `camel_case`, converts to PascalCase. For `kebab_case`, converts to Train-Case. |
+| `upcase` | `false` | For `snake_case`, converts to SCREAMING_SNAKE_CASE. |
+
+Depth starts at `0` for the receiver itself. Each nested Hash, Array, or Struct increases
 the depth by `1`. Leaf values are not counted.
 
 ```rb
@@ -123,14 +177,168 @@ using Keycase::CamelCase
 # raises Keycase::StructureTooDeepError
 ```
 
+### Traversal scope (`recursive`, `arrays`)
+
+Use these when you want shallow conversion (for example only the outer hash or skipping arrays) without relying on `max_depth` alone.
+
+-   **`recursive`:** With `false`, **only hashes nested as values of another hash** are left untouched—same object as in the input for those inner hashes. Hashes that appear **as array elements** are still converted by default, because their parent is an Array, not a Hash.
+
+    ```rb
+    using Keycase::CamelCase
+
+    { outer_key: { inner_key: 1 } }.with_camel_case_keys(recursive: false)
+    # => { :outerKey => { :inner_key => 1 } }
+
+    { items: [{ nested_key: 1 }] }.with_camel_case_keys(recursive: false)
+    # => { :items => [{ :nestedKey => 1 }] }
+    ```
+
+-   **`arrays`:** With `false`, arrays are not walked: elements stay as-is inside a new outer Array.
+
+    ```rb
+    { items: [{ nested_key: 1 }] }.with_camel_case_keys(arrays: false)
+    # => { :items => [{ :nested_key => 1 }] }
+    ```
+
+Combine both for “top-level hash keys only” when values include nested hashes and arrays you do not want to reshape:
+
+```rb
+payload = { user_profile: { display_name: "Ada" }, tags: [{ tag_name: "ruby" }] }
+
+payload.with_camel_case_keys(recursive: false, arrays: false)
+# => { :userProfile => { :display_name => "Ada" }, :tags => [{ :tag_name => "ruby" }] }
+```
+
+`recursive` and `arrays` must be exactly `true` or `false`; other values raise `ArgumentError`.
+
+With `recursive: false`, **structs nested as members of another struct** are left untouched—the same object as in the input—mirroring hash-under-hash behavior. Structs inside hashes or arrays are still converted.
+
+### Structs
+
+`Struct` member names are converted like hash keys. Nested hashes and arrays inside struct members are traversed by default.
+If a member name converts to an empty name (for example `:[]=` or `:_`), its original name is preserved; its value is still traversed.
+
+```rb
+using Keycase::CamelCase
+
+Point = Struct.new(:foo_bar, :nested_hash, keyword_init: true)
+point = Point.new(foo_bar: 1, nested_hash: { inner_key: 2 })
+
+point.with_camel_case_keys
+# => #<struct fooBar=1, nestedHash={ innerKey: 2 }>
+```
+
+When member names change, a new anonymous `Struct` class is built (custom `Struct` subclasses are not preserved after rename).
+
+### Key types (`only`)
+
+Pass `only:` as an array of `:string`, `:symbol`, and/or the classes `String` and `Symbol`. Only matching keys are passed through the case converter; other keys stay unchanged (same object).
+
+Omit the option or pass `nil` for the usual behavior (string and symbol keys are converted). An **empty array** converts **no** keys.
+
+```rb
+using Keycase::CamelCase
+
+{ "foo_bar" => 1, baz_qux: 2 }.with_camel_case_keys(only: [:string])
+# => { "fooBar" => 1, :baz_qux => 2 }
+
+{ "foo_bar" => 1, baz_qux: 2 }.with_camel_case_keys(only: [:symbol])
+# => { "foo_bar" => 1, :bazQux => 2 }
+```
+
+Unsupported entries or a non-Array `only:` raise `ArgumentError`.
+
+### Key collisions (`on_collision`)
+
+By default, if two keys in the same Hash map to the same key after conversion, Keycase raises `Keycase::KeyCollisionError` so data is never dropped without you noticing. For migrations or log shaping you can pick another strategy:
+
+| `on_collision` | Behavior |
+| --- | --- |
+| `:raise` | **Default.** Raise `Keycase::KeyCollisionError`. |
+| `:overwrite` | Keep the **last** entry in Ruby Hash iteration order (insertion order) for that destination key. |
+| `:keep_first` | Keep the **first** entry; later colliding keys are ignored (their values are not traversed). |
+
+Unknown values raise `ArgumentError`. The option applies **per Hash** at each nesting level.
+
+```rb
+using Keycase::CamelCase
+
+h = { :user_id => 1, :userID => 2 }
+
+h.with_camel_case_keys
+# raises Keycase::KeyCollisionError
+
+h.with_camel_case_keys(on_collision: :overwrite)
+# => { :userId => 2 }
+
+h.with_camel_case_keys(on_collision: :keep_first)
+# => { :userId => 1 }
+
+Keycase.with_snake_case_keys({ "SomeKey" => 1, "someKey" => 2 }, on_collision: :keep_first)
+# => { "some_key" => 1 }
+```
+
+### Acronyms (initialisms)
+
+Use `acronyms` when you want multi-letter abbreviations to stay as you spell them (for example `API` instead of `Api`) after splitting a name into words.
+
+Where it applies:
+
+-   `Keycase.camel_case` and `Keycase.kebab_case(..., capitalize: true)` accept a keyword: `acronyms:`.
+-   `Keycase.with_camel_case_keys` and `Keycase.with_kebab_case_keys(..., capitalize: true)` accept `acronyms:` in their **options hash** alongside `max_depth`, `on_collision`, `recursive`, `arrays`, and `only`.
+
+Pass an array of strings. Matching is **case-insensitive** per word; the output uses the string from the array (the last occurrence wins if the same word appears twice with different casing). `nil` or omitting the option keeps the previous behavior.
+
+**camelCase** lowercases the first character of the full name only when the **first** word is *not* one of the configured acronyms. That way `APIResponse` can stay `APIResponse`, while `myHTTPConnection` becomes `myHTTPConnection`.
+
+**PascalCase** and **Train-Case** are selected with `capitalize: true`; they replace each matching word with the acronym spelling and title-Case other words as before.
+
+snake_case, SCREAMING_SNAKE, and kebab_case do not use `acronyms`; they still normalize segments with `downcase` / `upcase` as usual.
+
+```rb
+abbr = %w[API HTTP ID]
+
+Keycase.camel_case("APIResponse", acronyms: abbr)           # => "APIResponse"
+Keycase.camel_case("HTTPResponseCode", acronyms: abbr, capitalize: true)
+# => "HTTPResponseCode"
+Keycase.kebab_case("HTTP-Response-Code", acronyms: abbr, capitalize: true)
+# => "HTTP-Response-Code"
+
+using Keycase::CamelCase
+"userID".to_camel_case(acronyms: abbr)                      # => "userID"
+
+Keycase.with_camel_case_keys({ "api_key" => 1 }, acronyms: abbr, capitalize: true)
+# => { "APIKey" => 1 }
+```
+
+### Word splitting and character sets
+
+Keycase splits names into words with `Keycase::Support::Tokenizer`, which collects runs of
+**Unicode letters and numbers** (`\p{L}`, `\p{N}`) and inserts boundaries at common case
+transitions in scripts that distinguish letter case (for example `userID` → `user`, `ID`;
+`HTTPResponse` → `HTTP`, `Response`). Separators such as `-` and `_` between those runs are not
+preserved as characters—only the letter and number pieces become words (for example
+`API-Key` → `API`, `Key`; `ユーザー-user_id` → `ユーザー`, `user`, `id`).
+
+**Characters outside `\p{L}` and `\p{N}`**—punctuation, symbols, emoji, and most whitespace—act as
+separators and are not included in tokens. Scripts without cased letters (for example CJK) form a
+single letter run unless you separate them with `-`, `_`, or similar. Mixed-script keys glued
+without separators (for example Latin camelCase next to CJK text) are not split at the script
+boundary.
+
+Multilingual **Rails `I18n`** key paths that rely on punctuation or non-alphanumeric characters can
+still behave unexpectedly after conversion, or make separate keys collide after conversion
+(**`KeyCollisionError`** by default, or use [`on_collision`](#key-collisions-on_collision) to
+overwrite or keep the first key) when you bulk-convert hashes.
+
 ## Errors
 
-`with_*_keys` raises Keycase-specific errors when recursive conversion cannot be completed without ambiguity or infinite traversal.
+`Keycase.with_*_keys` and refinement `with_*_keys` raise Keycase-specific errors when recursive conversion cannot be completed without ambiguity or infinite traversal.
 
 | Error | Raised when |
 | --- | --- |
-| `Keycase::CircularStructureError` | A Hash or Array references itself through the current traversal path. |
-| `Keycase::KeyCollisionError` | Multiple source keys in the same Hash convert to the same destination key. |
+| `Keycase::CircularStructureError` | A Hash, Array, or Struct references itself through the current traversal path. |
+| `Keycase::KeyCollisionError` | Multiple source keys in the same Hash convert to the same destination key and `on_collision` is `:raise` (the default). |
 | `Keycase::StructureTooDeepError` | Traversal exceeds the supplied `max_depth`. |
 
 Circular references are rejected because recursive conversion could not finish.
@@ -145,20 +353,13 @@ hash.with_camel_case_keys
 # raises Keycase::CircularStructureError
 ```
 
-Key collisions are rejected so conversion never silently overwrites data. The check is performed per Hash after the keys are converted.
-
-```rb
-using Keycase::CamelCase
-
-{ :user_id => 1, :userID => 2 }.with_camel_case_keys
-# raises Keycase::KeyCollisionError
-```
+`Keycase::KeyCollisionError` is documented with examples under [Key collisions (`on_collision`)](#key-collisions-on_collision).
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests with the local Ruby version defined in `mise.toml` (currently Ruby 3.4.9). You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-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 tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To publish a version, use the GitHub Actions workflow described in [Releasing](#releasing).
 
 Tasks are defined in `mise.toml`. They run **RuboCop, and RSpec inside Docker** (via Docker Compose), so Docker must be available. Use these tasks for syntax checks and tests across supported Ruby versions.
 
@@ -187,14 +388,19 @@ To list all tasks and descriptions:
 mise tasks
 ```
 
-## Release Authentication
+## Releasing
 
 Gem releases from GitHub Actions use RubyGems Trusted Publishing. No long-lived RubyGems API key or GitHub secret is required; GitHub Actions obtains a short-lived RubyGems API token through OIDC during the release job.
 
-Configure the trusted publisher once on RubyGems.org:
+### One-time setup
+
+1.  Open the repository's [Settings → Environments](https://github.com/naoigcat/ruby-keycase/settings/environments) and create an environment named `release` if it does not exist. If deployment branch restrictions are enabled, allow `main`.
+2.  Ensure repository or organization rules allow GitHub Actions to run the actions used in `.github/workflows/release.yml` and allow its `GITHUB_TOKEN` to create release tags (`v*`).
+
+Configure the [trusted publisher](https://guides.rubygems.org/trusted-publishing/) on RubyGems.org:
 
 1.  Log in to <https://rubygems.org> with an owner account for the `keycase` gem.
-2.  Open the `keycase` gem page and go to `Trusted publishers`.
+2.  Open the [`keycase`](https://rubygems.org/gems/keycase) gem page and go to `Trusted publishers`.
 3.  Create a GitHub Actions trusted publisher with these values:
 
     -   Repository owner: `naoigcat`
@@ -202,7 +408,18 @@ Configure the trusted publisher once on RubyGems.org:
     -   Workflow filename: `release.yml`
     -   Environment name: `release`
 
-After this setup, run the `Release Gem` workflow manually from GitHub Actions. Enter the version already committed in `lib/keycase/version.rb`; the workflow verifies the version, creates the `v<version>` tag through Bundler's release task, and publishes the gem to RubyGems.org.
+### Publish 1.3.0
+
+1.  Commit the changes, including `Keycase::VERSION = "1.3.0"` in `lib/keycase/version.rb`, and merge or push them to `main`. Confirm that the `CI` workflow passes for that commit.
+2.  Open [Actions → Release Gem](https://github.com/naoigcat/ruby-keycase/actions/workflows/release.yml), click **Run workflow**, select `main`, and enter `1.3.0` for `version`. Click **Run workflow** to publish.
+3.  If the `release` environment requires approval, approve the deployment in the workflow run.
+4.  Confirm that the workflow succeeds, the `v1.3.0` tag exists on GitHub, and [keycase 1.3.0](https://rubygems.org/gems/keycase/versions/1.3.0) is available on RubyGems.org.
+
+The workflow checks the version input, rejects an existing release tag, runs RSpec, and uses Bundler's release task to create the tag and publish the gem. Do not create `v1.3.0` manually before running it.
+
+If publishing fails after the tag was pushed, check RubyGems.org before retrying. An existing tag makes this workflow fail on rerun. If the version is already published, do not delete or recreate its tag; if it is unpublished, resolve the failure and remove only the failed release's tag before rerunning.
+
+For later releases, update `lib/keycase/version.rb` and substitute the new version in these steps.
 
 ## Contributing
 

data/keycase.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary                = "Converts the case of strings, symbols, and keys of hash."
   spec.description            = <<-DESCRIPTION
     This gem converts the case of strings, symbols, and keys of hash recursively.
-    The convertible cases are camelCase, PascalCase, snake_case, etc.
+    The convertible cases are camelCase, snake_case, kebab-case.
   DESCRIPTION
   spec.homepage               = "https://github.com/naoigcat/ruby-keycase"
   spec.license                = "MIT"

data/lib/keycase/camel_case.rb

@@ -1,14 +1,42 @@
 # frozen_string_literal: true
 
-require "set"
-
-require_relative "support/transformer"
+require_relative "support/acronyms"
+require_relative "support/structure_keys"
 require_relative "support/tokenizer"
 
 module Keycase
   module CamelCase
+    def self.convert_string(str, acronyms: nil, capitalize: false)
+      words = Keycase::Support::Tokenizer.words(str)
+      acronyms_by_downcase = Keycase::Support::Acronyms.index(acronyms)
+      segments = words.map do |word|
+        Keycase::Support::Acronyms.segment(word, acronyms_by_downcase)
+      end
+      pascal = segments.join
+      return pascal if capitalize
+      return pascal if Keycase::Support::Acronyms.leading_acronym?(words.first, acronyms_by_downcase)
+
+      pascal.sub(/^./, &:downcase)
+    end
+
+    def self.convert(value, acronyms: nil, capitalize: false)
+      case value
+      when String then convert_string(value, acronyms: acronyms, capitalize: capitalize)
+      when Symbol then convert_string(value.to_s, acronyms: acronyms, capitalize: capitalize).to_sym
+      else value
+      end
+    end
+
+    def self.convert_keys(structure, options = {})
+      acronyms = options[:acronyms]
+      capitalize = options.fetch(:capitalize, false)
+      Keycase::Support::StructureKeys.transform(structure, options) do |key|
+        convert(key, acronyms: acronyms, capitalize: capitalize)
+      end
+    end
+
     refine Object do
-      def to_camel_case
+      def to_camel_case(_options = {})
         self
       end
 
@@ -18,43 +46,43 @@ module Keycase
     end
 
     refine String do
-      def to_camel_case
-        Keycase::Support::Tokenizer.words(self).map do |word|
-          word.capitalize
-        end.join.sub(/^./, &:downcase)
+      def to_camel_case(acronyms: nil, capitalize: false)
+        Keycase::CamelCase.convert_string(self, acronyms: acronyms, capitalize: capitalize)
       end
     end
 
     refine Symbol do
-      def to_camel_case
-        to_s.to_camel_case.to_sym
+      def to_camel_case(acronyms: nil, capitalize: false)
+        Keycase::CamelCase.convert(self, acronyms: acronyms, capitalize: capitalize)
       end
     end
 
     refine Array do
       def with_camel_case_keys(options = {})
-        Keycase::Support::Transformer.transform_array(
-          self,
-          ::Set.new,
-          0,
-          options[:max_depth]
-        ) do |key|
-          key.to_camel_case
-        end
+        Keycase::CamelCase.convert_keys(self, options)
       end
     end
 
     refine Hash do
       def with_camel_case_keys(options = {})
-        Keycase::Support::Transformer.transform_hash(
-          self,
-          ::Set.new,
-          0,
-          options[:max_depth]
-        ) do |key|
-          key.to_camel_case
-        end
+        Keycase::CamelCase.convert_keys(self, options)
+      end
+    end
+
+    refine Struct do
+      def with_camel_case_keys(options = {})
+        Keycase::CamelCase.convert_keys(self, options)
       end
     end
   end
+
+  class << self
+    def camel_case(value, acronyms: nil, capitalize: false)
+      CamelCase.convert(value, acronyms: acronyms, capitalize: capitalize)
+    end
+
+    def with_camel_case_keys(value, options = {})
+      CamelCase.convert_keys(value, options)
+    end
+  end
 end

data/lib/keycase/kebab_case.rb

@@ -1,14 +1,39 @@
 # frozen_string_literal: true
 
-require "set"
-
-require_relative "support/transformer"
+require_relative "support/acronyms"
+require_relative "support/structure_keys"
 require_relative "support/tokenizer"
 
 module Keycase
   module KebabCase
+    def self.convert_string(str, acronyms: nil, capitalize: false)
+      words = Keycase::Support::Tokenizer.words(str)
+      return words.map(&:downcase).join("-") unless capitalize
+
+      acronyms_by_downcase = Keycase::Support::Acronyms.index(acronyms)
+      words.map do |word|
+        Keycase::Support::Acronyms.segment(word, acronyms_by_downcase)
+      end.join("-")
+    end
+
+    def self.convert(value, acronyms: nil, capitalize: false)
+      case value
+      when String then convert_string(value, acronyms: acronyms, capitalize: capitalize)
+      when Symbol then convert_string(value.to_s, acronyms: acronyms, capitalize: capitalize).to_sym
+      else value
+      end
+    end
+
+    def self.convert_keys(structure, options = {})
+      acronyms = options[:acronyms]
+      capitalize = options.fetch(:capitalize, false)
+      Keycase::Support::StructureKeys.transform(structure, options) do |key|
+        convert(key, acronyms: acronyms, capitalize: capitalize)
+      end
+    end
+
     refine Object do
-      def to_kebab_case
+      def to_kebab_case(_options = {})
         self
       end
 
@@ -18,43 +43,43 @@ module Keycase
     end
 
     refine String do
-      def to_kebab_case
-        Keycase::Support::Tokenizer.words(self).map do |word|
-          word.downcase
-        end.join("-")
+      def to_kebab_case(acronyms: nil, capitalize: false)
+        Keycase::KebabCase.convert_string(self, acronyms: acronyms, capitalize: capitalize)
       end
     end
 
     refine Symbol do
-      def to_kebab_case
-        to_s.to_kebab_case.to_sym
+      def to_kebab_case(acronyms: nil, capitalize: false)
+        Keycase::KebabCase.convert(self, acronyms: acronyms, capitalize: capitalize)
       end
     end
 
     refine Array do
       def with_kebab_case_keys(options = {})
-        Keycase::Support::Transformer.transform_array(
-          self,
-          ::Set.new,
-          0,
-          options[:max_depth]
-        ) do |key|
-          key.to_kebab_case
-        end
+        Keycase::KebabCase.convert_keys(self, options)
       end
     end
 
     refine Hash do
       def with_kebab_case_keys(options = {})
-        Keycase::Support::Transformer.transform_hash(
-          self,
-          ::Set.new,
-          0,
-          options[:max_depth]
-        ) do |key|
-          key.to_kebab_case
-        end
+        Keycase::KebabCase.convert_keys(self, options)
       end
     end
+
+    refine Struct do
+      def with_kebab_case_keys(options = {})
+        Keycase::KebabCase.convert_keys(self, options)
+      end
+    end
+  end
+
+  class << self
+    def kebab_case(value, acronyms: nil, capitalize: false)
+      KebabCase.convert(value, acronyms: acronyms, capitalize: capitalize)
+    end
+
+    def with_kebab_case_keys(value, options = {})
+      KebabCase.convert_keys(value, options)
+    end
   end
 end