lab42_data_class 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1819694c4684f3f4e377f04f4eb17d0842a1075ff7859eeef443c66dd7cfb458
-  data.tar.gz: 5af74933329ed924d51a1820d666c671973004edbd3ab00f6ba93378df71180f
+  metadata.gz: 2ae30c490e9b798403214f49c4cbc43564bf47b741878f9aa174e27dc17a85b8
+  data.tar.gz: 2e7ab04142e8eb38206ba14bd03464465844b307087708d382e253fc40dd8f1b
 SHA512:
-  metadata.gz: 5e14f2656f03703aa867dce065bf9e4770cf043fd97d035cab9a6b869d9fb6e9749c2de3eef0b948e02c7ade07f85f75423c4b2412ed154574a6672e28411d9f
-  data.tar.gz: f831c9c8094f7224de088f6f03847791bcc91a33db6e565fc1ef3f45d5f3f5e29d18b05dfbcdbc7dcc422755d0ab87dc73f0c50a9de45dcd3df0916d87fb1c16
+  metadata.gz: f40faa136f73115809cea4f73d722188ea62e9299319313b1ffcbcc852c710de0c399c3d1c54dcdb1ae1de57173baabfb66607f636ff62b747f133774e4c205a
+  data.tar.gz: 294c975087b12a3cab2731eb78840d735dbdeac923f1c2edb8d5beaf598848caf18d571e3129b42dac0ad2d276657507f4df10268a41863ffb2150ea11df5d8a

data/README.md

@@ -1,4 +1,5 @@
 
+
 [![Issue Count](https://codeclimate.com/github/RobertDober/lab42_data_class/badges/issue_count.svg)](https://codeclimate.com/github/RobertDober/lab42_data_class)
 [![CI](https://github.com/robertdober/lab42_data_class/workflows/CI/badge.svg)](https://github.com/robertdober/lab42_data_class/actions)
 [![Coverage Status](https://coveralls.io/repos/github/RobertDober/lab42_data_class/badge.svg?branch=main)](https://coveralls.io/github/RobertDober/lab42_data_class?branch=main)
@@ -11,9 +12,31 @@
 
 An Immutable DataClass for Ruby
 
-Exposes a class factory function `Kernel::DataClass` and a class
-modifer `Module#dataclass`, also creates two _tuple_ classes, `Pair` and
-`Triple`
+Exposes a class factory function `Kernel::DataClass` and a module `Lab42::DataClass` which can
+extend classes to become _Data Classes_.
+
+Also exposes two _tuple_ classes, `Pair` and `Triple`
+
+## Synopsis
+
+Having immutable Objects has many well known advantages that I will not ponder upon in detail here.
+
+One advantage which is of particular interest though is that, as every, _modification_ is in fact the
+creation of a new object **strong contraints** on the data can **easily** be maintained, and this
+library makes that available to the user.
+
+Therefore we can summarise the features (or not so features, that is for you to decide and you to chose to use or not):
+
+  - Immutable with an Interface à la `OpenStruct`
+  - Attributes are predefined and can have **default values**
+  - Construction with _keyword arguments_, **exclusively**
+  - Conversion to `Hash` instances (if you must)
+  - Pattern matching exactly like `Hash` instances
+  - Possibility to impose **strong constraints** on attributes
+  - Predefined constraints and concise syntax for constraints
+  - Possibility to impose **arbitrary validation** (constraints on the whole object)
+  - Declaration of **dependent attributes** which are memoized (thank you _Immutability_)
+  - Inheritance with **mixin of other dataclasses** (multiple if you must)
 
 ## Usage
 
@@ -33,465 +56,128 @@ In your code
 require 'lab42/data_class'
 ```
 
+## Speculations (literate specs)
 
-## So what does it do?
-
-Well let us [speculate about](https://github.com/RobertDober/speculate_about) it to find out:
-
-## Context `DataClass`
-
-
-### Context: `DataClass` function
-
-Given
-```ruby
-    let(:my_data_class) { DataClass(:name, email: nil) }
-    let(:my_instance) { my_data_class.new(name: "robert") }
-```
-
-Then we can access its fields
-```ruby
-    expect(my_instance.name).to eq("robert")
-    expect(my_instance.email).to be_nil
-```
-
-But we cannot access undefined fields
-```ruby
-    expect{ my_instance.undefined }.to raise_error(NoMethodError)
-```
-
-And we need to provide values to fields without defaults
-```ruby
-    expect{ my_data_class.new(email: "some@mail.org") }
-      .to raise_error(ArgumentError, "missing initializers for [:name]")
-```
-And we can extract the values
-```ruby
-    expect(my_instance.to_h).to eq(name: "robert", email: nil)
-```
-
-#### Context: Immutable → self
-
-Then `my_instance` is frozen:
-```ruby
-    expect(my_instance).to be_frozen
-```
-And we cannot even mute `my_instance`  by means of metaprogramming
-```ruby
-    expect{ my_instance.instance_variable_set("@x", nil) }.to raise_error(FrozenError)
-```
-
-#### Context: Immutable → Cloning
-
-Given
-```ruby
-    let(:other_instance) { my_instance.merge(email: "robert@mail.provider") }
-```
-Then we have a new instance with the old instance unchanged
-```ruby
-    expect(other_instance.to_h).to eq(name: "robert", email: "robert@mail.provider")
-    expect(my_instance.to_h).to eq(name: "robert", email: nil)
-```
-And the new instance is frozen again
-```ruby
-    expect(other_instance).to be_frozen
-```
-
-### Context: Defining behavior with blocks
-
-Given
-```ruby
-    let :my_data_class do
-      DataClass :value, prefix: "<", suffix: ">" do
-        def show
-          [prefix, value, suffix].join
-        end
-      end
-    end
-    let(:my_instance) { my_data_class.new(value: 42) }
-```
-
-Then I have defined a method on my dataclass
-```ruby
-    expect(my_instance.show).to eq("<42>")
-```
-
-### Context: Equality
-
-Given two instances of a DataClass
-```ruby
-    let(:data_class) { DataClass :a }
-    let(:instance1) { data_class.new(a: 1) }
-    let(:instance2) { data_class.new(a: 1) }
-```
-Then they are equal in the sense of `==` and `eql?`
-```ruby
-    expect(instance1).to eq(instance2)
-    expect(instance2).to eq(instance1)
-    expect(instance1 == instance2).to be_truthy
-    expect(instance2 == instance1).to be_truthy
-```
-But not in the sense of `equal?`, of course
-```ruby
-    expect(instance1).not_to be_equal(instance2)
-    expect(instance2).not_to be_equal(instance1)
-```
-
-#### Context: Immutability of `dataclass` modified classes
-
-Then we still get frozen instances
-```ruby
-    expect(instance1).to be_frozen
-```
-
-### Context: Inheritance
-
-... is a no, we do not want inheritance although we **like** code reuse, how to do it then?
-
-Well there shall be many different possibilities, depending on your style, use case and
-context, here is just one example:
-
-Given a class factory
-```ruby
-    let :token do
-      ->(*a, **k) do
-        DataClass(*a, **(k.merge(text: "")))
-        end
-    end
-```
-
-Then we have reused the `token` successfully
-```ruby
-    empty = token.()
-    integer = token.(:value)
-    boolean = token.(value: false)
-
-    expect(empty.new.to_h).to eq(text: "")
-    expect(integer.new(value: -1).to_h).to eq(text: "", value: -1)
-    expect(boolean.new.value).to eq(false)
-```
-
-#### Context: Mixing in a module can be used of course
-
-Given a behavior like
-```ruby
-    module Humanize
-      def humanize
-        "my value is #{value}"
-      end
-    end
-
-    let(:class_level) { DataClass(value: 1).include(Humanize) }
-```
-
-Then we can access the included method
-```ruby
-    expect(class_level.new.humanize).to eq("my value is 1")
-```
-
-### Context: Pattern Matching
-
-A `DataClass` object behaves like the result of it's `to_h` in pattern matching
-
-Given
-```ruby
-    let(:numbers) { DataClass(:name, values: []) }
-    let(:odds) { numbers.new(name: "odds", values: (1..4).map{ _1 + _1 + 1}) }
-    let(:evens) { numbers.new(name: "evens", values: (1..4).map{ _1 + _1}) }
-```
-
-Then we can match accordingly
-```ruby
-    match = case odds
-            in {name: "odds", values: [1, *]}
-              :not_really
-            in {name: "evens"}
-              :still_naaah
-            in {name: "odds", values: [hd, *]}
-              hd
-            else
-              :strange
-            end
-    expect(match).to eq(3)
-```
-
-And in `in` expressions
-```ruby
-    evens => {values: [_, second, *]}
-    expect(second).to eq(4)
-```
-
-#### Context: In Case Statements
-
-Given a nice little dataclass `Box`
-```ruby
-    let(:box) { DataClass content: nil }
-```
-
-Then we can also use it in a case statement
-```ruby
-    value = case box.new
-      when box
-        42
-      else
-        0
-      end
-    expect(value).to eq(42)
-```
-
-And all the associated methods
-```ruby
-    expect(box.new).to be_a(box)
-    expect(box === box.new).to be_truthy
-```
-
-### Context: Behaving like a `Proc`
-
-It is useful to be able to filter heterogeneous lists of `DataClass` instances by means of `&to_proc`, therefore
+The following specs are executed with the [speculate about](https://github.com/RobertDober/speculate_about) gem.
 
-Given two different `DataClass` objects
+Given that we have imported the `Lab42` namespace
 ```ruby
-    let(:class1) { DataClass :value }
-    let(:class2) { DataClass :value }
+    DataClass = Lab42::DataClass
 ```
 
-And a list of instances
-```ruby
-    let(:list) {[class1.new(value: 1), class2.new(value: 2), class1.new(value: 3)]}
-```
-
-Then we can filter
-```ruby
-    expect(list.filter(&class2)).to eq([class2.new(value: 2)])
-```
-
-### Context: Behaving like a `Hash`
-
-We have already seen the `to_h` method, however if we want to pass an instance of `DataClass` as 
-keyword parameters we need an implementation of `to_hash`, which of course is just an alias
-
-Given this keyword method
-```ruby
-    def extract_value(value:, **others)
-      [value, others]
-    end
-```
-And this `DataClass`:
-```ruby
-    let(:my_class) { DataClass(value: 1, base: 2) }
-```
+## Context: Data Classes
 
-Then we can pass it as keyword arguments
-```ruby
-    expect(extract_value(**my_class.new)).to eq([1, base: 2])
-```
-
-### Context: Constraints
-
-Values of attributes of a `DataClass` can have constraints
+### Basic Use Case
 
-Given a `DataClass` with constraints
+Given a simple Data Class
 ```ruby
-    let :switch do
-      DataClass(on: false).with_constraint(on: -> { [false, true].member? _1 })
+    class SimpleDataClass
+      extend DataClass
+      attributes :a, :b
     end
 ```
 
-Then boolean values are acceptable
+And an instance of it
 ```ruby
-    expect{ switch.new }.not_to raise_error
-    expect(switch.new.merge(on: true).on).to eq(true)
+    let(:simple_instance) { SimpleDataClass.new(a: 1, b: 2) }
 ```
 
-But we can neither construct or merge with non boolean values
+Then we access the fields
 ```ruby
-    expect{ switch.new(on: nil) }
-     .to raise_error(Lab42::DataClass::ConstraintError, "value nil is not allowed for attribute :on")
-    expect{ switch.new.merge(on: 42) }
-     .to raise_error(Lab42::DataClass::ConstraintError, "value 42 is not allowed for attribute :on")
+    expect(simple_instance.a).to eq(1)
+    expect(simple_instance.b).to eq(2)
 ```
 
-And therefore defaultless attributes cannot have a constraint that is violated by a nil value
+And we convert to a hash
 ```ruby
-    error_head = "constraint error during validation of default value of attribute :value"
-    error_body = "  undefined method `>' for nil:NilClass"
-    error_message = [error_head, error_body].join("\n")
-
-    expect{ DataClass(value: nil).with_constraint(value: -> { _1 > 0 }) }
-      .to raise_error(Lab42::DataClass::ConstraintError, /#{error_message}/)
+    expect(simple_instance.to_h).to eq(a: 1, b: 2)
 ```
 
-And defining constraints for undefined attributes is not the best of ideas
+And we can derive new instances
 ```ruby
-    expect { DataClass(a: 1).with_constraint(b: -> {true}) }
-      .to raise_error(ArgumentError, "constraints cannot be defined for undefined attributes [:b]")
+    new_instance = simple_instance.merge(b: 3)
+    expect(new_instance.to_h).to eq(a: 1, b: 3)
+    expect(simple_instance.to_h).to eq(a: 1, b: 2)
 ```
 
+For detailed speculations please see [here](speculations/DATA_CLASSES.md)
 
-#### Context: Convenience Constraints
+## Context: `DataClass` function
 
-Often repeating patterns are implemented as non lambda constraints, depending on the type of a constraint
-it is implicitly converted to a lambda as specified below:
+As seen in the speculations above it seems appropriate to declare a `Class` and
+extend it as we will add quite some code for constraints, derived attributes and validations.
 
-Given a shortcut for our `ConstraintError`
-```ruby
-    let(:constraint_error) { Lab42::DataClass::ConstraintError }
-    let(:positive) { DataClass(:value) }
-```
+However a more concise _Factory Function_ might still be very useful in some use cases...
 
-##### Symbols
+Enter `Kernel::DataClass` **The Function**
 
-... are sent to the value of the attribute, this is not very surprising of course ;)
+### Context: Just Attributes
 
-Then a first implementation of `Positive`
-```ruby
-    positive_by_symbol = positive.with_constraint(value: :positive?)
-
-    expect(positive_by_symbol.new(value: 1).value).to eq(1)
-    expect{positive_by_symbol.new(value: 0)}.to raise_error(constraint_error)
-```
+If there are no _Constraints_, _Derived Attributes_, _Validation_ or _Inheritance_ this concise syntax
+might easily be preferred by many:
 
-##### Arrays
-
-... are also sent to the value of the attribute, this time we can provide paramaters
-And we can implement a different form of `Positive`
+Given some example instances like these
 ```ruby
-    positive_by_ary = positive.with_constraint(value: [:>, 0])
-
-    expect(positive_by_ary.new(value: 1).value).to eq(1)
-    expect{positive_by_ary.new(value: 0)}.to raise_error(constraint_error)
+    let(:my_data_class) { DataClass(:name, email: nil) }
+    let(:my_instance) { my_data_class.new(name: "robert") }
 ```
 
-If however we are interested in membership we have to wrap the `Array` into a `Set`
-
-##### Membership
-
-And this works with a `Set`
+Then we can access its fields
 ```ruby
-    positive_by_set = positive.with_constraint(value: Set.new([*1..10]))
-
-    expect(positive_by_set.new(value: 1).value).to eq(1)
-    expect{positive_by_set.new(value: 0)}.to raise_error(constraint_error)
+    expect(my_instance.name).to eq("robert")
+    expect(my_instance[:email]).to be_nil
 ```
 
-And also with a `Range`
+But we cannot access undefined fields
 ```ruby
-    positive_by_range = positive.with_constraint(value: 1..Float::INFINITY)
-
-    expect(positive_by_range.new(value: 1).value).to eq(1)
-    expect{positive_by_range.new(value: 0)}.to raise_error(constraint_error)
+    expect{ my_instance.undefined }.to raise_error(NoMethodError)
 ```
 
-##### Regexen
-
-This seems quite obvious, and of course it works
-
-Then we can also have a regex based constraint
+And this is even true for the `[]` syntax
 ```ruby
-    vowel = DataClass(:word).with_constraint(word: /[aeiou]/)
-
-    expect(vowel.new(word: "alpha").word).to eq("alpha")
-    expect{vowel.new(word: "krk")}.to raise_error(constraint_error)
+    expect{ my_instance[:undefined] }.to raise_error(KeyError)
 ```
 
-##### Other callable objects as constraints
-
-
-Then we can also use instance methods to implement our `Positive`
+And we need to provide values to fields without defaults
 ```ruby
-    positive_by_instance_method = positive.with_constraint(value: Fixnum.instance_method(:positive?))
-
-    expect(positive_by_instance_method.new(value: 1).value).to eq(1)
-    expect{positive_by_instance_method.new(value: 0)}.to raise_error(constraint_error)
+    expect{ my_data_class.new(email: "some@mail.org") }
+      .to raise_error(ArgumentError, "missing initializers for [:name]")
 ```
-
-Or we can use methods to implement it
+And we can extract the values
 ```ruby
-    positive_by_method = positive.with_constraint(value: 0.method(:<))
-
-    expect(positive_by_method.new(value: 1).value).to eq(1)
-    expect{positive_by_method.new(value: 0)}.to raise_error(constraint_error)
+    expect(my_instance.to_h).to eq(name: "robert", email: nil)
 ```
 
-#### Context: Global Constraints aka __Validations__
-
-So far we have only speculated about constraints concerning one attribute, however sometimes we want
-to have arbitrary constraints which can only be calculated by access to more attributes
-
-Given a `Point` DataClass
-```ruby
-    let(:point) { DataClass(:x, :y).validate{ |point| point.x > point.y } }
-    let(:validation_error) { Lab42::DataClass::ValidationError }
-```
+#### Context: Immutable → self
 
-Then we will get a `ValidationError` if we construct a point left of the main diagonal
+Then `my_instance` is frozen:
 ```ruby
-    expect{ point.new(x: 0, y: 1) }
-      .to raise_error(validation_error)
+    expect(my_instance).to be_frozen
 ```
-
-But as validation might need more than the default values we will not execute them at compile time
+And we cannot even mute `my_instance`  by means of metaprogramming
 ```ruby
-    expect{ DataClass(x: 0, y: 0).validate{ |inst| inst.x > inst.y } }
-      .to_not raise_error
+    expect{ my_instance.instance_variable_set("@x", nil) }.to raise_error(FrozenError)
 ```
 
-And we can name validations to get better error messages
-```ruby
-    better_point = DataClass(:x, :y).validate(:too_left){ |point| point.x > point.y }
-    ok_point     = better_point.new(x: 1, y: 0)
-    expect{ ok_point.merge(y: 1) }
-      .to raise_error(validation_error, "too_left")
-```
+#### Context: Immutable → Cloning
 
-And remark how bad unnamed validation errors might be
+Given
 ```ruby
-    error_message_rgx = %r{
-       \#<Proc:0x[0-9a-f]+ \s .* spec/speculations/README_spec\.rb: \d+ > \z
-    }x
-    expect{ point.new(x: 0, y: 1) }
-      .to raise_error(validation_error, error_message_rgx)
+    let(:other_instance) { my_instance.merge(email: "robert@mail.provider") }
 ```
-
-### Context: Usage with `extend`
-
-All the above mentioned features can be achieved with a more conventional syntax by extending a class
-with `Lab42::DataClass`
-
-Given a class that extends `DataClass`
+Then we have a new instance with the old instance unchanged
 ```ruby
-    let :my_class do
-      Class.new do
-        extend Lab42::DataClass
-        attributes :age, member: false
-        constraint :member, Set.new([false, true])
-        validate(:too_young_for_member) { |instance| !(instance.member && instance.age < 18) }
-      end
-    end
-    let(:constraint_error) { Lab42::DataClass::ConstraintError }
-    let(:validation_error) { Lab42::DataClass::ValidationError }
-    let(:my_instance) { my_class.new(age: 42) }
-    let(:my_vip)      { my_instance.merge(member: true) }
+    expect(other_instance.to_h).to eq(name: "robert", email: "robert@mail.provider")
+    expect(my_instance.to_h).to eq(name: "robert", email: nil)
 ```
-
-Then we can observe that instances of such a class
+And the new instance is frozen again
 ```ruby
-    expect(my_instance.to_h).to eq(age: 42, member: false)
-    expect(my_vip.to_h).to eq(age: 42, member: true)
-    expect(my_instance.member).to be_falsy
+    expect(other_instance).to be_frozen
 ```
 
-And we will get constraint errors if applicable
-```ruby
-    expect{my_instance.merge(member: nil)}
-      .to raise_error(constraint_error)
-```
+For speculations how to add all the other features to the _Factory Function_ syntax please
+look [here](speculations/FACTORY_FUNCTION.md)
 
-And of course validations still work too
-```ruby
-    expect{ my_vip.merge(age: 17) }
-      .to raise_error(validation_error, "too_young_for_member")
-```
 
 
 ## Context: `Pair` and `Triple`

data/lib/lab42/data_class/duplicate_definition_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lab42
+  module DataClass
+    class DuplicateDefinitionError < RuntimeError
+    end
+  end
+end
+#  SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/proxy/constraints/maker.rb

@@ -19,6 +19,8 @@ module Lab42
               -> { constraint.match?(_1) }
             when UnboundMethod
               -> { constraint.bind(_1).() }
+            when Module
+              -> { constraint === _1 }
             else
               _make_member_constraint(constraint)
             end

data/lib/lab42/data_class/proxy/derived.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lab42
+  module DataClass
+    class Proxy
+      module Derived
+        private
+        def _define_derived
+          proxy = self
+          ->(*) do
+            define_method :derive do |att_name, &blk|
+              proxy.define_derived_attribute(att_name, &blk)
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/proxy/memos.rb

@@ -4,6 +4,10 @@ module Lab42
   module DataClass
     class Proxy
       module Memos
+        def all_attributes
+          @__all_attributes__ ||= members&.union(Set.new(derived_attributes.keys))
+        end
+
         def constraints
           @__constraints__ ||= Hash.new { |h, k| h[k] = [] }
         end
@@ -12,6 +16,10 @@ module Lab42
           @__defaults__ ||= {}
         end
 
+        def derived_attributes
+          @__derived_attributes__ ||= {}
+        end
+
         def members
           @__members__ ||= unless (positionals + defaults.keys).empty?
                              Set.new(positionals + defaults.keys)

data/lib/lab42/data_class/proxy.rb

@@ -2,15 +2,33 @@
 
 require 'set'
 require_relative 'proxy/constraints'
+require_relative 'proxy/derived'
 require_relative 'proxy/memos'
 require_relative 'proxy/validations'
 require_relative 'proxy/mixin'
 module Lab42
   module DataClass
     class Proxy
-      include Constraints, Memos, Validations
+      include Constraints, Derived, Memos, Validations
 
-      attr_reader :actual_params, :block, :klass
+      attr_reader :actual_params, :block, :klass, :klass_defined
+
+      def self.from_parent(parent, klass)
+        new(klass).tap do |proxy|
+          proxy.positionals.push(*parent.positionals)
+          proxy.defaults.update(parent.defaults)
+          proxy.constraints.update(parent.constraints)
+          proxy.validations.push(*parent.validations)
+        end
+      end
+
+      def access(data_class_instance, key)
+        if all_attributes.member?(key)
+          data_class_instance.send(key)
+        else
+          raise KeyError, "#{key} is not an attribute of #{data_class_instance}"
+        end
+      end
 
       def check!(**params)
         @actual_params = params
@@ -21,22 +39,33 @@ module Lab42
       end
 
       def define_class!
+        return if @klass_defined
+
+        @klass_defined = true
         klass.module_eval(&_define_attr_reader)
-        klass.module_eval(&_define_initializer)
+        klass.module_eval(&_define_initializer) if Class === klass
         _define_methods
         klass.include(Mixin)
         klass.module_eval(&block) if block
         klass
       end
 
+      def define_derived_attribute(name, &blk)
+        positionals.delete(name)
+        defaults.delete(name)
+        derived_attributes.update(name => true) do |_key, _old,|
+          raise DuplicateDefinitionError, "Redefinition of derived attribute #{name}"
+        end
+        klass.module_eval(&_define_derived_attribute(name, &blk))
+      end
+
       def init(data_class, **params)
         _init(data_class, defaults.merge(params))
       end
 
       def to_hash(data_class_instance)
-        members
-          .map { [_1, data_class_instance.instance_variable_get("@#{_1}")] }
-          .to_h
+        all_attributes
+          .inject({}) { |result, (k, _)| result.merge(k => data_class_instance[k]) }
       end
 
       def update!(with_positionals, with_keywords)
@@ -46,12 +75,13 @@ module Lab42
 
       private
       def initialize(*args, **kwds, &blk)
-        @klass = if Class === args.first
+        @klass = if Module === args.first
                    args.shift
                  else
                    Class.new
                  end
 
+        @klass_defined = false
         @block = blk
         defaults.update(kwds)
         positionals.push(*args)
@@ -64,6 +94,12 @@ module Lab42
         end
       end
 
+      def _define_derived_attribute(name, &blk)
+        ->(*) do
+          define_method(name) { blk.call(self) }
+        end
+      end
+
       def _define_freezing_constructor
         ->(*) do
           define_method :new do |*a, **p, &b|
@@ -93,8 +129,8 @@ module Lab42
       end
 
       def _define_methods
-        class << klass; self end
-          .tap { |singleton| _define_singleton_methods(singleton) }
+        _define_singleton_methods(klass.singleton_class)
+        klass.module_eval(&_define_access)
         klass.module_eval(&_define_to_h)
         klass.module_eval(&_define_merge)
       end
@@ -103,9 +139,19 @@ module Lab42
         singleton.module_eval(&_define_freezing_constructor)
         singleton.module_eval(&_define_to_proc)
         singleton.module_eval(&_define_with_constraint)
+        singleton.module_eval(&_define_derived)
         singleton.module_eval(&_define_with_validations)
       end
 
+      def _define_access
+        proxy = self
+        ->(*) do
+          define_method :[] do |key|
+            proxy.access(self, key)
+          end
+        end
+      end
+
       def _define_to_h
         proxy = self
         ->(*) do

data/lib/lab42/data_class/version.rb

@@ -2,7 +2,7 @@
 
 module Lab42
   module DataClass
-    VERSION = "0.6.0"
+    VERSION = "0.7.0"
   end
 end
 #  SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './data_class/constraint_error'
+require_relative './data_class/duplicate_definition_error'
 require_relative './data_class/kernel'
 require_relative './data_class/validation_error'
 require_relative './data_class/proxy'
@@ -9,10 +10,18 @@ require_relative './triple'
 
 module Lab42
   module DataClass
-    def self.extended(extender)
-      proxy = Proxy.new(extender)
+    def self.extended(extendee)
+      base_proxy =
+        extendee
+        .ancestors
+        .grep(self)
+        .drop(1)
+        .first
+          &.__data_class_proxy__
 
-      extender.module_eval do
+      proxy = base_proxy ? Proxy.from_parent(base_proxy, extendee) : Proxy.new(extendee)
+
+      extendee.module_eval do
         define_singleton_method(:__data_class_proxy__){ proxy }
       end
     end
@@ -24,10 +33,16 @@ module Lab42
       end
     end
 
+    def derive(att_name, &blk)
+      __data_class_proxy__.define_derived_attribute(att_name, &blk)
+      __data_class_proxy__.define_class!
+    end
+
     def constraint(member, constraint = nil, &block)
       raise ArgumentError, "must not provide constraint (2nd argument) and a block" if block && constraint
 
       __data_class_proxy__.define_constraints(member => constraint || block)
+      __data_class_proxy__.define_class!
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_data_class
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-02-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   An Immutable DataClass for Ruby
@@ -25,10 +25,12 @@ files:
 - README.md
 - lib/lab42/data_class.rb
 - lib/lab42/data_class/constraint_error.rb
+- lib/lab42/data_class/duplicate_definition_error.rb
 - lib/lab42/data_class/kernel.rb
 - lib/lab42/data_class/proxy.rb
 - lib/lab42/data_class/proxy/constraints.rb
 - lib/lab42/data_class/proxy/constraints/maker.rb
+- lib/lab42/data_class/proxy/derived.rb
 - lib/lab42/data_class/proxy/memos.rb
 - lib/lab42/data_class/proxy/mixin.rb
 - lib/lab42/data_class/proxy/validations.rb