lab42_data_class 0.6.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1819694c4684f3f4e377f04f4eb17d0842a1075ff7859eeef443c66dd7cfb458
-  data.tar.gz: 5af74933329ed924d51a1820d666c671973004edbd3ab00f6ba93378df71180f
+  metadata.gz: 746ce73ef4464de258f683f0d8366f15799cb8e3ea34a062cc6f4deb34f0a60d
+  data.tar.gz: 96c679474b72b872f4885ab2c98f7ddfd5f914268b3a9da5ba59f7ae026e5eed
 SHA512:
-  metadata.gz: 5e14f2656f03703aa867dce065bf9e4770cf043fd97d035cab9a6b869d9fb6e9749c2de3eef0b948e02c7ade07f85f75423c4b2412ed154574a6672e28411d9f
-  data.tar.gz: f831c9c8094f7224de088f6f03847791bcc91a33db6e565fc1ef3f45d5f3f5e29d18b05dfbcdbc7dcc422755d0ab87dc73f0c50a9de45dcd3df0916d87fb1c16
+  metadata.gz: 184dc66df2185e0869a5cbce9811c8bedf685123037fadf8d17c30bfd762884b9f0d0756bc0d43787dce2586c8094bb2a798aba9b54087198b59a1a0d95023c0
+  data.tar.gz: 859c555137b976c4885157c5b39d42393c528adf94abb3dd28b9cbd3e38625d3bccac9b5cf5e317cdf3dddb08494fa989dd11523902f79402ed915822d616a64

data/README.md

@@ -8,490 +8,174 @@
 
 # Lab42::DataClass
 
-
 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`
-
-## Usage
-
-```sh
-gem install lab42_data_class
-```
-
-With bundler
-
-```ruby
-  gem 'lab42_data_class'
-```
-
-In your code
-
-```ruby
-require 'lab42/data_class'
-```
-
-
-## 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")
-```
+Exposes a class factory function `Kernel::DataClass` and a module `Lab42::DataClass` which can
+extend classes to become _Data Classes_.
 
-### Context: Pattern Matching
+Also exposes two _tuple_ classes, `Pair` and `Triple`
 
-A `DataClass` object behaves like the result of it's `to_h` in pattern matching
+## Synopsis
 
-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}) }
-```
+Having immutable Objects has many well known advantages that I will not ponder upon in detail here.
 
-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)
-```
+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.
 
-And in `in` expressions
-```ruby
-    evens => {values: [_, second, *]}
-    expect(second).to eq(4)
-```
-
-#### Context: In Case Statements
+Therefore we can summarise the features (or not so features, that is for you to decide and you to chose to use or not):
 
-Given a nice little dataclass `Box`
-```ruby
-    let(:box) { DataClass content: nil }
-```
+  - 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)
 
-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)
-```
+## Usage
 
-And all the associated methods
-```ruby
-    expect(box.new).to be_a(box)
-    expect(box === box.new).to be_truthy
+```sh
+  gem install lab42_data_class
 ```
 
-### Context: Behaving like a `Proc`
-
-It is useful to be able to filter heterogeneous lists of `DataClass` instances by means of `&to_proc`, therefore
+With bundler
 
-Given two different `DataClass` objects
 ```ruby
-    let(:class1) { DataClass :value }
-    let(:class2) { DataClass :value }
+  gem 'lab42_data_class'
 ```
 
-And a list of instances
-```ruby
-    let(:list) {[class1.new(value: 1), class2.new(value: 2), class1.new(value: 3)]}
-```
+In your code
 
-Then we can filter
 ```ruby
-    expect(list.filter(&class2)).to eq([class2.new(value: 2)])
+require 'lab42/data_class'
 ```
 
-### 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
+## Speculations (literate specs)
 
-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) }
-```
+The following specs are executed with the [speculate about](https://github.com/RobertDober/speculate_about) gem.
 
-Then we can pass it as keyword arguments
+Given that we have imported the `Lab42` namespace
 ```ruby
-    expect(extract_value(**my_class.new)).to eq([1, base: 2])
+    DataClass = Lab42::DataClass
 ```
 
-### Context: Constraints
+## Context: Data Classes
 
-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/builtin_constraints.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "constraint"
+require_relative "constraints/kernel"
+
+module Lab42
+  module DataClass
+    module BuiltinConstraints
+      extend self
+    end
+  end
+end
+
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraint.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lab42/data_class"
+module Lab42
+  module DataClass
+    class Constraint
+      attr_reader :name, :function
+
+      def call(value)
+        function.(value)
+      end
+
+      def to_s
+        "Constraint<#{name}>"
+      end
+
+      private
+      def initialize(name:, function:)
+        raise ArgumentError, "name not a String, but #{name}" unless String === name
+        unless function.respond_to?(:arity) && function.arity == 1
+          raise ArgumentError, "function not a callable with arity 1 #{function}"
+        end
+
+        @name = name
+        @function = function
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/kernel.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Kernel
+  Constraint = Lab42::DataClass::Constraint
+  Maker = Lab42::DataClass::Proxy::Constraints::Maker # TODO: Move Maker to Lab42::DataClass:ConstraintMaker
+  Anything = Constraint.new(name: "Anything", function: ->(_) { true })
+  Boolean = Constraint.new(name: "Boolean", function: -> { [false, true].member?(_1) })
+
+  def All?(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> do
+      _1.all?(&constraint)
+    end
+    Constraint.new(name: "All?(#{constraint})", function: f)
+  end
+
+  def Any?(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> do
+      _1.any?(&constraint)
+    end
+    Constraint.new(name: "Any?(#{constraint})", function: f)
+  end
+
+  def Choice(*constraints)
+    constraints = constraints.map{ Maker.make_constraint _1 }
+    f = ->(value) do
+      constraints.any?{ _1.(value) }
+    end
+    Constraint.new(name: "Choice(#{constraints.join(', ')})", function: f)
+  end
+
+  def Contains(str)
+    f = -> { _1.include?(str) rescue false }
+    Constraint.new(name: "Contains(#{str})", function: f)
+  end
+
+  def EndsWith(str)
+    f = -> { _1.end_with?(str) rescue false }
+    Constraint.new(name: "EndsWith(#{str})", function: f)
+  end
+
+  def Lambda(arity)
+    f = -> do
+      _1.arity == arity rescue false
+    end
+    Constraint.new(name: "Lambda(#{arity})", function: f)
+  end
+
+  def NilOr(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> { _1.nil? || constraint.(_1) }
+    Constraint.new(name: "NilOr(#{constraint})", function: f)
+  end
+
+  def Not(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> { !constraint.(_1) }
+    Constraint.new(name: "Not(#{constraint})", function: f)
+  end
+
+  def PairOf(fst, snd)
+    fst_constraint = Maker.make_constraint(fst)
+    snd_constraint = Maker.make_constraint(snd)
+    f = -> do
+      Lab42::Pair === _1 && fst_constraint.(_1.first) && snd_constraint.(_1.second)
+    end
+    Constraint.new(name: "PairOf(#{fst_constraint}, #{snd_constraint})", function: f)
+  end
+
+  def StartsWith(str)
+    f = -> { _1.start_with?(str) rescue false }
+    Constraint.new(name: "StartsWith(#{str})", function: f)
+  end
+
+  def TripleOf(fst, snd, trd)
+    fst_constraint = Maker.make_constraint(fst)
+    snd_constraint = Maker.make_constraint(snd)
+    trd_constraint = Maker.make_constraint(trd)
+    f = -> do
+      Lab42::Triple === _1 && fst_constraint.(_1.first) && snd_constraint.(_1.second) && trd_constraint.(_1.third)
+    end
+    Constraint.new(name: "TripleOf(#{fst_constraint}, #{snd_constraint}, #{trd_constraint})", function: f)
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "lab42/data_class/constraint"
 module Lab42
   module DataClass
     class Proxy
@@ -7,9 +8,17 @@ module Lab42
         module Maker
           extend self
 
-          def make_constraint(constraint)
+          def make_constraint(constraint, &blk)
+            raise ArgumentError, "must not pass a callable #{constraint} and a block" if constraint && blk
+
+            _make_constraint(constraint || blk)
+          end
+
+          private
+
+          def _make_constraint(constraint)
             case constraint
-            when Proc, Method
+            when Lab42::DataClass::Constraint, Proc, Method
               constraint
             when Symbol
               -> { _1.send(constraint) }
@@ -19,13 +28,13 @@ module Lab42
               -> { constraint.match?(_1) }
             when UnboundMethod
               -> { constraint.bind(_1).() }
+            when Module
+              -> { constraint === _1 }
             else
               _make_member_constraint(constraint)
             end
           end
 
-          private
-
           def _make_member_constraint(constraint)
             if constraint.respond_to?(:member?)
               -> { constraint.member?(_1) }

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

@@ -14,7 +14,7 @@ module Lab42
 
         def define_constraint
           ->((attr, constraint)) do
-            if members.member?(attr)
+            if members!.member?(attr)
               constraints[attr] << Maker.make_constraint(constraint)
               nil
             else
@@ -26,7 +26,7 @@ module Lab42
         def define_constraints(constraints)
           errors = constraints.map(&define_constraint).compact
           unless errors.empty?
-            raise ArgumentError,
+            raise UndefinedAttributeError,
                   "constraints cannot be defined for undefined attributes #{errors.inspect}"
           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,12 +16,20 @@ module Lab42
           @__defaults__ ||= {}
         end
 
+        def derived_attributes
+          @__derived_attributes__ ||= {}
+        end
+
         def members
           @__members__ ||= unless (positionals + defaults.keys).empty?
                              Set.new(positionals + defaults.keys)
                            end
         end
 
+        def members!
+          @__members__ = Set.new(positionals + defaults.keys)
+        end
+
         def positionals
           @__positionals__ ||= []
         end

data/lib/lab42/data_class/proxy.rb

@@ -2,41 +2,73 @@
 
 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 check!(**params)
-        @actual_params = params
+      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, merge_with = defaults)
         raise ArgumentError, "missing initializers for #{_missing_initializers}" unless _missing_initializers.empty?
         raise ArgumentError, "illegal initializers #{_illegal_initializers}" unless _illegal_initializers.empty?
 
-        _check_constraints!(defaults.merge(params))
+        _check_constraints!(merge_with.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.inspect}"
+        end
+        klass.module_eval(&_define_derived_attribute(name, &blk))
+      end
+
       def init(data_class, **params)
         _init(data_class, defaults.merge(params))
       end
 
+      def set_actual_params(params)
+        @actual_params = 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 +78,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,11 +97,42 @@ module Lab42
         end
       end
 
+      def _define_derived_attribute(name, &blk)
+        ->(*) do
+          if instance_methods.include?(name)
+            begin
+              remove_method(name)
+            rescue StandardError
+              nil
+            end
+          end
+          define_method(name) { blk.call(self) }
+        end
+      end
+
       def _define_freezing_constructor
+        proxy = self
+        ->(*) do
+          define_method :new do |**params, &b|
+            allocate.tap do |o|
+              proxy.set_actual_params(params)
+              proxy.check!(params)
+              o.send(:initialize, **params, &b)
+            end.freeze
+          end
+        end
+      end
+
+      def _define_merging_constructor
+        proxy = self
         ->(*) do
-          define_method :new do |*a, **p, &b|
-            super(*a, **p, &b).freeze
+          define_method :_new_from_merge do |new_params, params|
+            allocate.tap do |o|
+              proxy.check!(new_params, {})
+              o.send(:initialize, **params)
+            end.freeze
           end
+          private :_new_from_merge
         end
       end
 
@@ -76,7 +140,6 @@ module Lab42
         proxy = self
         ->(*) do
           define_method :initialize do |**params|
-            proxy.check!(**params)
             proxy.init(self, **params)
             proxy.validate!(self)
           end
@@ -87,25 +150,36 @@ module Lab42
         ->(*) do
           define_method :merge do |**params|
             values = to_h.merge(params)
-            self.class.new(**values)
+            self.class.send(:_new_from_merge, params, values)
           end
         end
       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
 
       def _define_singleton_methods(singleton)
         singleton.module_eval(&_define_freezing_constructor)
+        singleton.module_eval(&_define_merging_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/undefined_attribute_error.rb

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

data/lib/lab42/data_class/version.rb

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

data/lib/lab42/data_class.rb

@@ -1,7 +1,9 @@
 # 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/undefined_attribute_error'
 require_relative './data_class/validation_error'
 require_relative './data_class/proxy'
 require_relative './pair'
@@ -9,10 +11,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 +34,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.2
 platform: ruby
 authors:
 - Robert Dober
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-03-03 00:00:00.000000000 Z
 dependencies: []
 description: |
   An Immutable DataClass for Ruby
@@ -24,14 +24,20 @@ files:
 - LICENSE
 - README.md
 - lib/lab42/data_class.rb
+- lib/lab42/data_class/builtin_constraints.rb
+- lib/lab42/data_class/constraint.rb
 - lib/lab42/data_class/constraint_error.rb
+- lib/lab42/data_class/constraints/kernel.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/undefined_attribute_error.rb
 - lib/lab42/data_class/validation_error.rb
 - lib/lab42/data_class/version.rb
 - lib/lab42/eq_and_patterns.rb
@@ -41,7 +47,7 @@ homepage: https://github.com/robertdober/lab42_data_class
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -57,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Finally a dataclass in ruby
 test_files: []