static_association 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dd88c2ff7fc56c68c7afb52e5ecc34d05d00ff06
-  data.tar.gz: 247e7c6ec09c4aeabc7405caa0af4895ea2527c2
+SHA256:
+  metadata.gz: 5666e88a0802eea2fe4650de42230959d14a792dd161c50ee81c1abeb681df12
+  data.tar.gz: fd5d870372e99f9ba199eef79c0550b673b707d051831ed35197489de6c5e017
 SHA512:
-  metadata.gz: 2430eb60d4dfee691c90cceb8607ed4021ab21fbee8918a13d53ef2acb1ae4e628957717ddb005df1676037de734968d3a97b0e2fd59fccb8e4369057a89e075
-  data.tar.gz: 2a5e771bb651c00f24068ce82e5b10307b2a7c4d7ce6729f50e329424adfc2772aa61c99a2c4fd5094575b7aec91fe97b13032485cbed1d12daf3ba3d4becfe5
+  metadata.gz: 8b6462940e27e5abccfe7938e63efceed99418e8dc3b808ab42926525e914835d9a42b25e49942039c5108ca90b63fbb2adaab23bb4ef9a0c6c13069bbd00949
+  data.tar.gz: 4b594996748a63859e1326ab389b23dd17d8ba67e2c3b12b3ed63d4d13b1539be2851c85abd2e7b712e7a5c15bcd9f0753d33871caf79aa53e7bc38c4b6e181e

data/.github/workflows/lint.yml

@@ -0,0 +1,15 @@
+name: Lint
+
+on: push
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1'
+          bundler-cache: true
+      - run: bundle exec standardrb

data/.github/workflows/test.yml

@@ -0,0 +1,24 @@
+name: Test
+
+on: push
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['3.2', '3.3', '3.4']
+        gemfile: ['7.1', '7.2', '8.0']
+
+    runs-on: ubuntu-latest
+
+    env:
+      BUNDLE_GEMFILE: ${{ github.workspace }}/gemfiles/${{ matrix.gemfile }}.gemfile
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rspec

data/.gitignore

@@ -4,6 +4,7 @@
 .bundle
 .config
 .yardoc
+.tool-versions
 Gemfile.lock
 InstalledFiles
 _yardoc

data/.standard.yml

@@ -0,0 +1,3 @@
+fix: false
+parallel: false
+format: progress

data/Appraisals

@@ -1,25 +1,11 @@
-appraise "3.0" do
-  gem "i18n"
-  gem "activesupport", "3.0"
+appraise "7.1" do
+  gem "activesupport", "7.1"
 end
 
-appraise "3.1" do
-  gem "i18n"
-  gem "activesupport", "3.1"
+appraise "7.2" do
+  gem "activesupport", "7.2"
 end
 
-appraise "3.2" do
-  gem "activesupport", "3.2"
-end
-
-appraise "4.0" do
-  gem "activesupport", "4.0"
-end
-
-appraise "4.1" do
-  gem "activesupport", "4.1"
-end
-
-appraise "4.2" do
-  gem "activesupport", "4.2"
+appraise "8.0" do
+  gem "activesupport", "8.0"
 end

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## v0.3.0 (24 October 2025)
+
+- Add `attr_evaluated` to define attributes that are evaluated/computed at runtime (#32)
+- Use including class name for error messages (#31)
+
+## v0.2.0 (20 June 2025)
+
+### Added
+
+- `standardrb` gem for linting (#11)
+- `.where` method for finding multiple records with an array of IDs (#16)
+- `.ids` method which returns an array of all record IDs (#25)
+- `.find_by` method to return the first method matching a specific condition (#26)
+- `.find_by!` method which behaves like `find_by` but raises when a matching
+   record is not found (#28)
+
+### Changed
+- Use GitHub Actions for CI (#10)
+- Refactor specs to be more inline with thoughtbot style (#15)
+- Require `activesupport` v7.1.0 or higher (#22)
+- Coerce `.find_by_id` argument to integer (#23)
+- More descriptive exception messages (#24)

data/CODEOWNERS

@@ -0,0 +1,16 @@
+# Lines starting with '#' are comments.
+# Each line is a file pattern followed by one or more owners.
+
+# More details are here: https://help.github.com/articles/about-codeowners/
+
+# The '*' pattern is global owners.
+
+# Order is important. The last matching pattern has the most precedence.
+# The folders are ordered as follows:
+
+# In each subsection folders are ordered first by depth, then alphabetically.
+# This should make it easy to add new rules without breaking existing ones.
+
+# Global rule:
+
+* @sidane

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in static_association.gemspec
 gemspec

data/README.md

@@ -1,6 +1,7 @@
 # StaticAssociation
 
-[![Build Status](https://travis-ci.org/New-Bamboo/static_association.png?branch=master)](https://travis-ci.org/New-Bamboo/static_association)
+![test](https://github.com/thoughtbot/static_association/actions/workflows/test.yml/badge.svg)
+![lint](https://github.com/thoughtbot/static_association/actions/workflows/lint.yml/badge.svg)
 
 Adds basic ActiveRecord-like associations to static data.
 
@@ -9,7 +10,7 @@ Adds basic ActiveRecord-like associations to static data.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'static_association'
+gem "static_association"
 ```
 
 And then execute:
@@ -38,13 +39,28 @@ class Day
 end
 ```
 
-Calling `record` will allow you to create an instance of this static model, a unique id is mandatory. The newly created object is yielded to the passed block.
+Calling `record` will allow you to create an instance of this static model,
+a unique id is mandatory. The newly created object is yielded to the passed
+block.
 
-The `Day` class will gain an `all` and `find` method.
+The `Day` class will gain the following methods:
+
+- `.all`: returns all the static records defined in the class.
+- `.ids`: returns an array of all the ids of the static records.
+- `.find`: accepts a single id and returns the matching record. If the record
+  does not exist, a `RecordNotFound` error is raised.
+- `.find_by_id`: behaves similarly to the `.find` method, except it returns
+  `nil` when a record does not exist.
+- `.find_by`: finds the first record matching the specified conditions. If no
+  record is found, returns `nil`.
+- `find_by!` behaves like `find_by` but raises a
+  `StaticAssociation::RecordNotFound` error if no record is found.
+- `.where`: accepts an array of ids and returns all records with matching ids.
 
 ### Associations
 
-Currently just a 'belongs to' association can be created. This behaviour can be mixed into an `ActiveRecord` model:
+Currently just a `belongs_to` association can be created. This behaviour can be
+mixed into an `ActiveRecord` model:
 
 ```ruby
 class Event < ActiveRecord::Base
@@ -61,6 +77,6 @@ This assumes your model has a field `day_id`.
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Run the tests (`rake`)
+4. Run lint checks and tests (`bundle exec rake`)
 5. Push to the branch (`git push origin my-new-feature`)
 6. Create new Pull Request

data/Rakefile

@@ -1,7 +1,8 @@
 require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
-require 'appraisal'
+require "rspec/core/rake_task"
+require "appraisal"
+require "standard/rake"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: [:standard, :spec]

data/gemfiles/{4.0.gemfile → 7.1.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activesupport", "4.0"
+gem "activesupport", "7.1"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{4.1.gemfile → 7.2.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activesupport", "4.1"
+gem "activesupport", "7.2"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{4.2.gemfile → 8.0.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activesupport", "4.2"
+gem "activesupport", "8.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/lib/static_association/version.rb

@@ -1,3 +1,3 @@
 module StaticAssociation
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/static_association.rb

@@ -1,15 +1,20 @@
-require 'static_association/version'
-require 'active_support/concern'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/string/inflections'
+require "static_association/version"
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/string/inflections"
 
 module StaticAssociation
   extend ActiveSupport::Concern
 
+  class ArgumentError < StandardError; end
+
   class DuplicateID < StandardError; end
+
   class RecordNotFound < StandardError; end
 
+  class UndefinedAttribute < StandardError; end
+
   attr_reader :id
 
   private
@@ -24,46 +29,99 @@ module StaticAssociation
     delegate :each, to: :all
 
     def index
-      @index ||= {} 
+      @index ||= {}
     end
 
     def all
       index.values
     end
 
+    def ids
+      index.keys
+    end
+
     def find(id)
-      find_by_id(id) or raise RecordNotFound
+      find_by_id(id) or raise RecordNotFound.new(
+        "Couldn't find #{name} with 'id'=#{id}"
+      )
     end
 
     def find_by_id(id)
-      index[id]
+      index[
+        Integer(id, exception: false) || id
+      ]
+    end
+
+    def where(id: [])
+      all.select { |record| id.include?(record.id) }
+    end
+
+    def find_by(**args)
+      args.any? or raise ArgumentError
+
+      all.find { |record| matches_attributes?(record: record, attributes: args) }
+    end
+
+    def find_by!(**args)
+      find_by(**args) or raise RecordNotFound.new(
+        "Couldn't find #{name} with " +
+        args.map { |k, v| "#{k}=#{v}" }.join(", ")
+      )
     end
 
     def record(settings, &block)
       settings.assert_valid_keys(:id)
       id = settings.fetch(:id)
-      raise DuplicateID if index.has_key?(id)
-      record = self.new(id)
-      record.instance_exec(record, &block) if block_given?
+
+      if index.has_key?(id)
+        raise DuplicateID.new("Duplicate record with 'id'=#{id} found")
+      end
+
+      record = new(id)
+      record.instance_exec(record, &block) if block
       index[id] = record
     end
+
+    def attr_evaluated(*names)
+      attr_writer(*names)
+
+      names.each do |name|
+        define_method(name) do
+          attr_value = instance_variable_get("@#{name}")
+
+          if attr_value.respond_to?(:call)
+            instance_exec(&attr_value)
+          else
+            attr_value
+          end
+        end
+      end
+    end
+
+    private
+
+    def matches_attributes?(record:, attributes:)
+      attributes.all? do |attribute, value|
+        record.respond_to?(attribute) or raise UndefinedAttribute.new(
+          "Undefined attribute '#{attribute}'"
+        )
+
+        record.public_send(attribute) == value
+      end
+    end
   end
 
   module AssociationHelpers
     def belongs_to_static(name, opts = {})
       class_name = opts.fetch(:class_name, name.to_s.camelize)
 
-      self.send(:define_method, name) do
-        begin
-          foreign_key = self.send("#{name}_id")
-          class_name.constantize.find(foreign_key) if foreign_key
-        rescue RecordNotFound
-          nil
-        end
+      send(:define_method, name) do
+        foreign_key = send(:"#{name}_id")
+        class_name.constantize.find_by_id(foreign_key)
       end
 
-      self.send(:define_method, "#{name}=") do |assoc|
-        self.send("#{name}_id=", assoc.id)
+      send(:define_method, "#{name}=") do |assoc|
+        send(:"#{name}_id=", assoc.id)
       end
     end
   end

data/spec/spec_helper.rb

@@ -4,12 +4,10 @@
 # loaded once.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-require 'bundler/setup'
+require "bundler/setup"
 
-require 'rspec/its'
-
-require 'static_association'
+require "static_association"
 
 RSpec.configure do |config|
-  config.order = 'random'
+  config.order = "random"
 end

data/spec/static_association_spec.rb

@@ -1,142 +1,472 @@
-require 'spec_helper'
-require 'static_association'
+require "spec_helper"
+require "static_association"
 
-describe StaticAssociation do
+class DummyClass
+  include StaticAssociation
 
-  class DummyClass
-    include StaticAssociation
-    attr_accessor :name
-  end
+  attr_accessor :name
+  attr_evaluated :gender
+end
+
+class AssociationClass
+  attr_accessor :dummy_class_id
+  attr_accessor :dodo_class_id
+
+  extend StaticAssociation::AssociationHelpers
+
+  belongs_to_static :dummy_class
+  belongs_to_static :dodo_class, class_name: "DummyClass"
+end
 
+RSpec.describe StaticAssociation do
   after do
-    DummyClass.instance_variable_set("@index", {})
+    DummyClass.instance_variable_set(:@index, {})
   end
 
   describe ".record" do
-    it "should add a record" do
-      expect {
-        DummyClass.record id: 1 do
-          self.name = 'asdf'
-        end
-      }.to change(DummyClass, :count).by(1)
+    it "adds a record" do
+      expect { DummyClass.record(id: 1) { self.name = "test" } }
+        .to change(DummyClass, :count).by(1)
     end
 
-    context "id uniqueness" do
-      it "should raise an error with a duplicate id" do
-        expect {
-          DummyClass.record id: 1 do
-            self.name = 'asdf'
-          end
+    context "when using `self`" do
+      it "assigns attributes" do
+        record = DummyClass.record(id: 1) { self.name = "test" }
 
-          DummyClass.record id: 1 do
-            self.name = 'asdf'
+        expect(record.id).to eq(1)
+        expect(record.name).to eq("test")
+      end
+    end
+
+    context "when using the object" do
+      it "assigns attributes" do
+        record = DummyClass.record(id: 1) { |i| i.name = "test" }
+
+        expect(record.id).to eq(1)
+        expect(record.name).to eq("test")
+      end
+    end
+
+    context "when the id is a duplicate" do
+      it "raises an error" do
+        DummyClass.record(id: 1) { self.name = "test0" }
+
+        expect { DummyClass.record(id: 1) { self.name = "test1" } }
+          .to raise_error(
+            StaticAssociation::DuplicateID,
+            "Duplicate record with 'id'=1 found"
+          )
+      end
+    end
+
+    context "when an attribute is not defined" do
+      it "raises an error" do
+        expect { DummyClass.record(id: 1) { self.foo = "bar" } }
+          .to raise_error(NoMethodError)
+      end
+    end
+
+    context "when a key is invalid" do
+      it "raises an error" do
+        expect { DummyClass.record(id: 1, foo: "bar") }
+          .to raise_error(ArgumentError)
+      end
+    end
+
+    context "without a block" do
+      it "adds a record" do
+        expect { DummyClass.record(id: 1) }.to change(DummyClass, :count).by(1)
+      end
+    end
+
+    context "when attr_evaluated defined attribute is assigned a lambda" do
+      it "evaluates the lambda when the attribute is read" do
+        record = DummyClass.record(id: 1) do
+          self.gender = -> do
+            if name == "Jane"
+              :female
+            else
+              :male
+            end
           end
-        }.to raise_error(StaticAssociation::DuplicateID)
+        end
+
+        expect(record.gender).to eq(:male)
       end
     end
 
-    context "sets up the instance using self" do
-      subject {
-        DummyClass.record id: 1 do
-          self.name = 'asdf'
+    context "when attr_evaluated defined attribute is assigned a proc" do
+      it "evaluates the proc when the attribute is read" do
+        record = DummyClass.record(id: 1) do
+          self.name = "Jane"
+          self.gender = proc do
+            if @name == "Jane"
+              :female
+            else
+              :male
+            end
+          end
         end
-      }
 
-      its(:id) { should == 1 }
-      its(:name) { should == 'asdf' }
+        expect(record.gender).to eq(:female)
+      end
     end
 
-    context "sets up the instance using the object passed in" do
-      subject {
-        DummyClass.record id: 1 do |c|
-          c.name = 'asdf'
+    context "when attr_evaluated defined attribute is assigned a static value" do
+      it "returns the assigned value when the attribute is read" do
+        record = DummyClass.record(id: 1) do
+          self.gender = "Not disclosed"
         end
-      }
 
-      its(:id) { should == 1 }
-      its(:name) { should == 'asdf' }
+        expect(record.gender).to eq("Not disclosed")
+      end
     end
+  end
 
+  describe ".all" do
+    it "returns all records" do
+      record1 = DummyClass.record(id: 1)
+      record2 = DummyClass.record(id: 2)
 
-    context "without a block" do
-      subject { DummyClass.record id: 1 }
+      records = DummyClass.all
 
-      its(:id) { should == 1 }
-      its(:name) { should be_nil }
+      expect(records).to contain_exactly(record1, record2)
     end
+  end
 
-    context "asserting valid keys" do
-      it "should raise an error" do
-        expect {
-          DummyClass.record id: 1, foo: :bar
-        }.to raise_error(ArgumentError)
+  describe ".ids" do
+    it "returns array of ids for all records" do
+      _record1 = DummyClass.record(id: 1)
+      _record2 = DummyClass.record(id: 2)
+
+      ids = DummyClass.ids
+
+      expect(ids).to contain_exactly(1, 2)
+    end
+  end
+
+  describe ".find" do
+    context "when the record exists" do
+      it "returns the record" do
+        record = DummyClass.record(id: 1)
+
+        found_record = DummyClass.find(1)
+
+        expect(found_record).to eq(record)
+      end
+    end
+
+    context "when the record does not exist" do
+      it "raises an error" do
+        expect { DummyClass.find(1) }
+          .to raise_error(
+            StaticAssociation::RecordNotFound,
+            "Couldn't find DummyClass with 'id'=1"
+          )
+
+        stub_const("NewDummyClass", Class.new(DummyClass))
+        expect { NewDummyClass.find(1) }
+          .to raise_error(
+            StaticAssociation::RecordNotFound,
+            "Couldn't find NewDummyClass with 'id'=1"
+          )
+      end
+    end
+
+    context "when argument is numeric string" do
+      it "returns the record" do
+        record = DummyClass.record(id: 1)
+
+        found_record = DummyClass.find("1")
+
+        expect(found_record).to eq(record)
       end
     end
   end
 
-  describe "finders" do
-    before do
-      DummyClass.record id: 1 do
-        self.name = 'asdf'
+  describe ".find_by_id" do
+    context "when the record exists" do
+      it "returns the record" do
+        record = DummyClass.record(id: 1)
+
+        found_record = DummyClass.find_by_id(1)
+
+        expect(found_record).to eq(record)
       end
     end
 
-    describe ".find" do
-      context "record exists" do
-        subject { DummyClass.find(1) }
+    context "when the record does not exist" do
+      it "returns nil" do
+        found_record = DummyClass.find_by_id(1)
 
-        it { should be_kind_of(DummyClass) }
-        its(:id) { should == 1 }
+        expect(found_record).to be_nil
       end
+    end
+
+    context "when id argument is a numeric string" do
+      it "returns the record" do
+        record = DummyClass.record(id: 1)
+
+        found_record = DummyClass.find_by_id("1")
 
-      context "record does not exist" do
-        it "should raise a StaticAssociation::RecordNotFoundError" do
+        expect(found_record).to eq(record)
+      end
+    end
+
+    context "when id argument is a non-numeric string" do
+      it "returns the record" do
+        DummyClass.record(id: 1)
+
+        found_record = DummyClass.find_by_id("foo")
+
+        expect(found_record).to be_nil
+      end
+    end
+
+    context "when record ids are strings and id argument matches a record" do
+      it "returns the record" do
+        record = DummyClass.record(id: "foo")
+
+        found_record = DummyClass.find_by_id("foo")
+
+        expect(found_record).to eq(record)
+      end
+    end
+
+    context "when record ids are strings and id argument doesn't match a record" do
+      it "returns nil" do
+        DummyClass.record(id: "foo")
+
+        found_record = DummyClass.find_by_id("bar")
+
+        expect(found_record).to be_nil
+      end
+    end
+  end
+
+  describe ".where" do
+    it "returns all records with the given ids" do
+      record1 = DummyClass.record(id: 1)
+      _record2 = DummyClass.record(id: 2)
+      record3 = DummyClass.record(id: 3)
+
+      results = DummyClass.where(id: [1, 3, 4])
+
+      expect(results).to contain_exactly(record1, record3)
+    end
+
+    describe ".find_by" do
+      context "when record exists with the specified attribute value" do
+        it "returns the record" do
+          record1 = DummyClass.record(id: 1) do |r|
+            r.name = "foo"
+          end
+          _record2 = DummyClass.record(id: 2) do |r|
+            r.name = "bar"
+          end
+
+          found_record = DummyClass.find_by(name: "foo")
+
+          expect(found_record).to eq(record1)
+        end
+      end
+
+      context "when no record exists that matches the specified attribute value" do
+        it "returns nil" do
+          DummyClass.record(id: 1) do |r|
+            r.name = "foo"
+          end
+
+          found_record = DummyClass.find_by(name: "bar")
+
+          expect(found_record).to be_nil
+        end
+      end
+
+      context "when multiple records match the specified attribute value" do
+        it "returns the first matching record" do
+          record1 = DummyClass.record(id: 1) do |r|
+            r.name = "foo"
+          end
+          _record2 = DummyClass.record(id: 2) do |r|
+            r.name = "foo"
+          end
+
+          found_record = DummyClass.find_by(name: "foo")
+
+          expect(found_record).to eq(record1)
+        end
+      end
+
+      context "when specifying multiple attribute values" do
+        it "returns the record matching all attributes" do
+          _record1 = DummyClass.record(id: 1) do |r|
+            r.name = "foo"
+          end
+          record2 = DummyClass.record(id: 2) do |r|
+            r.name = "foo"
+          end
+
+          found_record = DummyClass.find_by(id: 2, name: "foo")
+
+          expect(found_record).to eq(record2)
+        end
+      end
+
+      context "when specifying multiple attribute values but no record " \
+              "matches all attributes" do
+        it "returns nil" do
+          _record1 = DummyClass.record(id: 1) do |r|
+            r.name = "foo"
+          end
+
+          found_record = DummyClass.find_by(id: 1, name: "bar")
+
+          expect(found_record).to be_nil
+        end
+      end
+
+      context "with undefined attributes" do
+        it "raises an error" do
+          DummyClass.record(id: 1)
+
+          expect {
+            DummyClass.find_by(undefined_attribute: 1)
+          }.to raise_error(
+            StaticAssociation::UndefinedAttribute,
+            "Undefined attribute 'undefined_attribute'"
+          )
+        end
+      end
+
+      context "with no attributes" do
+        it "raises a StaticAssociation::ArgumentError" do
           expect {
-            DummyClass.find(:not_in_the_index)
-          }.to raise_error(StaticAssociation::RecordNotFound)
+            DummyClass.find_by
+          }.to raise_error(StaticAssociation::ArgumentError)
         end
       end
     end
+  end
 
-    describe ".find_by_id" do
-      context "record exists" do
-        subject { DummyClass.find_by_id(1) }
+  describe ".find_by!" do
+    context "when record exists with the specified attribute value" do
+      it "returns the record" do
+        record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        _record2 = DummyClass.record(id: 2) do |r|
+          r.name = "bar"
+        end
+
+        found_record = DummyClass.find_by!(name: "foo")
 
-        it { should be_kind_of(DummyClass) }
-        its(:id) { should == 1 }
+        expect(found_record).to eq(record1)
       end
+    end
+
+    context "when no record exists that matches the specified attribute value" do
+      it "raises an error" do
+        DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
 
-      context "record does not exist" do
-        subject { DummyClass.find_by_id(:not_in_the_index) }
-        it { should be_nil }
+        expect {
+          DummyClass.find_by!(name: "bar")
+        }.to raise_error(
+          StaticAssociation::RecordNotFound,
+          "Couldn't find DummyClass with name=bar"
+        )
       end
     end
-  end
 
-  describe ".belongs_to_static" do
-    class AssociationClass
-      attr_accessor :dummy_class_id
-      attr_accessor :dodo_class_id
+    context "when multiple records match the specified attribute value" do
+      it "returns the first matching record" do
+        record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        _record2 = DummyClass.record(id: 2) do |r|
+          r.name = "foo"
+        end
+
+        found_record = DummyClass.find_by!(name: "foo")
+
+        expect(found_record).to eq(record1)
+      end
+    end
+
+    context "when specifying multiple attribute values" do
+      it "returns the record matching all attributes" do
+        _record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+        record2 = DummyClass.record(id: 2) do |r|
+          r.name = "foo"
+        end
+
+        found_record = DummyClass.find_by!(id: 2, name: "foo")
+
+        expect(found_record).to eq(record2)
+      end
+    end
+
+    context "when specifying multiple attribute values but no record " \
+            "matches all attributes" do
+      it "raises an error" do
+        _record1 = DummyClass.record(id: 1) do |r|
+          r.name = "foo"
+        end
+
+        expect {
+          DummyClass.find_by!(id: 1, name: "bar")
+        }.to raise_error(
+          StaticAssociation::RecordNotFound,
+          "Couldn't find DummyClass with id=1, name=bar"
+        )
+      end
+    end
+
+    context "with undefined attributes" do
+      it "raises a StaticAssociation::UndefinedAttribute" do
+        DummyClass.record(id: 1)
+
+        expect {
+          DummyClass.find_by!(undefined_attribute: 1)
+        }.to raise_error(
+          StaticAssociation::UndefinedAttribute,
+          "Undefined attribute 'undefined_attribute'"
+        )
+      end
+    end
 
-      extend StaticAssociation::AssociationHelpers
-      belongs_to_static :dummy_class
-      belongs_to_static :dodo_class, class_name: 'DummyClass'
+    context "with no attributes" do
+      it "raises a StaticAssociation::ArgumentError" do
+        expect {
+          DummyClass.find_by!
+        }.to raise_error(StaticAssociation::ArgumentError)
+      end
     end
+  end
 
-    let(:associated_class) { AssociationClass.new }
+  describe ".belongs_to_static" do
+    it "defines a reader method for the association" do
+      associated_class = AssociationClass.new
+      allow(DummyClass).to receive(:find_by_id)
 
-    it "creates reader method that uses the correct singularized class when finding static association" do
-      expect {
-        DummyClass.should_receive(:find)
-      }
       associated_class.dummy_class
+
+      expect(DummyClass).to have_received(:find_by_id)
     end
 
-    it "creates a different reader method that uses the specified class when finding static asssociation" do
-      expect {
-        DummyClass.should_receive(:find)
-      }
-      associated_class.dodo_class
+    context "when `class_name` is specified" do
+      it "defines a reader method for the association" do
+        associated_class = AssociationClass.new
+        allow(DummyClass).to receive(:find_by_id)
+
+        associated_class.dodo_class
+
+        expect(DummyClass).to have_received(:find_by_id)
+      end
     end
   end
 end

data/static_association.gemspec

@@ -1,28 +1,24 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'static_association/version'
+require "static_association/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "static_association"
-  spec.version       = StaticAssociation::VERSION
-  spec.authors       = ["Oliver Nightingale"]
-  spec.email         = ["oliver.nightingale1@gmail.com"]
-  spec.description   = %q{StaticAssociation adds a simple enum type that can act like an ActiveRecord association for static data.}
-  spec.summary       = %q{ActiveRecord like associations for static data}
-  spec.license       = "MIT"
-  spec.homepage      = "https://github.com/New-Bamboo/static_association"
+  spec.name = "static_association"
+  spec.version = StaticAssociation::VERSION
+  spec.authors = ["Oliver Nightingale"]
+  spec.email = ["oliver.nightingale1@gmail.com"]
+  spec.description = "StaticAssociation adds a simple enum type that can act like an ActiveRecord association for static data."
+  spec.summary = "ActiveRecord like associations for static data"
+  spec.license = "MIT"
+  spec.homepage = "https://github.com/thoughtbot/static_association"
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = `git ls-files`.split($/)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", ">= 3.0.0"
+  spec.add_dependency "activesupport", ">= 7.1.0"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rspec", "~> 3.4"
-  spec.add_development_dependency "rspec-its", "~> 1.2"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
   spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "standard"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: static_association
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Oliver Nightingale
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-04 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,58 +15,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.4'
-- !ruby/object:Gem::Dependency
-  name: rspec-its
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -102,29 +73,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/lint.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
-- ".travis.yml"
+- ".standard.yml"
 - Appraisals
+- CHANGELOG.md
+- CODEOWNERS
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
-- gemfiles/3.0.gemfile
-- gemfiles/3.1.gemfile
-- gemfiles/3.2.gemfile
-- gemfiles/4.0.gemfile
-- gemfiles/4.1.gemfile
-- gemfiles/4.2.gemfile
+- gemfiles/7.1.gemfile
+- gemfiles/7.2.gemfile
+- gemfiles/8.0.gemfile
 - lib/static_association.rb
 - lib/static_association/version.rb
 - spec/spec_helper.rb
 - spec/static_association_spec.rb
 - static_association.gemspec
-homepage: https://github.com/New-Bamboo/static_association
+homepage: https://github.com/thoughtbot/static_association
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -139,11 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: ActiveRecord like associations for static data
-test_files:
-- spec/spec_helper.rb
-- spec/static_association_spec.rb
+test_files: []

data/.travis.yml

@@ -1,17 +0,0 @@
-language: ruby
-install: bundle install
-sudo: false
-script:
- - bundle exec rake
-rvm:
-  - 2.2
-  - 2.1
-  - 2.0
-  - 1.9.3
-gemfile:
-  - gemfiles/3.0.gemfile
-  - gemfiles/3.1.gemfile
-  - gemfiles/3.2.gemfile
-  - gemfiles/4.0.gemfile
-  - gemfiles/4.1.gemfile
-  - gemfiles/4.2.gemfile

data/gemfiles/3.0.gemfile

@@ -1,8 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "i18n"
-gem "activesupport", "3.0"
-
-gemspec :path => "../"

data/gemfiles/3.1.gemfile

@@ -1,8 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "i18n"
-gem "activesupport", "3.1"
-
-gemspec :path => "../"

data/gemfiles/3.2.gemfile

@@ -1,7 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "activesupport", "3.2"
-
-gemspec :path => "../"