everythingrb 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 747441fc1a0c8be071a4465edb190dead79eea7195b66b262976e8ae91b6bc0f
-  data.tar.gz: 491c3bc6c22bc02495425fecfb51166c8982d86ad0eede1b10980e2bf040b705
+  metadata.gz: dfa8c1ad4940f61e609e0b70618493a050979540beb9e3388828d9c8741f9103
+  data.tar.gz: a4851a664e888577d68a01fc9830d9d8c812ff5758edce994eacd0f1440887f4
 SHA512:
-  metadata.gz: f6605c462aeeb634fe3342a3befb424fe3a67f31059f486d4c835a3670192962a44f6237f51947629cbe1a27d7a21579c03a48f9c98e22f155821cdb62f1e8c1
-  data.tar.gz: e6d2ce8fca0b90b513c686dfc44f8010cfb2aca9cc3be84cdbd08c6fccbbac49727ffbe42805f5a0789496df7b3f68ace624b7c201b30f5ee5305be16af485fa
+  metadata.gz: dd750b905857c86db3cdd8c054c50a7900e2ef194fdd51df69bd35267f0f947bbb93dca3df9bb7596758b15a5312203cb02875ff99c90eca03aab7d63c064e79
+  data.tar.gz: 6c9c6198b3ef913c4cfebcae52cc85573a499a29b4d21eb2826e22f13dfd58f20fa96333faa92a3ff2d7e88ad38df97247d1836b7b554eb859e59dcd17f03bd2

data/CHANGELOG.md

@@ -23,6 +23,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Removed
 
+## [0.4.0]
+
+### 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 +98,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 +117,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 +141,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 +170,8 @@ 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.4.0...HEAD
+[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,19 @@
 #
 # 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
+# - #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 +35,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
 
   #
@@ -339,6 +364,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

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.4.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.4.0
 platform: ruby
 authors:
 - Bryan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-09 00:00:00.000000000 Z
+date: 2025-04-12 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: