ruby-standard-library

name	ruby-standard-library
user-invocable	false
description	Use when working with Ruby's standard library including Enumerable, File I/O, Time/Date, Regular Expressions, and core classes.
allowed-tools	["Bash","Read","Write","Edit"]

Ruby Standard Library

Master Ruby's rich standard library. Ruby comes with powerful built-in classes and modules that handle common programming tasks elegantly.

Enumerable

The Enumerable module provides iteration methods for collections.

Common Enumerable Methods

numbers = [1, 2, 3, 4, 5]

# map/collect - Transform elements
numbers.map { |n| n * 2 }  # [2, 4, 6, 8, 10]
numbers.map(&:to_s)        # ["1", "2", "3", "4", "5"]

# select/filter - Keep elements matching condition
numbers.select { |n| n.even? }  # [2, 4]
numbers.filter(&:odd?)          # [1, 3, 5]

# reject - Remove elements matching condition
numbers.reject { |n| n.even? }  # [1, 3, 5]

# find/detect - First element matching condition
numbers.find { |n| n > 3 }  # 4

# find_all - All elements matching condition (alias for select)
numbers.find_all { |n| n > 2 }  # [3, 4, 5]

# reduce/inject - Accumulate values
numbers.reduce(0) { |sum, n| sum + n }  # 15
numbers.reduce(:+)  # 15
numbers.reduce(:*)  # 120

# each - Iterate over elements
numbers.each { |n| puts n }

# each_with_index - Iterate with index
numbers.each_with_index { |n, i| puts "#{i}: #{n}" }

# each_with_object - Iterate with mutable object
numbers.each_with_object({}) { |n, hash| hash[n] = n * 2 }

# any? - True if any element matches
numbers.any? { |n| n > 4 }  # true
numbers.any?(&:even?)       # true

# all? - True if all elements match
numbers.all? { |n| n > 0 }  # true
numbers.all?(&:even?)       # false

# none? - True if no elements match
numbers.none? { |n| n < 0 }  # true

# one? - True if exactly one element matches
numbers.one? { |n| n == 3 }  # true

# partition - Split into two arrays [matching, non-matching]
evens, odds = numbers.partition(&:even?)

# group_by - Group elements by key
numbers.group_by { |n| n % 2 == 0 ? :even : :odd }
# => {:odd=>[1, 3, 5], :even=>[2, 4]}

# chunk - Group consecutive elements
[1, 2, 2, 3, 3, 3, 4].chunk(&:itself).to_a
# => [[1, [1]], [2, [2, 2]], [3, [3, 3, 3]], [4, [4]]]

# take - First n elements
numbers.take(3)  # [1, 2, 3]

# drop - Skip first n elements
numbers.drop(3)  # [4, 5]

# take_while - Elements until condition fails
numbers.take_while { |n| n < 4 }  # [1, 2, 3]

# drop_while - Skip elements until condition fails
numbers.drop_while { |n| n < 4 }  # [4, 5]

# zip - Combine arrays
[1, 2, 3].zip(['a', 'b', 'c'])  # [[1, "a"], [2, "b"], [3, "c"]]

# min, max
numbers.min  # 1
numbers.max  # 5
numbers.minmax  # [1, 5]

# sort
[3, 1, 4, 1, 5].sort  # [1, 1, 3, 4, 5]
['cat', 'dog', 'bird'].sort_by(&:length)

# uniq - Remove duplicates
[1, 2, 2, 3, 3, 3].uniq  # [1, 2, 3]

# compact - Remove nil values
[1, nil, 2, nil, 3].compact  # [1, 2, 3]

# flat_map - Map and flatten
[[1, 2], [3, 4]].flat_map { |arr| arr.map { |n| n * 2 } }  # [2, 4, 6, 8]

# tally - Count occurrences
['a', 'b', 'a', 'c', 'b', 'a'].tally  # {"a"=>3, "b"=>2, "c"=>1}

Arrays

# Creation
arr = [1, 2, 3]
arr = Array.new(3, 0)  # [0, 0, 0]
arr = Array.new(3) { |i| i * 2 }  # [0, 2, 4]

# Access
arr[0]        # First element
arr[-1]       # Last element
arr[1..3]     # Range
arr.first     # 1
arr.last      # 3
arr.at(1)     # 2

# Modification
arr << 4              # Append
arr.push(5)           # Append
arr.unshift(0)        # Prepend
arr.pop               # Remove and return last
arr.shift             # Remove and return first
arr.delete_at(1)      # Delete at index
arr.delete(3)         # Delete value
arr.insert(1, 'a')    # Insert at index

# Combination
[1, 2] + [3, 4]       # [1, 2, 3, 4]
[1, 2] * 2            # [1, 2, 1, 2]
[1, , ] - []       
[, ] & [, ]       
[, ] |

Hashes

# Creation
hash = { name: 'Alice', age: 30 }
hash = Hash.new(0)  # Default value 0
hash = Hash.new { |h, k| h[k] = [] }  # Default block

# Access
hash[:name]           # 'Alice'
hash.fetch(:age)      # 30
hash.fetch(:email, 'N/A')  # With default
hash.dig(:person, :name)   # Safe nested access

# Modification
hash[:email] = '[e-mail]'
hash.delete(:age)
hash.merge!(other_hash)
hash.transform_keys(&:to_s)
hash.transform_values { |v| v.to_s }

# Iteration
hash.each { |key, value| puts "#{key}: #{value}" }
hash.each_key { |key| puts key }
hash.each_value { |value| puts value }

# Query
hash.key?(:name)      # true
hash.value?('Alice')  # true
hash.empty?           # false
hash.size             # 2

# Transformation
hash.keys             # [:name, :age]
hash.values           # ['Alice', 30]
hash.invert           # Swap keys and values
hash.select { |k, v| v.is_a?(String) }
hash.reject { || v.? }
hash.compact          
hash.slice(, )  

Strings

str = "Hello, World!"

# Case
str.upcase            # "HELLO, WORLD!"
str.downcase          # "hello, world!"
str.capitalize        # "Hello, world!"
str.swapcase          # "hELLO, wORLD!"
str.titleize          # Requires ActiveSupport

# Trimming
"  hello  ".strip    # "hello"
"  hello  ".lstrip   # "hello  "
"  hello  ".rstrip   # "  hello"

# Searching
str.include?("World")    # true
str.start_with?("Hello") # true
str.end_with?("!")       # true
str.index("World")       # 7
str.rindex("o")          # 8

# Splitting and joining
"a,b,c".split(",")       # ["a", "b", "c"]
["a", "b", "c"].join("-")  # "a-b-c"

# Replacement
str.sub("World", "Ruby")    # Replace first
str.gsub("o", "0")          # Replace all
str.delete("l")             # Remove characters
str.tr("aeiou", "12345")    # Translate characters

# Substring
str[0]                
str[..]             
str[..]              
str.slice(, )       


str.empty?            
str.length            
str.size              
str.count()        


.to_i            
.to_f           
.to_s          


str.encoding          
str.force_encoding()
str.encode()


text = 

Regular Expressions

# Creation
regex = /pattern/
regex = Regexp.new("pattern")

# Matching
"hello" =~ /ll/               # 2 (index)
"hello" !~ /zz/               # true
"hello".match(/l+/)           # #<MatchData "ll">
"hello".match?(/l+/)          # true (faster, no MatchData)

# Match data
match = "hello123".match(/(\w+)(\d+)/)
match[0]                      # "hello123" (full match)
match[1]                      # "hello" (first group)
match[2]                      # "123" (second group)

# Named captures
match = "hello123".match(/(?<word>\w+)(?<num>\d+)/)
match[:word]                  # "hello"
match[:num]                   # "123"

# String methods with regex
"hello world".scan(/\w+/)     # ["hello", "world"]
"a1b2c3".scan(/\d/)           # ["1", "2", "3"]

"hello".sub(/l/, 'L')         # "heLlo"
"hello".gsub(/l/, 'L')        # "heLLo"

"a:b:c".split()            


/pattern/i                    
/pattern/m                    
/pattern/x                    


/\d+\w+\s+^start/                      
/                        
/[aeiou]/                     
/[^aeiou]/                    
/(cat|

File I/O

# Reading
content = File.read("file.txt")
lines = File.readlines("file.txt")

File.open("file.txt", "r") do |file|
  file.each_line do |line|
    puts line
  end
end

# Writing
File.write("file.txt", "content")

File.open("file.txt", "w") do |file|
  file.puts "line 1"
  file.puts "line 2"
end

# Appending
File.open("file.txt", "a") do |file|
  file.puts "appended line"
end

# File modes
# "r"  - Read only
# "w"  - Write (truncate)
# "a"  - Append
# "r+" - Read and write
# "w+" - Read and write (truncate)
# "a+" - Read and append

# File operations
File.exist?("file.txt")       # true/false
File.file?("file.txt")        # Is it a file?
File.directory?("dir")        # Is it a directory?
.size()         
.mtime()        
.basename()  
.dirname()   
.extname()      
.join(, , )  


.entries()              
.glob()              
.glob()           

.mkdir()
.rmdir()
.pwd                       
.chdir()            

.mkdir_p()    
.rm_rf()        
.cp(, )   
.mv(, )   

Time and Date

require 'time'
require 'date'

# Time
now = Time.now
utc = Time.now.utc
local = Time.now.localtime

# Components
now.year              # 2024
now.month             # 11
now.day               # 25
now.hour              # 14
now.min               # 30
now.sec               # 45
now.wday              # Day of week (0=Sunday)

# Creation
Time.new(2024, 11, 25, 14, 30, 45)
Time.parse("2024-11-25 14:30:45")
Time.at(1700000000)   # From Unix timestamp

# Formatting
now.strftime("%Y-%m-%d %H:%M:%S")
now.strftime("%B %d, %Y")          # November 25, 2024
now.iso8601                        # ISO 8601 format

# Arithmetic
now + 3600            # Add 1 hour (in seconds)
now - 86400           # Subtract 1 day
time2 - time1         # Difference in seconds

# Date
date = Date.today
date = Date.new(2024, 11, 25)
date = Date.parse("2024-11-25")

date.year             
date.month            
date.day              
date.wday             

date +               
date -               
date.next_day         
date.prev_day         
date.next_month       
date.prev_year        


dt = .now
dt = .parse()

Range

# Inclusive
(1..5).to_a           # [1, 2, 3, 4, 5]

# Exclusive
(1...5).to_a          # [1, 2, 3, 4]

# Methods
(1..10).include?(5)   # true
(1..10).cover?(5)     # true (faster)
(1..10).member?(5)    # true

(1..5).each { |n| puts n }
(1..5).map { |n| n * 2 }

# String ranges
('a'..'e').to_a       # ["a", "b", "c", "d", "e"]

# Case statement
case age
when 0..12
  "child"
when 13..19
  "teen"
else
  "adult"
end

Set

require 'set'

# Creation
set = Set.new([1, 2, 3])
set = Set[1, 2, 3]

# Operations
set.add(4)
set << 5
set.delete(3)

# Set operations
set1 | set2           # Union
set1 & set2           # Intersection
set1 - set2           # Difference
set1 ^ set2           # Symmetric difference

# Query
set.include?(2)       # true
set.empty?            # false
set.size              # 3

# Subset/superset
set1.subset?(set2)
set1.superset?(set2)

Best Practices

1. Use Enumerable methods instead of manual loops
2. Chain methods for readability: array.select(&:even?).map(&:to_s)
3. Use symbol-to-proc (&:method_name) when possible
4. Prefer File.open with blocks for automatic file closing
5. Use fetch for hashes when you want to handle missing keys
6. Leverage lazy enumerables for large collections
7. Use Pathname for complex path operations

Anti-Patterns

❌ Don't use for loops - use Enumerable methods ❌ Don't forget to close files - use blocks with File.open ❌ Don't use each for transformation - use map ❌ Don't use each for filtering - use select or reject ❌ Don't mutate arrays while iterating - use methods that return new arrays

Related Skills

• ruby-oop - For understanding core classes
• ruby-blocks-procs-lambdas - For working with Enumerable
• ruby-metaprogramming - For advanced library usage