everythingrb 0.9.0 → 1.0.0

data/benchmarks/string_benchmark.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("String Extension Benchmarks")
+
+# Test data
+simple_json = '{"name": "Alice", "age": 30}'
+nested_json = '{"user": {"profile": {"name": "Alice"}, "settings": {"theme": "dark"}}}'
+large_json = "{" + (1..100).map { |i| %("key#{i}": #{i}) }.join(", ") + "}"
+invalid_json = "not valid json"
+
+simple_string = "hello_world"
+complex_string = "welcome to the jungle!"
+mixed_string = "please-WAIT while_loading..."
+special_chars = "test@#$%^&*()string_with-special.chars!"
+
+# ============================================================================
+# parse_json benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("parse_json - simple JSON") do |x|
+  x.report("parse_json") { simple_json.parse_json }
+  x.report("parse_json(symbolize: false)") { simple_json.parse_json(symbolize_names: false) }
+end
+
+BenchmarkHelper.run("parse_json - nested JSON") do |x|
+  x.report("parse_json") { nested_json.parse_json }
+end
+
+BenchmarkHelper.run("parse_json - large JSON (100 keys)") do |x|
+  x.report("parse_json") { large_json.parse_json }
+end
+
+BenchmarkHelper.run("parse_json - invalid JSON") do |x|
+  x.report("parse_json (returns nil)") { invalid_json.parse_json }
+end
+
+# ============================================================================
+# to_istruct / to_ostruct / to_struct benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("JSON to struct conversions - simple") do |x|
+  x.report("to_istruct") { simple_json.to_istruct }
+  x.report("to_ostruct") { simple_json.to_ostruct }
+  x.report("to_struct") { simple_json.to_struct }
+end
+
+BenchmarkHelper.run("JSON to struct conversions - nested") do |x|
+  x.report("to_istruct") { nested_json.to_istruct }
+  x.report("to_ostruct") { nested_json.to_ostruct }
+  x.report("to_struct") { nested_json.to_struct }
+end
+
+# ============================================================================
+# to_camelcase benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("to_camelcase - simple underscore string") do |x|
+  x.report("to_camelcase(:upper)") { simple_string.to_camelcase }
+  x.report("to_camelcase(:lower)") { simple_string.to_camelcase(:lower) }
+end
+
+BenchmarkHelper.run("to_camelcase - complex string with spaces") do |x|
+  x.report("to_camelcase(:upper)") { complex_string.to_camelcase }
+  x.report("to_camelcase(:lower)") { complex_string.to_camelcase(:lower) }
+end
+
+BenchmarkHelper.run("to_camelcase - mixed formatting") do |x|
+  x.report("to_camelcase(:upper)") { mixed_string.to_camelcase }
+end
+
+BenchmarkHelper.run("to_camelcase - special characters") do |x|
+  x.report("to_camelcase(:upper)") { special_chars.to_camelcase }
+end
+
+# ============================================================================
+# in_quotes / with_quotes benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes / with_quotes") do |x|
+  x.report("short string in_quotes") { "hello".in_quotes }
+  x.report("medium string in_quotes") { complex_string.in_quotes }
+  x.report("with_quotes (alias)") { complex_string.with_quotes }
+end

data/lib/everythingrb/array.rb

@@ -188,49 +188,4 @@ class Array
       to_sentence(options)
     end
   end
-
-  #
-  # Recursively converts all elements that respond to #to_h
-  #
-  # Maps over the array and calls #to_deep_h on any Hash/String elements,
-  # #to_h on any objects that respond to it, and handles nested arrays.
-  #
-  # @return [Array] A new array with all convertible elements deeply converted
-  #
-  # @example Converting arrays with mixed object types
-  #   users = [
-  #     {name: "Alice", roles: ["admin"]},
-  #     OpenStruct.new(name: "Bob", active: true),
-  #     Data.define(:name).new(name: "Carol")
-  #   ]
-  #   users.to_deep_h
-  #   # => [
-  #   #      {name: "Alice", roles: ["admin"]},
-  #   #      {name: "Bob", active: true},
-  #   #      {name: "Carol"}
-  #   #    ]
-  #
-  # @example With nested arrays and JSON strings
-  #   data = [
-  #     {profile: '{"level":"expert"}'},
-  #     [OpenStruct.new(id: 1), OpenStruct.new(id: 2)]
-  #   ]
-  #   data.to_deep_h
-  #   # => [{profile: {level: "expert"}}, [{id: 1}, {id: 2}]]
-  #
-  def to_deep_h
-    map do |value|
-      case value
-      when Hash
-        value.to_deep_h
-      when Array
-        value.to_deep_h
-      when String
-        # If the string is not valid JSON, #to_deep_h will return `nil`
-        value.to_deep_h || value
-      else
-        value.respond_to?(:to_h) ? value.to_h : value
-      end
-    end
-  end
 end

data/lib/everythingrb/data.rb

@@ -4,27 +4,8 @@
 # Extensions to Ruby's core Data class
 #
 # Provides:
-# - #to_deep_h: Recursively convert to hash with all nested objects
 # - #in_quotes, #with_quotes: Wrap object in quotes
 #
 class Data
   include Everythingrb::InspectQuotable
-
-  #
-  # 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
-  #   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/date.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "date"
+
 #
 # Extensions to Ruby's core Date class
 #

data/lib/everythingrb/hash.rb

@@ -8,9 +8,8 @@
 # - #join_map: Combine filter_map and join operations
 # - #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
+# - #find_value, #select_values: 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
 # - #compact_merge, #compact_merge!: Merge only non-nil values
@@ -37,59 +36,6 @@ class Hash
   #
   EMPTY_STRUCT = Struct.new(:_).new(nil)
 
-  #
-  # 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. 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 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
-  #   users # => {john: {role: "admin"}}
-  #
-  # @example Deep nesting without initialization
-  #   stats = Hash.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
-
   #
   # Combines filter_map and join operations
   #
@@ -127,53 +73,6 @@ class Hash
     end
   end
 
-  #
-  # Recursively converts all values that respond to #to_h
-  #
-  # Similar to #to_h but recursively traverses the Hash structure
-  # 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
-  #
-  # @example Converting nested Data objects
-  #   user = { name: "Alice", metadata: Data.define(:source).new(source: "API") }
-  #   user.to_deep_h  # => {name: "Alice", metadata: {source: "API"}}
-  #
-  # @example Parsing nested JSON strings
-  #   nested = { profile: '{"role":"admin"}' }
-  #   nested.to_deep_h  # => {profile: {role: "admin"}}
-  #
-  # @example Mixed nested structures
-  #   data = {
-  #     config: OpenStruct.new(api_key: "secret"),
-  #     users: [
-  #       Data.define(:name).new(name: "Bob"),
-  #       {role: "admin"}
-  #     ]
-  #   }
-  #   data.to_deep_h
-  #   # => {
-  #   #      config: {api_key: "secret"},
-  #   #      users: [{name: "Bob"}, {role: "admin"}]
-  #   #    }
-  #
-  def to_deep_h
-    transform_values do |value|
-      case value
-      when Hash
-        value.to_deep_h
-      when Array
-        value.to_deep_h
-      when String
-        # If the string is not valid JSON, #to_deep_h will return `nil`
-        value.to_deep_h || value
-      else
-        value.respond_to?(:to_h) ? value.to_h : value
-      end
-    end
-  end
-
   #
   # Converts hash to an immutable Data structure
   #
@@ -512,10 +411,10 @@ class Hash
   #     bob: {name: "Bob", role: "user"},
   #     charlie: {name: "Charlie", role: "admin"}
   #   }
-  #   users.value_where { |k, v| v[:role] == "admin" } # => {name: "Alice", role: "admin"}
+  #   users.find_value { |k, v| v[:role] == "admin" } # => {name: "Alice", role: "admin"}
   #
-  def value_where(&block)
-    return to_enum(:value_where) if block.nil?
+  def find_value(&block)
+    return to_enum(:find_value) if block.nil?
 
     find(&block)&.last
   end
@@ -537,11 +436,11 @@ class Hash
   #     bob: {name: "Bob", role: "user"},
   #     charlie: {name: "Charlie", role: "admin"}
   #   }
-  #   users.values_where { |k, v| v[:role] == "admin" }
+  #   users.select_values { |k, v| v[:role] == "admin" }
   #   # => [{name: "Alice", role: "admin"}, {name: "Charlie", role: "admin"}]
   #
-  def values_where(&block)
-    return to_enum(:values_where) if block.nil?
+  def select_values(&block)
+    return to_enum(:select_values) if block.nil?
 
     select(&block).values
   end

data/lib/everythingrb/module.rb

@@ -20,17 +20,26 @@
 #
 class Module
   #
-  # Creates predicate (boolean) methods that return true/false
-  # Similar to attr_reader, attr_writer, etc. Designed to work with
-  # regular classes, Struct, and Data objects.
+  # Creates predicate (boolean) methods that return true/false based on an attribute's value.
+  # Similar to attr_reader, attr_writer, etc. Designed to work with regular classes, Struct,
+  # and Data objects.
   #
-  # Note: If ActiveSupport is loaded, this will check if the value is present? instead of truthy
+  # Values are evaluated as follows:
+  # - nil and false are always false
+  # - With ActiveSupport: uses +present?+ (empty strings, arrays, hashes are false)
+  # - Without ActiveSupport: checks +empty?+ if available, otherwise uses truthiness
   #
   # @param attributes [Array<Symbol, String>] Attribute names
+  # @param opts [Hash] Options hash
+  # @option opts [Symbol, String, nil] :from Source ivar or method to read from. Use @ prefix
+  #   for instance variables (e.g., :@started_at), omit for methods (e.g., :status). When
+  #   specified, only one attribute may be provided (ambiguous mapping otherwise).
+  # @option opts [Boolean] :private If true, defines the predicate as a private method
   #
   # @return [nil]
   #
   # @raise [ArgumentError] If a predicate method of the same name already exists
+  # @raise [ArgumentError] If from: is specified with multiple attributes
   #
   # @example With a regular class
   #   class User
@@ -50,24 +59,80 @@ class Module
   #   person = Person.new(active: true)
   #   person.active? # => true
   #
-  def attr_predicate(*attributes)
+  # @example Mapping to a different ivar with from:
+  #   class Task
+  #     attr_accessor :started_at, :stopped_at
+  #     attr_predicate :started, from: :@started_at
+  #     attr_predicate :finished, from: :@stopped_at
+  #   end
+  #
+  #   task = Task.new
+  #   task.started? # => false
+  #   task.started_at = Time.now
+  #   task.started? # => true
+  #
+  # @example Mapping to a method with from:
+  #   class Job
+  #     attr_accessor :error_messages
+  #     attr_predicate :errored, from: :error_messages
+  #   end
+  #
+  #   job = Job.new
+  #   job.errored? # => false
+  #   job.error_messages = ["Something went wrong"]
+  #   job.errored? # => true
+  #
+  # @example Private predicate method
+  #   class Account
+  #     attr_accessor :verified
+  #     attr_predicate :verified, private: true
+  #   end
+  #
+  #   account = Account.new
+  #   account.verified? # => NoMethodError (private method)
+  #
+  def attr_predicate(*attributes, **opts)
+    from = opts[:from]
+    private_method = !!opts[:private]
+
+    if from && attributes.size > 1
+      raise ArgumentError, "Cannot use from: option with multiple attributes - each predicate needs its own source mapping"
+    end
+
     attributes.each do |attribute|
       if method_defined?(:"#{attribute}?")
         raise ArgumentError, "Cannot create predicate method on #{self.class} - #{attribute}? is already defined. Please choose a different name or remove the existing method."
       end
 
-      module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{attribute}?
-          value =
-            if instance_variable_defined?(:@#{attribute})
-              @#{attribute}
-            elsif respond_to?(:#{attribute})
-              self.#{attribute}
-            end
+      signature = "def #{attribute}?"
+      signature.prepend("private ") if private_method
+
+      # Performance note:
+      # This was originally checked if an instance variable or method was defined, both of which are sllllooooowwwww
+      # Now as of 1.0.0, this assumes an instance variable (with exceptions) by default
+      getter =
+        if from
+          from.to_s.start_with?("@") ? from : "self.#{from}"
+        elsif self < Struct || self < OpenStruct || self < Data
+          "self.#{attribute}"
+        else
+          "@#{attribute}"
+        end
+
+      checker =
+        if defined?(ActiveSupport)
+          "!!value.presence"
+        else
+          # Handle empty arrays/hashes/strings
+          "value.respond_to?(:empty?) ? !value.empty? : !!value"
+        end
 
+      module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        #{signature}
+          value = #{getter}
           return false if value.nil?
 
-          defined?(ActiveSupport) ? !!value.presence : !!value
+          #{checker}
         end
       RUBY
     end

data/lib/everythingrb/ostruct.rb

@@ -7,7 +7,6 @@
 # - #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
 # - #in_quotes, #with_quotes: Wrap struct in quotes
 #
 # @example
@@ -117,23 +116,4 @@ class OpenStruct
   def to_ostruct
     self
   end
-
-  #
-  # 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
-  #   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/string.rb

@@ -4,8 +4,7 @@
 # Extensions to Ruby's core String class
 #
 # Provides:
-# - #to_h, #to_a: Convert JSON strings to Hash/Array with error handling
-# - #to_deep_h: Recursively parse nested JSON strings
+# - #parse_json: Parse JSON strings with error handling
 # - #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
@@ -21,61 +20,36 @@ class String
   include Everythingrb::StringQuotable
 
   #
-  # Converts JSON string to Hash, returning nil if it failed
+  # Parses the string as JSON and returns the result
   #
-  # @return [Hash, nil] Parsed JSON as hash or nil if invalid JSON
+  # Safely parses JSON with symbolized keys by default. Returns nil
+  # instead of raising an exception if the string is not valid JSON.
   #
-  # @example
-  #   '{"name": "Alice"}'.to_h  # => {name: "Alice"}
-  #   "invalid json".to_h       # => nil
+  # @param opts [Hash] Options to pass to JSON.parse
+  # @option opts [Boolean] :symbolize_names (true) Whether to symbolize keys
   #
-  def to_h
-    JSON.parse(self, symbolize_names: true)
-  rescue JSON::ParserError
-    nil
-  end
-
-  alias_method :to_a, :to_h
-
+  # @return [Hash, Array, nil] Parsed JSON or nil if invalid
   #
-  # Deep parsing of nested JSON strings
-  # Recursively attempts to parse string values as JSON
+  # @example Basic usage
+  #   '{"name": "Alice"}'.parse_json  # => {name: "Alice"}
   #
-  # @return [Hash] Deeply parsed hash with all nested JSON strings converted
-  # @return [nil] If the string is not valid JSON at the top level
+  # @example With nested data
+  #   '{"user": {"roles": ["admin"]}}'.parse_json
+  #   # => {user: {roles: ["admin"]}}
   #
-  # @note If nested JSON strings fail to parse, they remain as strings
-  #   rather than causing the entire operation to fail
+  # @example Invalid JSON returns nil
+  #   "not json".parse_json  # => nil
   #
-  # @example
-  #   nested_json = '{
-  #     "user": "{\"name\":\"Alice\",\"roles\":[\"admin\"]}"
-  #   }'
-  #   nested_json.to_deep_h
-  #   # => {user: {name: "Alice", roles: ["admin"]}}
-  #
-  def to_deep_h
-    recursive_convert = lambda do |object|
-      case object
-      when Array
-        object.map { |v| recursive_convert.call(v) }
-      when String
-        result = object.to_deep_h
-
-        # Nested JSON
-        if result.is_a?(Array) || result.is_a?(Hash)
-          recursive_convert.call(result)
-        else
-          object
-        end
-      when Hash
-        object.transform_values { |v| recursive_convert.call(v) }
-      else
-        object
-      end
-    end
+  # @example Disable symbolized keys
+  #   '{"name": "Alice"}'.parse_json(symbolize_names: false)
+  #   # => {"name" => "Alice"}
+  #
+  def parse_json(**opts)
+    opts[:symbolize_names] = true unless opts.key?(:symbolize_names)
 
-    recursive_convert.call(to_h)
+    JSON.parse(self, opts)
+  rescue JSON::ParserError
+    nil
   end
 
   #
@@ -89,7 +63,7 @@ class String
   #   "not json".to_istruct               # => nil
   #
   def to_istruct
-    to_h&.to_istruct
+    parse_json&.to_istruct
   end
 
   #
@@ -103,7 +77,7 @@ class String
   #   "not json".to_ostruct               # => nil
   #
   def to_ostruct
-    to_h&.to_ostruct
+    parse_json&.to_ostruct
   end
 
   #
@@ -117,7 +91,7 @@ class String
   #   "not json".to_struct                # => nil
   #
   def to_struct
-    to_h&.to_struct
+    parse_json&.to_struct
   end
 
   #

data/lib/everythingrb/struct.rb

@@ -4,7 +4,6 @@
 # Extensions to Ruby's core Struct class
 #
 # Provides:
-# - #to_deep_h: Recursively convert to hash with all nested objects
 # - #in_quotes, #with_quotes: Wrap struct in quotes
 #
 # @example
@@ -12,27 +11,7 @@
 #
 #   Person = Struct.new(:name, :profile)
 #   person = Person.new("Alice", {roles: ["admin"]})
-#   person.to_deep_h  # => {name: "Alice", profile: {roles: ["admin"]}}
 #
 class Struct
   include Everythingrb::InspectQuotable
-
-  #
-  # 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
-  #   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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everythingrb
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Bryan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-02 00:00:00.000000000 Z
+date: 2026-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -54,6 +54,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/array_benchmark.rb
+- benchmarks/benchmark_helper.rb
+- benchmarks/enumerable_benchmark.rb
+- benchmarks/hash_benchmark.rb
+- benchmarks/kernel_benchmark.rb
+- benchmarks/module_benchmark.rb
+- benchmarks/ostruct_benchmark.rb
+- benchmarks/quotable_benchmark.rb
+- benchmarks/run_all.rb
+- benchmarks/string_benchmark.rb
 - flake.lock
 - flake.nix
 - lib/everythingrb.rb