everythingrb 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 747441fc1a0c8be071a4465edb190dead79eea7195b66b262976e8ae91b6bc0f
-  data.tar.gz: 491c3bc6c22bc02495425fecfb51166c8982d86ad0eede1b10980e2bf040b705
+  metadata.gz: 320458b0c0e09c8556129b456eb191ff588a6b2277b5da46a5273dc36c4f3a50
+  data.tar.gz: 824f8c91fbe4749022a8a5f2caf6d6f76714a6d7faf747a4f25818342d5d5b39
 SHA512:
-  metadata.gz: f6605c462aeeb634fe3342a3befb424fe3a67f31059f486d4c835a3670192962a44f6237f51947629cbe1a27d7a21579c03a48f9c98e22f155821cdb62f1e8c1
-  data.tar.gz: e6d2ce8fca0b90b513c686dfc44f8010cfb2aca9cc3be84cdbd08c6fccbbac49727ffbe42805f5a0789496df7b3f68ace624b7c201b30f5ee5305be16af485fa
+  metadata.gz: ac7ed45151941a1e124372ebfb1394fb8176f4703bc903fa634d3672a251c8a4e497f8555bc1433848512d7e8edb04926c8a043420d3337041c7fc00e9e7eebd
+  data.tar.gz: b0d711b08f5ec75aa07ab009587784a926f2e5832a35037da89a96fa5d800a29e4e4b1c3beb81ba6b86b3d5821252aeda2ab2f124234f859af477cbeb186a8cb

data/CHANGELOG.md

@@ -23,6 +23,58 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [0.5.0] - 12025-04-17
+
+**BREAKING:**
+
+The parameter order in `Hash#transform_values.with_key` has been changed to yield `|value, key|` instead of `|key, value|` to maintain consistency with Ruby's standard enumeration methods like `each_with_index`.
+
+**Before:**
+```ruby
+hash.transform_values.with_key { |key, value| "#{key}: #{value}" }
+```
+
+**After:**
+```ruby
+hash.transform_values.with_key { |value, key| "#{key}: #{value}" }
+```
+
+This change aligns our method signatures with Ruby's conventions and matches our other methods like `join_map(with_index: true)` which yields `|value, index|`.
+
+### Added
+
+- Added `Hash#transform` and `Hash#transform!` for transforming a hash's keys and values at the same time.
+
+### Changed
+- Changed parameter order in `Hash#transform_values.with_key` to yield `|value, key|` instead of `|key, value|` for consistency with Ruby conventions.
+
+### Removed
+
+
+## [0.4.0] - 12025-04-11
+
+### Added
+
+- Added new `Hash` methods for renaming keys:
+  - `#rename_key` - Renames a key in the hash while preserving the original order of elements
+  - `#rename_key!` - Same as `#rename_key` but modifies the hash in place
+  - `#rename_keys` - Renames multiple keys in the hash while preserving the original order of elements
+  - `#rename_keys!` - Same as `#rename_keys` but modifies the hash in place
+  - `#rename_key_unordered` - Renames a key without preserving element order (faster operation)
+  - `#rename_key_unordered!` - Same as `#rename_key_unordered` but modifies the hash in place
+- Added `to_deep_h` to core Ruby classes for consistent deep hash conversion:
+  - `Struct#to_deep_h` - Recursively converts Struct objects and all nested values to hashes
+  - `OpenStruct#to_deep_h` - Recursively converts OpenStruct objects and all nested values to hashes
+  - `Data#to_deep_h` - Recursively converts Data objects and all nested values to hashes
+- Added `depth` parameter to `Hash.new_nested_hash` to control nesting behaviors
+
+### Changed
+
+- Reorganized internal file structure for better modularity with full backward compatibility
+- Updated documentation headers to each module file explaining available extensions
+
+### Removed
+
 ## [0.3.1] - 12025-04-09
 
 ### Added
@@ -74,7 +126,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added `Symbol#with_quotes` and `Symbol#in_quotes`
 
-
 ## [0.2.2] - 12025-03-03
 
 ### Added
@@ -94,7 +145,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Removed `Data` definition check for `to_istruct`
 
-
 ## [0.2.0] - 12025-02-17
 
 ### Added
