activerecord-hashlike_access 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3b639e40814dc74be8707c77afa1ae4e356482c1d287ff736e9b13b2a4333ffb
+  data.tar.gz: 7dfabf54b88b563a9583e4cfebb11e825e2143ce08b66988752d3b3783eee954
+SHA512:
+  metadata.gz: 7b7a842f6c8385d8f288d5fdf90b07bc26f9d4ccc09c66c48e8d8533e602324086a9894bcb005c71be50e28336670967fb32a601425581c2ac016f15abe33ff1
+  data.tar.gz: d5e8c429394c07c2b5191d297ef394c122b1b0aa35506df9fc0755f069a6ba2b9f8af133f3187f841dbb226488b3747585791c821822c4a06b3cdd9c83296b49

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,75 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+
+Layout/HashAlignment:
+  # Align the elements of a hash literal if they span more than one line.
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+
+Lint/DuplicateBranch:
+  # Checks that there are no repeated bodies within `if/unless`, `case-when` and `rescue` constructs.
+  Enabled: false
+
+
+Metrics/AbcSize:
+  # Checks that the ABC size of methods is not higher than the configured maximum.
+  Max: 20
+
+Metrics/BlockLength:
+  # Avoid long blocks with many lines.
+  Exclude:
+    - spec/**/*
+
+Metrics/CyclomaticComplexity:
+  # A complexity metric that is strongly correlated to the number of test cases needed to validate a method.
+  Max: 10
+
+Metrics/MethodLength:
+  # Avoid methods longer than 25 lines of code.
+  Max: 25
+
+
+Naming/VariableNumber:
+  # Use the configured style when numbering symbols, methods and variables.
+  Enabled: false
+
+
+Style/AsciiComments:
+  # Use only ASCII symbols in comments.
+  #
+  # NLC: We're allowing non-breaking spaces (' '), as they're needed to prevent
+  #      browsers from collapsing multiple spaces in documentation code blocks.
+  AllowedChars:
+    - ' '
+
+Style/FormatString:
+  # Enforce the use of Kernel#sprintf, Kernel#format or String#%.
+  EnforcedStyle: percent
+
+Style/FrozenStringLiteralComment:
+  # Enforces use of the frozen_string_literal comment in every file.
+  EnforcedStyle: never
+
+Style/NumericLiterals:
+  # Add underscores to large numeric literals to improve their readability.
+  Enabled: false
+
+Style/PreferredHashMethods:
+  # Checks use of `has_key?` and `has_value?` Hash methods.
+  EnforcedStyle: verbose
+
+Style/RegexpLiteral:
+  # Use / or %r around regular expressions.
+  EnforcedStyle: percent_r
+
+Style/RescueModifier:
+  # Avoid using rescue in its modifier form.
+  Enabled: false
+
+Style/StringLiterals:
+  # Check for use of ' vs ".
+  ConsistentQuotesInMultiline: true

data/.ruby-version

@@ -0,0 +1 @@
+3.4

data/.yardopts

@@ -0,0 +1,4 @@
+--format=html
+--markup=markdown
+--output-dir=./docs
+--private

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.0.0] - 2026-08-06
+
+- Initial release.

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'irb'
+gem 'rake', '~> 13'
+gem 'rspec', '~> 3'
+gem 'rubocop'
+gem 'sqlite3'
+gem 'yard'

data/Gemfile.lock

@@ -0,0 +1,207 @@
+PATH
+  remote: .
+  specs:
+    activerecord-hashlike_access (0.0.0)
+      activerecord (>= 6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (8.1.3.1)
+      activesupport (= 8.1.3.1)
+    activerecord (8.1.3.1)
+      activemodel (= 8.1.3.1)
+      activesupport (= 8.1.3.1)
+      timeout (>= 0.4.0)
+    activesupport (8.1.3.1)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
+    concurrent-ruby (1.3.8)
+    connection_pool (3.0.2)
+    diff-lcs (1.6.2)
+    drb (2.2.3)
+    erb (6.0.7)
+    i18n (1.15.2)
+      concurrent-ruby (~> 1.0)
+    io-console (0.9.2)
+    irb (1.18.0)
+      pp (>= 0.6.0)
+      prism (>= 1.3.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.21.2)
+    language_server-protocol (3.17.0.6)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    minitest (6.0.6)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    parallel (2.1.0)
+    parser (3.3.12.0)
+      ast (~> 2.4.1)
+      racc
+    pp (0.6.4)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.4.2)
+    rbs (4.1.3)
+      logger
+      prism (>= 1.6.0)
+      tsort
+    rdoc (8.0.0)
+      erb
+      prism (>= 1.6.0)
+      rbs (>= 4.0.0)
+      tsort
+    regexp_parser (2.12.0)
+    reline (0.7.0)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.89.0)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (>= 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.50.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    sqlite3 (2.9.5-aarch64-linux-gnu)
+    sqlite3 (2.9.5-aarch64-linux-musl)
+    sqlite3 (2.9.5-arm-linux-gnu)
+    sqlite3 (2.9.5-arm-linux-musl)
+    sqlite3 (2.9.5-arm64-darwin)
+    sqlite3 (2.9.5-x86-linux-gnu)
+    sqlite3 (2.9.5-x86-linux-musl)
+    sqlite3 (2.9.5-x86_64-darwin)
+    sqlite3 (2.9.5-x86_64-linux-gnu)
+    sqlite3 (2.9.5-x86_64-linux-musl)
+    timeout (0.6.1)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+    yard (0.9.45)
+
+PLATFORMS
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86-linux-gnu
+  x86-linux-musl
+  x86_64-darwin
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  activerecord-hashlike_access!
+  irb
+  rake (~> 13)
+  rspec (~> 3)
+  rubocop
+  sqlite3
+  yard
+
+CHECKSUMS
+  activemodel (8.1.3.1) sha256=99cc02ce2faec371d14440949d85787ebd23a907c9baef0a9d4bcd4d21888f88
+  activerecord (8.1.3.1) sha256=0a2fb6c28f4938f6b013a3a549bec0a7e37d535f3dc8990e804bcc3258c0403b
+  activerecord-hashlike_access (0.0.0)
+  activesupport (8.1.3.1) sha256=85458765f25ea48b9019c46b6bb3fa5683197bf4280d9f06710a6e8d7a831376
+  ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
+  base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
+  bigdecimal (4.1.2) sha256=53d217666027eab4280346fba98e7d5b66baaae1b9c3c1c0ffe89d48188a3fbd
+  bundler (4.0.14) sha256=d09a0a965cf772266a7e49e83610be7c2f4e49e61134c42a56804bb383cc24b8
+  concurrent-ruby (1.3.8) sha256=b2f1be836e968ccc78ccfce277ea79c72a88633f22306782c16ff23fb415d1e1
+  connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a
+  diff-lcs (1.6.2) sha256=9ae0d2cba7d4df3075fe8cd8602a8604993efc0dfa934cff568969efb1909962
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  erb (6.0.7) sha256=c5ca6dc25b0ef974a44dc8f59fe847577122483b1968a38dec305c60bf91ee92
+  i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5
+  io-console (0.9.2) sha256=efa74f891dd03c0939a931dfc6e74c2813d904763d456ea9762b0525e748db08
+  irb (1.18.0) sha256=de9454a0703a54704b9811a5ef31a60c86949fbf4013fcf244fabc7c775248e3
+  json (2.21.2) sha256=1f1d3b7cf2b3ba1a69beca0bb6db13d5438b80bff3cd54cdaaa620b9b07c1c6a
+  language_server-protocol (3.17.0.6) sha256=5ef2c0c138f8267e1bc631d3328347d354f96724b0af22f2c79516120443b7f0
+  lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87
+  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
+  parallel (2.1.0) sha256=b35258865c2e31134c5ecb708beaaf6772adf9d5efae28e93e99260877b09356
+  parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828
+  pp (0.6.4) sha256=dfcb0fce700c41456265922884f9fe195d7fbb0674a3578e6c0f69588e82b570
+  prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193
+  prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
+  racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
+  rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  rbs (4.1.3) sha256=0c4474a9751cdc14364bfad0b3e53678323bbdc2c31683b0445932867dbab8c4
+  rdoc (8.0.0) sha256=03bf8c08a9639658855a0cfd77c0abca8325c227693f7f33f82957811348c469
+  regexp_parser (2.12.0) sha256=35a916a1d63190ab5c9009457136ae5f3c0c7512d60291d0d1378ba18ce08ebb
+  reline (0.7.0) sha256=5b012d8e55dbf9d450f12bde2cf7d15ff546ae80b3f8f3b30e570d431815583d
+  rspec (3.13.2) sha256=206284a08ad798e61f86d7ca3e376718d52c0bc944626b2349266f239f820587
+  rspec-core (3.13.6) sha256=a8823c6411667b60a8bca135364351dda34cd55e44ff94c4be4633b37d828b2d
+  rspec-expectations (3.13.5) sha256=33a4d3a1d95060aea4c94e9f237030a8f9eae5615e9bd85718fe3a09e4b58836
+  rspec-mocks (3.13.8) sha256=086ad3d3d17533f4237643de0b5c42f04b66348c28bf6b9c2d3f4a3b01af1d47
+  rspec-support (3.13.7) sha256=0640e5570872aafefd79867901deeeeb40b0c9875a36b983d85f54fb7381c47c
+  rubocop (1.89.0) sha256=4dee8e3ee9c45e474834efd9e8d6fd031e8331c8dacdff0de4ad65ae0a6faae7
+  rubocop-ast (1.50.0) sha256=b9ca88300da0803ee222ad20cdb30494c0a784eed06fdc35d254b06d662788db
+  ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
+  securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
+  sqlite3 (2.9.5-aarch64-linux-gnu) sha256=78075b6337d3d182c6d2b4691049ed45cd220826160c9ea18946bf6a1de200dc
+  sqlite3 (2.9.5-aarch64-linux-musl) sha256=18c801185deb4adc01ddb281e8f672a39e3d1729979ca91e39439cd3eac0402d
+  sqlite3 (2.9.5-arm-linux-gnu) sha256=1bdfca0c7d63998c60b0f4a8e3c8df2d33800ccc4abd2d612eddbbbc92a4c48b
+  sqlite3 (2.9.5-arm-linux-musl) sha256=bae1109d12b2e9f588455967729b008e1ff4feb7761749df695019c9079913c6
+  sqlite3 (2.9.5-arm64-darwin) sha256=d0cf444a70fc9395d513cfbcc1e6719e224aa645314e3824cb0474c721425aa2
+  sqlite3 (2.9.5-x86-linux-gnu) sha256=c94b96b16f17796be6fa099d15218b52e396f55690c4760faaaefa21ebab9dd5
+  sqlite3 (2.9.5-x86-linux-musl) sha256=063a8c13cbadfe7f29453b1706cbdf91fca4a78d244f816ff20bac4fb259f1e4
+  sqlite3 (2.9.5-x86_64-darwin) sha256=8e9caae38bd7ebb29cbeee3e7ab1d12dc2327d9a1b92c7fcf0dda05589627a81
+  sqlite3 (2.9.5-x86_64-linux-gnu) sha256=233dbcb6714148dd23bc5aeb33e8efd6eac974969564ddd5794c23d5f52b231e
+  sqlite3 (2.9.5-x86_64-linux-musl) sha256=e7d3a7474e8af0f96150c21abc203fbab5437206bfcdf11deab7741c0ca516f2
+  timeout (0.6.1) sha256=78f57368a7e7bbadec56971f78a3f5ecbcfb59b7fcbb0a3ed6ddc08a5094accb
+  tsort (0.2.0) sha256=9650a793f6859a43b6641671278f79cfead60ac714148aabe4e3f0060480089f
+  tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
+  unicode-display_width (3.2.0) sha256=0cdd96b5681a5949cdbc2c55e7b420facae74c4aaf9a9815eee1087cb1853c42
+  unicode-emoji (4.2.0) sha256=519e69150f75652e40bf736106cfbc8f0f73aa3fb6a65afe62fefa7f80b0f80f
+  uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
+  yard (0.9.45) sha256=52e211493f7cb8a3ebf7e104a25a1e73937a3103092545d34cb88fafebb3dc51
+
+BUNDLED WITH
+  4.0.14

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Nestor Custodio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,241 @@
+[![MIT License](https://img.shields.io/github/license/nestor-custodio/activerecord-hashlike_access)](https://tldrlegal.com/license/mit-license)
+
+
+# ActiveRecord::HashlikeAccess
+
+Pulling this module into your ActiveRecord models gives you Hash-like getters (`[]`) and setters (`[]=`) for _individual records/values_. This is not only slightly cleaner to read/write, but also encourages fetching items by either their `id` or a canonical "lookup field", minimizing the likelihood of pulling records by an unindexed field.
+
+In simplest terms:
+```ruby
+# Given a "roles" table with
+# `id`, `name`, and `display_text`...
+
+
+# Hash-Like Access to Records:
+
+class Role < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+  hashlike_access by: :name
+end
+
+role = Role.find_by name: name
+# ... becomes ...
+role = Role[name]
+
+
+# Hash-Like Access to Values:
+
+class Role < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+  hashlike_access to: :display_text, by: :name
+end
+
+role_display_text = Role.find_by(name: name).display_text
+# ... becomes ...
+role_display_text = Role[name]
+
+Role.find_by(name: name).update! display_text: new_display_text
+# ... becomes ...
+Role[name] = new_display_text
+
+```
+
+Importantly, note that **this gem works on the model, not its relations**. ActiveRecord's existing bracket constructs for referencing _relations_ (i.e. resultsets) in an `Array`-like fashion will continue to work as they always have.
+
+
+## Installation
+
+- If your project uses [Bundler](https://github.com/bundler/bundler):
+  - Add the following to your application's Gemfile:
+    ```ruby
+    gem 'activerecord-hashlike_access'
+    ```
+  - And then run a:
+    ```shell
+    $ bundle install
+    ```
+
+- Or, you can keep things simple with a manual install:
+  ```shell
+  $ gem install activerecord-hashlike_access
+  ```
+
+
+## Usage
+
+Incorporating the `ActiveRecord::HashlikeAccess` module into a model will allow you to access it by a hash-like syntax, with the entrypoints for defining _what_ you would like access to and _how_ you would like to access it being the `hashlike_access` and `hashlike_access!` methods.
+
+These two methods are nearly identical, the only difference being that a `hashlike_access` lookup that finds no matching records will return a `nil` (similar to ActiveRecord's `find_by`), whereas a failed `hashlike_access!` lookup will instead `raise ActiveRecord::RecordNotFound` (as a `find_by!` would).
+
+`hashlike_access`/`hashlike_access!` take two arguments:
+- `to` (optional): the field (or _arity-0_ method) whose value you would like to get back for hash-like lookups; if omitted, the full record is returned
+- `by` (optional): the field by which you would like to find matching records; if omitted, the model's primary key is used
+
+If your model pulls from `ActiveRecord::HashlikeAccess` but does not explicitly call one of these methods, the default behaviour will grant you hash-like access to records by the model's primary key.
+
+
+### Hash-Like Access to _Records_
+
+```ruby
+class YourModel < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+
+  # For implicit access to records BY the primary key,
+  # you can omit the `hashlike_access` call altogether.
+
+  # ...
+
+
+  # For explicit access to records BY the primary key,
+  # call `hashlike_access` while omitting the `to` option:
+
+  hashlike_access by: primary_key
+
+
+  # For access to records BY an arbitrary "lookup field",
+  # give `hashlike_access` the 'by' field and no 'to' option:
+
+  hashlike_access by: :some_lookup_field_name
+
+end
+```
+
+Any of the above options will make hash-like access (`YourModel[some_value]`) equivalent to a `find_by` (or a `find_by!`, in the case of `hashlike_access!`) using the requested field, resulting in:
+- the matching record, if one is found
+- a `nil` value, in the case of `hashlike_access`
+- an `ActiveRecord::RecordNotFound` error, in the case of `hashlike_access!`
+
+
+### Hash-Like Access to _Values_
+
+```ruby
+class YourModel < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+
+  # For access TO a specific value for records matched BY the primary key,
+  # `hashlike_access` needs the target name via 'to', but the 'by' is optional:
+
+  hashlike_access to: :field_or_method_name
+  # ... or ...
+  hashlike_access to: :field_or_method_name, by: primary_key
+
+
+  # For access TO a specific value BY an arbitrary "lookup field",
+  # give `hashlike_access` both the 'to' target and the 'by' field:
+
+  hashlike_access to: :field_or_method_name, by: :some_lookup_field_name
+
+end
+```
+
+Any of the above options will make hash-like access (`YourModel[some_value]`) equivalent to a `find_by`/`find_by!` followed by the requested method call. As with record lookups: if no matching record is found, expect a `nil` value or an `ActiveRecord::RecordNotFound` error, depending on whether you use `hashlike_access` or `hashlike_access!`.
+
+
+### Hash-Like Assignment to _Values_
+
+Requesting hash-like access to a value ([see above](#hash-like-access-to-values)) also makes hash-like _assignment_ (`[]=`) available **provided that makes sense**, i.e.:
+
+- You have hash-like access to a field and the model is not read-only:
+  ```ruby
+  class YourModel < ApplicationRecord
+    extend ActiveRecord::HashlikeAccess
+    hashlike_access to: :field_x
+  end
+
+  # Getting a value:
+  field_x = YourModel[some_key]
+
+  # Setting a value:
+  YourModel[some_key] = new_value_for_field_x
+  ```
+
+- You have hash-like access to a method and there is _also_ a corresponding `=` method for it:
+  ```ruby
+  class YourModel < ApplicationRecord
+    extend ActiveRecord::HashlikeAccess
+    hashlike_access to: :method_x
+
+    def method_x
+      # ...
+    end
+
+    def method_x=(value)
+      # ...
+    end
+  end
+
+  # Getting a value:
+  method_x = YourModel[some_key]
+
+  # Setting a value:
+  YourModel[some_key] = value_to_pass_to_method_x_assignment
+  ```
+  If you attempt a hash-like value assignment and the requisite assignment method has not been defined, a `NoMethodError` will be raised.
+
+Note hash-like value assignments are backed by an `update!` call, which will:
+- run validations, possibly raising an `ActiveRecord::RecordInvalid` error
+- trigger callbacks, possibly raising an `ActiveRecord::RecordNotSaved` error
+- update timestamps
+
+
+### Using Non-Scalar Keys
+
+If your model uses a composite primary key, hash-like access happens by passing all the needed values:
+```ruby
+class YourModel < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+  self.primary_key = [:primary_key_1, :primary_key_2]
+end
+
+
+# You need to provide as many key values
+# as there are fields in the primary key:
+
+record = YourModel[1, 2]
+# ... or if you have an array:
+record = YourModel[*key_values]
+```
+
+You can also do this if you want to use multiple non-primary-key lookup fields by passing an array to the `by` option:
+```ruby
+class YourModel < ApplicationRecord
+  extend ActiveRecord::HashlikeAccess
+  hashlike_access by: [:lookup_field_1, :lookup_field_2]
+end
+
+
+# You need to provide as many key values
+# as there were fields in the "by" option:
+
+record = YourModel[1, 2]
+# ... or if you have an array:
+record = YourModel[*lookup_values]
+```
+
+
+## Performance Considerations
+
+Every instance of a hash-like lookup (`[some_key]`) is backed by a `find_by`/`find_by!` call, but ActiveRecord's query cache goes _a long way_ to reducing the performance penalty from repeated calls for the same record within a single worker.
+
+
+## Potential Gotchas
+
+As with anything ActiveRecord-related, there are always several ways to shoot yourself in the foot if you're not careful. Here are a few items to keep in mind and hopefully prevent this:
+
+- The hash-like access construct is essentially syntax sugar around ActiveRecord's `find_by` mechanism. For many (most?) database engines, selecting (or _including_, in the case of a multi-field key) an unindexed field for your lookups will likely result in a full-table scan with every hash-like access. Be mindful of what field(s) you're using as your key(s).
+
+- Selecting a lookup field with non-unique values means the matching record you get back is non-deterministic _unless you take precautions to avoid this_ (e.g. by setting a default scope with an `order` on fields that yield a unique combination of values). This should go without saying, but: maybe don't use a non-unique field to try to find a specific record?
+
+
+## Contribution / Development
+
+Bug reports and pull requests are welcome at: [https://github.com/nestor-custodio/activerecord-hashlike_access](https://github.com/nestor-custodio/activerecord-hashlike_access)
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+Linting is courtesy of [Rubocop](https://docs.rubocop.org/) (`rake rubocop`) and documentation is built using [YARD](https://yardoc.org/). Please ensure you have a clean bill of health from Rubocop and that any new features and/or changes to behaviour are reflected in the adjacent documentation before submitting a pull request.
+
+
+## License
+
+`ActiveRecord::HashlikeAccess` is available as open source under the terms of the [MIT License](https://tldrlegal.com/license/mit-license).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/activerecord-hashlike_access.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/active_record/hashlike_access/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'activerecord-hashlike_access'
+  spec.version = ActiveRecord::HashlikeAccess::VERSION
+  spec.authors = ['Nestor Custodio']
+  spec.email = ['nestor@custodio.org']
+
+  spec.summary = 'Provides Hash-like access to ActiveRecord models.'
+  spec.homepage = 'https://github.com/nestor-custodio/activerecord-hashlike_acces'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  # 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 .circleci appveyor])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # This of course requires ActiveRecord.
+  #
+  spec.add_dependency 'activerecord', '>= 6'
+end

data/lib/active_record/hashlike_access/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module HashlikeAccess
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/active_record/hashlike_access.rb

@@ -0,0 +1,114 @@
+require 'active_record'
+
+module ActiveRecord
+  # The HashlikeAccess module simplifies querying for model records by providing
+  # `find_by`-equivalent access to records (or their values) via bracket syntax.
+  #
+  module HashlikeAccess
+    # Finds a record by the previously-configured "lookup_fields" and calls the requested "response_method" on it.
+    #
+    # @param * [Array]
+    #   A list consisting of lookup values to match against the "lookup_fields" in search of a record.
+    #   These are passed through, unaltered, to {.hashlike_access_lookup}.
+    #
+    # @return
+    #   Returns either `nil` or the result of calling the "response_method" on the matched record.
+    #
+    # @raise [ActiveRecord::RecordNotFound]
+    #
+    def [](*)
+      hashlike_access_lookup(*)&.public_send hashlike_access_config[:response_method]
+    end
+
+    # Finds a record (as in {.[]}), and calls the "assignment_method" with the remaining param.
+    #
+    # @param * [Array]
+    #   A list consisting of lookup values as well as the actual assignment value.
+    #   All but the last of these is passed through, unaltered, to {.hashlike_access_lookup}.
+    #
+    # @return
+    #   As with all assignment methods, this returns the assignment value given.
+    #
+    # @raise [NoMethodError, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved]
+    #
+    def []=(*args)
+      value = args.pop
+      record = hashlike_access_lookup(*args) || return
+
+      record.public_send hashlike_access_config[:assignment_method], value
+      record.save!
+    end
+
+    private
+
+    # The primary entrypoint for defining hash-like access behaviours.
+    #
+    # @option [Symbol, String] :to
+    #   The name of the method to call on a record once found. Defaults to `:itself`, yielding the full record.
+    #
+    # @option [Symbol, String, Array<Symbol>, Array<String>] :by
+    #   The field name (or list of names) against which lookup values should match to yield a "found record".
+    #   IOW, this is the list of keys that will be passed to a `find_by` equivalent when looking for a record.
+    #
+    # @option [true, false] :raise_if_not_found
+    #   Determines whether failing to find a requested record should raise an `ActiveRecord::RecordNotFound` error.
+    #   Defaults to `false`.
+    #
+    # @return [Hash]
+    #   Returns the resulting hash-like access config.
+    #
+    def hashlike_access(to: :itself, by: nil, raise_if_not_found: false)
+      requested_config = { lookup_fields:      Array.wrap(by),
+                           response_method:    to,
+                           assignment_method:  :"#{to}=",
+                           raise_if_not_found: raise_if_not_found }
+
+      hashlike_access_config.merge! requested_config.compact_blank
+    end
+
+    # A convenience method that calls {.hashlike_access} with `raise_if_not_found: true`.
+    #
+    # @option [Symbol, String] :to
+    #   The name of the method to call on a record once found. Defaults to `:itself`, yielding the full record.
+    #
+    # @option [Symbol, String, Array<Symbol>, Array<String>] :by
+    #   The field name (or list of names) against which lookup values should match to yield a "found record".
+    #   IOW, this is the list of keys that will be passed to a `find_by` equivalent when looking for a record.
+    #
+    # @return [Hash]
+    #   Returns the resulting hash-like access config.
+    #
+    def hashlike_access!(to: :itself, by: nil)
+      hashlike_access(to:, by:, raise_if_not_found: true)
+    end
+
+    # Returns the current hash-like access config, with sensible defaults if {.hashlike_access} has not been called.
+    #
+    # @return [Hash]
+    #   Returns the current hash-like access config.
+    #
+    def hashlike_access_config
+      @hashlike_access_config ||= { lookup_fields:      Array.wrap(primary_key),
+                                    response_method:    :itself,
+                                    assignment_method:  nil,
+                                    raise_if_not_found: false }
+    end
+
+    # Finds a record using the configured "lookup_fields" matched to the provided "lookup_values".
+    #
+    # @param lookup_values [Array]
+    #   A list consisting of lookup values to match against the "lookup_fields" in search of a record.
+    #
+    # @return [ActiveRecord::Base, nil]
+    #   Returns the matching record or `nil` if none was found and the "raise_if_not_found" config is `false`.
+    #
+    # @raise [ActiveRecord::RecordNotFound]
+    #
+    def hashlike_access_lookup(*lookup_values)
+      record = find_by hashlike_access_config[:lookup_fields].zip(lookup_values).to_h
+      raise ActiveRecord::RecordNotFound if record.blank? && hashlike_access_config[:raise_if_not_found]
+
+      record
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-hashlike_access
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nestor Custodio
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+email:
+- nestor@custodio.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".yardopts"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- activerecord-hashlike_access.gemspec
+- lib/active_record/hashlike_access.rb
+- lib/active_record/hashlike_access/version.rb
+homepage: https://github.com/nestor-custodio/activerecord-hashlike_acces
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/nestor-custodio/activerecord-hashlike_acces
+  changelog_uri: https://github.com/nestor-custodio/activerecord-hashlike_acces/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Provides Hash-like access to ActiveRecord models.
+test_files: []