keycase 1.0.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e6f493b80f7e3db6e7ef62af37c153849e924bc8bdb297fc112758f9d41147e
-  data.tar.gz: 6b45dfb8ec00157c8e098fb6e9b227206d1aa6804d0b8408afa6c03d983cc853
+  metadata.gz: f9cd4f359e0bdcfad518f08a8bbb845060cb4d66d2d8a3738b68aa46c53f183e
+  data.tar.gz: d0c79c9129587e65c2588efff8a969c5877ac802d1e1b818c2f9eaf2ff8bb114
 SHA512:
-  metadata.gz: a1f3a2dd6e435edb695b3de39c0fbc13bf746ab9bcf55a2206f8e8cbdc484b862d8aae3813352107ae855a2ba3b4f1cc505daca6a7ab17eff19fc29435d9b30f
-  data.tar.gz: 37480590ce74499c8ccc9c3fc55611187f311b966ecb48da8de70b26ffa2fab0af89bc04ef50e27de88b60a5430b037552bdca5b3ed4e4dee68201e517781f99
+  metadata.gz: 606ecc4d4358942e9b5e00c4f5ac1c6dfda3fc0b548948b69c3d3fb30dfe935c6382c3964cb7ca4a737d8cad755c2d2db8ca55d0f40291faff1d3ab60072d2d6
+  data.tar.gz: 376edfd2e6bc64564adb3b11ef63e658cc540d0c7759b6388bf84973e0fcee55b056b5d21ed01577c6346a0cdf01e13fdb2270ed195efced6e3e8d9436f048ae

data/README.md

@@ -64,12 +64,146 @@ irb --context-mode=1
 }
 ```
 
+## Interface
+
+Keycase is provided as Ruby refinements. Enable the case conversion you want with `using`.
+
+| 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` |
+
+`String#to_*` returns a converted string. `Symbol#to_*` returns a converted symbol. Other objects respond to these methods and return 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.
+Key type is preserved: string keys remain strings, and symbol keys remain symbols.
+
+```rb
+using Keycase::SnakeCase
+
+"userID".to_snake_case
+# => "user_id"
+
+:userID.to_snake_case
+# => :user_id
+
+[
+  { "userID" => 1 },
+  { :createdAt => "2026-05-09" },
+].with_snake_case_keys
+# => [
+#   { "user_id" => 1 },
+#   { :created_at => "2026-05-09" },
+# ]
+```
+
+## Options
+
+All `with_*_keys` methods 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
+the depth by `1`. Leaf values are not counted.
+
+```rb
+using Keycase::CamelCase
+
+{ user: { profile_data: { display_name: "Alice" } } }.with_camel_case_keys(max_depth: 2)
+# => { :user => { :profileData => { :displayName => "Alice" } } }
+
+{ user: { profile_data: { display_name: "Alice" } } }.with_camel_case_keys(max_depth: 1)
+# raises Keycase::StructureTooDeepError
+```
+
+## Errors
+
+`with_*_keys` raises 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::StructureTooDeepError` | Traversal exceeds the supplied `max_depth`. |
+
+Circular references are rejected because recursive conversion could not finish.
+Reusing the same non-circular object from multiple places is supported; each path is converted into a separate result object.
+
+```rb
+using Keycase::CamelCase
+
+hash = {}
+hash[:self_reference] = hash
+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
+```
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+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).
 
+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.
+
+Run **RuboCop** on every supported Ruby image (2.3 through 4.0):
+
+```sh
+mise run -j 1 rubocop
+```
+
+Run **RSpec** the same way:
+
+```sh
+mise run -j 1 rspec
+```
+
+These commands execute the version-specific tasks in order (`rubocop23` … `rubocop40`, `rspec23` … `rspec40`). To run against a **single** Ruby version, use the matching task name, for example:
+
+```sh
+mise run rubocop34
+mise run rspec34
+```
+
+To list all tasks and descriptions:
+
+```sh
+mise tasks
+```
+
+## Release Authentication
+
+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:
+
+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`.
+3.  Create a GitHub Actions trusted publisher with these values:
+
+    -   Repository owner: `naoigcat`
+    -   Repository name: `ruby-keycase`
+    -   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.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at <https://github.com/naoigcat/ruby-keycase>.

data/keycase.gemspec

@@ -9,22 +9,22 @@ Gem::Specification.new do |spec|
   spec.email                  = ["17925623+naoigcat@users.noreply.github.com"]
 
   spec.summary                = "Converts the case of strings, symbols, and keys of hash."
-  spec.description            = <<~DESCRIPTION
+  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.
   DESCRIPTION
   spec.homepage               = "https://github.com/naoigcat/ruby-keycase"
   spec.license                = "MIT"
-  spec.required_ruby_version  = Gem::Requirement.new(">= 2.0.0")
+  spec.required_ruby_version  = Gem::Requirement.new(">= 2.3.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.require_paths          = ["lib"]
   spec.files                  = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").select do |f|
+      f.match(%r{^lib/|^LICENSE\.md$|^README\.md$|^keycase\.gemspec$})
+    end
   end
-  spec.bindir                 = "exe"
-  spec.executables            = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths          = ["lib"]
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage

data/lib/keycase/camel_case.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
 module Keycase
   module CamelCase
     refine Object do
@@ -7,22 +12,16 @@ module Keycase
         self
       end
 
-      def with_camel_case_keys
+      def with_camel_case_keys(_options = {})
         self
       end
     end
 
     refine String do
       def to_camel_case
-        gsub(/(?<=[0-9a-z])(?=[A-Z])/) do |_|
-          "_"
-        end.gsub(/(?<=\b|\W|_)[0-9A-Za-z]+(?=\b|\W|_)/) do |matched| # rubocop:disable Style/SymbolProc
-          matched.capitalize
-        end.sub(/^(?:\W|_)*([A-Z]+(?=[A-Z][0-9A-Za-z]|\d|$)|[A-Z][a-z])/) do |_|
-          Regexp.last_match(1).downcase
-        end.gsub(/(?:\b|\W|_)*([0-9A-Z])/) do |_|
-          Regexp.last_match(1)
-        end.gsub(/(?:\W|_)*$/, "")
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.capitalize
+        end.join.sub(/^./, &:downcase)
       end
     end
 
@@ -33,17 +32,27 @@ module Keycase
     end
 
     refine Array do
-      def with_camel_case_keys
-        map do |value| # rubocop:disable Style/SymbolProc
-          value.with_camel_case_keys
+      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
       end
     end
 
     refine Hash do
-      def with_camel_case_keys
-        each_with_object({}) do |(key, value), memo|
-          memo[key.to_camel_case] = value.with_camel_case_keys
+      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
       end
     end

data/lib/keycase/kebab_case.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
 module Keycase
   module KebabCase
     refine Object do
@@ -7,18 +12,16 @@ module Keycase
         self
       end
 
-      def with_kebab_case_keys
+      def with_kebab_case_keys(_options = {})
         self
       end
     end
 
     refine String do
       def to_kebab_case
-        gsub(/(?<=[0-9a-z])(?=[A-Z])/) do |_|
-          "-"
-        end.gsub(/(?<=\b|\W|_)[0-9A-Za-z]+(?=\b|\W|_)/) do |matched|
-          "-#{matched.downcase}"
-        end.gsub(/(?:\W|_)+/, "-").gsub(/^(?:\W|_)*|(?:\W|_)*$/, "").downcase
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.downcase
+        end.join("-")
       end
     end
 
@@ -29,17 +32,27 @@ module Keycase
     end
 
     refine Array do
-      def with_kebab_case_keys
-        map do |value| # rubocop:disable Style/SymbolProc
-          value.with_kebab_case_keys
+      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
       end
     end
 
     refine Hash do
-      def with_kebab_case_keys
-        each_with_object({}) do |(key, value), memo|
-          memo[key.to_kebab_case] = value.with_kebab_case_keys
+      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
       end
     end

data/lib/keycase/pascal_case.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
 module Keycase
   module PascalCase
     refine Object do
@@ -7,22 +12,16 @@ module Keycase
         self
       end
 
-      def with_pascal_case_keys
+      def with_pascal_case_keys(_options = {})
         self
       end
     end
 
     refine String do
       def to_pascal_case
-        gsub(/(?<=[0-9a-z])(?=[A-Z])/) do |_|
-          "_"
-        end.gsub(/(?<=\b|\W|_)[0-9A-Za-z]+(?=\b|\W|_)/) do |matched| # rubocop:disable Style/SymbolProc
-          matched.capitalize
-        end.sub(/^(?:\W|_)*([A-Z]+(?=[A-Z][0-9A-Za-z]|\d|$)|[A-Z][a-z])/) do |_|
-          Regexp.last_match(1).capitalize
-        end.gsub(/(?:\b|\W|_)*([0-9A-Z])/) do |_|
-          Regexp.last_match(1)
-        end.gsub(/(?:\W|_)*$/, "")
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.capitalize
+        end.join
       end
     end
 
@@ -33,17 +32,27 @@ module Keycase
     end
 
     refine Array do
-      def with_pascal_case_keys
-        map do |value| # rubocop:disable Style/SymbolProc
-          value.with_pascal_case_keys
+      def with_pascal_case_keys(options = {})
+        Keycase::Support::Transformer.transform_array(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_pascal_case
         end
       end
     end
 
     refine Hash do
-      def with_pascal_case_keys
-        each_with_object({}) do |(key, value), memo|
-          memo[key.to_pascal_case] = value.with_pascal_case_keys
+      def with_pascal_case_keys(options = {})
+        Keycase::Support::Transformer.transform_hash(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_pascal_case
         end
       end
     end

data/lib/keycase/screaming_snake_case.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
+module Keycase
+  module ScreamingSnakeCase
+    refine Object do
+      def to_screaming_snake_case
+        self
+      end
+
+      def with_screaming_snake_case_keys(_options = {})
+        self
+      end
+    end
+
+    refine String do
+      def to_screaming_snake_case
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.upcase
+        end.join("_")
+      end
+    end
+
+    refine Symbol do
+      def to_screaming_snake_case
+        to_s.to_screaming_snake_case.to_sym
+      end
+    end
+
+    refine Array do
+      def with_screaming_snake_case_keys(options = {})
+        Keycase::Support::Transformer.transform_array(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_screaming_snake_case
+        end
+      end
+    end
+
+    refine Hash do
+      def with_screaming_snake_case_keys(options = {})
+        Keycase::Support::Transformer.transform_hash(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_screaming_snake_case
+        end
+      end
+    end
+  end
+end

data/lib/keycase/snake_case.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
 module Keycase
   module SnakeCase
     refine Object do
@@ -7,18 +12,16 @@ module Keycase
         self
       end
 
-      def with_snake_case_keys
+      def with_snake_case_keys(_options = {})
         self
       end
     end
 
     refine String do
       def to_snake_case
-        gsub(/(?<=[0-9a-z])(?=[A-Z])/) do |_|
-          "_"
-        end.gsub(/(?<=\b|\W|_)[0-9A-Za-z]+(?=\b|\W|_)/) do |matched|
-          "_#{matched.downcase}"
-        end.gsub(/(?:\W|_)+/, "_").gsub(/^(?:\W|_)*|(?:\W|_)*$/, "").downcase
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.downcase
+        end.join("_")
       end
     end
 
@@ -29,17 +32,27 @@ module Keycase
     end
 
     refine Array do
-      def with_snake_case_keys
-        map do |value| # rubocop:disable Style/SymbolProc
-          value.with_snake_case_keys
+      def with_snake_case_keys(options = {})
+        Keycase::Support::Transformer.transform_array(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_snake_case
         end
       end
     end
 
     refine Hash do
-      def with_snake_case_keys
-        each_with_object({}) do |(key, value), memo|
-          memo[key.to_snake_case] = value.with_snake_case_keys
+      def with_snake_case_keys(options = {})
+        Keycase::Support::Transformer.transform_hash(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_snake_case
         end
       end
     end

data/lib/keycase/support/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Keycase
+  # Signals that recursive key conversion cannot finish because the input graph loops.
+  class CircularStructureError < StandardError; end
+
+  # Signals that conversion would overwrite data by mapping multiple source keys to one key.
+  class KeyCollisionError < StandardError; end
+
+  # Signals that the caller's depth limit rejected input that is too deeply nested.
+  class StructureTooDeepError < StandardError; end
+end

data/lib/keycase/support/tokenizer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Keycase
+  module Support
+    module Tokenizer
+      module_function
+
+      def words(value)
+        value
+          .gsub(/(?<=[A-Z])(?=[A-Z][a-z])/) do |_|
+            "_"
+          end
+          .gsub(/(?<=[0-9a-z])(?=[A-Z])/) do |_|
+            "_"
+          end
+          .scan(/[0-9A-Za-z]+/)
+      end
+    end
+  end
+end

data/lib/keycase/support/transformer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Keycase
+  module Support
+    module Transformer
+      class << self
+        def transform_hash(hash, visiting, depth, max_depth, &key_converter)
+          check_depth!(depth, max_depth)
+
+          oid = hash.object_id
+          raise CircularStructureError, "Keycase detected a circular reference in a Hash" if visiting.include?(oid)
+
+          visiting.add(oid)
+          begin
+            hash.each_with_object({}) do |(key, value), memo|
+              new_key = key_converter.call(key)
+              if memo.key?(new_key)
+                message = "Keycase detected a key collision: #{key.inspect} converted to " \
+                          "#{new_key.inspect}, which already exists in the transformed hash"
+                raise KeyCollisionError, message
+              end
+
+              memo[new_key] = transform_value(
+                value,
+                visiting,
+                depth + 1,
+                max_depth,
+                &key_converter
+              )
+            end
+          ensure
+            visiting.delete(oid)
+          end
+        end
+
+        def transform_array(array, visiting, depth, max_depth, &key_converter)
+          check_depth!(depth, max_depth)
+
+          oid = array.object_id
+          raise CircularStructureError, "Keycase detected a circular reference in an Array" if visiting.include?(oid)
+
+          visiting.add(oid)
+          begin
+            array.map do |element|
+              transform_value(
+                element,
+                visiting,
+                depth + 1,
+                max_depth,
+                &key_converter
+              )
+            end
+          ensure
+            visiting.delete(oid)
+          end
+        end
+
+        def transform_value(value, visiting, depth, max_depth, &key_converter)
+          case value
+          when Hash
+            transform_hash(value, visiting, depth, max_depth, &key_converter)
+          when Array
+            transform_array(value, visiting, depth, max_depth, &key_converter)
+          else
+            value
+          end
+        end
+
+        private
+
+        def check_depth!(depth, max_depth)
+          return if max_depth.nil?
+
+          raise StructureTooDeepError, "Keycase nesting exceeds max_depth (#{max_depth})" if depth > max_depth
+        end
+      end
+    end
+  end
+end

data/lib/keycase/train_case.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "support/transformer"
+require_relative "support/tokenizer"
+
+module Keycase
+  module TrainCase
+    refine Object do
+      def to_train_case
+        self
+      end
+
+      def with_train_case_keys(_options = {})
+        self
+      end
+    end
+
+    refine String do
+      def to_train_case
+        Keycase::Support::Tokenizer.words(self).map do |word|
+          word.capitalize
+        end.join("-")
+      end
+    end
+
+    refine Symbol do
+      def to_train_case
+        to_s.to_train_case.to_sym
+      end
+    end
+
+    refine Array do
+      def with_train_case_keys(options = {})
+        Keycase::Support::Transformer.transform_array(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_train_case
+        end
+      end
+    end
+
+    refine Hash do
+      def with_train_case_keys(options = {})
+        Keycase::Support::Transformer.transform_hash(
+          self,
+          ::Set.new,
+          0,
+          options[:max_depth]
+        ) do |key|
+          key.to_train_case
+        end
+      end
+    end
+  end
+end

data/lib/keycase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Keycase
-  VERSION = "1.0.2"
+  VERSION = "1.2.0"
 end

data/lib/keycase.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
 require "keycase/version"
+require "keycase/support/errors"
+require "keycase/support/transformer"
+require "keycase/support/tokenizer"
 require "keycase/camel_case"
 require "keycase/kebab_case"
 require "keycase/pascal_case"
+require "keycase/screaming_snake_case"
 require "keycase/snake_case"
+require "keycase/train_case"
 
 module Keycase
 end

metadata

@@ -1,39 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: keycase
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.2.0
 platform: ruby
 authors:
 - naoigcat
-autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-12-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: |
-  This gem converts the case of strings, symbols, and keys of hash recursively.
-  The convertible cases are camelCase, PascalCase, snake_case, etc.
+description: |2
+      This gem converts the case of strings, symbols, and keys of hash recursively.
+      The convertible cases are camelCase, PascalCase, snake_case, etc.
 email:
 - 17925623+naoigcat@users.noreply.github.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- Gemfile
 - LICENSE.md
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
 - keycase.gemspec
 - lib/keycase.rb
 - lib/keycase/camel_case.rb
 - lib/keycase/kebab_case.rb
 - lib/keycase/pascal_case.rb
+- lib/keycase/screaming_snake_case.rb
 - lib/keycase/snake_case.rb
+- lib/keycase/support/errors.rb
+- lib/keycase/support/tokenizer.rb
+- lib/keycase/support/transformer.rb
+- lib/keycase/train_case.rb
 - lib/keycase/version.rb
 homepage: https://github.com/naoigcat/ruby-keycase
 licenses:
@@ -42,7 +39,6 @@ metadata:
   homepage_uri: https://github.com/naoigcat/ruby-keycase
   source_code_uri: https://github.com/naoigcat/ruby-keycase
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -50,15 +46,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.23
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Converts the case of strings, symbols, and keys of hash.
 test_files: []

data/.gitignore

@@ -1,14 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status
-
-# bundler
-Gemfile.lock

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.rubocop.yml

@@ -1,39 +0,0 @@
-require:
-  - rubocop-rake
-  - rubocop-rspec
-
-AllCops:
-  TargetRubyVersion: 2.7
-  DisplayCopNames: true
-  DisplayStyleGuide: true
-  NewCops: enable
-
-Gemspec/RequiredRubyVersion:
-  Enabled: false
-
-Metrics/BlockLength:
-  Enabled: false
-
-Metrics/MethodLength:
-  Enabled: false
-
-Naming/VariableNumber:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/MultilineBlockChain:
-  Enabled: false
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
-
-RSpec/ExampleLength:
-  Enabled: false
-
-RSpec/MultipleExpectations:
-  Enabled: false

data/Gemfile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"
-gem "rubocop"
-gem "rubocop-rake"
-gem "rubocop-rspec"

data/Rakefile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "rubocop/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-RuboCop::RakeTask.new
-
-task default: :spec

data/bin/console

@@ -1,15 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "keycase"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here