ruby-development

Senior Ruby developer using functional programming techniques. Use when writing Ruby code, implementing Ruby features, or working with Ruby projects. Follows TDD methodology via development skill. Used as a part of the XP skill.

⭐3stars🔀0forks📁View on GitHub🕐Updated Jan 3, 2026

When & Why to Use This Skill

This Ruby Development skill acts as a senior-level programming assistant specialized in functional Ruby techniques and Test-Driven Development (TDD). It helps developers write cleaner, more maintainable code by enforcing immutability, single-return functions, and declarative patterns over imperative loops. By integrating industry-standard testing (RSpec/Minitest) and linting (Rubocop) practices, it ensures high-quality software delivery within Extreme Programming (XP) environments.

Use Cases

  • Functional Refactoring: Converting complex imperative loops and mutable state logic into clean, chainable functional operations using map, reduce, and select.
  • Test-Driven Development: Generating robust test suites following the Arrange-Act-Assert (AAA) pattern to ensure feature reliability and prevent regressions.
  • Code Quality & Linting: Automatically identifying and fixing style inconsistencies or non-idiomatic Ruby code using Rubocop standards.
  • Immutable Architecture Design: Implementing data structures and constants with strict freezing to prevent side effects in multi-threaded or complex Ruby applications.
nameRuby Development
descriptionSenior Ruby developer using functional programming techniques. Use when writing Ruby code, implementing Ruby features, or working with Ruby projects. Follows TDD methodology via development skill. Used as a part of the XP skill.

Ruby Development

Principles

  • Functional programming techniques
  • Single return per function (no early returns)
  • Prefer immutable data structures (freeze objects)
  • Use map, reduce, select, reject over imperative loops
  • Favour composition over inheritance

Testing

Use project's existing test framework. Test structure follows AAA pattern:

describe 'ClassName' do
  describe '#method_name' do
    it 'describes expected behaviour' do
      # Arrange
      input = build_test_data

      # Act
      result = subject.method_name(input)

      # Assert
      expect(result).to eq(expected)
    end
  end
end

Run tests:

bundle exec rspec           # RSpec
bundle exec rake test       # Minitest

Linting

bundle exec rubocop         # Check style
bundle exec rubocop -a      # Auto-fix safe issues
bundle exec rubocop -A      # Auto-fix all (review changes)

Functional Patterns

Transform with map:

# ❌ Imperative
results = []
items.each { |i| results << transform(i) }

# ✅ Functional
results = items.map { |i| transform(i) }

Filter with select/reject:

valid_items = items.select(&:valid?)
invalid_items = items.reject(&:valid?)

Reduce for accumulation:

total = items.reduce(0) { |sum, item| sum + item.value }

Chain operations:

items
  .select(&:active?)
  .map(&:transform)
  .reduce(initial) { |acc, x| combine(acc, x) }

Immutability:

CONSTANTS = ['a', 'b', 'c'].freeze
hash = { key: 'value' }.freeze