simple_symbolize 4.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69d7f99fc0ead5eeda918161fe2995fb4b58bcd39e297dae0af8d7efceb0b030
-  data.tar.gz: e5685b751c32abb542e6599f9677a785d7584be97d0c47a45067125192e0687e
+  metadata.gz: 1da0a7a552ad0fd3c5901bbf7141a0cb03437b96379df5506690d65f1424592b
+  data.tar.gz: 4725b7b1c52b62649b683369856d9eb37d66b9569db9e283acfaa426fdad4be9
 SHA512:
-  metadata.gz: 196774c36c21335f2699a7db17dbe10e7df3727533b9d53b401c852371d8347aaf900dbea9811e948b23d333b344d44b11bfff4dbce99888e0ac70557f67304d
-  data.tar.gz: c7e76fa9f182ad23ccef97ab8e47a40626316369dd2bf187609a292043c0f91a432455399d086b79eb61daf0aa2ba46accc23bab72946a7dd3b47de5d922400e
+  metadata.gz: ebaeea1ca71fb7532b98e6b9c020ac35432e0c17eeedb908081f6e7dc0656e38471a9bf98f37fee1f87cafb1e4d185d49d51ad6c4f4b7c89b79e985a0b127c3a
+  data.tar.gz: 5cc276021f11076c11f3ac704388b67e37451acdc0d0eab68bc11f6fcf007c94d321e6d5acf253e5ff7382e943008122a4f9ca835bf709db05b125ad34da7fd6

data/.github/workflows/ruby.yml

@@ -18,10 +18,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: [ '3.0', '3.1', '3.2' ]
+        ruby-version: [ '3.2', '3.3', '3.4' ]
 
     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.0', '3.1', '3.2' ]
+        ruby-version: [ '3.2', '3.3', '3.4' ]
 
     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 3.4
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 3.0.1
+          ruby-version: 3.4
           bundler-cache: true
 
       - name: Publish to RubyGems

data/.rubocop.yml

@@ -1,7 +1,7 @@
 AllCops:
   NewCops: enable
   SuggestExtensions: false
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.2
 
 Gemspec/DevelopmentDependencies:
   EnforcedStyle: gemspec
@@ -15,19 +15,4 @@ Metrics/BlockLength:
     - spec/**/*.rb
 
 Style/MixinUsage:
-  Enabled: false
-
-Lint/BooleanSymbol:
-  Enabled: false
-
-Metrics/AbcSize:
-  Enabled: false
-
-Metrics/MethodLength:
-  Max: 25
-
-Layout/LineLength:
-  Max: 130
-
-Metrics/CyclomaticComplexity:
-  Max: 8
+  Enabled: false

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.4.5

data/Gemfile

@@ -4,3 +4,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in simple_symbolize.gemspec
 gemspec
+
+gem 'rake', '~> 13.3'
+gem 'rspec', '~> 3.13'
+gem 'rubocop', '~> 1.80'
+gem 'simplecov', '~> 0.22'

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,9 +67,37 @@ String.include SimpleSymbolize::CoreExt::String
 '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) |                                                                                                        |
+
+### Mixing into Symbol
+
+```ruby
+require 'simple_symbolize'
+
+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!
 
@@ -74,13 +111,54 @@ end
 
 ## Updates!
 
+### 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.
+
+```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 deliberatly mixin the methods on the String class:
+You now need to deliberately mixin the methods on the String class:
 
 ```ruby
 String.include SimpleSymbolize::CoreExt::String
@@ -98,9 +176,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.
@@ -125,6 +207,8 @@ Arrays are now supported when configuring the gem
 SimpleSymbolize.translate { |trans| trans.to_underscore = %w[!&*] }
 ```
 
+---
+
 ### V2
 
 SimpleSymbolize has got new friends!
@@ -142,7 +226,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/symbol/symbolize.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Extends the Symbol class by mixing in the symbolize module.
+# @example Mixin the methods to the Symbol class
+#   Symbol.include SimpleSymbolize::CoreExt::Symbol
+
+module SimpleSymbolize
+  module CoreExt
+    # Contains methods to be mixed into the String class
+    module Symbol
+      # @example Symbolize a string using the String object method
+      #   :hello_world!.symbolize #=> :hello_world
+      def simple_symbolize
+        SimpleSymbolize.symbolize(self)
+      end
+
+      # @example Turns a String into a camelCase Symbol
+      #   :hello_world.simple_camelize => :helloWorld
+      def simple_camelize
+        SimpleSymbolize.camelize(self)
+      end
+
+      # @example Symbolizes a String then calls #to_s
+      #   :helloWorld!.simple_elementize => 'hello_word'
+      def simple_elementize
+        SimpleSymbolize.elementize(self)
+      end
+
+      # @example Turns a String into it's snake_case equivalent
+      #   :helloWorld.simple_snakeize => :hello_word
+      def simple_snakeize
+        SimpleSymbolize.snakeize(self)
+      end
+    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.0.0'
+  VERSION = '5.0.0'
 end

data/lib/simple_symbolize.rb

@@ -4,6 +4,7 @@ require 'simple_symbolize/version'
 
 require_relative 'simple_symbolize/translations'
 require_relative 'simple_symbolize/core_ext/string/symbolize'
+require_relative 'simple_symbolize/core_ext/symbol/symbolize'
 
 # Main module for the gem
 # Contains the base methods and allows configuration
@@ -31,9 +32,7 @@ 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?
+    return obj unless valid_input?(obj)
 
     obj = if SimpleSymbolize.translations.handle_camel_case
             snakeize(obj)
@@ -53,9 +52,7 @@ 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?
+    return obj unless valid_input?(obj)
 
     symbolize(obj).to_s
   end
@@ -67,14 +64,12 @@ 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?
+    return obj unless valid_input?(obj)
 
     first, *rest = elementize(obj).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,9 +79,7 @@ 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?
+    return obj unless valid_input?(obj)
 
     obj.to_s
        .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
@@ -96,4 +89,41 @@ module SimpleSymbolize
        .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
+  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.2')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
@@ -29,10 +29,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'pry', '~> 0.14'
-  spec.add_development_dependency 'rake', '~> 13.0'
-  spec.add_development_dependency 'rspec', '~> 3.12'
-  spec.add_development_dependency 'rubocop', '~> 1.54'
-  spec.add_development_dependency 'simplecov', '~> 0.22'
 end

metadata

@@ -1,86 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: simple_symbolize
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - alexo
 - Driver and Vehicle Licensing Agency (DVLA)
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-01-12 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.54'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.54'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.22'
+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
   method. Configure this gem to your hearts content!'
@@ -104,6 +33,7 @@ files:
 - bin/setup
 - lib/simple_symbolize.rb
 - lib/simple_symbolize/core_ext/string/symbolize.rb
+- lib/simple_symbolize/core_ext/symbol/symbolize.rb
 - lib/simple_symbolize/translations.rb
 - lib/simple_symbolize/version.rb
 - simple_symbolize.gemspec
@@ -113,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
@@ -121,15 +50,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Turns Strings into Symbols.
 test_files: []