everythingrb 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8d091206968f382cb9d1539fb05c31eaf80ac63842db773c7b0c10ae81a757f
-  data.tar.gz: be5753c698445e4efc5c476f08ebc696d304cf8566303bd57df771ff0a6a0ba2
+  metadata.gz: 0b3c80f8891826722af0d521a4dad5ba31e90540ad46cc31e25d6fc0ed34cd52
+  data.tar.gz: 8e7f1daa4a9db4e31b2c4c3f58d3573ed36d833ab98e51d2daa997839f28eefd
 SHA512:
-  metadata.gz: ece0c1ccf513a9bfb2a77bd405b88e3dd09cffd2e1c07ef377b94582018ce18a2a3b9dd981c73b0107eb9fb1b1b82d0df852b54cf1daff38e61a2ca6850cc6c9
-  data.tar.gz: 5ede278236fc54a3f6297d8a54ef0bd77bcea530b7e58cab98861ee3d8676bedd090aceccfdeb8527349027fbf1d8f80d3a493c2c8140c798e143fa7b2761b6e
+  metadata.gz: 9bc88ea3c150c7e6cb6b55364d78f2eb863ec368c39b40f1f7d855dbaa43a3f3c7cde240971e649ca2b0eeded6c639179614d472446f37a5a89ae59cd026616d
+  data.tar.gz: 0327b5ae60b07e38ac81a292ca34639b6295beb23dab45410e0420350c3451e14745d1660e08520bcda2c92bc74a796bfdd12ecea1036414f01f1375218de1f1

data/CHANGELOG.md

@@ -23,6 +23,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [0.8.0] - 12025-05-11
+
+### Added
+
+- Added conditional hash merging methods:
+  - `Hash#merge_if` and `Hash#merge_if!` - Merge key-value pairs based on a condition
+  - `Hash#merge_if_values` and `Hash#merge_if_values!` - Merge based on values only
+  - `Hash#merge_compact` and `Hash#merge_compact!` - Merge only non-nil values
+- Added `String#to_camelcase` - Converts strings to camelCase/PascalCase while handling spaces, hyphens, underscores, and special characters
+  - Supports both lowercase first letter (`:lower`) and uppercase first letter (`:upper`), which is default
+
+### Changed
+
+- Updated documentation
+
+### Removed
+
+- Removed potentially dangerous `Array#deep_freeze` and `Hash#deep_freeze` methods to prevent accidental freezing of classes and singleton objects. This creates a safer API for the 1.0.0 milestone.
+
 ## [0.7.0] - 12025-05-04
 
 ### Added
@@ -264,7 +283,8 @@ This change aligns our method signatures with Ruby's conventions and matches our
 
 - Added alias `each` to `each_pair` in OpenStruct for better enumerable compatibility
 
-[unreleased]: https://github.com/itsthedevman/everythingrb/compare/v0.7.0...HEAD
+[unreleased]: https://github.com/itsthedevman/everythingrb/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/itsthedevman/everythingrb/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/itsthedevman/everythingrb/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/itsthedevman/everythingrb/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/itsthedevman/everythingrb/compare/v0.5.0...v0.6.0

data/README.md

@@ -4,18 +4,33 @@
 ![Ruby Version](https://img.shields.io/badge/ruby-3.3.7-ruby)
 [![Tests](https://github.com/itsthedevman/everythingrb/actions/workflows/main.yml/badge.svg)](https://github.com/everythingrb/sortsmith/actions/workflows/main.yml)
 
-Super handy extensions to Ruby core classes that make your code more expressive, readable, and fun to write.
+Super handy extensions to Ruby core classes that make your code more expressive, readable, and fun to write. Stop writing boilerplate and start writing code that *actually matters*!
+
+## Express Your Intent, Not Your Logic
+
+We've all been there - writing the same tedious patterns over and over:
 
 ```ruby
+# BEFORE
 users = [{ name: "Alice", role: "admin" }, { name: "Bob", role: "user" }]
+admin_users = users.select { |u| u[:role] == "admin" }
+admin_names = admin_users.map { |u| u[:name] }
+result = admin_names.join(", ")
+# => "Alice"
+```
 
-# Instead of this:
-admin_names = users.select { |u| u[:role] == "admin" }.map { |u| u[:name] }.join(", ")
+With EverythingRB, you can write code that actually says what you mean:
 
-# Write this:
+```ruby
+# AFTER
 users.join_map(", ") { |u| u[:name] if u[:role] == "admin" }
+# => "Alice"
 ```
 
+*Methods used: [`join_map`](https://itsthedevman.com/docs/everythingrb/Array.html#join_map-instance_method)*
+
+Because life's too short to write all that boilerplate!
+
 ## Installation
 
 ```ruby
@@ -47,7 +62,7 @@ config.server.port  # => 443
 
 ### Cherry-Pick Extensions
 
-If you only need specific extensions, you can load just what you want:
+If you only need specific extensions (or you're a minimalist at heart):
 
 ```ruby
 require "everythingrb/prelude"  # Required base module
@@ -68,7 +83,7 @@ Available modules:
 - `data`: Data extensions (to_deep_h, in_quotes)
 - `date`: Date and DateTime extensions (in_quotes)
 - `enumerable`: Enumerable extensions (join_map, group_by_key)
-- `hash`: Hash extensions (to_ostruct, deep_freeze, etc.)
+- `hash`: Hash extensions (to_ostruct, transform_values(with_key: true), etc.)
 - `kernel`: Kernel extensions (morph alias for then)
 - `module`: Extensions like attr_predicate
 - `nil`: NilClass extensions (in_quotes)
@@ -76,126 +91,412 @@ Available modules:
 - `ostruct`: OpenStruct extensions (map, join_map, etc.)
 - `range`: Range extensions (in_quotes)
 - `regexp`: Regexp extensions (in_quotes)
-- `string`: String extensions (to_h, to_ostruct, etc.)
+- `string`: String extensions (to_h, to_ostruct, to_camelcase, etc.)
 - `struct`: Struct extensions (to_deep_h, in_quotes)
 - `symbol`: Symbol extensions (with_quotes)
 - `time`: Time extensions (in_quotes)
 
 ## What's Included
 
-EverythingRB extends Ruby's core classes with intuitive methods that simplify common patterns.
-
 ### Data Structure Conversions
 
+Stop writing complicated parsers and nested transformations:
+
+```ruby
+# BEFORE
+json_string = '{"user":{"name":"Alice","roles":["admin"]}}'
+parsed = JSON.parse(json_string)
+result = OpenStruct.new(
+  user: OpenStruct.new(
+    name: parsed["user"]["name"],
+    roles: parsed["user"]["roles"]
+  )
+)
+result.user.name  # => "Alice"
+```
+
+With EverythingRB, it's one elegant step:
+
+```ruby
+# AFTER
+'{"user":{"name":"Alice","roles":["admin"]}}'.to_ostruct.user.name  # => "Alice"
+```
+
+*Methods used: [`to_ostruct`](https://itsthedevman.com/docs/everythingrb/String.html#to_ostruct-instance_method)*
+
 Convert between data structures with ease:
 
 ```ruby
-# Convert hashes to more convenient structures
-config = { server: { host: "example.com", port: 443 } }.to_ostruct
+# BEFORE
+config_hash = { server: { host: "example.com", port: 443 } }
+ServerConfig = Struct.new(:host, :port)
+Config = Struct.new(:server)
+config = Config.new(ServerConfig.new(config_hash[:server][:host], config_hash[:server][:port]))
+```
+
+```ruby
+# AFTER
+config = { server: { host: "example.com", port: 443 } }.to_struct
 config.server.host  # => "example.com"
+```
+
+*Methods used: [`to_struct`](https://itsthedevman.com/docs/everythingrb/Hash.html#to_struct-instance_method)*
 
-# Parse JSON directly to your preferred structure
-'{"user":{"name":"Alice"}}'.to_istruct.user.name  # => "Alice"
+Deep conversion to plain hashes is just as easy:
 
-# Deep conversion to plain hashes
+```ruby
+# BEFORE
+data = OpenStruct.new(user: Data.define(:name).new(name: "Bob"))
+result = {
+  user: {
+    name: data.user.name
+  }
+}
+```
+
+```ruby
+# AFTER
 data = OpenStruct.new(user: Data.define(:name).new(name: "Bob"))
 data.to_deep_h  # => {user: {name: "Bob"}}
 ```
 
-**Extensions:** `to_struct`, `to_ostruct`, `to_istruct`, `to_h`, `to_deep_h`
+*Methods used: [`to_deep_h`](https://itsthedevman.com/docs/everythingrb/OpenStruct.html#to_deep_h-instance_method)*
+
+**Extensions:** [`to_struct`](https://itsthedevman.com/docs/everythingrb/Hash.html#to_struct-instance_method), [`to_ostruct`](https://itsthedevman.com/docs/everythingrb/Hash.html#to_ostruct-instance_method), [`to_istruct`](https://itsthedevman.com/docs/everythingrb/Hash.html#to_istruct-instance_method), [`to_h`](https://itsthedevman.com/docs/everythingrb/String.html#to_h-instance_method), [`to_deep_h`](https://itsthedevman.com/docs/everythingrb/Hash.html#to_deep_h-instance_method)
 
 ### Collection Processing
 
-Extract and transform data elegantly:
+Extract and transform data with elegant, expressive code:
 
 ```ruby
-# Extract data from arrays of hashes in one step
+# BEFORE
 users = [{ name: "Alice", roles: ["admin"] }, { name: "Bob", roles: ["user"] }]
+names = users.map { |user| user[:name] }
+# => ["Alice", "Bob"]
+```
+
+```ruby
+# AFTER
 users.key_map(:name)  # => ["Alice", "Bob"]
-users.dig_map(:roles, 0)  # => ["admin", "user"]
+```
+
+*Methods used: [`key_map`](https://itsthedevman.com/docs/everythingrb/Array.html#key_map-instance_method)*
+
+Simplify nested data extraction:
+
+```ruby
+# BEFORE
+users = [
+  {user: {profile: {name: "Alice"}}},
+  {user: {profile: {name: "Bob"}}}
+]
+names = users.map { |u| u.dig(:user, :profile, :name) }
+# => ["Alice", "Bob"]
+```
+
+```ruby
+# AFTER
+users.dig_map(:user, :profile, :name)  # => ["Alice", "Bob"]
+```
+
+*Methods used: [`dig_map`](https://itsthedevman.com/docs/everythingrb/Array.html#dig_map-instance_method)*
 
-# Filter, map, and join in a single operation
+Combine filter, map, and join operations in one step:
+
+```ruby
+# BEFORE
+data = [1, 2, nil, 3, 4]
+result = data.compact.filter_map { |n| "Item #{n}" if n.odd? }.join(" | ")
+# => "Item 1 | Item 3"
+```
+
+```ruby
+# AFTER
 [1, 2, nil, 3, 4].join_map(" | ") { |n| "Item #{n}" if n&.odd? }
 # => "Item 1 | Item 3"
+```
 
-# Group elements by key or nested keys
-users.group_by_key(:roles, 0)
-# => {"admin" => [{name: "Alice", roles: ["admin"]}], "user" => [{name: "Bob", roles: ["user"]}]}
+*Methods used: [`join_map`](https://itsthedevman.com/docs/everythingrb/Array.html#join_map-instance_method)*
 
-# With ActiveSupport loaded, join arrays in natural language with "or"
-["red", "blue", "green"].to_or_sentence  # => "red, blue, or green"
+Group elements with natural syntax:
+
+```ruby
+# BEFORE
+users = [
+  {name: "Alice", department: {name: "Engineering"}},
+  {name: "Bob", department: {name: "Sales"}},
+  {name: "Charlie", department: {name: "Engineering"}}
+]
+users.group_by { |user| user[:department][:name] }
+# => {"Engineering"=>[{name: "Alice",...}, {name: "Charlie",...}], "Sales"=>[{name: "Bob",...}]}
 ```
 
-**Extensions:** `join_map`, `key_map`, `dig_map`, `to_or_sentence`, `group_by_key`
+```ruby
+# AFTER
+users.group_by_key(:department, :name)
+# => {"Engineering"=>[{name: "Alice",...}, {name: "Charlie",...}], "Sales"=>[{name: "Bob",...}]}
+```
 
-### Object Protection
+*Methods used: [`group_by_key`](https://itsthedevman.com/docs/everythingrb/Enumerable.html#group_by_key-instance_method)*
 
-Prevent unwanted modifications with a single call:
+Create natural language lists:
 
 ```ruby
-config = {
-  api: {
-    key: "secret",
-    endpoints: ["v1", "v2"]
-  }
-}.deep_freeze
+# BEFORE
+options = ["red", "blue", "green"]
+# The default to_sentence uses "and"
+options.to_sentence  # => "red, blue, and green"
+
+# Need "or" instead? Time for string surgery
+if options.size <= 2
+  options.to_sentence(words_connector: " or ")
+else
+  # Replace the last "and" with "or" - careful with i18n!
+  options.to_sentence.sub(/,?\s+and\s+/, ", or ")
+end
+# => "red, blue, or green"
+```
 
-# Everything is frozen!
-config.frozen?  # => true
-config[:api][:endpoints][0].frozen?  # => true
+```ruby
+# AFTER
+["red", "blue", "green"].to_or_sentence  # => "red, blue, or green"
 ```
 
-**Extensions:** `deep_freeze`
+*Methods used: [`to_or_sentence`](https://itsthedevman.com/docs/everythingrb/Array.html#to_or_sentence-instance_method)*
+
+**Extensions:** [`join_map`](https://itsthedevman.com/docs/everythingrb/Array.html#join_map-instance_method), [`key_map`](https://itsthedevman.com/docs/everythingrb/Array.html#key_map-instance_method), [`dig_map`](https://itsthedevman.com/docs/everythingrb/Array.html#dig_map-instance_method), [`to_or_sentence`](https://itsthedevman.com/docs/everythingrb/Array.html#to_or_sentence-instance_method), [`group_by_key`](https://itsthedevman.com/docs/everythingrb/Enumerable.html#group_by_key-instance_method)
 
 ### Hash Convenience
 
 Work with hashes more intuitively:
 
 ```ruby
-# Create deeply nested structures without initialization
-stats = Hash.new_nested_hash
+# BEFORE
+stats = {}
+stats[:server] ||= {}
+stats[:server][:region] ||= {}
+stats[:server][:region][:us_east] ||= {}
+stats[:server][:region][:us_east][:errors] ||= []
 stats[:server][:region][:us_east][:errors] << "Connection timeout"
+```
+
+```ruby
+# AFTER
+stats = Hash.new_nested_hash(depth: 3)
+(stats[:server][:region][:us_east][:errors] ||= []) << "Connection timeout"
 # No need to initialize each level first!
+```
+
+*Methods used: [`new_nested_hash`](https://itsthedevman.com/docs/everythingrb/Hash.html#new_nested_hash-class_method)*
+
+Transform values with access to their keys:
+
+```ruby
+# BEFORE
+users = {alice: {name: "Alice"}, bob: {name: "Bob"}}
+result = {}
+users.each do |key, value|
+  result[key] = "User #{key}: #{value[:name]}"
+end
+# => {alice: "User alice: Alice", bob: "User bob: Bob"}
+```
 
-# Transform values with access to keys
+```ruby
+# AFTER
 users.transform_values(with_key: true) { |v, k| "User #{k}: #{v[:name]}" }
+# => {alice: "User alice: Alice", bob: "User bob: Bob"}
+```
+
+*Methods used: [`transform_values(with_key: true)`](https://itsthedevman.com/docs/everythingrb/Hash.html#transform_values-instance_method)*
+
+Find values based on conditions:
+
+```ruby
+# BEFORE
+users = {
+  alice: {name: "Alice", role: "admin"},
+  bob: {name: "Bob", role: "user"},
+  charlie: {name: "Charlie", role: "admin"}
+}
+admins = users.select { |_k, v| v[:role] == "admin" }.values
+# => [{name: "Alice", role: "admin"}, {name: "Charlie", role: "admin"}]
+```
+
+```ruby
+# AFTER
+users.values_where { |_k, v| v[:role] == "admin" }
+# => [{name: "Alice", role: "admin"}, {name: "Charlie", role: "admin"}]
+```
+
+*Methods used: [`values_where`](https://itsthedevman.com/docs/everythingrb/Hash.html#values_where-instance_method)*
+
+Just want the first match? Even simpler:
+
+```ruby
+# BEFORE
+users.find { |_k, v| v[:role] == "admin" }&.last
+# => {name: "Alice", role: "admin"}
+```
+
+```ruby
+# AFTER
+users.value_where { |_k, v| v[:role] == "admin" }
+# => {name: "Alice", role: "admin"}
+```
+
+*Methods used: [`value_where`](https://itsthedevman.com/docs/everythingrb/Hash.html#value_where-instance_method)*
 
-# Find values based on conditions
-users.value_where { |_k, v| v[:role] == "admin" }  # Returns first admin
-users.values_where { |_k, v| v[:role] == "admin" } # Returns all admins
+Rename keys while preserving order:
 
-# Rename keys while preserving order
+```ruby
+# BEFORE
+config = {api_key: "secret", timeout: 30}
+new_config = config.each_with_object({}) do |(key, value), hash|
+  new_key =
+    case key
+    when :api_key
+      :key
+    when :timeout
+      :request_timeout
+    else
+      key
+    end
+
+  hash[new_key] = value
+end
+# => {key: "secret", request_timeout: 30}
+```
+
+```ruby
+# AFTER
 config = {api_key: "secret", timeout: 30}
 config.rename_keys(api_key: :key, timeout: :request_timeout)
 # => {key: "secret", request_timeout: 30}
+```
+
+*Methods used: [`rename_keys`](https://itsthedevman.com/docs/everythingrb/Hash.html#rename_keys-instance_method)*
+
+Filter hash by values:
 
-# Filter hash by values
+```ruby
+# BEFORE
+result = {a: 1, b: nil, c: 2}.select { |_k, v| v.is_a?(Integer) && v > 1 }
+# => {c: 2}
+```
+
+```ruby
+# AFTER
 {a: 1, b: nil, c: 2}.select_values { |v| v.is_a?(Integer) && v > 1 }
 # => {c: 2}
 ```
 
-**Extensions:** `new_nested_hash`, `with_key`, `value_where`, `values_where`, `rename_key(s)`, `select_values`, `reject_values`
+*Methods used: [`select_values`](https://itsthedevman.com/docs/everythingrb/Hash.html#select_values-instance_method)*
+
+Conditionally merge hashes with clear intent:
+
+```ruby
+# BEFORE
+user_params = {name: "Alice", role: "user"}
+filtered = {verified: true, admin: true}.select { |k, v| v == true && k == :verified }
+user_params.merge(filtered)
+# => {name: "Alice", role: "user", verified: true}
+```
+
+```ruby
+# AFTER
+user_params = {name: "Alice", role: "user"}
+user_params.merge_if(verified: true, admin: true) { |k, v| v == true && k == :verified }
+# => {name: "Alice", role: "user", verified: true}
+```
+
+*Methods used: [`merge_if`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_if-instance_method)*
+
+The nil-filtering pattern we've all written dozens of times:
+
+```ruby
+# BEFORE
+params = {sort: "created_at"}
+filtered = {filter: "active", search: nil}.compact
+params.merge(filtered)
+# => {sort: "created_at", filter: "active"}
+```
+
+```ruby
+# AFTER
+params = {sort: "created_at"}
+params.merge_compact(filter: "active", search: nil)
+# => {sort: "created_at", filter: "active"}
+```
+
+*Methods used: [`merge_compact`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_compact-instance_method)*
+
+**Extensions:** [`new_nested_hash`](https://itsthedevman.com/docs/everythingrb/Hash.html#new_nested_hash-class_method), [`transform_values(with_key: true)`](https://itsthedevman.com/docs/everythingrb/Hash.html#transform_values-instance_method), [`value_where`](https://itsthedevman.com/docs/everythingrb/Hash.html#value_where-instance_method), [`values_where`](https://itsthedevman.com/docs/everythingrb/Hash.html#values_where-instance_method), [`rename_key`](https://itsthedevman.com/docs/everythingrb/Hash.html#rename_key-instance_method), [`rename_keys`](https://itsthedevman.com/docs/everythingrb/Hash.html#rename_keys-instance_method), [`select_values`](https://itsthedevman.com/docs/everythingrb/Hash.html#select_values-instance_method), [`reject_values`](https://itsthedevman.com/docs/everythingrb/Hash.html#reject_values-instance_method), [`merge_if`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_if-instance_method), [`merge_if!`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_if%21-instance_method), [`merge_if_values`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_if_values-instance_method), [`merge_if_values!`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_if_values%21-instance_method), [`merge_compact`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_compact-instance_method), [`merge_compact!`](https://itsthedevman.com/docs/everythingrb/Hash.html#merge_compact%21-instance_method)
 
 ### Array Cleaning
 
 Clean up array boundaries while preserving internal structure:
 
 ```ruby
-# Remove nil values from the beginning/end
+# BEFORE
+data = [nil, nil, 1, nil, 2, nil, nil]
+data.drop_while(&:nil?).reverse.drop_while(&:nil?).reverse
+# => [1, nil, 2]
+```
+
+```ruby
+# AFTER
 [nil, nil, 1, nil, 2, nil, nil].trim_nils  # => [1, nil, 2]
+```
+
+*Methods used: [`trim_nils`](https://itsthedevman.com/docs/everythingrb/Array.html#trim_nils-instance_method)*
+
+With ActiveSupport, remove blank values too:
+
+```ruby
+# BEFORE
+data = [nil, "", 1, "", 2, nil, ""]
+data.drop_while(&:blank?).reverse.drop_while(&:blank?).reverse
+# => [1, "", 2]
+```
 
-# With ActiveSupport, remove blank values
+```ruby
+# AFTER
 [nil, "", 1, "", 2, nil, ""].trim_blanks  # => [1, "", 2]
 ```
 
-**Extensions:** `trim_nils`, `compact_prefix`, `compact_suffix`, `trim_blanks` (with ActiveSupport)
+*Methods used: [`trim_blanks`](https://itsthedevman.com/docs/everythingrb/Array.html#trim_blanks-instance_method)*
+
+**Extensions:** [`trim_nils`](https://itsthedevman.com/docs/everythingrb/Array.html#trim_nils-instance_method), [`compact_prefix`](https://itsthedevman.com/docs/everythingrb/Array.html#compact_prefix-instance_method), [`compact_suffix`](https://itsthedevman.com/docs/everythingrb/Array.html#compact_suffix-instance_method), [`trim_blanks`](https://itsthedevman.com/docs/everythingrb/Array.html#trim_blanks-instance_method) (with ActiveSupport)
 
 ### String Formatting
 
-Add quotation marks to any value with a consistent interface - useful for user messages, formatting, and more:
+Format strings and other values consistently:
 
 ```ruby
-# Wrap any value in quotes - works on ALL types!
+# BEFORE
+def format_value(value)
+  case value
+  when String
+    "\"#{value}\""
+  when Symbol
+    "\"#{value}\""
+  when Numeric
+    "\"#{value}\""
+  when NilClass
+    "\"nil\""
+  when Array, Hash
+    "\"#{value.inspect}\""
+  else
+    "\"#{value}\""
+  end
+end
+
+selection = nil
+message = "You selected #{format_value(selection)}"
+```
+
+```ruby
+# AFTER
 "hello".in_quotes      # => "\"hello\""
 42.in_quotes           # => "\"42\""
 nil.in_quotes          # => "\"nil\""
@@ -203,28 +504,61 @@ nil.in_quotes          # => "\"nil\""
 [1, 2].in_quotes       # => "\"[1, 2]\""
 Time.now.in_quotes     # => "\"2025-05-04 12:34:56 +0000\""
 
-# Perfect for user-facing messages with mixed types
-puts "You selected #{selection.in_quotes}"
-puts "Item #{id.in_quotes} was added to category #{category.in_quotes}"
+message = "You selected #{selection.in_quotes}"
+```
+
+*Methods used: [`in_quotes`](https://itsthedevman.com/docs/everythingrb/Everythingrb/InspectQuotable.html#in_quotes-instance_method), [`with_quotes`](https://itsthedevman.com/docs/everythingrb/Everythingrb/InspectQuotable.html#with_quotes-instance_method)*
+
+Convert strings to camelCase with ease:
 
-# Great for formatting responses
-response = "Command #{command.in_quotes} completed successfully"
+```ruby
+# BEFORE
+name = "user_profile_settings"
+pascal_case = name.gsub(/[-_\s]+([a-z])/i) { $1.upcase }.gsub(/[-_\s]/, '')
+pascal_case[0].upcase!
+pascal_case
+# => "UserProfileSettings"
+
+camel_case = name.gsub(/[-_\s]+([a-z])/i) { $1.upcase }.gsub(/[-_\s]/, '')
+camel_case[0].downcase!
+camel_case
+# => "userProfileSettings"
+```
 
-# Ideal for error messages and logging
-log.info "Received values: #{values.join_map(", ", &:in_quotes)}"
-raise "Expected #{expected.in_quotes} but got #{actual.in_quotes}"
+```ruby
+# AFTER
+"user_profile_settings".to_camelcase       # => "UserProfileSettings"
+"user_profile_settings".to_camelcase(:lower)  # => "userProfileSettings"
 
-# CLI argument descriptions
-puts "Valid modes are: #{MODES.join_map(", ", &:in_quotes)}"
+# Handles all kinds of input consistently
+"please-WAIT while_loading...".to_camelcase  # => "PleaseWaitWhileLoading"
 ```
 
-**Extensions:** `in_quotes`, `with_quotes` (alias)
+*Methods used: [`to_camelcase`](https://itsthedevman.com/docs/everythingrb/String.html#to_camelcase-instance_method)*
+
+**Extensions:** [`in_quotes`](https://itsthedevman.com/docs/everythingrb/Everythingrb/InspectQuotable.html#in_quotes-instance_method), [`with_quotes`](https://itsthedevman.com/docs/everythingrb/Everythingrb/InspectQuotable.html#with_quotes-instance_method) (alias), [`to_camelcase`](https://itsthedevman.com/docs/everythingrb/String.html#to_camelcase-instance_method)
 
 ### Boolean Methods
 
 Create predicate methods with minimal code:
 
 ```ruby
+# BEFORE
+class User
+  attr_accessor :admin
+
+  def admin?
+    !!@admin
+  end
+end
+
+user = User.new
+user.admin = true
+user.admin?  # => true
+```
+
+```ruby
+# AFTER
 class User
   attr_accessor :admin
   attr_predicate :admin
@@ -233,8 +567,21 @@ end
 user = User.new
 user.admin = true
 user.admin?  # => true
+```
+
+*Methods used: [`attr_predicate`](https://itsthedevman.com/docs/everythingrb/Module.html#attr_predicate-instance_method)*
+
+Works with Data objects too:
+
+```ruby
+# BEFORE
+Person = Data.define(:active) do
+  def active?
+    !!active
+  end
+end
 
-# Works with Data objects too!
+# AFTER
 Person = Data.define(:active)
 Person.attr_predicate(:active)
 
@@ -242,21 +589,27 @@ person = Person.new(active: false)
 person.active? # => false
 ```
 
-**Extensions:** `attr_predicate`
+*Methods used: [`attr_predicate`](https://itsthedevman.com/docs/everythingrb/Module.html#attr_predicate-instance_method)*
+
+**Extensions:** [`attr_predicate`](https://itsthedevman.com/docs/everythingrb/Module.html#attr_predicate-instance_method)
 
 ### Value Transformation
 
 Chain transformations with a more descriptive syntax:
 
 ```ruby
-# Instead of this:
+# BEFORE
 result = value.then { |v| transform_it(v) }
+```
 
-# Write this:
+```ruby
+# AFTER
 result = value.morph { |v| transform_it(v) }
 ```
 
-**Extensions:** `morph` (alias for `then`/`yield_self`)
+*Methods used: [`morph`](https://itsthedevman.com/docs/everythingrb/Kernel.html#morph-instance_method)*
+
+**Extensions:** [`morph`](https://itsthedevman.com/docs/everythingrb/Kernel.html#morph-instance_method) (alias for `then`/`yield_self`)
 
 ## Full Documentation
 

data/lib/everythingrb/array.rb

@@ -6,7 +6,6 @@
 # Provides:
 # - #join_map: Combine filter_map and join operations in one step
 # - #key_map, #dig_map: Extract values from arrays of hashes
-# - #deep_freeze: Recursively freeze array and contents
 # - #compact_prefix, #compact_suffix, #trim_nils: Clean up array boundaries
 # - ActiveSupport integrations: #trim_blanks and more when ActiveSupport is loaded
 #
@@ -75,34 +74,17 @@ class Array
   # @return [Array] Array of nested values
   #
   # @example
-  #   [
+  #   users = [
   #     {user: {profile: {name: "Alice"}}},
   #     {user: {profile: {name: "Bob"}}}
-  #   ].dig_map(:user, :profile, :name)
+  #   ]
+  #   users.dig_map(:user, :profile, :name)
   #   # => ["Alice", "Bob"]
   #
   def dig_map(*keys)
     map { |v| v.dig(*keys) }
   end
 
-  #
-  # Recursively freezes self and all of its contents
-  #
-  # @return [self] Returns the frozen array
-  #
-  # @example Freeze an array with nested structures
-  #   ["hello", { name: "Alice" }, [1, 2, 3]].deep_freeze
-  #   # => All elements and nested structures are now frozen
-  #
-  # @note CAUTION: Be careful when freezing collections that contain class objects
-  #   or singleton instances - this will freeze those classes/objects globally!
-  #   Only use deep_freeze on pure data structures you want to make immutable.
-  #
-  def deep_freeze
-    each { |v| v.respond_to?(:deep_freeze) ? v.deep_freeze : v.freeze }
-    freeze
-  end
-
   #
   # Removes nil values from the beginning of an array
   #

data/lib/everythingrb/data.rb

@@ -13,6 +13,10 @@ class Data
   #
   # Recursively converts the Data object and all nested objects to hashes
   #
+  # This method traverses the entire Data structure, converting not just
+  # the top-level Data object but also nested Data objects, Structs, OpenStructs,
+  # and any other objects that implement `to_h`.
+  #
   # @return [Hash] A deeply converted hash of the Data object
   #
   # @example

data/lib/everythingrb/enumerable.rb

@@ -4,8 +4,8 @@
 # Extensions to Ruby's core Enumerable module
 #
 # Provides:
-# - #join_map: Combine filter_map and join operations
-# - #group_by_key: Group elements by a given key or nested keys
+# - #join_map: Combine filter_map and join operations into one step
+# - #group_by_key: Group elements by key or nested keys, simplifying collection organization
 #
 # @example
 #   require "everythingrb/enumerable"
@@ -24,6 +24,7 @@ module Enumerable
   # @yieldparam index [Integer] The index of the current element (only if with_index: true)
   #
   # @return [String] Joined string of filtered and transformed elements
+  # @return [Enumerator] If no block is given
   #
   # @example Without index
   #   [1, 2, nil, 3].join_map(" ") { |n| n&.to_s if n&.odd? }
@@ -57,6 +58,7 @@ module Enumerable
   # @yieldreturn [Object] The transformed value to use as the group key
   #
   # @return [Hash] A hash where keys are the grouped values and values are arrays of elements
+  # @return [Enumerator] If no block is given
   #
   # @example Group by a single key
   #   users = [

data/lib/everythingrb/extensions/quotable.rb

@@ -29,14 +29,17 @@ module Everythingrb
   # Adds quotable functionality using inspect representation
   #
   # Provides methods for wrapping an object's inspection
-  # representation in double quotes for debugging and error messages.
+  # representation in double quotes.
   #
   # @example
   #   [1, 2, 3].in_quotes  # => "\"[1, 2, 3]\""
   #
   module InspectQuotable
     #
-    # Returns the object's inspection representation wrapped in double quotes
+    # Adds quotable functionality using inspect representation
+    #
+    # Provides methods for wrapping an object's inspection
+    # representation in double quotes.
     #
     # @return [String] The object's inspect representation surrounded by double quotes
     #
@@ -55,7 +58,7 @@ module Everythingrb
   # Adds quotable functionality using to_s representation
   #
   # Provides methods for wrapping an object's string
-  # representation in double quotes for cleaner output.
+  # representation in double quotes.
   #
   # @example
   #   Time.now.in_quotes  # => "\"2025-05-03 12:34:56 -0400\""

data/lib/everythingrb/hash.rb

@@ -6,12 +6,14 @@
 # Provides:
 # - #to_struct, #to_ostruct, #to_istruct: Convert hashes to different structures
 # - #join_map: Combine filter_map and join operations
-# - #deep_freeze: Recursively freeze hash and contents
 # - #transform_values.with_key: Transform values with access to keys
 # - #transform, #transform!: Transform keys and values
 # - #value_where, #values_where: Find values based on conditions
 # - #rename_key, #rename_keys: Rename hash keys while preserving order
 # - ::new_nested_hash: Create automatically nesting hashes
+# - #merge_if, #merge_if!: Conditionally merge based on key-value pairs
+# - #merge_if_values, #merge_if_values!: Conditionally merge based on values
+# - #merge_compact, #merge_compact!: Merge only non-nil values
 #
 # @example
 #   require "everythingrb/hash"
@@ -48,6 +50,10 @@ class Hash
   #
   # @return [Hash] A hash that creates nested hashes for missing keys
   #
+  # @note This implementation is not thread-safe for concurrent modifications of deeply
+  #   nested structures. If you need thread safety, consider using a mutex when modifying
+  #   the deeper levels of the hash.
+  #
   # @example Unlimited nesting (default behavior)
   #   users = Hash.new_nested_hash
   #   users[:john][:role] = "admin"  # No need to initialize users[:john] first
@@ -115,7 +121,7 @@ class Hash
   # and calls #to_h on any object that responds to it. Useful for
   # normalizing nested data structures and parsing nested JSON.
   #
-  # @return [Hash] A deeply converted hash with all nested objects converted
+  # @return [Hash] A deeply converted hash with all nested objects
   #
   # @example Converting nested Data objects
   #   user = { name: "Alice", metadata: Data.define(:source).new(source: "API") }
@@ -235,28 +241,10 @@ class Hash
     OpenStruct.new(**transform_values { |value| recurse.call(value) })
   end
 
-  #
-  # Recursively freezes self and all of its values
-  #
-  # @return [self] Returns the frozen hash
-  #
-  # @example
-  #   { user: { name: "Alice", roles: ["admin"] } }.deep_freeze
-  #   # => Hash and all nested structures are now frozen
-  #
-  # @note CAUTION: Be careful when freezing collections that contain class objects
-  #   or singleton instances - this will freeze those classes/objects globally!
-  #   Only use deep_freeze on pure data structures you want to make immutable.
-  #
-  def deep_freeze
-    each_value { |v| v.respond_to?(:deep_freeze) ? v.deep_freeze : v.freeze }
-    freeze
-  end
-
-  # Allows calling original method. See below
+  # @!visibility private
   alias_method :og_transform_values, :transform_values
 
-  # Allows calling original method. See below
+  # @!visibility private
   alias_method :og_transform_values!, :transform_values!
 
   #
@@ -335,10 +323,10 @@ class Hash
 
   # ActiveSupport integrations
   if defined?(ActiveSupport)
-    # Allows calling original method. See below
+    # @!visibility private
     alias_method :og_deep_transform_values, :deep_transform_values
 
-    # Allows calling original method. See below
+    # @!visibility private
     alias_method :og_deep_transform_values!, :deep_transform_values!
 
     #
@@ -761,4 +749,141 @@ class Hash
 
     reject! { |_k, v| block.call(v) }
   end
+
+  #
+  # Conditionally merges key-value pairs from another hash based on a block
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @yield [key, value] Block that determines whether to include each key-value pair
+  # @yieldparam key [Object] The key from the other hash
+  # @yieldparam value [Object] The value from the other hash
+  # @yieldreturn [Boolean] Whether to include this key-value pair
+  #
+  # @return [Hash] A new hash with conditionally merged key-value pairs
+  #
+  # @example Merge only even-numbered keys
+  #   {a: 1, b: 2}.merge_if(c: 3, d: 4) { |key, _| key.to_s.ord.even? }
+  #   # => {a: 1, b: 2, d: 4}
+  #
+  # @example Merge only positive values
+  #   {a: 1, b: 2}.merge_if(c: 3, d: -4) { |_, value| value > 0 }
+  #   # => {a: 1, b: 2, c: 3}
+  #
+  def merge_if(other = {}, &block)
+    other = other.select(&block) unless block.nil?
+
+    merge(other)
+  end
+
+  #
+  # Conditionally merges key-value pairs from another hash in place
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @yield [key, value] Block that determines whether to include each key-value pair
+  # @yieldparam key [Object] The key from the other hash
+  # @yieldparam value [Object] The value from the other hash
+  # @yieldreturn [Boolean] Whether to include this key-value pair
+  #
+  # @return [self] The modified hash
+  #
+  # @example Merge only even-numbered keys in place
+  #   hash = {a: 1, b: 2}
+  #   hash.merge_if!(c: 3, d: 4) { |key, _| key.to_s.ord.even? }
+  #   # => {a: 1, b: 2, d: 4}
+  #
+  def merge_if!(other = {}, &block)
+    other = other.select(&block) unless block.nil?
+
+    merge!(other)
+  end
+
+  #
+  # Conditionally merges key-value pairs based only on values
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @yield [value] Block that determines whether to include each value
+  # @yieldparam value [Object] The value from the other hash
+  # @yieldreturn [Boolean] Whether to include this value
+  #
+  # @return [Hash] A new hash with conditionally merged values
+  #
+  # @example Merge only string values
+  #   {a: 1, b: "old"}.merge_if_values(c: "new", d: 2) { |v| v.is_a?(String) }
+  #   # => {a: 1, b: "old", c: "new"}
+  #
+  def merge_if_values(other = {}, &block)
+    merge_if(other) { |k, v| block.call(v) }
+  end
+
+  #
+  # Conditionally merges key-value pairs based only on values, in place
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @yield [value] Block that determines whether to include each value
+  # @yieldparam value [Object] The value from the other hash
+  # @yieldreturn [Boolean] Whether to include this value
+  #
+  # @return [self] The modified hash
+  #
+  # @example Merge only numeric values in place
+  #   hash = {a: 1, b: "text"}
+  #   hash.merge_if_values!(c: "ignore", d: 2) { |v| v.is_a?(Numeric) }
+  #   # => {a: 1, b: "text", d: 2}
+  #
+  def merge_if_values!(other = {}, &block)
+    merge_if!(other) { |k, v| block.call(v) }
+  end
+
+  #
+  # Merges only non-nil values from another hash
+  #
+  # This is a convenience method for the common pattern of merging
+  # only values that are not nil.
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @return [Hash] A new hash with non-nil values merged
+  #
+  # @example Merge only non-nil values (common when building parameters)
+  #   user_id = 42
+  #   email = nil
+  #   name = "Alice"
+  #
+  #   {}.merge_compact(
+  #     id: user_id,
+  #     email: email,
+  #     name: name
+  #   )
+  #   # => {id: 42, name: "Alice"}
+  #
+  def merge_compact(other = {})
+    merge_if_values(other, &:itself)
+  end
+
+  #
+  # Merges only non-nil values from another hash, in place
+  #
+  # This is a convenience method for the common pattern of merging
+  # only values that are not nil.
+  #
+  # @param other [Hash] The hash to merge from
+  #
+  # @return [self] The modified hash
+  #
+  # @example Merge only non-nil values in place
+  #   params = {format: "json"}
+  #   params.merge_compact!(
+  #     page: 1,
+  #     per_page: nil,
+  #     sort: "created_at"
+  #   )
+  #   # => {format: "json", page: 1, sort: "created_at"}
+  #
+  def merge_compact!(other = {})
+    merge_if_values!(other, &:itself)
+  end
 end

data/lib/everythingrb/kernel.rb

@@ -9,7 +9,11 @@
 # @example
 #   require "everythingrb/kernel"
 #
-#   version.get_info.morph { |v| "#{v.major}.#{v.minor}" }
+#   # Instead of:
+#   config.fetch(:key).then { |v| process(v) }
+#
+#   # More expressive with morph:
+#   config.fetch(:key).morph { |v| process(v) }
 #
 module Kernel
   #

data/lib/everythingrb/nil.rb

@@ -7,7 +7,7 @@
 # - #in_quotes, #with_quotes: Wrap nil's string representation in quotes
 #
 # @example
-#   require "everythingrb/extensions/nil_class"
+#   require "everythingrb/nil"
 #   nil.in_quotes  # => "\"nil\""
 #
 class NilClass

data/lib/everythingrb/ostruct.rb

@@ -26,6 +26,8 @@ class OpenStruct
     #
     # @return [Boolean] true if the OpenStruct has no attributes
     #
+    # @note Only available when ActiveSupport is loaded
+    #
     def blank?
       @table.blank?
     end
@@ -33,7 +35,9 @@ class OpenStruct
     #
     # Checks if the OpenStruct has any attributes
     #
-    # @return [Boolean] true if the OpenStruct has attributes
+    # @return [Boolean] true if the OpenStruct has any attributes
+    #
+    # @note Only available when ActiveSupport is loaded
     #
     def present?
       @table.present?
@@ -117,6 +121,9 @@ class OpenStruct
   #
   # Recursively converts the OpenStruct and all nested objects to hashes
   #
+  # This method will convert the OpenStruct and all nested OpenStructs,
+  # Structs, Data objects, and other convertible objects to plain hashes.
+  #
   # @return [Hash] A deeply converted hash of the OpenStruct
   #
   # @example

data/lib/everythingrb/range.rb

@@ -12,6 +12,9 @@
 #   (1..5).in_quotes     # => "\"1..5\""
 #   ('a'..'z').in_quotes # => "\"a..z\""
 #
+#   # Helpful in error messages:
+#   raise "Expected value in #{valid_range.in_quotes}"
+#
 class Range
   include Everythingrb::InspectQuotable
 end

data/lib/everythingrb/regexp.rb

@@ -11,6 +11,9 @@
 #
 #   /\d+/.in_quotes  # => "\"/\\d+/\""
 #
+#   # Useful in debugging output:
+#   puts "Pattern used: #{pattern.in_quotes}"
+#
 class Regexp
   include Everythingrb::InspectQuotable
 end

data/lib/everythingrb/string.rb

@@ -8,12 +8,14 @@
 # - #to_deep_h: Recursively parse nested JSON strings
 # - #to_ostruct, #to_istruct, #to_struct: Convert JSON to data structures
 # - #with_quotes, #in_quotes: Wrap strings in quotes
+# - #to_camelcase: Convert strings to camelCase or PascalCase
 #
 # @example
 #   require "everythingrb/string"
 #
 #   '{"user": {"name": "Alice"}}'.to_ostruct.user.name  # => "Alice"
 #   "Hello".with_quotes  # => "\"Hello\""
+#   "hello_world".to_camelcase  # => "HelloWorld"
 #
 class String
   include Everythingrb::StringQuotable
@@ -40,6 +42,10 @@ class String
   # Recursively attempts to parse string values as JSON
   #
   # @return [Hash] Deeply parsed hash with all nested JSON strings converted
+  # @return [nil] If the string is not valid JSON at the top level
+  #
+  # @note If nested JSON strings fail to parse, they remain as strings
+  #   rather than causing the entire operation to fail
   #
   # @example
   #   nested_json = '{
@@ -113,4 +119,44 @@ class String
   def to_struct
     to_h&.to_struct
   end
+
+  #
+  # Converts a string to camelCase or PascalCase
+  #
+  # Handles strings with spaces, hyphens, underscores, and special characters.
+  # - Hyphens and underscores are treated like spaces
+  # - Special characters and symbols are removed
+  # - Capitalizing each word (except the first if set)
+  #
+  # @param first_letter [Symbol] Whether the first letter should be uppercase (:upper)
+  #   or lowercase (:lower)
+  #
+  # @return [String] The camelCased string
+  #
+  # @example Convert a string to PascalCase (default)
+  #   "welcome to the jungle!".to_camelcase     # => "WelcomeToTheJungle"
+  #
+  # @example Convert a string to camelCase (lowercase first)
+  #   "welcome to the jungle!".to_camelcase(:lower)     # => "welcomeToTheJungle"
+  #
+  # @example With mixed formatting
+  #   "please-WAIT while_loading...".to_camelcase    # => "PleaseWaitWhileLoading"
+  #
+  # @see String#capitalize
+  # @see String#downcase
+  #
+  def to_camelcase(first_letter = :upper)
+    gsub(/[-_]/, " ") # Treat dash/underscore as new words so they are capitalized
+      .gsub(/[^a-zA-Z0-9\s]/, "") # Remove any special characters
+      .split(/\s+/) # Split by word (removes extra whitespace)
+      .map # Don't use `join_map(with_index: true)`, this is faster
+      .with_index do |word, index| # Convert the words
+        if index == 0 && first_letter == :lower
+          word.downcase
+        else
+          word.capitalize
+        end
+      end
+      .join # And join it back together
+  end
 end

data/lib/everythingrb/struct.rb

@@ -20,6 +20,10 @@ class Struct
   #
   # Recursively converts the Struct and all nested objects to hashes
   #
+  # This method traverses the entire Struct structure, converting not just
+  # the top-level Struct but also nested Structs, OpenStructs, Data objects,
+  # and any other objects that implement `to_h`.
+  #
   # @return [Hash] A deeply converted hash of the Struct
   #
   # @example

data/lib/everythingrb/time.rb

@@ -9,7 +9,10 @@
 # @example
 #   require "everythingrb/time"
 #
-#   Time.new(2025, 5, 3).in_quotes
+#   Time.new(2025, 5, 3).in_quotes  # => "\"2025-05-03 00:00:00 +0000\""
+#
+#   # Useful in formatted output:
+#   "Event created at #{Time.now.in_quotes}"
 #
 class Time
   include Everythingrb::StringQuotable

data/lib/everythingrb/version.rb

@@ -7,5 +7,5 @@
 #
 module Everythingrb
   # Current version of the everythingrb gem
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everythingrb
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Bryan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-05 00:00:00.000000000 Z
+date: 2025-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct