sortsmith 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb5b3aee0492a9a38de3999f07444c05e0e7ad00c86c3c3f6a87be19151e5b23
-  data.tar.gz: e3a1f4497ffc436f56ee881e58086e23dc0009357e1bfe3cd9393dc4642162de
+  metadata.gz: 16b369873631fe1de4c59f32bbbf5fbdb383ee1b3924a864ccd11a2ac6c4f1d5
+  data.tar.gz: cb329eecad62b7cf05e13624258fc09dd4a21e0aab192e50774a8e2a6c6beed3
 SHA512:
-  metadata.gz: 64d378b0764c272de8ba01a1230ef7457ea36627712c5c38f1531b9d57e1ca44e2627bb880aeede760f0bfc168cfdffccea8d1b3577e07daa8fe64181e3cb8cd
-  data.tar.gz: 373dea1996fbe61a6c2e0cf3095c761b4b388f52932e78e8e43f1d3e7cac696d949ecf2233cd4f8d89c77cd1133c9aa6b2e84d40fc0e9c70d7e5795b5e65b84a
+  metadata.gz: e3ada898d22d88aabe5c314dc67ac35dced713ec5f7bced55ec4ca87d12f10cd62b9fe218d6acb45831d9ec62734917d72c5343dce56b15bace088b23188bc95
+  data.tar.gz: e362605cde0d51b9eb63ef435e69cf13d91651ff2a9ba22dfe07a8cdd1e33c9c8bb0ce695c0914bfb3579226a3306c2d4d03f029752c25f8b17dbff22133fb1d

data/CHANGELOG.md

@@ -5,6 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+<!--
 ## [Unreleased]
 
 ### Added
