simple_symbolize 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fcd4f78253aed92cf1895fd948418deac6fe69f2e3ce80efae55eb79556b157c
-  data.tar.gz: 7cefb49253c485e825b05e27bf6fcf020f4ef24f1995cc0ab1590e76a5ef0aed
+  metadata.gz: 69d7f99fc0ead5eeda918161fe2995fb4b58bcd39e297dae0af8d7efceb0b030
+  data.tar.gz: e5685b751c32abb542e6599f9677a785d7584be97d0c47a45067125192e0687e
 SHA512:
-  metadata.gz: fee566211bb3708c7f3225897008f9f5434fbaa8840f3fcab3b50d7031e74263a4b14a39fbf383834bbd3948cb4020457e00c6d83777f3235fa7d3d77877f312
-  data.tar.gz: a453a5a9be5d81ea8198f21b5fbd0fc1663f71f58f6051a9aa3ebc7c87893d76413d7b1c38b3e184032a7b773ed9ecabe92374f88fb467853ab986a55d17e57b
+  metadata.gz: 196774c36c21335f2699a7db17dbe10e7df3727533b9d53b401c852371d8347aaf900dbea9811e948b23d333b344d44b11bfff4dbce99888e0ac70557f67304d
+  data.tar.gz: c7e76fa9f182ad23ccef97ab8e47a40626316369dd2bf187609a292043c0f91a432455399d086b79eb61daf0aa2ba46accc23bab72946a7dd3b47de5d922400e

data/.rubocop.yml

@@ -27,4 +27,7 @@ Metrics/MethodLength:
   Max: 25
 
 Layout/LineLength:
-  Max: 130
+  Max: 130
+
+Metrics/CyclomaticComplexity:
+  Max: 8

data/README.md

@@ -17,7 +17,7 @@ It works by removing special characters in a String like `'!'` and underscoring
 'hello world!'.to_sym # => :"hello world!"
 
 # Symbolize gem
-'hello world!'.symbolize # => :hello_world
+'hello world!'.simple_symbolize # => :hello_world
 ```
 
 ## Installation
@@ -53,7 +53,9 @@ SimpleSymbolize.symbolize('hello world!') # => :hello_world
 ```ruby
 require 'simple_symbolize'
 
-'hello world!'.symbolize # => :hello_world
+String.include SimpleSymbolize::CoreExt::String
+
+'hello world!'.simple_symbolize # => :hello_world
 ```
 
 ## Configuration
@@ -72,15 +74,41 @@ end
 
 ## Updates!
 
+### 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 
+certain methods names with.
+
+You now need to deliberatly mixin the methods on the String class:
+
+```ruby
+String.include SimpleSymbolize::CoreExt::String
+```
+
+To make them easier to spot, the method names on the String class have been prefixed with `simple_` to avoid confusion.
+
+```ruby
+'Hello World!'.simple_symbolize #=> :hello_world
+'Hello World!'.simple_elementize #=> 'hello_world'
+'Hello World!'.simple_camelize #=> :helloWorld
+'Hello World!'.simple_snakeize #=> :hello_world
+```
+
+#### 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.
+
 ### V3
-#### String to_snake_case
+#### 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.
 
 #### Handle camelCase with Symbolize
 
 ```ruby
-symbolize('helloWorld!') # => :hello_world
+SimpleSymbolize.symbolize('helloWorld!') # => :hello_world
 ```
 
 This is the default behaviour and can be switched off by setting `#handle_camel_case` to `false`
@@ -109,7 +137,7 @@ Sometimes you just want a simple String obj without all the fuss. Elementize tak
 and returns you a simple-to-use String.
 
 ```ruby
-elementize('hello world!') # => "hello_world"
+SimpleSymbolize.elementize('hello world!') # => "hello_world"
 ```
 
 #### Camelize

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Extends the String class by mixing in the symbolize module.
+# @example Mixin the methods to the String class
+#   String.include SimpleSymbolize::CoreExt::String
+
+module SimpleSymbolize
+  module CoreExt
+    # Contains methods to be mixed into the String class
+    module String
+      # @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/version.rb

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

data/lib/simple_symbolize.rb

@@ -2,10 +2,8 @@
 
 require 'simple_symbolize/version'
 
-require_relative 'simple_symbolize/string'
 require_relative 'simple_symbolize/translations'
