Add attr_evaluated to StaticAssociation objects

`attr_evaluated` can be used to define an attribute who's return value
is evaluated/computed at runtime.

It defines a normal writer method using `attr_writer` which can take
either a static value or a proc/lambda.

If the latter, the reader method will evaluate the proc/lambda when
called and return its value. This allows for defining dynamic runtime
behaviour for specific record attributes.

A static value can still be assigned like other non-evaluated
attributes, and that value will always be returned.

E.g.

```ruby
class MyClass
  include StaticAssociation

  attr_accessor :toggle
  attr_evaluated :status

  record(id: 1) do
    self.toggle = true
    self.status = -> { toggle ? "on" : "off" }
  end

  record(id: 2) do
    self.toggle = true
    self.status = "static value"
  end
end

record1 = MyClass.find(1)
record1.status # => "on"

record2 = MyClass.find(2)
record2.status # => "static value"
```

As with `attr_accessor` you can pass multiple attribute names to a
single `attr_evaluated` call.

```ruby
attr_evaluated :my_attr_1, :my_attr_2
```

Author: sidane

lib/static_association.rb

@@ -82,6 +82,22 @@ def record(settings, &block)
       index[id] = record
     end
 
+    def attr_evaluated(*names)
+      attr_writer(*names)
+
+      names.each do |name|
+        define_method(name) do
+          attr_evaluated = instance_variable_get("@#{name}")
+
+          if attr_evaluated.respond_to?(:call)
+            instance_exec(&attr_evaluated)
+          else
+            attr_evaluated
+          end
+        end
+      end
+    end
+
     private
 
     def matches_attributes?(record:, attributes:)

spec/static_association_spec.rb

@@ -3,14 +3,17 @@
 
 class DummyClass
   include StaticAssociation
+
   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
@@ -75,6 +78,49 @@ class AssociationClass
         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
+        end
+
+        expect(record.gender).to eq(:male)
+      end
+    end
+
+    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
+
+        expect(record.gender).to eq(:female)
+      end
+    end
+
+    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
+
+        expect(record.gender).to eq("Not disclosed")
+      end
+    end
   end
 
   describe ".all" do