simple_symbolize 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fe69f67b8c3e4152dd088e6425f0a0e9c0c5206ff384bd599284f976b664e4e
-  data.tar.gz: d8ce3414da304b386a71e83f482bd3dc2a031274c61dbe8d69efbab1d9dc819a
+  metadata.gz: 1da0a7a552ad0fd3c5901bbf7141a0cb03437b96379df5506690d65f1424592b
+  data.tar.gz: 4725b7b1c52b62649b683369856d9eb37d66b9569db9e283acfaa426fdad4be9
 SHA512:
-  metadata.gz: da85cabac7e7f368cfd7a0366dffa7642e6f0b27f2cbac49b548264df55f82eb715d74cf80e2113a172b7451b2496a86ddcbc13ef818d66e8b7f72aa8df80ff1
-  data.tar.gz: 82a0bd3a48cecbf2ca49607dd136cc8dc46a3babb761507b88a74043a494f396fbe6e7ecc53393c5a2d065e2f8d0302ccfdf80dfe6cb2412d3188091f15d2f44
+  metadata.gz: ebaeea1ca71fb7532b98e6b9c020ac35432e0c17eeedb908081f6e7dc0656e38471a9bf98f37fee1f87cafb1e4d185d49d51ad6c4f4b7c89b79e985a0b127c3a
+  data.tar.gz: 5cc276021f11076c11f3ac704388b67e37451acdc0d0eab68bc11f6fcf007c94d321e6d5acf253e5ff7382e943008122a4f9ca835bf709db05b125ad34da7fd6

data/.github/workflows/ruby.yml

@@ -21,7 +21,7 @@ jobs:
         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

@@ -12,7 +12,7 @@ jobs:
         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/Gemfile

@@ -7,5 +7,5 @@ gemspec
 
 gem 'rake', '~> 13.3'
 gem 'rspec', '~> 3.13'
-gem 'rubocop', '~> 1.79'
+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,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,51 @@ 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.
+#### 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 +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.
@@ -145,6 +207,8 @@ Arrays are now supported when configuring the gem
 SimpleSymbolize.translate { |trans| trans.to_underscore = %w[!&*] }
 ```
 
+---
+
 ### V2
 
 SimpleSymbolize has got new friends!
@@ -162,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/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 = '5.0.0'
 end

data/lib/simple_symbolize.rb

@@ -32,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)
@@ -54,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
@@ -68,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
@@ -85,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), '_')
@@ -97,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

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_symbolize
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.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.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: []