everythingrb 0.9.1 → 1.0.0

data/benchmarks/enumerable_benchmark.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("Enumerable Extension Benchmarks")
+
+# Test data - using Range as an Enumerable that isn't Array
+small_range = 1..10
+medium_range = 1..100
+large_range = 1..1000
+
+users = [
+  {name: "Alice", role: "admin"},
+  {name: "Bob", role: "user"},
+  {name: "Charlie", role: "admin"},
+  {name: "Diana", role: "user"},
+  {name: "Eve", role: "moderator"}
+]
+
+nested_data = [
+  {department: {name: "Sales"}, employee: "Alice"},
+  {department: {name: "IT"}, employee: "Bob"},
+  {department: {name: "Sales"}, employee: "Charlie"},
+  {department: {name: "HR"}, employee: "Diana"},
+  {department: {name: "IT"}, employee: "Eve"}
+]
+
+large_users = (1..1000).map { |i| {name: "User#{i}", role: %w[admin user moderator][i % 3]} }
+
+# ============================================================================
+# join_map benchmarks (on Range)
+# ============================================================================
+
+BenchmarkHelper.run("join_map - small range (1..10)") do |x|
+  x.report("join_map") { small_range.join_map(" | ") { |n| "num#{n}" if n.even? } }
+  x.report("join_map(with_index)") { small_range.join_map(", ", with_index: true) { |n, i| "#{i}:#{n}" } }
+end
+
+BenchmarkHelper.run("join_map - medium range (1..100)") do |x|
+  x.report("join_map") { medium_range.join_map(" | ") { |n| "num#{n}" if n.even? } }
+end
+
+BenchmarkHelper.run("join_map - large range (1..1000)") do |x|
+  x.report("join_map") { large_range.join_map(" | ") { |n| "num#{n}" if n.even? } }
+end
+
+# ============================================================================
+# group_by_key benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("group_by_key - single key") do |x|
+  x.report("group_by_key(:role)") { users.group_by_key(:role) }
+end
+
+BenchmarkHelper.run("group_by_key - nested keys") do |x|
+  x.report("group_by_key(:department, :name)") { nested_data.group_by_key(:department, :name) }
+end
+
+BenchmarkHelper.run("group_by_key - with block transformation") do |x|
+  x.report("group_by_key with upcase") { users.group_by_key(:role) { |role| role.upcase } }
+end
+
+BenchmarkHelper.run("group_by_key - large dataset (1000 elements)") do |x|
+  x.report("group_by_key(:role)") { large_users.group_by_key(:role) }
+end
+
+# ============================================================================
+# Set as Enumerable
+# ============================================================================
+
+small_set = Set.new(1..10)
+medium_set = Set.new(1..100)
+
+BenchmarkHelper.run("join_map - Set (10 elements)") do |x|
+  x.report("join_map") { small_set.join_map(", ") { |n| "item#{n}" if n.odd? } }
+end
+
+BenchmarkHelper.run("join_map - Set (100 elements)") do |x|
+  x.report("join_map") { medium_set.join_map(", ") { |n| "item#{n}" if n.odd? } }
+end

data/benchmarks/hash_benchmark.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("Hash Extension Benchmarks")
+
+# Test data
+small_hash = {a: 1, b: 2, c: 3}
+medium_hash = (1..100).each_with_object({}) { |i, h| h[:"key#{i}"] = i }
+
+nested_hash = {
+  user: {
+    profile: {name: "Alice", age: 30},
+    settings: {theme: "dark", notifications: true}
+  },
+  meta: {created_at: "2024-01-01"}
+}
+
+users_hash = {
+  alice: {name: "Alice", role: "admin"},
+  bob: {name: "Bob", role: "user"},
+  charlie: {name: "Charlie", role: "admin"}
+}
+
+# ============================================================================
+# join_map benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("join_map - small hash (3 keys)") do |x|
+  x.report("join_map") { small_hash.join_map(", ") { |k, v| "#{k}=#{v}" } }
+  x.report("join_map(with_index)") { small_hash.join_map(", ", with_index: true) { |(k, v), i| "#{i}:#{k}=#{v}" } }
+end
+
+BenchmarkHelper.run("join_map - medium hash (100 keys)") do |x|
+  x.report("join_map") { medium_hash.join_map(", ") { |k, v| "#{k}=#{v}" } }
+end
+
+# ============================================================================
+# to_struct / to_ostruct / to_istruct benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("to_struct - small hash") do |x|
+  x.report("to_struct") { small_hash.to_struct }
+end
+
+BenchmarkHelper.run("to_ostruct - small hash") do |x|
+  x.report("to_ostruct") { small_hash.to_ostruct }
+end
+
+BenchmarkHelper.run("to_istruct - small hash") do |x|
+  x.report("to_istruct") { small_hash.to_istruct }
+end
+
+BenchmarkHelper.run("structure conversion - nested hash") do |x|
+  x.report("to_struct") { nested_hash.to_struct }
+  x.report("to_ostruct") { nested_hash.to_ostruct }
+  x.report("to_istruct") { nested_hash.to_istruct }
+end
+
+# ============================================================================
+# transform_values with_key benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("transform_values - small hash") do |x|
+  x.report("transform_values") { small_hash.transform_values { |v| v * 2 } }
+  x.report("transform_values(with_key)") { small_hash.transform_values(with_key: true) { |v, k| "#{k}:#{v * 2}" } }
+end
+
+BenchmarkHelper.run("transform_values - medium hash") do |x|
+  x.report("transform_values") { medium_hash.transform_values { |v| v * 2 } }
+  x.report("transform_values(with_key)") { medium_hash.transform_values(with_key: true) { |v, k| "#{k}:#{v * 2}" } }
+end
+
+# ============================================================================
+# transform / transform! benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("transform - small hash") do |x|
+  x.report("transform") { small_hash.transform { |k, v| [:"new_#{k}", v * 2] } }
+end
+
+BenchmarkHelper.run("transform - medium hash") do |x|
+  x.report("transform") { medium_hash.transform { |k, v| [:"new_#{k}", v * 2] } }
+end
+
+# ============================================================================
+# find_value / select_values benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("find_value / select_values") do |x|
+  x.report("find_value") { users_hash.find_value { |_k, v| v[:role] == "admin" } }
+  x.report("select_values") { users_hash.select_values { |_k, v| v[:role] == "admin" } }
+end
+
+# ============================================================================
+# rename_key / rename_keys benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("rename_key - small hash") do |x|
+  x.report("rename_key (ordered)") { small_hash.rename_key(:b, :middle) }
+  x.report("rename_key_unordered") { small_hash.rename_key_unordered(:b, :middle) }
+end
+
+BenchmarkHelper.run("rename_keys - small hash") do |x|
+  x.report("rename_keys") { small_hash.rename_keys(a: :first, c: :last) }
+end
+
+BenchmarkHelper.run("rename_key - medium hash") do |x|
+  x.report("rename_key (ordered)") { medium_hash.rename_key(:key50, :middle) }
+  x.report("rename_key_unordered") { medium_hash.rename_key_unordered(:key50, :middle) }
+end
+
+# ============================================================================
+# merge_if / merge_if_values benchmarks
+# ============================================================================
+
+other_hash = {d: 4, e: 5, f: nil}
+
+BenchmarkHelper.run("merge_if / merge_if_values") do |x|
+  x.report("merge_if") { small_hash.merge_if(other_hash) { |_k, v| v&.even? } }
+  x.report("merge_if_values") { small_hash.merge_if_values(other_hash) { |v| v&.odd? } }
+end
+
+# ============================================================================
+# compact_merge benchmarks
+# ============================================================================
+
+hash_with_nils = {a: 1, b: nil, c: 3, d: nil}
+
+BenchmarkHelper.run("compact_merge") do |x|
+  x.report("compact_merge") { small_hash.compact_merge(hash_with_nils) }
+end
+
+# ============================================================================
+# in_quotes benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes / with_quotes") do |x|
+  x.report("small hash in_quotes") { small_hash.in_quotes }
+  x.report("nested hash in_quotes") { nested_hash.in_quotes }
+end
+
+# ============================================================================
+# ActiveSupport-only benchmarks
+# ============================================================================
+
+if BenchmarkHelper.active_support?
+  BenchmarkHelper.run("deep_transform_values(with_key)") do |x|
+    x.report("deep_transform_values") { nested_hash.deep_transform_values { |v| v.to_s.upcase } }
+    x.report("deep_transform_values(with_key)") { nested_hash.deep_transform_values(with_key: true) { |v, k| "#{k}:#{v}" } }
+  end
+
+  hash_with_blanks = {a: 1, b: "", c: [], d: "present"}
+
+  BenchmarkHelper.run("compact_blank_merge") do |x|
+    x.report("compact_blank_merge") { small_hash.compact_blank_merge(hash_with_blanks) }
+  end
+else
+  puts "\n[SKIPPED] ActiveSupport benchmarks - run with LOAD_ACTIVE_SUPPORT=true"
+end

data/benchmarks/kernel_benchmark.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("Kernel Extension Benchmarks")
+
+# Test data
+number = 42
+string = "hello"
+hash = {name: "Alice", age: 30}
+array = [1, 2, 3, 4, 5]
+
+# ============================================================================
+# morph benchmarks (alias for then/yield_self)
+# ============================================================================
+
+BenchmarkHelper.run("morph - simple transformation") do |x|
+  x.report("morph { * 2 }") { number.morph { |n| n * 2 } }
+  x.report("morph { upcase }") { string.morph { |s| s.upcase } }
+end
+
+BenchmarkHelper.run("morph - chained transformations") do |x|
+  x.report("morph chain (2 steps)") do
+    number.morph { |n| n * 2 }.morph { |n| n.to_s }
+  end
+
+  x.report("morph chain (3 steps)") do
+    string.morph { |s| s.upcase }.morph { |s| s.reverse }.morph { |s| s.chars }
+  end
+end
+
+BenchmarkHelper.run("morph - with hash") do |x|
+  x.report("morph hash transform") do
+    hash.morph { |h| h.transform_values(&:to_s) }
+  end
+end
+
+BenchmarkHelper.run("morph - with array") do |x|
+  x.report("morph array transform") do
+    array.morph { |a| a.map { |n| n * 2 } }.morph { |a| a.sum }
+  end
+end
+
+# ============================================================================
+# morph vs then (should be identical - they're aliases)
+# ============================================================================
+
+BenchmarkHelper.run("morph vs then (alias verification)") do |x|
+  x.report("morph") { number.morph { |n| n * 2 } }
+  x.report("then") { number.then { |n| n * 2 } }
+end

data/benchmarks/module_benchmark.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("Module Extension Benchmarks")
+
+# Define test classes with attr_predicate
+class UserWithPredicate
+  attr_accessor :admin, :active, :verified
+  attr_predicate :admin, :active, :verified
+end
+
+class TaskWithFrom
+  attr_accessor :started_at, :stopped_at
+  attr_predicate :started, from: :@started_at
+  attr_predicate :finished, from: :@stopped_at
+end
+
+class JobWithMethodFrom
+  attr_accessor :error_messages
+  attr_predicate :errored, from: :error_messages
+end
+
+PersonStruct = Struct.new(:active, :name)
+PersonStruct.attr_predicate(:active)
+
+# Test data
+user_true = UserWithPredicate.new.tap do |u|
+  u.admin = true
+  u.active = true
+  u.verified = true
+end
+
+user_false = UserWithPredicate.new.tap do |u|
+  u.admin = false
+  u.active = nil
+  u.verified = ""
+end
+
+task_started = TaskWithFrom.new.tap { |t| t.started_at = Time.now }
+task_not_started = TaskWithFrom.new
+
+job_errored = JobWithMethodFrom.new.tap { |j| j.error_messages = ["Error 1", "Error 2"] }
+job_clean = JobWithMethodFrom.new.tap { |j| j.error_messages = [] }
+
+person_active = PersonStruct.new(true, "Alice")
+person_inactive = PersonStruct.new(false, "Bob")
+
+# ============================================================================
+# attr_predicate - basic usage benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("attr_predicate - truthy values") do |x|
+  x.report("admin? (true)") { user_true.admin? }
+  x.report("active? (true)") { user_true.active? }
+  x.report("verified? (true)") { user_true.verified? }
+end
+
+BenchmarkHelper.run("attr_predicate - falsy values") do |x|
+  x.report("admin? (false)") { user_false.admin? }
+  x.report("active? (nil)") { user_false.active? }
+  x.report("verified? (empty string)") { user_false.verified? }
+end
+
+# ============================================================================
+# attr_predicate - with from: option (ivar)
+# ============================================================================
+
+BenchmarkHelper.run("attr_predicate with from: @ivar") do |x|
+  x.report("started? (has value)") { task_started.started? }
+  x.report("started? (nil)") { task_not_started.started? }
+end
+
+# ============================================================================
+# attr_predicate - with from: option (method)
+# ============================================================================
+
+BenchmarkHelper.run("attr_predicate with from: method") do |x|
+  x.report("errored? (has errors)") { job_errored.errored? }
+  x.report("errored? (empty array)") { job_clean.errored? }
+end
+
+# ============================================================================
+# attr_predicate - with Struct
+# ============================================================================
+
+BenchmarkHelper.run("attr_predicate on Struct") do |x|
+  x.report("active? (true)") { person_active.active? }
+  x.report("active? (false)") { person_inactive.active? }
+end
+
+# ============================================================================
+# attr_predicate definition time (one-time cost)
+# ============================================================================
+
+BenchmarkHelper.run("attr_predicate definition time") do |x|
+  x.report("define single predicate") do
+    klass = Class.new { attr_accessor :test }
+    klass.attr_predicate(:test)
+  end
+
+  x.report("define multiple predicates") do
+    klass = Class.new { attr_accessor :a, :b, :c }
+    klass.attr_predicate(:a, :b, :c)
+  end
+end

