lab42_data_class 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d8b97ca60e61ad4b3ec85555649e5538ca35ef1018bcdf2a1cd9f86d4183718
-  data.tar.gz: 7076ca2be4a3a8e5428b2fa0fa14523c416d491d14a8ba254842405332215dba
+  metadata.gz: 2ae30c490e9b798403214f49c4cbc43564bf47b741878f9aa174e27dc17a85b8
+  data.tar.gz: 2e7ab04142e8eb38206ba14bd03464465844b307087708d382e253fc40dd8f1b
 SHA512:
-  metadata.gz: c74e746f2f71ac1cbd89a10566b5655e0cb4e2e9d6ff6031e147bb833b8af91b5e1251e89b0ed826401a1915e3654b8543d065138fc705491bf1c684d85d4b97
-  data.tar.gz: bf15dd5127834637d6c9e0e78cbaf4cb50e75afd03b3ba4d763e186ad65f00df9076892bd151bebad30d4e1d8d49b287225e00ef0ccf6eed3e7965ba1f47af62
+  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,424 +56,129 @@ 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)
-```
+The following specs are executed with the [speculate about](https://github.com/RobertDober/speculate_about) gem.
 
-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
+Given that we have imported the `Lab42` namespace
 ```ruby
-    expect(my_instance.to_h).to eq(name: "robert", email: nil)
+    DataClass = Lab42::DataClass
 ```
 
-#### 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: Data Classes
 
-#### Context: Immutable → Cloning
+### Basic Use Case
 
-Given
+Given a simple Data Class
 ```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
+    class SimpleDataClass
+      extend DataClass
+      attributes :a, :b
     end
-    let(:my_instance) { my_data_class.new(value: 42) }
 ```
 
-Then I have defined a method on my dataclass
+And an instance of it
 ```ruby
-    expect(my_instance.show).to eq("<42>")
+    let(:simple_instance) { SimpleDataClass.new(a: 1, b: 2) }
 ```
 
-### 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?`
+Then we access the fields
 ```ruby
-    expect(instance1).to eq(instance2)
-    expect(instance2).to eq(instance1)
-    expect(instance1 == instance2).to be_truthy
-    expect(instance2 == instance1).to be_truthy
+    expect(simple_instance.a).to eq(1)
+    expect(simple_instance.b).to eq(2)
 ```
-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
+And we convert to a hash
 ```ruby
-    expect(instance1).to be_frozen
+    expect(simple_instance.to_h).to eq(a: 1, b: 2)
 ```
 
-### 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
+And we can derive new instances
 ```ruby
-    let :token do
-      ->(*a, **k) do
-        DataClass(*a, **(k.merge(text: "")))
-        end
-    end
+    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)
 ```
 
-Then we have reused the `token` successfully
-```ruby
-    empty = token.()
-    integer = token.(:value)
-    boolean = token.(value: false)
+For detailed speculations please see [here](speculations/DATA_CLASSES.md)
 
-    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: `DataClass` function
 
-#### Context: Mixing in a module can be used of course
+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 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
+However a more concise _Factory Function_ might still be very useful in some use cases...
 
-A `DataClass` object behaves like the result of it's `to_h` in pattern matching
+Enter `Kernel::DataClass` **The Function**
 
-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}) }
-```
+### Context: Just Attributes
 
-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)
-```
+If there are no _Constraints_, _Derived Attributes_, _Validation_ or _Inheritance_ this concise syntax
+might easily be preferred by many:
 
-And all the associated methods
+Given some example instances like these
 ```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
-
-Given two different `DataClass` objects
-```ruby
-    let(:class1) { DataClass :value }
-    let(:class2) { DataClass :value }
-```
-
-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) }
-```
-
-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
-
-Given a `DataClass` with constraints
-```ruby
-    let :switch do
-      DataClass(on: false).with_constraint(on: -> { [false, true].member? _1 })
-    end
-```
-
-Then boolean values are acceptable
-```ruby
-    expect{ switch.new }.not_to raise_error
-    expect(switch.new.merge(on: true).on).to eq(true)
-```
-
-But we can neither construct or merge with non boolean values
-```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")
+    let(:my_data_class) { DataClass(:name, email: nil) }
+    let(:my_instance) { my_data_class.new(name: "robert") }
 ```
 
-And therefore defaultless attributes cannot have a constraint that is violated by a nil value
+Then we can access its fields
 ```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(my_instance.name).to eq("robert")
+    expect(my_instance[:email]).to be_nil
 ```
 
-And defining constraints for undefined attributes is not the best of ideas
+But we cannot access undefined fields
 ```ruby
-    expect { DataClass(a: 1).with_constraint(b: -> {true}) }
-      .to raise_error(ArgumentError, "constraints cannot be defined for undefined attributes [:b]")
+    expect{ my_instance.undefined }.to raise_error(NoMethodError)
 ```
 
-
-#### Context: Convenience Constraints
-
-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:
-
-Given a shortcut for our `ConstraintError`
+And this is even true for the `[]` syntax
 ```ruby
-    let(:constraint_error) { Lab42::DataClass::ConstraintError }
-    let(:positive) { DataClass(:value) }
+    expect{ my_instance[:undefined] }.to raise_error(KeyError)
 ```
 
-##### Symbols
-
-... are sent to the value of the attribute, this is not very surprising of course ;)
-
-Then a first implementation of `Positive`
+And we need to provide values to fields without defaults
 ```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)
+    expect{ my_data_class.new(email: "some@mail.org") }
+      .to raise_error(ArgumentError, "missing initializers for [:name]")
 ```
-
-##### 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`
+And we can extract the values
 ```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)
+    expect(my_instance.to_h).to eq(name: "robert", email: nil)
 ```
 
-If however we are interested in membership we have to wrap the `Array` into a `Set`
-
-##### Membership
-
-And this works with a `Set`
-```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)
-```
+#### Context: Immutable → self
 
-And also with a `Range`
+Then `my_instance` is frozen:
 ```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).to be_frozen
 ```
-
-##### Regexen
-
-This seems quite obvious, and of course it works
-
-Then we can also have a regex based constraint
+And we cannot even mute `my_instance`  by means of metaprogramming
 ```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.instance_variable_set("@x", nil) }.to raise_error(FrozenError)
 ```
 
-##### Other callable objects as constraints
-
-
-Then we can also use instance methods to implement our `Positive`
-```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)
-```
+#### Context: Immutable → Cloning
 
-Or we can use methods to implement it
+Given
 ```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)
+    let(:other_instance) { my_instance.merge(email: "robert@mail.provider") }
 ```
-
-#### 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
+Then we have a new instance with the old instance unchanged
 ```ruby
-    let(:point) { DataClass(:x, :y).validate{ |point| point.x > point.y } }
-    let(:validation_error) { Lab42::DataClass::ValidationError }
+    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 will get a `ValidationError` if we construct a point left of the main diagonal
+And the new instance is frozen again
 ```ruby
-    expect{ point.new(x: 0, y: 1) }
-      .to raise_error(validation_error)
+    expect(other_instance).to be_frozen
 ```
 
-But as validation might need more than the default values we will not execute them at compile time
-```ruby
-    expect{ DataClass(x: 0, y: 0).validate{ |inst| inst.x > inst.y } }
-      .to_not raise_error
-```
+For speculations how to add all the other features to the _Factory Function_ syntax please
+look [here](speculations/FACTORY_FUNCTION.md)
 
-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")
-```
 
-And remark how bad unnamed validation errors might be
-```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)
-```
 
 ## 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/kernel.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kernel
+  def DataClass(*args, **kwds, &blk)
+    proxy = Lab42::DataClass::Proxy.new(*args, **kwds, &blk)
+    proxy.define_class!
+  end
+
+  def Pair(first, second)
+    Lab42::Pair.new(first, second)
+  end
+
+  def Triple(first, second, third)
+    Lab42::Triple.new(first, second, third)
+  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/constraints.rb

@@ -23,6 +23,16 @@ module Lab42
           end
         end
 
+        def define_constraints(constraints)
+          errors = constraints.map(&define_constraint).compact
+          unless errors.empty?
+            raise ArgumentError,
+                  "constraints cannot be defined for undefined attributes #{errors.inspect}"
+          end
+
+          check_constraints_against_defaults(constraints)
+        end
+
         private
 
         def _check_constraint_against_default
@@ -34,7 +44,7 @@ module Lab42
         end
 
         def _check_constraint_against_default_value(attr, value, constraint)
-          unless constraint.(value)
+          unless Maker.make_constraint(constraint).(value)
             "default value #{value.inspect} is not allowed for attribute #{attr.inspect}"
           end
         rescue StandardError => e
@@ -68,13 +78,7 @@ module Lab42
           proxy = self
           ->(*) do
             define_method :with_constraint do |**constraints|
-              errors = constraints.map(&proxy.define_constraint).compact
-              unless errors.empty?
-                raise ArgumentError,
-                      "constraints cannot be defined for undefined attributes #{errors.inspect}"
-              end
-
-              proxy.check_constraints_against_defaults(constraints)
+              proxy.define_constraints(constraints)
               self
             end
           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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+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
+
+        def defaults
+          @__defaults__ ||= {}
+        end
+
+        def derived_attributes
+          @__derived_attributes__ ||= {}
+        end
+
+        def members
+          @__members__ ||= unless (positionals + defaults.keys).empty?
+                             Set.new(positionals + defaults.keys)
+                           end
+        end
+
+        def positionals
+          @__positionals__ ||= []
+        end
+
+        def validations
+          @__validations__ ||= []
+        end
+
+        private
+
+        def _missing_initializers
+          @___missing_initializers__ ||=
+            positionals - actual_params.keys
+        end
+
+        def _illegal_initializers
+          @___illegal_initializers__ ||=
+            actual_params.keys - positionals - defaults.keys
+        end
+      end
+    end
+  end
+end
+#  SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/proxy.rb

@@ -2,58 +2,89 @@
 
 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, Validations
+      include Constraints, Derived, Memos, Validations
 
-      attr_reader :actual_params, :all_params, :block, :constraints, :defaults, :klass, :members, :positionals
+      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
-        @all_params = defaults.merge(params)
         raise ArgumentError, "missing initializers for #{_missing_initializers}" unless _missing_initializers.empty?
         raise ArgumentError, "illegal initializers #{_illegal_initializers}" unless _illegal_initializers.empty?
 
-        _check_constraints!(all_params)
+        _check_constraints!(defaults.merge(params))
       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 validations
-        @__validations__ ||= []
+      def update!(with_positionals, with_keywords)
+        positionals.push(*with_positionals)
+        defaults.update(with_keywords)
       end
 
       private
       def initialize(*args, **kwds, &blk)
-        @klass = Class.new
-
-        @constraints = Hash.new { |h, k| h[k] = [] }
+        @klass = if Module === args.first
+                   args.shift
+                 else
+                   Class.new
+                 end
 
+        @klass_defined = false
         @block = blk
-        @defaults = kwds
-        @members = Set.new(args + kwds.keys)
-        # TODO: Check for all symbols and no duplicates ⇒ v0.5.1
-        @positionals = args
+        defaults.update(kwds)
+        positionals.push(*args)
       end
 
       def _define_attr_reader
@@ -63,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|
@@ -92,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
@@ -102,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
@@ -128,16 +175,6 @@ module Lab42
           data_class_instance.instance_variable_set("@#{key}", value)
         end
       end
-
-      def _missing_initializers
-        @___missing_initializers__ ||=
-          positionals - actual_params.keys
-      end
-
-      def _illegal_initializers
-        @___illegal_initializers__ ||=
-          actual_params.keys - positionals - defaults.keys
-      end
     end
   end
 end

data/lib/lab42/data_class/version.rb

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

data/lib/lab42/data_class.rb

@@ -1,24 +1,49 @@
 # 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'
 require_relative './pair'
 require_relative './triple'
 
-module Kernel
-  def DataClass(*args, **kwds, &blk)
-    proxy = Lab42::DataClass::Proxy.new(*args, **kwds, &blk)
-    proxy.define_class!
-  end
+module Lab42
+  module DataClass
+    def self.extended(extendee)
+      base_proxy =
+        extendee
+        .ancestors
+        .grep(self)
+        .drop(1)
+        .first
+          &.__data_class_proxy__
 
-  def Pair(first, second)
-    Lab42::Pair.new(first, second)
-  end
+      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
+
+    def attributes(*args, **kwds)
+      __data_class_proxy__.tap do |proxy|
+        proxy.update!(args, kwds)
+        proxy.define_class!
+      end
+    end
 
-  def Triple(first, second, third)
-    Lab42::Triple.new(first, second, third)
+    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
-
 #  SPDX-License-Identifier: Apache-2.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_data_class
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-23 00:00:00.000000000 Z
+date: 2022-02-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   An Immutable DataClass for Ruby
@@ -25,9 +25,13 @@ 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
 - lib/lab42/data_class/validation_error.rb