@@ -12,6 +13,146 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 ### Removed
+-->
+
+## [1.0.0] - 12025-08-03
+
+### 🎉 API Stability Milestone
+
+Sortsmith has reached 1.0.0! After evolving through several major API redesigns and proving itself in real projects, the core interface is now stable and ready for broader adoption.
+
+**What 1.0.0 means:**
+- **Stable API**: Method signatures and behavior are locked for semver compatibility
+- **Complete Vision**: From the verbose early days to today's clean `collection.sort_by(:name).insensitive.desc.sort`, the API finally feels right
+- **Battle Tested**: Handles the weird edge cases and mixed data types you actually encounter in real Ruby apps
+
+This represents the sorting library I always wished Ruby had built-in. Simple things are simple, complex things are possible, and it all reads like English.
+
+### Added
+
+#### Universal Field Extraction
+
+- **Direct syntax**: `sort_by(field, **opts)` - Sort by any field/method without explicit chaining
+- **Object method extraction**: `method(*args, **kwargs)` - Call methods on objects with full argument support
+- **Mixed key handling**: Enhanced `indifferent: true` support across all extractors
+
+#### Semantic Aliases for Better Readability
+
+- `key` - Alias for `dig` (emphasizes hash key extraction)
+- `field` - Alias for `dig` (emphasizes object field access)
+- `attribute` - Alias for `method` (emphasizes object attribute access)
+- `case_insensitive` - Alias for `insensitive`/`downcase` (explicit case handling)
+
+#### Seamless Enumerable Integration
+
+- **Delegated methods**: `first`, `last`, `take`, `drop`, `each`, `map`, `select`, `[]`, `size`, `count`, `length`
+- **Fluent chaining**: Sort operations flow directly into array operations without breaking
+- **Full argument support**: All delegated methods support blocks, arguments, and return appropriate types
+
+#### Enhanced Terminators
+
+- `to_a!` - Mutating version of `to_a` for consistency with `sort!`
+
+## [0.9.0] - 12025-07-06
+
+### 🎉 MAJOR REWRITE: Fluent Chainable API
+
+**BREAKING CHANGES**: Complete API redesign introducing a fluent, chainable interface. See migration guide below.
+
+**Pre-1.0 Notice**: This release represents our new stable API design, but we're seeking community feedback before locking in 1.0.0 compatibility guarantees.
+
+### Added
+
+#### Core API Transformation
+
+- **Fluent API**: Direct extension of `Enumerable#sort_by` for natural Ruby integration
+- **Chainable Interface**: Method chaining that reads like English: `users.sort_by.dig(:name).downcase.desc.sort`
+- **Universal `dig` Method**: Single extraction method that works with hashes, objects, and nested structures
+- **Indifferent Key Access**: Handle mixed symbol/string hash keys with `dig(:name, indifferent: true)`
+
+#### New Extraction Methods
+
+- `dig(*identifiers, indifferent: false)` - Extract values from hashes, objects, or nested structures
+- Support for nested extraction: `dig(:user, :profile, :email)`
+- Automatic fallback to method calls for non-hash objects
+
+#### Enhanced Modifiers
+
+- `downcase` / `upcase` - Case transformations with automatic type checking
+- `insensitive` - Alias for `downcase` for semantic clarity
+- `asc` / `desc` - Explicit sort direction control
+- Smart modifier chaining that only affects compatible data types
+
+#### Multiple Terminators
+
+- `sort` - Returns new sorted array (non-mutating)
+- `sort!` - Mutates original array in place
+- `reverse` - Shorthand for `desc.sort`
+- `reverse!` - Shorthand for `desc.sort!`
+- `to_a` - Alias for `sort` for semantic clarity
+
+#### Backward Compatibility
+
+- `sort_by` with block maintains original Ruby behavior
+- `sort_by` without block returns Sortsmith::Sorter instance
+- Zero breaking changes for existing Ruby code
+
+### Changed
+
+#### API Design Philosophy
+
+- **Before**: `Sortsmith::Sorter.new(collection).by_key(:name).case_insensitive.desc.sort`
+- **After**: `collection.sort_by.dig(:name).insensitive.desc.sort`
+
+#### Improved Ergonomics
+
+- No more explicit `Sorter.new()` instantiation required
+- Tab-completable method discovery
+- Natural language flow in method chains
+- Unified `dig` method replaces separate `by_key`/`by_method` methods
+
+#### Enhanced Ruby Version Support
+
+- **Restored Ruby 3.0 and 3.1 compatibility** - Previously removed in v0.2.0, now supported again
+- Full compatibility matrix: Ruby 3.0.7, 3.1.7, 3.2.8, 3.3.8, 3.4.4
+- Expanded from Ruby 3.2+ requirement back to Ruby 3.0+ for broader accessibility
+
+### Removed
+
+#### Legacy API (Breaking Changes)
+
+- `by_key` method (replaced by `dig`)
+- `by_method`/`by_attribute` methods (replaced by `dig`)
+- `case_insensitive` method (replaced by `insensitive`/`downcase`)
+- `Sortsmith::Step` class (internal restructure)
+- Manual `Sorter.new()` instantiation requirement
+- `rbs` and `steep` type checking
+
+### Migration Guide
+
+The new API is more concise and intuitive, but requires updating existing code:
+
+```ruby
+# v0.2.x (OLD)
+Sortsmith::Sorter.new(users).by_key(:name).case_insensitive.desc.sort
+
+# v0.9.x (NEW)
+users.sort_by.dig(:name).insensitive.desc.sort
+
+# v0.2.x (OLD)
+Sortsmith::Sorter.new(objects).by_method(:calculate_score).sort
+
+# v0.9.x (NEW)
+objects.sort_by.dig(:calculate_score).sort
+```
+
+### Technical Improvements
+
+- Complete test suite rewrite with comprehensive edge case coverage
+- Enhanced error handling for mixed data types
+- Improved performance through reduced object allocations
+- Cleaner internal architecture with separation of concerns
+- Better documentation with extensive API examples
 
 ## [0.2.0] - 12025-02-17
 
@@ -30,11 +171,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.1] - 12025-01-15
 
 ### Changed
+
 - Improved handling of non-string objects when sorting
 
 ## [0.1.0] - 12025-01-14
 
 ### Added
+
 - Initial implementation of `Sortsmith::Sorter`
 - Support for case-insensitive sorting
 - Support for sorting by hash keys and object methods
@@ -42,7 +185,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Type checking with Steep/RBS
 - GitHub Actions workflow for automated testing and type checking
 