@@ -119,7 +169,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Separated out tests that require `ActiveSupport` into their own test process. Files that end with `_active_support` will be tested separately with ActiveSupport loaded
 
-
 ## [0.1.1] - 12025-02-07
 
 ### Added
@@ -149,7 +198,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added alias `each` to `each_pair` in OpenStruct for better enumerable compatibility
 
-[unreleased]: https://github.com/itsthedevman/everythingrb/compare/v0.3.1...HEAD
+[unreleased]: https://github.com/itsthedevman/everythingrb/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/itsthedevman/everythingrb/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/itsthedevman/everythingrb/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/itsthedevman/everythingrb/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/itsthedevman/everythingrb/compare/v0.2.5...v0.3.0
 [0.2.5]: https://github.com/itsthedevman/everythingrb/compare/v0.2.4...v0.2.5

data/README.md

@@ -25,6 +25,53 @@ gem "everythingrb"
 gem install everythingrb
 ```
 
+## Usage
+
+There are two ways to use EverythingRB:
+
+### Load Everything (Default)
+
+The simplest approach - just require and go:
+
+```ruby
+require "everythingrb"
+
+# Now you have access to all extensions!
+users = [{name: "Alice"}, {name: "Bob"}]
+users.key_map(:name).join(", ")  # => "Alice, Bob"
+
+config = {server: {port: 443}}.to_ostruct
+config.server.port  # => 443
+```
+
+### Cherry-Pick Extensions
+
+If you only need specific extensions, you can load just what you want:
+
+```ruby
+require "everythingrb/prelude"  # Required base module
+require "everythingrb/array"    # Just Array extensions
+require "everythingrb/string"   # Just String extensions
+
+# Now you have access to only the extensions you loaded
+["a", "b"].join_map(" | ") { |s| s.upcase }  # => "A | B"
+'{"name": "Alice"}'.to_ostruct.name   # => "Alice"
+
+# But Hash extensions aren't loaded yet
+{}.to_ostruct  # => NoMethodError
+```
+
+Available modules:
+- `array`: Array extensions (join_map, key_map, etc.)
+- `data`: Data extensions (to_deep_h)
+- `enumerable`: Enumerable extensions (join_map, group_by_key)
+- `hash`: Hash extensions (to_ostruct, deep_freeze, etc.)
+- `module`: Extensions like attr_predicate
+- `ostruct`: OpenStruct extensions (map, join_map, etc.)
+- `string`: String extensions (to_h, to_ostruct, etc.)
+- `struct`: Struct extensions (to_deep_h)
+- `symbol`: Symbol extensions (with_quotes)
+
 ## What's Included
 
 EverythingRB extends Ruby's core classes with intuitive methods that simplify common patterns.

data/lib/everythingrb/all.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "array"
+require_relative "data"
+require_relative "enumerable"
+require_relative "hash"
+require_relative "module"
+require_relative "ostruct"
+require_relative "string"
+require_relative "struct"
+require_relative "symbol"

data/lib/everythingrb/{core/array.rb → array.rb}

@@ -3,18 +3,17 @@
 #
 # Extensions to Ruby's core Array class
 #
-# This module adds convenient mapping, joining, and freezing functionality
-# to all Arrays in your application.
+# 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
 #
-# @example Using the extensions
-#   numbers = [1, 2, nil, 3]
-#
-#   # Filter out nils and format odd numbers
-#   numbers.join_map(", ") { |n| "odd: #{n}" if n&.odd? }
-#   # => "odd: 1, odd: 3"
-#
-#   users = [{name: "Alice", role: "admin"}, {name: "Bob", role: "user"}]
-#   users.key_map(:name)    # => ["Alice", "Bob"]
+# @example
+#   require "everythingrb/array"
+#   ["foo", nil, "bar"].join_map(", ") { |s| s&.upcase }  # => "FOO, BAR"
+#   [{name: "Alice"}, {name: "Bob"}].key_map(:name)  # => ["Alice", "Bob"]
 #
 class Array
   #

data/lib/everythingrb/data.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+#
+# Extensions to Ruby's core Data class
+#
+# Provides:
+# - #to_deep_h: Recursively convert to hash with all nested objects
+#
+class Data
+  #
+  # Recursively converts the Data object and all nested objects to hashes
+  #
+  # @return [Hash] A deeply converted hash of the Data object
+  #
+  # @example
+  #   Person = Data.define(:name, :profile)
+  #   person = Person.new(name: "Alice", profile: {roles: ["admin"]})
+  #   person.to_deep_h  # => {name: "Alice", profile: {roles: ["admin"]}}
+  #
+  def to_deep_h
+    to_h.to_deep_h
+  end
+end

data/lib/everythingrb/{core/enumerable.rb → enumerable.rb}

@@ -3,12 +3,14 @@
 #
 # Extensions to Ruby's core Enumerable module
 #
-# These additions make working with any enumerable collection more expressive
-# by combining common operations into convenient methods.
+# Provides:
+# - #join_map: Combine filter_map and join operations
+# - #group_by_key: Group elements by a given key or nested keys
 #
-# @example Using join_map with a Range
-#   (1..5).join_map(" | ") { |n| "item-#{n}" if n.even? }
-#   # => "item-2 | item-4"
+# @example
+#   require "everythingrb/enumerable"
+#   (1..5).join_map(" | ") { |n| "item-#{n}" if n.even? }  # => "item-2 | item-4"
+#   users.group_by_key(:role)  # Groups users by their role
 #
 module Enumerable
   #

data/lib/everythingrb/{core/hash.rb → hash.rb}

@@ -3,17 +3,20 @@
 #
 # Extensions to Ruby's core Hash class
 #
-# These additions make working with hashes more convenient by adding
-# conversion methods to different data structures and string formatting helpers.
+# 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
 #
-# @example Converting to different structures
-#   user = { name: "Alice", roles: ["admin"] }
-#   user.to_struct    # => #<struct name="Alice", roles=["admin"]>
-#   user.to_ostruct   # => #<OpenStruct name="Alice", roles=["admin"]>
-#
-#   # Filtering and joining hash entries
-#   { a: 1, b: nil, c: 3 }.join_map(", ") { |k, v| "#{k}:#{v}" if v }
-#   # => "a:1, c:3"
+# @example
+#   require "everythingrb/hash"
+#   config = {server: {port: 443}}.to_ostruct
+#   config.server.port  # => 443
 #
 class Hash
   #
@@ -33,26 +36,49 @@ class Hash
   # Creates a new Hash that automatically initializes missing keys with nested hashes
   #
   # This method creates a hash where any missing key access will automatically
-  # create another nested hash with the same behavior, allowing for unlimited
-  # nesting depth without explicit initialization.
+  # create another nested hash with the same behavior. You can control the nesting
+  # depth with the depth parameter.
+  #
+  # @param depth [Integer, nil] The maximum nesting depth for automatic hash creation
+  #   When nil (default), creates unlimited nesting depth
+  #   When 0, behaves like a regular hash (returns nil for missing keys)
+  #   When > 0, automatically creates hashes only up to the specified level
   #
-  # @return [Hash] A hash that recursively creates nested hashes for missing keys
+  # @return [Hash] A hash that creates nested hashes for missing keys
   #
-  # @example Basic usage with two levels
+  # @example Unlimited nesting (default behavior)
   #   users = Hash.new_nested_hash
   #   users[:john][:role] = "admin"  # No need to initialize users[:john] first
   #   users # => {john: {role: "admin"}}
   #
   # @example Deep nesting without initialization
   #   stats = Hash.new_nested_hash
-  #   (stats[:server][:region][:us_east][:errors] = []) << "Some Error"
-  #   stats # => {server: {region: {us_east: {errors: ["Some Error"]}}}}
-  #
-  # @note While extremely convenient, be cautious with very deep structures
-  #   as this creates new hashes on demand for any key access
-  #
-  def self.new_nested_hash
-    new { |hash, key| hash[key] = new_nested_hash }
+  #   stats[:server][:region][:us_east][:errors] = ["Error"]
+  #   stats # => {server: {region: {us_east: {errors: ["Error"]}}}}
+  #
+  # @example Limited nesting depth
+  #   hash = Hash.new_nested_hash(depth: 1)
+  #   hash[:user][:name] = "Alice"  # Works fine - only one level of auto-creation
+  #
+  #   # This pattern works correctly with limited nesting:
+  #   (hash[:user][:roles] ||= []) << "admin"
+  #   hash # => {user: {name: "Alice", roles: ["admin"]}}
+  #
+  # @note While unlimited nesting is convenient, it can interfere with common Ruby
+  #   patterns like ||= when initializing values at deep depths. Use the depth
+  #   parameter to control this behavior.
+  #
+  def self.new_nested_hash(depth: nil)
+    new do |hash, key|
+      next if depth == 0
+
+      hash[key] =
+        if depth.nil?
+          new_nested_hash
+        else
+          new_nested_hash(depth: depth - 1)
+        end
+    end
   end
 
   #
@@ -249,7 +275,7 @@ class Hash
   #   # => {a: 2, b: 4}
   #
   # @example Using with_key to access keys during transformation
-  #   {a: 1, b: 2}.transform_values.with_key { |k, v| "#{k}_#{v}" }
+  #   {a: 1, b: 2}.transform_values.with_key { |v, k| "#{k}_#{v}" }
   #   # => {a: "a_1", b: "b_2"}
   #
   def transform_values(&block)
@@ -279,7 +305,7 @@ class Hash
   #
   # @example Using with_key to access keys during in-place transformation
   #   hash = {a: 1, b: 2}
-  #   hash.transform_values!.with_key { |k, v| "#{k}_#{v}" }
+  #   hash.transform_values!.with_key { |v, k| "#{k}_#{v}" }
   #   # => {a: "a_1", b: "b_2"}
   #
   def transform_values!(&block)
@@ -288,6 +314,49 @@ class Hash
     og_transform_values!(&block)
   end
 
+  #
+  # Transforms keys and values to create a new hash
+  #
+  # @yield [key, value] Block that returns a new key-value pair
+  # @yieldparam key [Object] The original key
+  # @yieldparam value [Object] The original value
+  # @yieldreturn [Array] Two-element array containing the new key and value
+  #
+  # @return [Hash] A new hash with transformed keys and values
+  # @return [Enumerator] If no block is given
+  #
+  # @example Transform both keys and values
+  #   {a: 1, b: 2}.transform { |k, v| ["#{k}_key", v * 2] }
+  #   # => {a_key: 2, b_key: 4}
+  #
+  def transform(&block)
+    return to_enum(:transform) if block.nil?
+
+    to_h(&block)
+  end
+
+  #
+  # Transforms keys and values in place
+  #
+  # @yield [key, value] Block that returns a new key-value pair
+  # @yieldparam key [Object] The original key
+  # @yieldparam value [Object] The original value
+  # @yieldreturn [Array] Two-element array containing the new key and value
+  #
+  # @return [self] The transformed hash
+  # @return [Enumerator] If no block is given
+  #
+  # @example Transform both keys and values in place
+  #   hash = {a: 1, b: 2}
+  #   hash.transform! { |k, v| ["#{k}_key", v * 2] }
+  #   # => {a_key: 2, b_key: 4}
+  #
+  def transform!(&block)
+    return to_enum(:transform!) if block.nil?
+
+    replace(transform(&block))
+  end
+
   #
   # Returns the first value where the key-value pair satisfies the given condition
   #
@@ -339,6 +408,127 @@ class Hash
     select(&block).values
   end
 
+  #
+  # Renames a key in the hash while preserving the original order of elements
+  #
+  # @param old_key [Object] The key to rename
+  # @param new_key [Object] The new key to use
+  #
+  # @return [Hash] A new hash with the key renamed
+  #
+  # @example Renames a single key
+  #   {a: 1, b: 2, c: 3}.rename_key(:b, :middle)
+  #   # => {a: 1, middle: 2, c: 3}
+  #
+  def rename_key(old_key, new_key)
+    rename_keys(old_key => new_key)
+  end
+
+  #
+  # Renames a key in the hash in place while preserving the original order of elements
+  #
+  # @param old_key [Object] The key to rename
+  # @param new_key [Object] The new key to use
+  #
+  # @return [self] The modified hash
+  #
+  # @example Renames a key in place
+  #   hash = {a: 1, b: 2, c: 3}
+  #   hash.rename_key!(:b, :middle)
+  #   # => {a: 1, middle: 2, c: 3}
+  #
+  def rename_key!(old_key, new_key)
+    rename_keys!(old_key => new_key)
+  end
+
+  #
+  # Renames multiple keys in the hash while preserving the original order of elements
+  #
+  # This method maintains the original order of all keys in the hash, renaming
+  # only the specified keys while keeping their positions unchanged.
+  #
+  # @param keys [Hash] A mapping of old_key => new_key pairs
+  #
+  # @return [Hash] A new hash with keys renamed
+  #
+  # @example Renames multiple keys
+  #   {a: 1, b: 2, c: 3, d: 4}.rename_keys(a: :first, c: :third)
+  #   # => {first: 1, b: 2, third: 3, d: 4}
+  #
+  def rename_keys(**keys)
+    # I tried multiple different ways to rename the key while preserving the order, this was the fastest
+    transform_keys do |key|
+      keys.key?(key) ? keys[key] : key
+    end
+  end
+
+  #
+  # Renames multiple keys in the hash in place while preserving the original order of elements
+  #
+  # This method maintains the original order of all keys in the hash, renaming
+  # only the specified keys while keeping their positions unchanged.
+  #
+  # @param keys [Hash] A mapping of old_key => new_key pairs
+  #
+  # @return [self] The modified hash
+  #
+  # @example Rename multiple keys in place
+  #   hash = {a: 1, b: 2, c: 3, d: 4}
+  #   hash.rename_keys!(a: :first, c: :third)
+  #   # => {first: 1, b: 2, third: 3, d: 4}
+  #
+  def rename_keys!(**keys)
+    # I tried multiple different ways to rename the key while preserving the order, this was the fastest
+    transform_keys! do |key|
+      keys.key?(key) ? keys[key] : key
+    end
+  end
+
+  #
+  # Renames a key in the hash without preserving element order (faster)
+  #
+  # This method is significantly faster than #rename_key but does not
+  # guarantee that the order of elements in the hash will be preserved.
+  #
+  # @param old_key [Object] The key to rename
+  # @param new_key [Object] The new key to use
+  #
+  # @return [Hash] A new hash with the key renamed
+  #
+  # @example Rename a single key without preserving order
+  #   {a: 1, b: 2, c: 3}.rename_key_unordered(:b, :middle)
+  #   # => {a: 1, c: 3, middle: 2}  # Order may differ
+  #
+  def rename_key_unordered(old_key, new_key)
+    # Fun thing I learned. For small hashes, using #except is 1.5x faster than using dup and delete.
+    # But as the hash becomes larger, the performance improvements become diminished until they're roughly the same.
+    # Neat!
+    hash = except(old_key)
+    hash[new_key] = self[old_key]
+    hash
+  end
+
+  #
+  # Renames a key in the hash in place without preserving element order (faster)
+  #
+  # This method is significantly faster than #rename_key! but does not
+  # guarantee that the order of elements in the hash will be preserved.
+  #
+  # @param old_key [Object] The key to rename
+  # @param new_key [Object] The new key to use
+  #
+  # @return [self] The modified hash
+  #
+  # @example Rename a key in place without preserving order
+  #   hash = {a: 1, b: 2, c: 3}
+  #   hash.rename_key_unordered!(:b, :middle)
+  #   # => {a: 1, c: 3, middle: 2}  # Order may differ
+  #
+  def rename_key_unordered!(old_key, new_key)
+    self[new_key] = delete(old_key)
+    self
+  end
+
   private
 
   def transform_values_enumerator
@@ -350,7 +540,7 @@ class Hash
       raise ArgumentError, "Missing block for Hash#transform_values.with_key" if block.nil?
 
       original_hash.each_pair.with_object({}) do |(key, value), output|
-        output[key] = block.call(key, value)
+        output[key] = block.call(value, key)
       end
     end
 
@@ -366,7 +556,7 @@ class Hash
       raise ArgumentError, "Missing block for Hash#transform_values!.with_key" if block.nil?
 
       original_hash.each_pair do |key, value|
-        original_hash[key] = block.call(key, value)
+        original_hash[key] = block.call(value, key)
       end
 
       original_hash

data/lib/everythingrb/{core/module.rb → module.rb}

@@ -3,10 +3,12 @@
 #
 # Extensions to Ruby's core Module class
 #
-# These additions provide a convenient way to create boolean-style accessor
-# methods for any class.
+# Provides:
+# - #attr_predicate: Create boolean-style accessor methods
+#
+# @example
+#   require "everythingrb/module"
 #
-# @example Creating predicate methods
 #   class User
 #     attr_accessor :admin
 #     attr_predicate :admin
@@ -14,7 +16,7 @@
 #
 #   user = User.new
 #   user.admin = true
-#   user.admin? # => true
+#   user.admin?  # => true
 #
 class Module
   #

data/lib/everythingrb/{core/ostruct.rb → ostruct.rb}

@@ -3,12 +3,17 @@
 #
 # Extensions to Ruby's OpenStruct class
 #
-# These additions make OpenStructs way more flexible with enumeration
-# methods and ActiveSupport integration.
+# Provides:
+# - #map, #filter_map: Enumeration methods for OpenStruct entries
+# - #join_map: Combine filter_map and join operations
+# - #blank?, #present?: ActiveSupport integrations when available
+# - #to_deep_h: Recursively convert to hash with all nested objects
+#
+# @example
+#   require "everythingrb/ostruct"
 #
-# @example Using enumeration methods
 #   person = OpenStruct.new(name: "Alice", age: 30)
-#   person.map { |k, v| "#{k} is #{v}" } # => ["name is Alice", "age is 30"]
+#   person.map { |k, v| "#{k}: #{v}" }  # => ["name: Alice", "age: 30"]
 #
 class OpenStruct
   # ActiveSupport integrations
@@ -105,4 +110,20 @@ class OpenStruct
   def to_ostruct
     self
   end
+
+  #
+  # Recursively converts the OpenStruct and all nested objects to hashes
+  #
+  # @return [Hash] A deeply converted hash of the OpenStruct
+  #
+  # @example
+  #   person = OpenStruct.new(
+  #     name: "Alice",
+  #     address: OpenStruct.new(city: "New York", country: "USA")
+  #   )
+  #   person.to_deep_h  # => {name: "Alice", address: {city: "New York", country: "USA"}}
+  #
+  def to_deep_h
+    to_h.to_deep_h
+  end
 end

data/lib/everythingrb/prelude.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "json"
+
+#
+# EverythingRB - Super handy extensions to Ruby's core classes
+#
+# This gem enhances Ruby's built-in classes with useful methods that make
+# your code more expressive and fun to write. Just require "everythingrb"
+# and all the extensions are automatically available!
+#
+# @author Bryan "itsthedevman"
+# @since 0.1.0
+#
+# @example Basic usage
+#   # In your Gemfile
+#   gem "everythingrb"
+#
+#   # In your code
+#   require "everythingrb"
+#
+#   # Now you have access to all the extensions!
+#   users = [{name: "Alice"}, {name: "Bob"}]
+#   users.key_map(:name).join(", ")  # => "Alice, Bob"
+#
+module Everythingrb
+end
+
+require_relative "version"

data/lib/everythingrb/{core/string.rb → string.rb}

@@ -3,14 +3,17 @@
 #
 # Extensions to Ruby's core String class
 #
-# These additions make working with JSON strings easy by providing methods for conversion
-# to various Ruby data structures. Plus some nice formatting helpers that saves tons of typing
+# Provides:
+# - #to_h, #to_a: Convert JSON strings to Hash/Array with error handling
+# - #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
 #
-# @example Converting JSON to different structures
-#   json = '{"user": {"name": "Alice", "admin": true}}'
-#   json.to_h                 # => {user: {name: "Alice", admin: true}}
-#   json.to_istruct.user.name # => "Alice"
-#   json.to_ostruct.user.name # => "Alice"
+# @example
+#   require "everythingrb/string"
+#
+#   '{"user": {"name": "Alice"}}'.to_ostruct.user.name  # => "Alice"
+#   "Hello".with_quotes  # => "\"Hello\""
 #
 class String
   #

data/lib/everythingrb/struct.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# Extensions to Ruby's core Struct class
+#
+# Provides:
+# - #to_deep_h: Recursively convert to hash with all nested objects
+#
+# @example
+#   require "everythingrb/struct"
+#
+#   Person = Struct.new(:name, :profile)
+#   person = Person.new("Alice", {roles: ["admin"]})
+#   person.to_deep_h  # => {name: "Alice", profile: {roles: ["admin"]}}
+#
+class Struct
+  #
+  # Recursively converts the Struct and all nested objects to hashes
+  #
+  # @return [Hash] A deeply converted hash of the Struct
+  #
+  # @example
+  #   Address = Struct.new(:city, :country)
+  #   Person = Struct.new(:name, :address)
+  #   person = Person.new("Alice", Address.new("New York", "USA"))
+  #   person.to_deep_h  # => {name: "Alice", address: {city: "New York", country: "USA"}}
+  #
+  def to_deep_h
+    to_h.to_deep_h
+  end
+end

data/lib/everythingrb/{core/symbol.rb → symbol.rb}

@@ -3,9 +3,12 @@
 #
 # Extensions to Ruby's core Symbol class
 #
-# These additions provide handy formatting helpers for symbols.
+# Provides:
+# - #with_quotes, #in_quotes: Wrap symbols in quotes
 #
 # @example
+#   require "everythingrb/symbol"
+#
 #   :hello_world.with_quotes  # => :"\"hello_world\""
 #
 class Symbol

data/lib/everythingrb/version.rb

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

data/lib/everythingrb.rb

@@ -1,37 +1,4 @@
 # frozen_string_literal: true
 
-require "ostruct"
-require "json"
-
-require_relative "everythingrb/version"
-require_relative "everythingrb/core/array"
-require_relative "everythingrb/core/enumerable"
-require_relative "everythingrb/core/hash"
-require_relative "everythingrb/core/module"
-require_relative "everythingrb/core/ostruct"
-require_relative "everythingrb/core/string"
-require_relative "everythingrb/core/symbol"
-
-#
-# EverythingRB - Super handy extensions to Ruby's core classes
-#
-# This gem enhances Ruby's built-in classes with useful methods that make
-# your code more expressive and fun to write. Just require "everythingrb"
-# and all the extensions are automatically available!
-#
-# @author Bryan "itsthedevman"
-# @since 0.1.0
-#
-# @example Basic usage
-#   # In your Gemfile
-#   gem "everythingrb"
-#
-#   # In your code
-#   require "everythingrb"
-#
-#   # Now you have access to all the extensions!
-#   users = [{name: "Alice"}, {name: "Bob"}]
-#   users.key_map(:name).join(", ")  # => "Alice, Bob"
-#
-module Everythingrb
-end
+require_relative "everythingrb/prelude"
+require_relative "everythingrb/all"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everythingrb
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Bryan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-09 00:00:00.000000000 Z
+date: 2025-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.9'
+        version: '2.10'
 description: EverythingRB extends Ruby core classes with useful methods for combining
   operations (join_map), converting data structures (to_struct, to_ostruct, to_istruct),
   and handling JSON with nested parsing support.
@@ -57,13 +57,17 @@ files:
 - flake.lock
 - flake.nix
 - lib/everythingrb.rb
-- lib/everythingrb/core/array.rb
-- lib/everythingrb/core/enumerable.rb
-- lib/everythingrb/core/hash.rb
-- lib/everythingrb/core/module.rb
-- lib/everythingrb/core/ostruct.rb
-- lib/everythingrb/core/string.rb
-- lib/everythingrb/core/symbol.rb
+- lib/everythingrb/all.rb
+- lib/everythingrb/array.rb
+- lib/everythingrb/data.rb
+- lib/everythingrb/enumerable.rb
+- lib/everythingrb/hash.rb
+- lib/everythingrb/module.rb
+- lib/everythingrb/ostruct.rb
+- lib/everythingrb/prelude.rb
+- lib/everythingrb/string.rb
+- lib/everythingrb/struct.rb
+- lib/everythingrb/symbol.rb
 - lib/everythingrb/version.rb
 homepage: https://github.com/itsthedevman/everythingrb
 licenses: