Use when working with Ruby's standard library including Enumerable, File I/O, Time/Date, Regular Expressions, and core classes.
Applies Ruby's standard library methods for collections, files, dates, and regular expressions.
npx claudepluginhub thebushidocollective/hanThis skill is limited to using the following tools:
Master Ruby's rich standard library. Ruby comes with powerful built-in classes and modules that handle common programming tasks elegantly.
The Enumerable module provides iteration methods for collections.
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}
# 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, 2, 3] - [2] # [1, 3]
[1, 2] & [2, 3] # [2] (intersection)
[1, 2] | [2, 3] # [1, 2, 3] (union)
# Query
arr.include?(2) # true
arr.empty? # false
arr.length # 3
arr.count # 3
arr.count(2) # Count occurrences
# Transformation
arr.reverse # [3, 2, 1]
arr.flatten # Flatten nested arrays
arr.compact # Remove nils
arr.uniq # Remove duplicates
arr.join(', ') # Convert to string
arr.sample # Random element
arr.shuffle # Random order
# 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] = 'alice@example.com'
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 { |k, v| v.nil? }
hash.compact # Remove nil values
hash.slice(:name, :age) # Extract subset
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] # "H"
str[0..4] # "Hello"
str[7..] # "World!"
str.slice(0, 5) # "Hello"
# Query
str.empty? # false
str.length # 13
str.size # 13
str.count("l") # 3
# Conversion
"123".to_i # 123
"3.14".to_f # 3.14
:symbol.to_s # "symbol"
# Encoding
str.encoding # #<Encoding:UTF-8>
str.force_encoding("ASCII")
str.encode("ISO-8859-1")
# Multiline
text = <<~HEREDOC
This is a
multiline string
with indentation removed
HEREDOC
# 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(/:/) # ["a", "b", "c"]
# Flags
/pattern/i # Case insensitive
/pattern/m # Multiline
/pattern/x # Extended (ignore whitespace)
# Common patterns
/\d+/ # One or more digits
/\w+/ # One or more word characters
/\s+/ # One or more whitespace
/^start/ # Start of string
/end$/ # End of string
/[aeiou]/ # Character class
/[^aeiou]/ # Negated class
/(cat|dog)/ # Alternation
# 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?
File.size("file.txt") # Size in bytes
File.mtime("file.txt") # Modification time
File.basename("/path/to/file.txt") # "file.txt"
File.dirname("/path/to/file.txt") # "/path/to"
File.extname("file.txt") # ".txt"
File.join("path", "to", "file.txt") # "path/to/file.txt"
# Directory operations
Dir.entries(".") # List directory
Dir.glob("*.rb") # Pattern matching
Dir.glob("**/*.rb") # Recursive
Dir.mkdir("new_dir")
Dir.rmdir("old_dir")
Dir.pwd # Current directory
Dir.chdir("/path") # Change directory
FileUtils.mkdir_p("a/b/c") # Create nested dirs
FileUtils.rm_rf("dir") # Remove recursively
FileUtils.cp("src", "dest") # Copy file
FileUtils.mv("src", "dest") # Move file
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 # 2024
date.month # 11
date.day # 25
date.wday # 1 (Monday)
date + 7 # Add 7 days
date - 7 # Subtract 7 days
date.next_day # Tomorrow
date.prev_day # Yesterday
date.next_month # Next month
date.prev_year # Last year
# DateTime (combines Date and Time)
dt = DateTime.now
dt = DateTime.parse("2024-11-25T14:30:45")
# 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
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)
array.select(&:even?).map(&:to_s)&:method_name) when possiblefetch for hashes when you want to handle missing keysPathname for complex path operations❌ 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
Activates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Search, retrieve, and install Agent Skills from the prompts.chat registry using MCP tools. Use when the user asks to find skills, browse skill catalogs, install a skill for Claude, or extend Claude's capabilities with reusable AI agent components.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.