hash_of 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abd0405b2537b883cf128551077589f57e7222a0c768fc831c0a34c87d1f4c59
-  data.tar.gz: c7c16a9e52d80c23e5e139a415732ca11f21cbe1ec82f3566126fd7e4ae269e6
+  metadata.gz: 1031246240479bb3f4c2256f542bb1530e34878371458c255615133eb14c3d25
+  data.tar.gz: 9589f482f2dc1d8e29c7b80b264ddac410b965654d55fbcffcd1e08c0d3961ea
 SHA512:
-  metadata.gz: 02daed3abcb45213c7f7750ea9117b7962f628f7bcd367591b2485735c5e069da49a9a56301957d8972587a683d4d841dd3b6dae0681ef116611bf5755cee3a4
-  data.tar.gz: 540208b6ee76af2253f98adb7248bd1dadf797a30085b896ca9e3c73e79264073c743d0a8de7b34ee3359acff35afe9a5d8fa91853d2d00c2f7e8e0cb3bb286a
+  metadata.gz: 0053fc60c174a1fef807f5c8d6ef6976842961419a39fa4059d2aaaed23e45da5831bd1a95687c3d798e852aadb0ba54e4bfbe47898d9dd2cdaf5a28af64853b
+  data.tar.gz: d9301de5ec5afd829a3020922bce0a01d7544ea4b1775fbddc1d41f3235db65ef76275130a2839d15875f2a690b3443374ba9889ceadaa50924443d9daf95152

data/.rubocop.yml

@@ -1,11 +1,11 @@
-require:
+plugins:
   - rubocop-rake
   - rubocop-rspec
   - rubocop-performance
 
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 3.3
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 1.1.0 (February 27, 2026)
+
+- Raise `ArgumentError` for invalid type arguments (e.g., `Hash.of(:string)`)
+- Raise `ArgumentError` when passing `recursive: true` with `:array`
+- Drop Ruby < 3.3 support; now tested on Ruby 3.3, 3.4, and 4.0
+- Update all dependencies (rubocop 1.85, rubocop-rspec 3.x, etc.)
+
 # 1.0.1 (February 12, 2024)
 
 - Simpler internal approach for creating the recursive hash that avoids a new class

data/CLAUDE.md

@@ -0,0 +1,28 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project
+
+hash_of is a Ruby gem that extends `Hash` with a `.of()` class method for creating auto-populating hashes (arrays, hashes, or recursive hashes). It targets Ruby 3.0+.
+
+## Commands
+
+```bash
+bundle exec rake          # Default: runs tests + rubocop
+bundle exec rake spec     # Run RSpec tests only
+bundle exec rubocop       # Run linting only
+bundle exec rspec spec/hash_of_spec.rb  # Run a single test file
+bundle exec rake coverage # Generate coverage report and open in browser
+```
+
+## Architecture
+
+The entire gem is a single module in `lib/hash_of.rb`. It defines three lambdas (`OF_ARRAY_LAMBDA`, `OF_HASH_LAMBDA`, `OF_HASH_RECURSIVE_LAMBDA`) used as `default_proc` values and a single `of(type, recursive: false)` method. The module is extended onto `Hash` directly via `Hash.extend(HashOf)`.
+
+All tests live in `spec/hash_of_spec.rb`. Coverage is tracked with SimpleCov.
+
+## Style
+
+- RuboCop enforced: double-quoted strings, 120 char max line length
+- CI tests against Ruby 3.0, 3.1, 3.2, 3.3

data/README.md

@@ -1,24 +1,69 @@
 # Hash.of
 
-Mostly syntactic sugar to quickly and tersely create a hash of arrays or hashes, and optionally, recursive hashes.
+Syntactic sugar to tersely create a hash of arrays or hashes, and optionally, recursive hashes.
 
-If you find yourself doing `Hash.new { |hash, key] hash[key] = {} }` a lot you can make this more concise with `Hash.of(:hash)`.
+While clear, creating a hash of hashes via `Hash.new { |hash, key| hash[key] = {} }` is verbose. If this pattern is common in your codebase you can express it more concisely as `Hash.of(:hash)`. This can help readability when iterating with `#reduce` or `#each_with_object` to create efficient lookup tables.
 
-It helps readability when iterating with `#reduce` or `#each_with_object` to create efficient lookup tables. E.g.:
+## Example
+
+We have a bunch of records containing the winners of the Academy Awards. We'd like to provide a simple interface for people to look up winners by year and category like the following:
+
+```ruby
+winners_by_year_by_category[2024][:best_picture]
+# => "Oppenheimer"
+```
+
+Let's say we have `AcademyAwardResult` objects which have the properties `year`, `category`, and `winner`. They may look something like:
+
+```ruby
+[
+  #<AcademyAwardResult year=2024, category=:best_picture, winner="Oppenheimer">,
+  #<AcademyAwardResult year=2024, category=:best_actor, winner="Cillian Murphy">,
+  …
+  #<AcademyAwardResult year=2023, category=:best_picture, winner="Everything Everywhere All at Once">,
+  …
+  #<AcademyAwardResult year=2022, category=:best_picture, winner="CODA">
+]
+```
+
+The following turns this array of records into a lookup table:
 
 ```ruby
-# This is a contrived example for illustrative purposes only as Rails' `Enumerable#index_by` is a better tool for the specific case being depicted.
-a_buncha_records.each_with_object(Hash.new { |hash, key| hash[key] = {} }) do |record, cache|
-  cache[record.id] = record
+award_results.each_with_object(Hash.new { |hash, key| hash[key] = {} }) do |result, lookup|
+  lookup[result.year][result.category] = result.winner
 end
