Module: Securial::Helpers::KeyTransformer

Extended by:
KeyTransformer
Included in:
KeyTransformer
Defined in:
lib/securial/helpers/key_transformer.rb

Overview

Transforms hash keys between different naming conventions.

This module provides methods to convert between snake_case (Ruby convention), camelCase (JavaScript convention), and PascalCase (C# convention) for API response formatting. It supports deep transformation of nested structures.

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.deep_transform_keys(obj) {|key| ... } ⇒ Object

Recursively transforms all keys in a nested data structure.

Applies a key transformation block to all hash keys in a deeply nested structure containing hashes, arrays, and other objects. The transformation preserves the structure while only modifying the keys.

Examples:

Transforming a simple hash

data = { user_name: "john", user_email: "[email protected]" }
KeyTransformer.deep_transform_keys(data) { |key| key.to_s.upcase }
# => { "USER_NAME" => "john", "USER_EMAIL" => "[email protected]" }

Transforming nested structures

nested = {
  user_info: {
    first_name: "John",
    addresses: [
      { street_name: "Main St", zip_code: "12345" }
    ]
  }
}
result = KeyTransformer.deep_transform_keys(nested) { |key|
  KeyTransformer.camelize(key, :lowerCamelCase)
}
# => {
#   userInfo: {
#     firstName: "John",
#     addresses: [
#       { streetName: "Main St", zipCode: "12345" }
#     ]
#   }
# }

Non-hash objects are preserved

mixed = ["string", 123, { user_name: "john" }]
KeyTransformer.deep_transform_keys(mixed) { |key| key.to_s.upcase }
# => ["string", 123, { "USER_NAME" => "john" }]

Yield Parameters:

  • key (String, Symbol) —

    Each hash key to be transformed

Yield Returns:

  • (String, Symbol) —

    The transformed key



127
128
129
130
131
132
133
134
135
136
 
# File 'lib/securial/helpers/key_transformer.rb', line 127

def self.deep_transform_keys(obj, &block)
  case obj
  when Hash
    obj.transform_keys(&block).transform_values { |v| deep_transform_keys(v, &block) }
  when Array
    obj.map { |e| deep_transform_keys(e, &block) }
  else
    obj
  end
end

.underscore(str) ⇒ String

Converts a camelCase or PascalCase string to snake_case.

Transforms camelCase or PascalCase strings back to Ruby’s snake_case convention. Useful for converting API input keys to Ruby conventions.

Examples:

Converting from camelCase

KeyTransformer.underscore("userName")
# => "user_name"

Converting from PascalCase

KeyTransformer.underscore("EmailAddress")
# => "email_address"



81
82
83
 
# File 'lib/securial/helpers/key_transformer.rb', line 81

def self.underscore(str)
  str.to_s.underscore
end

Instance Method Details

#camelize(str, format) ⇒ String

Converts a string to camelCase or PascalCase format.

Transforms snake_case strings into camelCase variants based on the specified format. Useful for converting Ruby hash keys to JavaScript or other language conventions.

Examples:

Converting to lowerCamelCase

KeyTransformer.camelize("user_name", :lowerCamelCase)
# => "userName"

Converting to PascalCase

KeyTransformer.camelize("email_address", :UpperCamelCase)
# => "EmailAddress"

Unrecognized format returns original

KeyTransformer.camelize("user_name", :snake_case)
# => "user_name"

Options Hash (format):

  • :lowerCamelCase (Symbol) —

    Converts to lowerCamelCase (firstName)

  • :UpperCamelCase (Symbol) —

    Converts to PascalCase (FirstName)



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/securial/helpers/key_transformer.rb', line 54

def camelize(str, format)
  case format
  when :lowerCamelCase
    str.to_s.camelize(:lower)
  when :UpperCamelCase
    str.to_s.camelize
  else
    str.to_s
  end
end