-
-include SimpleSymbolize
+require_relative 'simple_symbolize/core_ext/string/symbolize'
 
 # Main module for the gem
 # Contains the base methods and allows configuration
@@ -31,18 +29,21 @@ module SimpleSymbolize
   # @param obj [Object] the String object to be symbolized.
   #
   # @example Symbolize a string using the symbolize method
-  #   symbolize("hello world!") #=> :hello_world
-  def symbolize(obj)
+  #   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?
 
-    str = obj.to_s
-    str = str.to_snake_case if SimpleSymbolize.translations.handle_camel_case
-
-    str.downcase
-       .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
-       .gsub(Regexp.union(SimpleSymbolize.translations.remove), '')
-       .to_sym
+    obj = if SimpleSymbolize.translations.handle_camel_case
+            snakeize(obj)
+          else
+            obj.to_s
+               .downcase
+               .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
+               .gsub(Regexp.union(SimpleSymbolize.translations.remove), '')
+          end
+    obj.to_sym
   end
 
   # Symbolizes a String object and returns it as a String object.
@@ -50,10 +51,11 @@ module SimpleSymbolize
   # @param obj [Object] the object to be symbolized.
   #
   # @example Elementize a string using the elementize method
-  #   elementize("hello world!") #=> "helloWorld"
-  def elementize(obj)
+  #   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?
 
     symbolize(obj).to_s
   end
@@ -63,14 +65,35 @@ module SimpleSymbolize
   # @param obj [Object] the String object to be camelized.
   #
   # @example Camelize a string using the camelize method
-  #   camelize("hello world!") #=> :helloWorld
-  def camelize(obj)
+  #   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?
 
     first, *rest = elementize(obj).split('_')
     return obj if first.nil?
 
     rest.size.positive? ? (first << rest.map(&:capitalize).join).to_sym : symbolize(first)
   end
+
+  # Turns a String || Symbol into a snake_case Symbol
+  #
+  # @param obj [Object] the object to be snakeize
+  #
+  # @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?
+
+    obj.to_s
+       .gsub(Regexp.union(SimpleSymbolize.translations.underscore), '_')
+       .gsub(Regexp.union(SimpleSymbolize.translations.remove), '')
+       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+       .downcase
+       .to_sym
+  end
 end

data/simple_symbolize.gemspec

@@ -5,7 +5,7 @@ require_relative 'lib/simple_symbolize/version'
 Gem::Specification.new do |spec|
   spec.name          = 'simple_symbolize'
   spec.version       = SimpleSymbolize::VERSION
-  spec.authors       = ['alexo']
+  spec.authors       = ['alexo', 'Driver and Vehicle Licensing Agency (DVLA)']
   spec.email         = ['']
 
   spec.summary       = 'Turns Strings into Symbols.'
@@ -18,11 +18,8 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 3.0')
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = spec.homepage
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
 
   # 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.
@@ -37,4 +34,5 @@ Gem::Specification.new do |spec|
   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,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: simple_symbolize
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - alexo
+- Driver and Vehicle Licensing Agency (DVLA)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-21 00:00:00.000000000 Z
+date: 2024-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -66,6 +67,20 @@ dependencies:
     - - "~>"
       - !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'
 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!'
@@ -88,7 +103,7 @@ files:
 - bin/console
 - bin/setup
 - lib/simple_symbolize.rb
-- lib/simple_symbolize/string.rb
+- lib/simple_symbolize/core_ext/string/symbolize.rb
 - lib/simple_symbolize/translations.rb
 - lib/simple_symbolize/version.rb
 - simple_symbolize.gemspec

data/lib/simple_symbolize/string.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'simple_symbolize'
-
-# Extends the String class by mixing in the symbolize module.
-class String
-  # @example Symbolize a string using the String object method
-  #   "hello world!".symbolize #=> :hello_world
-  def symbolize
-    SimpleSymbolize.symbolize(self)
-  end
-
-  # @example Turns a String into it's snake_case equivalent
-  #   "helloWorld".to_snake_case => 'hello_word'
-  def to_snake_case
-    # rubocop:disable Style/RedundantSelf
-    self.gsub(/([a-z\d])([A-Z])/, '\1_\2')
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        .downcase
-    # rubocop:enable Style/RedundantSelf
-  end
-end