+```
+
+`Hash.of` enables the terser:
 
-# vs.
-a_buncha_records.each_with_object(Hash.of(:hash)) do |record, cache|
-  cache[record.id] = record
+```ruby
+award_results.each_with_object(Hash.of(:hash)) do |result, lookup|
+  lookup[result.year][result.category] = result.winner
 end
 
-# or go nuts and inline it
-a_buncha_records.each_with_object(Hash.of(:hash)) { |record, cache| cache[record.id] = record }
+# or the incredibly terse inline
+
+award_results.each_with_object(Hash.of(:hash)) { _2[_1.year][_1.category] = _1.winner }
+```
+
+Both result in the following object that powers the specified interface:
+
+```ruby
+{
+  2024 => {
+    :best_picture => "Oppenheimer",
+    :best_actor => "Cillian Murphy",
+    …
+  },
+  2023 => {
+    :best_picture => "Everything Everywhere All at Once",
+    …
+  },
+  2022 => {
+    :best_picture => "CODA",
+    …
+  }
+}
 ```
 
 ## Installation
@@ -27,7 +72,7 @@ Install the gem and add to the application's Gemfile by executing:
 
     $ bundle add hash_of
 
-Alternatively add to your Gemfile via
+Alternatively add to your `Gemfile` via
 
     gem "hash_of", "~> 1.0"
 
@@ -35,10 +80,9 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install hash_of
 
-
 ## Usage
 
-Adds the `Hash.of` method providing the following uses
+`Hash.of` provides the following uses
 
 ### 1. `Hash.of(:array)`
 
@@ -90,12 +134,12 @@ recursive_hash_of_hashes
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run the tests and Rubocop. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake` to run the tests and RuboCop. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hash_of.
+Bug reports and pull requests are welcome on GitHub at https://github.com/agrberg/hash_of.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -10,3 +10,9 @@ require "rubocop/rake_task"
 RuboCop::RakeTask.new
 
 task default: %i[spec rubocop]
+
+desc "Generate code coverage with simplecov"
+task :coverage do
+  `COVERAGE=true rspec`
+  `open coverage/index.html`
+end

data/hash_of.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/hash_of/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "hash_of"
+  spec.version = HashOf::VERSION
+  spec.authors = ["Aaron Rosenberg"]
+  spec.email = ["aarongrosenberg@gmail.com"]
+
+  spec.summary = "Syntactic sugar to create hashes of hashes or arrays and ability to make them recursive."
+  spec.homepage = "https://github.com/agrberg/hash_of"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.3.0"
+
+  spec.metadata["bug_tracker_uri"] = "https://github.com/agrberg/hash_of/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/agrberg/hash_of/blob/main/CHANGELOG.md"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.require_paths = ["lib"]
+end

data/lib/hash_of/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HashOf
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/hash_of.rb

@@ -2,13 +2,20 @@
 
 require_relative "hash_of/version"
 
-# Module to contain the constants, subclass, and class method Hash will extend
+# Module to contain the constants and class method Hash will extend
 module HashOf
   OF_ARRAY_LAMBDA = ->(hash, key) { hash[key] = [] }
   OF_HASH_LAMBDA = ->(hash, key) { hash[key] = {} }
   OF_HASH_RECURSIVE_LAMBDA = ->(hash, key) { hash[key] = Hash.new(&hash.default_proc) }
 
+  VALID_TYPES = %i[array hash].freeze
+
   def of(type, recursive: false)
+    unless VALID_TYPES.include?(type)
+      raise ArgumentError, "Invalid type: #{type.inspect}. Valid types are: #{VALID_TYPES.join(", ")}"
+    end
+    raise ArgumentError, "recursive is only supported with type: :hash" if recursive && type != :hash
+
     case type
     when :array
       Hash.new(&OF_ARRAY_LAMBDA)

data/sig/hash_of.rbs

@@ -1,13 +1,10 @@
-# Module to contain the constants, subclass, and class method Hash will extend
+# Module to contain the constants and class method Hash will extend
 module HashOf
-  OF_ARRAY_LAMBDA: Lambda
-  OF_HASH_LAMBDA: Lambda
+  OF_ARRAY_LAMBDA: ^(Hash, untyped) -> Array[untyped]
+  OF_HASH_LAMBDA: ^(Hash, untyped) -> Hash[untyped, untyped]
+  OF_HASH_RECURSIVE_LAMBDA: ^(Hash, untyped) -> Hash[untyped, untyped]
+  VALID_TYPES: Array[Symbol]
   VERSION: String
 
-  # Produce new Hashes with their default proc set to create hashes recursively
-  class OfHash < Hash
-    def initialize: () -> void
-  end
-
-  def of: (Symbol type, ?recursive: bool) -> Hash
+  def of: (Symbol type, ?recursive: bool) -> Hash[untyped, untyped]
 end

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_of
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Aaron Rosenberg
-autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2024-02-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description:
 email:
 - aarongrosenberg@gmail.com
 executables: []
@@ -20,9 +18,11 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- hash_of.gemspec
 - lib/hash_of.rb
 - lib/hash_of/version.rb
 - sig/hash_of.rbs
@@ -30,11 +30,11 @@ homepage: https://github.com/agrberg/hash_of
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/agrberg/hash_of/issues
   changelog_uri: https://github.com/agrberg/hash_of/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/agrberg/hash_of
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/agrberg/hash_of
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -42,15 +42,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.5
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Syntactic sugar to create hashes of hashes or arrays and ability to make
   them recursive.