simple_symbolize 4.1.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fe69f67b8c3e4152dd088e6425f0a0e9c0c5206ff384bd599284f976b664e4e
-  data.tar.gz: d8ce3414da304b386a71e83f482bd3dc2a031274c61dbe8d69efbab1d9dc819a
+  metadata.gz: a61b74fb95d9b3e3e76a3256bc88cb1f7b35c684ba6c1ea18fb1eeaee09ace87
+  data.tar.gz: e4a37ab07e24568f3434d8725e3fcc63d20b5d2d06e429842bcbfd4109709d7f
 SHA512:
-  metadata.gz: da85cabac7e7f368cfd7a0366dffa7642e6f0b27f2cbac49b548264df55f82eb715d74cf80e2113a172b7451b2496a86ddcbc13ef818d66e8b7f72aa8df80ff1
-  data.tar.gz: 82a0bd3a48cecbf2ca49607dd136cc8dc46a3babb761507b88a74043a494f396fbe6e7ecc53393c5a2d065e2f8d0302ccfdf80dfe6cb2412d3188091f15d2f44
+  metadata.gz: 572ffe34944c55a5f805b05ede3af67c41789f4f2218e4d0a79a242b9d3599dc60a7e9e656590f18ba3fc2215fc4511d33445f3309d3e482cf52c89d8768010e
+  data.tar.gz: 48cdddc6da798147b3104bb94f6fa88f2d7752120d7eec66aaca43edfc4c46fcc4728117ec81944c3d592cab210e63f179037b8c3a913a98bad3d2f5b54b18a4

data/.github/workflows/ruby.yml

@@ -18,10 +18,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.2', '3.3', '3.4' ]
+        ruby-version: [ '3.4', '4.0' ]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:

data/.github/workflows/ruby_gem.yml

@@ -9,10 +9,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.2', '3.3', '3.4' ]
+        ruby-version: [ '3.4', '4.0' ]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -31,11 +31,11 @@ jobs:
       contents: read
 
     steps:
-      - uses: actions/checkout@v2
-      - name: Set up Ruby 3.0.1
+      - uses: actions/checkout@v4
+      - name: Set up Ruby 4.0
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.0.1
+          ruby-version: 4.0
           bundler-cache: true
 
       - name: Publish to RubyGems

data/.rubocop.yml

@@ -1,7 +1,7 @@
 AllCops:
   NewCops: enable
   SuggestExtensions: false
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.4
 
 Gemspec/DevelopmentDependencies:
   EnforcedStyle: gemspec
@@ -17,17 +17,8 @@ Metrics/BlockLength:
 Style/MixinUsage:
   Enabled: false
 
-Lint/BooleanSymbol:
-  Enabled: false
-
 Metrics/AbcSize:
-  Enabled: false
+  Max: 20
 
 Metrics/MethodLength:
-  Max: 25
-
-Layout/LineLength:
-  Max: 130
-
-Metrics/CyclomaticComplexity:
-  Max: 8
+  Max: 20

data/.ruby-version

@@ -1 +1 @@
-3.4.5
+ruby-4.0.5

data/Gemfile

@@ -5,7 +5,9 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in simple_symbolize.gemspec
 gemspec
 
-gem 'rake', '~> 13.3'
+gem 'rake', '~> 13.4'
 gem 'rspec', '~> 3.13'
-gem 'rubocop', '~> 1.79'
+gem 'rubocop', '~> 1.88'
 gem 'simplecov', '~> 0.22'
+
+gem 'irb', '~> 1.18'

data/README.md

@@ -1,11 +1,11 @@
 # SimpleSymbolize
 
-SimpleSymbolize takes a string and transforms it into a symbol. Why? Because working with symbols in Ruby makes for a 
+SimpleSymbolize takes a string and transforms it into a symbol. Why? Because working with symbols in Ruby makes for a
 good time.
 
 Wait, doesn't String already have a `to_sym` method?
 
-Correct! However, this gem takes it one step further by transforming special characters and whitespace to give you a 
+Correct! However, this gem takes it one step further by transforming special characters and whitespace to give you a
 simple easy to work with Symbol.
 
 It works by removing special characters in a String like `'!'` and underscoring any whitespace.
@@ -38,9 +38,9 @@ Or install it yourself as:
 
 ## Usage
 
-There are two ways to symbolize your String.
+There are three ways to use this gem.
 
-### Call the symbolize method and pass it your String
+### SimpleSymbolize
 
 ```ruby
 require 'simple_symbolize'
@@ -48,7 +48,16 @@ require 'simple_symbolize'
 SimpleSymbolize.symbolize('hello world!') # => :hello_world
 ```
 
-### Call the symbolize method on your String object
+Available methods:
+
+| Method     | What does it do?                                                                                                                         |
+|------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| symbolize  | Returns your object as a plain old symbol                                                                                                |
+| elementize | Returns your object as a plain old String                                                                                                |
+| camelize   | Returns your object as a plain old camelCase symbol                                                                                      |
+| snakeize   | Returns your object as a plain old snake_case symbol (very similar to symbolize, only it does not respect the handle_camel_case setting) |                                                                                                        |
+
+### Mixing into String
 
 ```ruby
 require 'simple_symbolize'
@@ -58,7 +67,16 @@ String.include SimpleSymbolize::CoreExt::String
 'hello world!'.simple_symbolize # => :hello_world
 ```
 
-### Call the symbolize method on your Symbol object
+Available methods:
+
+| Method     | What does it do?                                                                                                                         |
+|------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| simple_symbolize  | Returns your object as a plain old symbol                                                                                                |
+| simple_elementize | Returns your object as a plain old String                                                                                                |
+| simple_camelize   | Returns your object as a plain old camelCase symbol                                                                                      |
+| simple_snakeize   | Returns your object as a plain old snake_case symbol (very similar to symbolize, only it does not respect the handle_camel_case setting) |                                                                                                        |
+
+### Mixing into Symbol
 
 ```ruby
 require 'simple_symbolize'
@@ -68,9 +86,18 @@ Symbol.include SimpleSymbolize::CoreExt::Symbol
 :hello_world!.simple_symbolize # => :hello_world
 ```
 
+Available methods:
+
+| Method     | What does it do?                                                                                                                         |
+|------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| simple_symbolize  | Returns your object as a plain old symbol                                                                                                |
+| simple_elementize | Returns your object as a plain old String                                                                                                |
+| simple_camelize   | Returns your object as a plain old camelCase symbol                                                                                      |
+| simple_snakeize   | Returns your object as a plain old snake_case symbol (very similar to symbolize, only it does not respect the handle_camel_case setting) |                                                                                                        |
+
 ## Configuration
 
-Something not underscored or removed? Or even something underscored/removed that you didn't want transformed? 
+Something not underscored or removed? Or even something underscored/removed that you didn't want transformed?
 
 No sweat, you can configure this gem to underscore and remove to your hearts content!
 
@@ -84,20 +111,67 @@ end
 
 ## Updates!
 
+### V6.0.0
+
+#### Dropped support for Ruby < 3.4
+
+Ruby 3.2 reached EOL in 2026, and Ruby 3.3 will reach EOL in 2027.
+As such this gem no longer supports versions older than 3.4.
+
+#### Inline configuration
+
+You can now prevent chars being removed inline:
+
+```ruby
+SimpleSymbolize.symbolize('Hello World!', strip_chars: false)
+# => :hello_world!
+```
+
+### V5
+
+#### Dropped support for Ruby < 3.2
+
+Ruby 3.1 reached EOL in 2024, as such this gem no longer supports versions older than 3.2.
+
+#### Only deals with Strings and Symbols
+
+In previous iterations, certain non String/Symbol objects would be handled `SimpleSymbolize.symbolze(true)` returned
+`:true`.
+
+To be consistent, SimpleSymbolize now only accepts String/Symbols, everything else will be returned.
+
+#### Uppercase acronyms when camelizing
+
+Sometimes you want certain phrases to be in uppercase when camelizing, SimpleSymbolize now supports this.
+
+```ruby
+SimpleSymbolize.translate { |t| t.camel_case_acronym = ['gb'] }
+
+SimpleSymbolize.camelize('from gb') # => :fromGB (without setting the camel_case_acronym this would return :fromGb)
+```
+
+---
+
 ### V4.1
-### Symbol methods can now be Mixed in
 
-SimpleSymbolize now supports mixing in the methods on the Symbol class, allowing you to call `simple_symbolize` directly on a Symbol object.
+#### Symbol methods can now be Mixed in
+
+SimpleSymbolize now supports mixing in the methods on the Symbol class, allowing you to call `simple_symbolize` directly
+on a Symbol object.
 
 ```ruby
 Symbol.include SimpleSymbolize::CoreExt::Symbol
 :hello_world!.simple_symbolize # => :hello_world
 ```
 
+---
+
 ### V4
+
 #### String methods now need to be Mixed in
 
-SimpleSymbolize is safe to use with other gems, particularly the popular ActiveSupport gem which SimpleSymbolize use to share 
+SimpleSymbolize is safe to use with other gems, particularly the popular ActiveSupport gem which SimpleSymbolize use to
+share
 certain methods names with.
 
 You now need to deliberately mixin the methods on the String class:
@@ -118,9 +192,13 @@ To make them easier to spot, the method names on the String class have been pref
 #### Introducing #snakeize
 
 The `#snakeize` method will return your object in snake_case.
-This is the default behaviour of the `#symbolize` method however `#snakeize` will always return thr Symbol in snake_case.
+This is the default behaviour of the `#symbolize` method however `#snakeize` will always return thr Symbol in
+snake_case.
+
+---
 
 ### V3
+
 #### String to_snake_case [DEPRECATED - replaced with `#simple_snakeize` in v4]
 
 `#to_snake_case` extends the String class to return you your String object in snake_case format.
@@ -145,6 +223,8 @@ Arrays are now supported when configuring the gem
 SimpleSymbolize.translate { |trans| trans.to_underscore = %w[!&*] }
 ```
 
+---
+
 ### V2
 
 SimpleSymbolize has got new friends!
@@ -162,7 +242,7 @@ SimpleSymbolize.elementize('hello world!') # => "hello_world"
 
 #### Camelize
 
-Great for working with APIs that require fields in a JSON format. Camelize clears away the clutter and returns you 
+Great for working with APIs that require fields in a JSON format. Camelize clears away the clutter and returns you
 a Symbolized object in camelCase.
 
 [comment]: <> (## Contributing)

data/bin/console

@@ -3,7 +3,6 @@
 
 require 'bundler/setup'
 require 'simple_symbolize'
-require 'pry'
 
 # 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.

data/lib/simple_symbolize/core_ext/string/symbolize.rb

@@ -10,26 +10,26 @@ module SimpleSymbolize
     module String
       # @example Symbolize a string using the String object method
       #   "hello world!".symbolize #=> :hello_world
-      def simple_symbolize
-        SimpleSymbolize.symbolize(self)
+      def simple_symbolize(strip_chars: true)
+        SimpleSymbolize.symbolize(self, strip_chars:)
       end
 
       # @example Turns a String into a camelCase Symbol
       #   "Hello World".simple_camelize => :helloWorld
-      def simple_camelize
-        SimpleSymbolize.camelize(self)
+      def simple_camelize(strip_chars: true)
+        SimpleSymbolize.camelize(self, strip_chars:)
       end
 
       # @example Symbolizes a String then calls #to_s
       #   "helloWorld".simple_elementize => 'hello_word'
-      def simple_elementize
-        SimpleSymbolize.elementize(self)
+      def simple_elementize(strip_chars: true)
+        SimpleSymbolize.elementize(self, strip_chars:)
       end
 
       # @example Turns a String into it's snake_case equivalent
       #   "helloWorld".simple_snakeize => 'hello_word'
-      def simple_snakeize
-        SimpleSymbolize.snakeize(self)
+      def simple_snakeize(strip_chars: true)
+        SimpleSymbolize.snakeize(self, strip_chars:)
       end
     end
   end

data/lib/simple_symbolize/core_ext/symbol/symbolize.rb

@@ -10,26 +10,26 @@ module SimpleSymbolize
     module Symbol
       # @example Symbolize a string using the String object method
       #   :hello_world!.symbolize #=> :hello_world
-      def simple_symbolize
-        SimpleSymbolize.symbolize(self)
+      def simple_symbolize(strip_chars: true)
+        SimpleSymbolize.symbolize(self, strip_chars:)
       end
 
       # @example Turns a String into a camelCase Symbol
       #   :hello_world.simple_camelize => :helloWorld
-      def simple_camelize
-        SimpleSymbolize.camelize(self)
+      def simple_camelize(strip_chars: true)
+        SimpleSymbolize.camelize(self, strip_chars:)
       end
 
       # @example Symbolizes a String then calls #to_s
       #   :helloWorld!.simple_elementize => 'hello_word'
-      def simple_elementize
-        SimpleSymbolize.elementize(self)
+      def simple_elementize(strip_chars: true)
+        SimpleSymbolize.elementize(self, strip_chars:)
       end
 
       # @example Turns a String into it's snake_case equivalent
       #   :helloWorld.simple_snakeize => :hello_word
-      def simple_snakeize
-        SimpleSymbolize.snakeize(self)
+      def simple_snakeize(strip_chars: true)
+        SimpleSymbolize.snakeize(self, strip_chars:)
       end
     end
   end

data/lib/simple_symbolize/translations.rb

@@ -10,8 +10,10 @@ module SimpleSymbolize
     attr_reader :remove
     # @return [Array] the characters to be untouched from the String.
     attr_reader :omit
-
+    # @return [Boolean] whether to handle camelCase strings during symbolisation.
     attr_reader :handle_camel_case
+    # @return [Array] the characters to be transformed into uppercase during camelisation.
+    attr_reader :camel_case_acronyms
 
     # Creates an instance of the Translations class.
     #
@@ -21,44 +23,44 @@ module SimpleSymbolize
     end
 
     # Merges the String passed with the @underscore Array omitting duplicates.
-    # Removes those characters from the @remove and @omit Arrays to avoid the change being over-written.
+    # Removes those characters from @remove and @omit Arrays to avoid the change being over-written.
     #
-    # @param chars [Array] an object containing characters to be underscored.
+    # @param input [Array] an object containing characters to be underscored.
     #
     # @return [Array] the Array of characters to be underscored.
-    def to_underscore=(chars)
-      chars = sanitise_chars(chars)
+    def to_underscore=(input)
+      arr = sanitise(input)
 
-      @remove -= chars
-      @omit -= chars
-      @underscore |= chars
+      @remove -= arr
+      @omit -= arr
+      @underscore |= arr
     end
 
     # Merges the String passed with the @remove Array omitting duplicates.
-    # Removes those characters from the @underscore and @omit Arrays to avoid the change being over-written.
+    # Removes those characters from @underscore and @omit Arrays to avoid the change being over-written.
     #
-    # @param chars [String] a String object containing characters to be removed.
+    # @param input [String] a String object containing characters to be removed.
     #
     # @return [Array] the Array of characters to be removed.
-    def to_remove=(chars)
-      chars = sanitise_chars(chars)
+    def to_remove=(input)
+      arr = sanitise(input)
 
-      @underscore -= chars
-      @omit -= chars
-      @remove |= chars
+      @underscore -= arr
+      @omit -= arr
+      @remove |= arr
     end
 
-    # Removes characters within the String passed from the @remove and @underscore Arrays.
+    # Removes characters within the String passed from @remove and @underscore Arrays.
     #
-    # @param chars [String] a String object containing characters to be removed.
+    # @param input [String] a String object containing characters to be removed.
     #
     # @return [Array] the Array of characters to be omitted.
-    def to_omit=(chars)
-      chars = sanitise_chars(chars)
+    def to_omit=(input)
+      arr = sanitise(input)
 
-      @underscore -= chars
-      @remove -= chars
-      @omit += chars
+      @underscore -= arr
+      @remove -= arr
+      @omit += arr
     end
 
     def handle_camel_case=(handle)
@@ -68,26 +70,37 @@ module SimpleSymbolize
       @handle_camel_case = handle.eql?('true')
     end
 
+    def camel_case_acronyms=(input)
+      arr = sanitise(input)
+
+      @camel_case_acronyms = arr.map { |word| word.is_a?(String) ? word.to_s.downcase : nil }.compact.uniq
+    end
+
     def reset!
       @underscore = [' ', '::', '-']
       @remove = %w[' ( ) , . : " ! @ £ $ % ^ & * / { } [ ] < > ; = #]
       @omit = []
       @handle_camel_case = true
+      @camel_case_acronyms = []
     end
 
     private
 
-    # Converts chars into Array of Strings
+    # Sanitises the input into an Array of Strings
     #
-    # @param arg Arg to be converted
+    # @param input [String, Array] to be converted
     #
     # @return Array of Strings
     #
     # @raise [ArgumentError] if the arg is not either a String or an Array.
-    def sanitise_chars(arg)
-      raise ArgumentError 'needs to be a String or an Array of characters' unless [String, Array].include?(arg.class)
+    def sanitise(input)
+      raise ArgumentError 'needs to be a String or an Array' unless [String, Array].include?(input.class)
 
-      arg.respond_to?(:chars) ? arg.chars : arg.map(&:to_s)
+      if input.respond_to?(:chars)
+        input.chars
+      else
+        input.map { |obj| obj.respond_to?(:to_s) ? obj.to_s.downcase : nil }.compact.uniq
+      end
     end
   end
 end

data/lib/simple_symbolize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleSymbolize
-  VERSION = '4.1.0'
+  VERSION = '6.0.0'
 end

data/lib/simple_symbolize.rb

@@ -31,19 +31,20 @@ module SimpleSymbolize
   #
   # @example Symbolize a string using the symbolize method
   #   SimpleSymbolize.symbolize("hello world!") #=> :hello_world
-  def self.symbolize(obj)
-    return obj unless obj.respond_to?(:to_s)
-    return obj if [Hash, Array, NilClass].include?(obj.class)
-    return obj if obj.respond_to?(:empty?) && obj.empty?
+  def self.symbolize(obj, strip_chars: true)
+    return obj unless valid_input?(obj)
 
     obj = if SimpleSymbolize.translations.handle_camel_case
-            snakeize(obj)
+            snakeize(obj, strip_chars:)
           else
             obj.to_s
                .downcase
                .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
-               .gsub(Regexp.union(SimpleSymbolize.translations.remove), '')
+               .then do |str|
+                 strip_chars?(strip_chars) ? str.gsub(Regexp.union(SimpleSymbolize.translations.remove), '') : str
+               end
           end
+
     obj.to_sym
   end
 
@@ -53,12 +54,10 @@ module SimpleSymbolize
   #
   # @example Elementize a string using the elementize method
   #   SimpleSymbolize.elementize("hello world!") #=> "helloWorld"
-  def self.elementize(obj)
-    return obj unless obj.respond_to?(:to_s)
-    return obj if [Hash, Array, NilClass].include?(obj.class)
-    return obj if obj.respond_to?(:empty?) && obj.empty?
+  def self.elementize(obj, strip_chars: true)
+    return obj unless valid_input?(obj)
 
-    symbolize(obj).to_s
+    symbolize(obj, strip_chars:).to_s
   end
 
   # Turns a String object into a camelCase Symbol.
@@ -67,15 +66,13 @@ module SimpleSymbolize
   #
   # @example Camelize a string using the camelize method
   #   SimpleSymbolize.camelize("hello world!") #=> :helloWorld
-  def self.camelize(obj)
-    return obj unless obj.respond_to?(:to_s)
-    return obj if [Hash, Array, NilClass].include?(obj.class)
-    return obj if obj.respond_to?(:empty?) && obj.empty?
+  def self.camelize(obj, strip_chars: true)
+    return obj unless valid_input?(obj)
 
-    first, *rest = elementize(obj).split('_')
+    first, *rest = elementize(obj, strip_chars:).split('_')
     return obj if first.nil?
 
-    rest.size.positive? ? (first << rest.map(&:capitalize).join).to_sym : symbolize(first)
+    assemble_came_case_string(first, rest)
   end
 
   # Turns a String || Symbol into a snake_case Symbol
@@ -84,17 +81,56 @@ module SimpleSymbolize
   #
   # @example Snakeize an object using the snakeize method
   #   SimpleSymbolize.snakeize('Hello World!') #=> :hello_world
-  def self.snakeize(obj)
-    return obj unless obj.respond_to?(:to_s)
-    return obj if [Hash, Array, NilClass].include?(obj.class)
-    return obj if obj.respond_to?(:empty?) && obj.empty?
+  def self.snakeize(obj, strip_chars: true)
+    return obj unless valid_input?(obj)
 
     obj.to_s
        .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
-       .gsub(Regexp.union(SimpleSymbolize.translations.remove), '')
+       .then { |str| strip_chars?(strip_chars) ? str.gsub(Regexp.union(SimpleSymbolize.translations.remove), '') : str }
        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
        .downcase
        .to_sym
   end
+
+  class << self
+    private
+
+    # Validates if the input object should be processed
+    #
+    # @param obj [Object] the object to validate
+    #
+    # @return [Boolean] true if the object should be processed, false otherwise
+    def valid_input?(obj)
+      return false unless [String, Symbol].include?(obj.class)
+      return false unless obj.respond_to?(:to_s)
+      return false if obj.to_s.empty?
+
+      true
+    end
+
+    # Abstracts the complicated building of the camelCase String
+    #
+    # @param first [String] the first part of the camelCase String
+    # @param rest [Array] the rest of the camelCase String
+    #
+    # @return [Symbol] camelCase representation of the input
+    def assemble_came_case_string(first, rest)
+      return symbolize(first) unless rest.size.positive?
+
+      acronyms = SimpleSymbolize.translations.camel_case_acronyms
+      rest = if acronyms.empty?
+               rest.map(&:capitalize)
+             else
+               rest.map { |word| acronyms.include?(word) ? word.upcase : word.capitalize }
+             end
+
+      word = first + rest.join
+      word.to_sym
+    end
+
+    def strip_chars?(obj)
+      obj.to_s.downcase == 'true'
+    end
+  end
 end

data/simple_symbolize.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/dvla/simple-symbolize'
 
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 3.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.4')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_symbolize
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 6.0.0
 platform: ruby
 authors:
 - alexo
 - Driver and Vehicle Licensing Agency (DVLA)
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: 'simple_symbolize will remove special characters from a String, replacing
   whitespace with an underscore, down-casing and finally calling the #to_sym String
@@ -44,7 +43,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/dvla/simple-symbolize
   source_code_uri: https://github.com/dvla/simple-symbolize
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -52,15 +50,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Turns Strings into Symbols.
 test_files: []