-[unreleased]: https://github.com/itsthedevman/sortsmith/compare/v0.2.0...HEAD
+[unreleased]: https://github.com/itsthedevman/sortsmith/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/itsthedevman/sortsmith/compare/v0.9.0...v1.0.0
+[0.9.0]: https://github.com/itsthedevman/sortsmith/compare/v0.2.0...v0.9.0
 [0.2.0]: https://github.com/itsthedevman/sortsmith/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/itsthedevman/sortsmith/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/itsthedevman/sortsmith/compare/ac357965a1bc641d187333a5b032c5a423020ae9...v0.1.0

data/README.md

@@ -1,17 +1,66 @@
 # Sortsmith
 
 [![Gem Version](https://badge.fury.io/rb/sortsmith.svg)](https://badge.fury.io/rb/sortsmith)
+![Ruby Version](https://img.shields.io/badge/ruby-3.1+-ruby)
 [![Tests](https://github.com/itsthedevman/sortsmith/actions/workflows/main.yml/badge.svg)](https://github.com/itsthedevman/sortsmith/actions/workflows/main.yml)
-![Ruby Version](https://img.shields.io/badge/ruby-3.3.6-ruby)
 
-Sortsmith is a flexible sorting library for Ruby that makes complex sorting operations simple and composable. It makes handling common sorting patterns like case-insensitive sorting of hashes and objects easy, while remaining extensible for custom sorting needs.
+**Sortsmith** makes sorting Ruby collections feel natural and fun. Instead of wrestling with verbose blocks or complex comparisons, just chain together what you want in plain English.
 
-## Features
+```ruby
+# Instead of this...
+users.sort_by { |user| user[:name].downcase }.reverse
+
+# Write this!
+users.sort_by.dig(:name).downcase.reverse
+```
+
+Sortsmith extends Ruby's built-in `sort_by` method with a fluent, chainable API that handles the messy details so you can focus on expressing _what_ you want sorted, not _how_ to sort it.
+
+## Table of Contents
+
+- [Why Sortsmith?](#why-sortsmith)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Core Concepts](#core-concepts)
+- [Usage Examples](#usage-examples)
+  - [Array Sorting](#array-sorting)
+  - [Hash Collections](#hash-collections)
+  - [Object Collections](#object-collections)
+  - [Mixed Key Types](#mixed-key-types)
+- [API Reference](#api-reference)
+- [Migration from v0.2.x](#migration-from-v02x)
+- [Development](#development)
+- [Contributing](#contributing)
+- [License](#license)
 
-- Builder pattern for chainable sorting configuration
-- Built-in support for case-insensitive sorting
-- Hash key and method/attribute sorting
-- Flexible transformation pipeline
+## Why Sortsmith?
+
+Ruby's `sort_by` is powerful, but real-world sorting often gets messy:
+
+```ruby
+# Sorting users by name, case-insensitive, descending
+users.sort_by { |u| u[:name].to_s.downcase }.reverse
+
+# What if some names are nil?
+users.sort_by { |u| (u[:name] || "").downcase }.reverse
+
+# What about mixed string/symbol keys?
+users.sort_by { |u| (u[:name] || u["name"] || "").downcase }.reverse
+```
+
+Sortsmith handles all the edge cases and gives you a clean, readable API:
+
+```ruby
+users.sort_by.dig(:name, indifferent: true).insensitive.desc.sort
+```
+
+**Features:**
+
+- **Fluent chaining** - Reads like English
+- **Universal extraction** - Works with hashes, objects, and nested data
+- **Indifferent key access** - Handles mixed symbol/string keys automatically
+- **Nil-safe** - Graceful handling of missing data
+- **Minimal overhead** - Extends existing Ruby methods without breaking compatibility
 
 ## Installation
 
@@ -33,99 +82,259 @@ Or install it yourself as:
 $ gem install sortsmith
 ```
 
-## Usage
+## Quick Start
 
-### Basic Sorting
+Sortsmith extends Ruby's `sort_by` method with a fluent, chainable API. Use it with or without a block for maximum flexibility:
 
 ```ruby
-# Sort an array of Strings
-users = ["Bob", "Alice", "Carol"]
+require "sortsmith"
+
+# Direct syntax for simple cases (NEW!)
+names = ["charlie", "Alice", "bob"]
+names.sort_by(:name).insensitive.sort
+# => ["Alice", "bob", "charlie"]
 
-sorted_users = Sortsmith::Sorter.new(users).sort
+# Or use the chainable API for complex scenarios
+users = [
+  { name: "Charlie", age: 25 },
+  { name: "Alice", age: 30 },
+  { name: "Bob", age: 20 }
+]
 
-# Result: ["Alice", "Bob", "Carol"]
+users.sort_by.dig(:name).sort
+# => [{ name: "Alice", age: 30 }, { name: "Bob", age: 20 }, { name: "Charlie", age: 25 }]
+
+# Seamless integration with enumerable methods (NEW!)
+users.sort_by(:age).desc.first(2)
+# => [{ name: "Alice", age: 30 }, { name: "Charlie", age: 25 }]
+
+# The original sort_by with blocks still works exactly the same!
+users.sort_by { |u| u[:age] }
+# => [{ name: "Bob", age: 20 }, { name: "Charlie", age: 25 }, { name: "Alice", age: 30 }]
+```
+
+## Core Concepts
+
+Sortsmith uses a simple pipeline concept where each step is **optional** except for the terminator:
+
+1. **Extract** - Get the value to sort by (`dig`, `method`, etc.) - _optional_
+2. **Transform** - Modify the value for comparison (`downcase`, `upcase`, etc.) - _optional_
+3. **Order** - Choose sort direction (`asc`, `desc`) - _optional_
+4. **Execute** - Run the sort (`sort`, `sort!`, `reverse`, `to_a`, etc.) - **required**
+
+```ruby
+collection.sort_by.dig(:field).downcase.desc.sort
+#          ↑       ↑           ↑        ↑    ↑
+#          |    extract   transform  order execute
+#       chainable  (opt)      (opt)   (opt) (required)
+```
+
+**Minimal example:**
+
+```ruby
+# This works! (though not particularly useful)
+users.sort_by.sort  # Same as users.sort
+
+# More practical examples
+users.sort_by.dig(:name).sort           # Extract only
+users.sort_by.downcase.sort             # Transform only
+users.sort_by.desc.sort                 # Order only
+users.sort_by.dig(:name).desc.sort      # Extract + order
 ```
 
-### Hash Sorting
+Each step builds on the previous ones, so you can mix and match based on what your data needs. The only requirement is ending with a terminator to actually execute the sort.
+
+## Usage Examples
+
+### Simple Direct Syntax
 
 ```ruby
-# Sort an array of hashes by a key
+# Clean and direct for common operations
+words = ["elephant", "cat", "butterfly"]
+words.sort_by(:length).desc.sort
+# => ["butterfly", "elephant", "cat"]
+
+# Works great with hashes
 users = [
-  { name: "Carol", age: 35 },
-  { name: "Bob", age: 25 },
-  { name: "Alice", age: 30 }
+  { name: "Cat", score: 99 },
+  { name: "Charlie", score: 85 },
+  { name: "karen", score: 50 },
+  { name: "Alice", score: 92 },
+  { name: "bob", score: 78 },
 ]
 
-sorted_users = Sortsmith::Sorter.new(users)
-  .by_key(:name)
-  .sort
-
-# Result: [{ name: "Alice" }, { name: "Bob" }, { name: "Carol" }]
+# Get top 3 by score
+users.sort_by(:score).desc.first(3)
+# => [{ name: "Cat", score: 99 }, { name: "Alice", score: 92 }, { name: "Charlie", score: 85 }]
 ```
 
-### Object Sorting
+### Object Method Sorting
 
 ```ruby
-# Sort objects by method/attribute
-class User < Data.define(:name)
-end
+User = Struct.new(:name, :age, :city)
+
+users = [
+  User.new("Charlie", 25, "NYC"),
+  User.new("Alice", 30, "LA"),
+  User.new("bob", 20, "Chicago")
+]
 
-users = [User.new(name: "Bob"), User.new(name: "Carol"), User.new(name: "Alice")]
+# Sort by any method or attribute
+users.sort_by.method(:name).insensitive.sort
+# => [User.new("Alice"), User.new("bob"), User.new("Charlie")]
 
-sorted_users = Sortsmith::Sorter.new(users)
-  .by_method(:name)
-  .sort
+# Or use the semantic alias
+users.sort_by.attribute(:age).desc.first
+# => User.new("Alice", 30, "LA")
 
-# Result: [#<data User name="Alice">, #<data User name="Bob">, #<data User name="Carol">]
+# Methods with arguments work too
+class Product
+  def price_in(currency)
+    # calculation logic
+  end
+end
+
+products.sort_by.method(:price_in, "USD").sort
 ```
 
-### Case Insensitive Sorting
+### Hash Collections with Multiple Access Patterns
 
 ```ruby
 users = [
-  {"name" => "bob"},
-  {"name" => "Billy"},
-  {"name" => "Alice"},
-  {"name" => "carol"},
-  {"name" => "Cassidy"},
-  {"name" => "alex"}
+  { name: "Charlie", score: 85, team: "red" },
+  { name: "Alice", score: 92, team: "blue" },
+  { name: "bob", score: 78, team: "red" }
 ]
 
-# Order of methods does not matter
-# However, the hash's key type does
-sorted_users = Sortsmith::Sorter.new(users)
-    .case_insensitive
-    .by_key("name")
-    .sort
+# Multiple semantic ways to express extraction
+users.sort_by.key(:name).insensitive.sort      # Emphasizes hash keys
+users.sort_by.field(:score).desc.sort          # Emphasizes data fields
+users.sort_by.dig(:team, :name).sort           # Nested access
 
-# Result: [{"name"=>"Alice"}, {"name"=>"alex"}, {"name"=>"Billy"}, {"name"=>"bob"}, {"name"=>"Cassidy"}, {"name"=>"carol"}]
+# Case handling with explicit naming
+users.sort_by(:name).case_insensitive.reverse
+# => [{ name: "bob" }, { name: "Charlie" }, { name: "Alice" }]
 ```
 
-### Reverse Sorting
+### Seamless Enumerable Integration
 
 ```ruby
-# Sort in descending order
-sorted_desc = Sortsmith::Sorter.new(array)
-  .by_attribute(:name)
-  .desc
-  .sort
+# Chain directly into enumerable methods - no .to_a needed!
+users.sort_by(:score).desc.first(2)           # Top 2 performers
+users.sort_by(:name).each { |u| puts u }      # Iterate in order
+users.sort_by(:team).map(&:name)              # Transform sorted results
+users.sort_by(:score).select { |u| u[:active] } # Filter sorted results
+
+# Array access works too
+users.sort_by(:score).desc[0]                 # Best performer
+users.sort_by(:name)[1..3]                    # Users 2-4 alphabetically
+
+# Quick stats
+users.sort_by(:score).count                   # Total count
+users.sort_by(:team).count { |u| u[:active] } # Conditional count
+```
+
+### Mixed Key Types
+
+Real-world data often has inconsistent key types. Sortsmith handles this gracefully:
+
+```ruby
+mixed_users = [
+  { name: "Charlie" },        # symbol key
+  { "name" => "Alice" },      # string key
+  { :name => "Bob" },         # symbol key again
+  { "name" => "Diana" }       # string key again
+]
+
+# The indifferent option handles both key types
+mixed_users.sort_by.dig(:name, indifferent: true).sort
+# => [{ "name" => "Alice" }, { :name => "Bob" }, { name: "Charlie" }, { "name" => "Diana" }]
+
+# Without indifferent access, you'd get sorting failures or unexpected results
+```
+
+**Performance Note**: Indifferent key access adds modest overhead (~2x slower depending on the machine) but operates in microseconds and is typically worth the convenience for mixed-key scenarios.
+
+```ruby
+# Rails users can also normalize keys upfront for better performance
+mixed_users.map(&:symbolize_keys).sort_by.dig(:name).sort
+
+# But indifferent access is handy when you can't control the data source
+api_response.sort_by.dig(:name, indifferent: true).sort
+```
+
+## API Reference
+
+### Universal Extraction
+
+- **`sort_by(field, **opts)`\*\* - Direct field extraction (NEW!)
+  - Works with hashes, objects, and any method name
+  - Supports all the same options as `dig` and `method`
+
+### Extractors
+
+- **`dig(*identifiers, indifferent: false)`** - Extract values from hashes, objects, or nested structures
+- **`method(method_name, \*args, **kwargs)`\*\* - Call methods on objects with arguments (NEW!)
+- **`key(\*identifiers, **opts)`** - Alias for `dig` (semantic clarity for hash keys) (NEW!)
+- **`field(\*identifiers, **opts)`** - Alias for `dig` (semantic clarity for object fields) (NEW!)
+- **`attribute(method_name, \*args, **kwargs)`** - Alias for `method` (semantic clarity) (NEW!)
+
+### Modifiers
+
+- **`downcase`** - Convert extracted strings to lowercase for comparison
+- **`upcase`** - Convert extracted strings to uppercase for comparison
+- **`insensitive`** - Alias for `downcase` (semantic clarity)
+- **`case_insensitive`** - Alias for `downcase` (explicit case handling) (NEW!)
+
+### Ordering
+
+- **`asc`** - Sort in ascending order (default)
+- **`desc`** - Sort in descending order
+
+### Terminators
+
+- **`sort`** - Execute sort and return new array
+- **`sort!`** - Execute sort and mutate original array
+- **`to_a`** - Alias for `sort`
+- **`to_a!`** - Alias for `sort!` (NEW!)
+- **`reverse`** - Shorthand for `desc.sort`
+- **`reverse!`** - Shorthand for `desc.sort!`
+
+### Delegated Enumerable Methods (NEW!)
+
+The following methods execute the sort and delegate to the resulting array:
+
+- **`first(n=1)`**, **`last(n=1)`** - Get first/last n elements
+- **`take(n)`**, **`drop(n)`** - Take/drop n elements
+- **`each`**, **`map`**, **`select`** - Standard enumerable operations
+- **`[](index)`** - Array access by index or range
+- **`size`**, **`count`**, **`length`** - Size information
+
+```ruby
+# All of these execute the sort first, then apply the operation
+users.sort_by(:score).desc.first(3)    # Get top 3
+users.sort_by(:name).take(5)           # Take first 5 alphabetically
+users.sort_by(:team)[0]                # First by team name
+users.sort_by(:score).size             # Total size after sorting
 ```
 
 ## Development
 
 ### Prerequisites
 
-- Ruby 3.3.6
+- Ruby 3.0+
 - Nix with Direnv (optional, but recommended)
 
 ### Setting Up the Development Environment
 
 With Nix:
+
 ```bash
 direnv allow
 ```
 
 Without Nix:
+
 ```bash
 bundle install
 ```
@@ -136,12 +345,6 @@ bundle install
 bundle exec rake test
 ```
 
-### Type Checking
-
-```bash
-bundle exec steep check
-```
-
 ### Code Style
 
 This project uses StandardRB. To check your code:
@@ -168,7 +371,7 @@ Please note that this project is released with a [Contributor Code of Conduct](C
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](LICENSE.md).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
 ## Changelog
 
@@ -177,3 +380,9 @@ See [CHANGELOG.md](CHANGELOG.md) for a list of changes.
 ## Credits
 
 - Author: Bryan "itsthedevman"
+
+## Looking for a Software Engineer?
+
+I'm currently looking for opportunities where I can tackle meaningful problems and help build reliable software while mentoring the next generation of developers. If you're looking for a senior engineer with full-stack Rails expertise and a passion for clean, maintainable code, let's talk!
+
+[bryan@itsthedevman.com](mailto:bryan@itsthedevman.com)

data/flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1736798957,
-        "narHash": "sha256-qwpCtZhSsSNQtK4xYGzMiyEDhkNzOCz/Vfu4oL2ETsQ=",
+        "lastModified": 1751792365,
+        "narHash": "sha256-J1kI6oAj25IG4EdVlg2hQz8NZTBNYvIS0l4wpr9KcUo=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "9abb87b552b7f55ac8916b6fc9e5cb486656a2f3",
+        "rev": "1fd8bada0b6117e6c7eb54aad5813023eed37ccb",
         "type": "github"
       },
       "original": {

data/flake.nix

@@ -1,21 +1,27 @@
 {
-  description = "Ruby 3.4 development environment";
+  description = "Ruby 3.2 development environment";
 
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
       let
         pkgs = nixpkgs.legacyPackages.${system};
       in
       {
         devShells.default = pkgs.mkShell {
           buildInputs = with pkgs; [
-            (ruby_3_4.override {
-              jemallocSupport = true;
+            (ruby_3_2.override {
+              jemallocSupport = false;
               docSupport = false;
             })