data/benchmarks/ostruct_benchmark.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("OpenStruct Extension Benchmarks")
+
+# Test data
+small_ostruct = OpenStruct.new(a: 1, b: 2, c: 3)
+medium_ostruct = OpenStruct.new((1..20).each_with_object({}) { |i, h| h[:"attr#{i}"] = i })
+ostruct_with_nil = OpenStruct.new(a: 1, b: nil, c: 3, d: nil, e: 5)
+empty_ostruct = OpenStruct.new
+
+# ============================================================================
+# map / filter_map benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("map - small OpenStruct (3 attributes)") do |x|
+  x.report("map") { small_ostruct.map { |k, v| [k, v * 2] } }
+end
+
+BenchmarkHelper.run("map - medium OpenStruct (20 attributes)") do |x|
+  x.report("map") { medium_ostruct.map { |k, v| [k, v * 2] } }
+end
+
+BenchmarkHelper.run("filter_map - with nils") do |x|
+  x.report("filter_map") { ostruct_with_nil.filter_map { |k, v| v * 2 if v } }
+end
+
+# ============================================================================
+# join_map benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("join_map - small OpenStruct") do |x|
+  x.report("join_map") { small_ostruct.join_map(", ") { |k, v| "#{k}=#{v}" } }
+  x.report("join_map (no block)") { small_ostruct.join_map(", ") }
+end
+
+BenchmarkHelper.run("join_map - with nils") do |x|
+  x.report("join_map (filtering nils)") { ostruct_with_nil.join_map(" ") { |k, v| "#{k}-#{v}" if v } }
+end
+
+# ============================================================================
+# each (alias for each_pair)
+# ============================================================================
+
+BenchmarkHelper.run("each - small OpenStruct") do |x|
+  x.report("each") do
+    result = []
+    small_ostruct.each { |k, v| result << [k, v] }
+    result
+  end
+end
+
+# ============================================================================
+# to_ostruct (identity method)
+# ============================================================================
+
+BenchmarkHelper.run("to_ostruct (identity)") do |x|
+  x.report("to_ostruct") { small_ostruct.to_ostruct }
+end
+
+# ============================================================================
+# in_quotes benchmarks
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes / with_quotes") do |x|
+  x.report("small ostruct in_quotes") { small_ostruct.in_quotes }
+  x.report("medium ostruct in_quotes") { medium_ostruct.in_quotes }
+end
+
+# ============================================================================
+# ActiveSupport-only benchmarks
+# ============================================================================
+
+if BenchmarkHelper.active_support?
+  BenchmarkHelper.run("blank? / present?") do |x|
+    x.report("blank? (empty)") { empty_ostruct.blank? }
+    x.report("blank? (non-empty)") { small_ostruct.blank? }
+    x.report("present? (empty)") { empty_ostruct.present? }
+    x.report("present? (non-empty)") { small_ostruct.present? }
+  end
+else
+  puts "\n[SKIPPED] ActiveSupport benchmarks - run with LOAD_ACTIVE_SUPPORT=true"
+end

data/benchmarks/quotable_benchmark.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_helper"
+
+BenchmarkHelper.header("Quotable Extension Benchmarks")
+
+# Test data for InspectQuotable types
+array_value = [1, 2, 3]
+hash_value = {a: 1, b: 2}
+true_value = true
+false_value = false
+nil_value = nil
+numeric_int = 42
+numeric_float = 3.14159
+range_value = 1..10
+regexp_value = /hello/
+struct_value = Struct.new(:name, :age).new("Alice", 30)
+
+# Test data for StringQuotable types
+string_value = "hello world"
+date_value = Date.new(2024, 1, 15)
+datetime_value = DateTime.new(2024, 1, 15, 12, 30, 0)
+time_value = Time.new(2024, 1, 15, 12, 30, 0)
+
+# Symbol has its own implementation
+symbol_value = :my_symbol
+
+# ============================================================================
+# InspectQuotable types
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes - Array") do |x|
+  x.report("array.in_quotes") { array_value.in_quotes }
+  x.report("array.with_quotes") { array_value.with_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Hash") do |x|
+  x.report("hash.in_quotes") { hash_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Boolean") do |x|
+  x.report("true.in_quotes") { true_value.in_quotes }
+  x.report("false.in_quotes") { false_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - NilClass") do |x|
+  x.report("nil.in_quotes") { nil_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Numeric") do |x|
+  x.report("integer.in_quotes") { numeric_int.in_quotes }
+  x.report("float.in_quotes") { numeric_float.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Range") do |x|
+  x.report("range.in_quotes") { range_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Regexp") do |x|
+  x.report("regexp.in_quotes") { regexp_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Struct") do |x|
+  x.report("struct.in_quotes") { struct_value.in_quotes }
+end
+
+# ============================================================================
+# StringQuotable types
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes - String") do |x|
+  x.report("string.in_quotes") { string_value.in_quotes }
+  x.report("string.with_quotes") { string_value.with_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Date") do |x|
+  x.report("date.in_quotes") { date_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - DateTime") do |x|
+  x.report("datetime.in_quotes") { datetime_value.in_quotes }
+end
+
+BenchmarkHelper.run("in_quotes - Time") do |x|
+  x.report("time.in_quotes") { time_value.in_quotes }
+end
+
+# ============================================================================
+# Symbol (custom implementation)
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes - Symbol") do |x|
+  x.report("symbol.in_quotes") { symbol_value.in_quotes }
+  x.report("symbol.with_quotes") { symbol_value.with_quotes }
+end
+
+# ============================================================================
+# All types comparison
+# ============================================================================
+
+BenchmarkHelper.run("in_quotes - all types comparison") do |x|
+  x.report("Array") { array_value.in_quotes }
+  x.report("Hash") { hash_value.in_quotes }
+  x.report("String") { string_value.in_quotes }
+  x.report("Symbol") { symbol_value.in_quotes }
+  x.report("Integer") { numeric_int.in_quotes }
+  x.report("nil") { nil_value.in_quotes }
+  x.report("true") { true_value.in_quotes }
+  x.report("Date") { date_value.in_quotes }
+  x.report("Time") { time_value.in_quotes }
+end

data/benchmarks/run_all.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Run all EverythingRB benchmarks
+#
+# Usage:
+#   ruby benchmarks/run_all.rb                    # Run all benchmarks
+#   ruby benchmarks/run_all.rb array hash         # Run specific benchmarks
+#   LOAD_ACTIVE_SUPPORT=true ruby benchmarks/run_all.rb  # Include ActiveSupport benchmarks
+#
+# Available benchmarks:
+#   array, hash, string, enumerable, ostruct, module, kernel, quotable
+
+BENCHMARK_DIR = File.expand_path(__dir__)
+
+AVAILABLE_BENCHMARKS = %w[
+  array
+  hash
+  string
+  enumerable
+  ostruct
+  module
+  kernel
+  quotable
+].freeze
+
+def run_benchmark(name)
+  file = File.join(BENCHMARK_DIR, "#{name}_benchmark.rb")
+
+  if File.exist?(file)
+    load file
+  else
+    puts "Warning: Benchmark file not found: #{file}"
+  end
+end
+
+def print_header
+  puts
+  puts "#" * 70
+  puts "#" + "EverythingRB Benchmarks".center(68) + "#"
+  puts "#" * 70
+  puts
+  puts "Ruby version: #{RUBY_VERSION}"
+  puts "Platform: #{RUBY_PLATFORM}"
+  puts "ActiveSupport: #{(ENV["LOAD_ACTIVE_SUPPORT"] == "true") ? "loaded" : "not loaded"}"
+  puts
+  puts "Tip: Run with LOAD_ACTIVE_SUPPORT=true to include ActiveSupport benchmarks"
+  puts
+end
+
+def print_footer
+  puts
+  puts "#" * 70
+  puts "#" + "Benchmarks Complete".center(68) + "#"
+  puts "#" * 70
+  puts
+end
+
+# Main execution
+print_header
+
+benchmarks_to_run = ARGV.empty? ? AVAILABLE_BENCHMARKS : ARGV
+
+benchmarks_to_run.each do |benchmark|
+  if AVAILABLE_BENCHMARKS.include?(benchmark)
+    run_benchmark(benchmark)
+  else
+    puts "Unknown benchmark: #{benchmark}"
+    puts "Available benchmarks: #{AVAILABLE_BENCHMARKS.join(", ")}"
+    exit 1
+  end
+end
+
+print_footer