lab42_checked_class 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6a2f963809a4e9d945d7f856d5ed6e8bd2af2462e6af8f1c27ec666900adf89
-  data.tar.gz: b40b601f78decd3af0d7ee5e24e097f64bd546381e92b7d17cd6be532de80431
+  metadata.gz: 010c1b5675022a9214b591ff4a4516928d5a55019c2203fadf75b6206a3fa744
+  data.tar.gz: b9b6e7396a49f3fe5b2e29734623108112556095a8b13d3086b42e94d987166c
 SHA512:
-  metadata.gz: 909347acc4fe94f3573718e6a74f325a438dbd4c05af727356c2defce73cac2e4a8e0e80748f6c0333e5cb0b3aff25da52433ab836d76701caf0a33bcca5949d
-  data.tar.gz: 66921f5b30a49125c5a437a494260dd7c5602e27088d0b34c280cb6eccee9b151cac5582fb15a1ba5e0af224895ca367ce33765614fbca0a00bed3c077b4d6e7
+  metadata.gz: c128e03d74d01e824ba153e5d21a2dee18035c0953b1f4ccea9f346fdcbe0f57bf83ec7815c7e83559e72e2c0174ce4b0bcdb0a5d1d0b0da1e813beacb61eece
+  data.tar.gz: 8e4ddb87d4b4dfa542c76fb5c8a91203fdd6bb99b598d67575692dd2003d0e96007d8ae0063f275a97518b587d703a954142530cc8c76c9deb234ae0e558cf16

data/README.md

@@ -58,8 +58,27 @@ These specs assume the following setup code
     require 'lab42/checked_class'
     CheckedClass = Lab42::CheckedClass
     ConstraintError = CheckedClass::ConstraintError
+    Constraint = CheckedClass::Constraint
 ```
+This is realized in the spec_helper, but if you want to have these three constants in your namespace you can
+do the following:
 
+## Context: Importing constants into your namespace
+
+Then we will get them loaded
+```ruby
+  expected_output = <<~EOT
+  #{ENV["PWD"]}/lib/lab42/checked_class/all.rb:5: warning: already initialized constant CheckedClass
+  #{ENV["PWD"]}/spec/spec_helper.rb:38: warning: previous definition of CheckedClass was here
+  #{ENV["PWD"]}/lib/lab42/checked_class/all.rb:6: warning: already initialized constant Constraint
+  #{ENV["PWD"]}/spec/spec_helper.rb:39: warning: previous definition of Constraint was here
+  #{ENV["PWD"]}/lib/lab42/checked_class/all.rb:7: warning: already initialized constant ConstraintError
+  #{ENV["PWD"]}/spec/spec_helper.rb:40: warning: previous definition of ConstraintError was here
+  EOT
+  expect {
+    require 'lab42/checked_class/all'
+  }.to output(expected_output).to_stderr
+```
 ## Context: Attribute definitions and constraints
 
 Given a checked class
@@ -70,10 +89,10 @@ Given a checked class
         attr :a # No constraints, no defaults
         attr b: 42 # No constraints, but a default
         attr :c, Integer # Constraint, no default
-        attr(d: 1) { it > 0 } # Constraint and default 
+        attr(d: 1) { it > 0 } # Default and block constraint
         attr(:e, :even?) # Symbolic constraint, no default
         attr(:f) { (it % 10).zero? } # Block constraint, no default
-        attr(g: 2) { it > 1 } # Block Constraint and default
+        attr(:g, [:>, 1], default: 2) # Default and functional constraint
 
         # Named constraint
         constrain("a + b > e") { it.a + it.b > it.e }   
@@ -119,7 +138,40 @@ And also we cannot create an instance that violates the constraints
     expect { MyChecked.new(a: 10, c: -4, e: 90, f: 0) }.to raise_error(ConstraintError, "a + b > e")
 ```
 
-## Context: More on constraints
+### Context: Defining attributes with `method` missing.
+
+As long as a method is called that is not defined inside the `attributes` block, it will be
+interpreted as an attribute definition, as it cannot have a default value assigned, we can
+also use the `defaults` macro
+
+Given such implicit attribute definitions
+```ruby
+    Implicit = Class.new do
+      extend CheckedClass
+      attributes do
+        alpha Numeric
+        beta Constraint.bool?
+
+        defaults alpha: 0, beta: true
+      end
+    end
+    let(:instance) { Implicit.new }
+```
+
+Then we can access the implicitly defined attributes
+```ruby
+    expect(instance.to_h).to eq(alpha: 0, beta: true)
+```
+And we will get a constraint error as expeced
+```ruby
+    expected_message = "bool? constraint for beta"
+    expect { instance.update(beta: 42) }
+      .to raise_error(ConstraintError, expected_message)
+```
+
+You can see all predefined builtin constraints [here](speculations/built_in_constraints.md)
+
+## Context: Runtime Semantics of Constraints
 
 ### Context: Checked und unchecked attribute updates
 

data/lib/lab42/checked_class/all.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'lab42/checked_class'
+
+CheckedClass = Lab42::CheckedClass
+Constraint = CheckedClass::Constraint
+ConstraintError = CheckedClass::ConstraintError
+
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/lab42/checked_class/constraint/predefined.rb

@@ -0,0 +1,24 @@
+
+# frozen_string_literal: true
+module Lab42
+  module CheckedClass
+    class Constraint
+      module Predefined
+
+        def bool? =
+          tagged('bool?') { [false, true].member? it } 
+
+        def match?(rgx) =
+          tagged("match?(#{rgx}") { rgx === it rescue false }
+
+        def member?(container) =
+          tagged("member?(#{container.inspect}") { container.member? it }
+
+        private
+        def tagged(name, &blk) = [self, blk, name]
+
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: AGPL-3.0-or-later

data/lib/lab42/checked_class/constraint.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
+require_relative 'constraint/predefined'
 module Lab42
   module CheckedClass
     class Constraint
+      extend Predefined
+
 
       def check(subject)
-        subject = @attr ? subject[@attr] : subject
+       subject = @attr ? subject[@attr] : subject
         return nil if @constraint.(subject)
 
         @name
@@ -25,15 +28,14 @@ module Lab42
 
       def _mk_constraint(constraint, name, &blk)
         case constraint
-        in Symbol
-          constraint.to_proc
-        in [Symbol, *] => args
-          -> { it.send(*args) }
-        in Module
-          -> { constraint === it }
+        in Proc
+          constraint
+        in [Predefined, blk, name]
+          @name = [name, @name].join(' ')   
+          blk
         in nil
           blk
-        in _
+        else
           raise ArgumentError, "Type Error for constraint of attr #{name.inspect}; must be a Module, Symbol, or an array starting with a Symbol, but was #{constraint.inspect}"
         end
       end

data/lib/lab42/checked_class/injector.rb

@@ -59,6 +59,13 @@ module Lab42
             constraint_checker.check!(self)
           end
 
+          define_method :legal? do
+            check!
+            true
+          rescue ConstraintError
+            false
+          end
+
           define_method :to_h do
             attributes.inject(Hash.new) { |result, ele|
               result.update(ele => self[ele])

data/lib/lab42/checked_class/proxy.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'ex_aequo/base/fn'
+require 'ex_aequo/base/to_proc'
+
 require_relative 'constraint'
 require_relative 'constraint_checker'
 require_relative 'injector'
@@ -7,6 +10,7 @@ require_relative 'injector'
 module Lab42
   module CheckedClass
     class Proxy
+      Fn = ExAequo::Base::Fn
       None = Object.new.freeze
 
       attr_reader :klass
@@ -26,22 +30,27 @@ module Lab42
         @klass = klass
       end
 
-      def attr(att, *args, &blk)
-        if Hash === att 
-          raise ArgumentError, "attr definition with default does not support symbolic constraints" unless args.empty?
-          raise ArgumentError, "only one attribute can be defined with defaults, not #{att.keys.inspect}" if att.size != 1
-
-          return _define_att(att.keys.first, default: att.values.first, &blk)
-        end
-
-        raise ArgumentError, "attributes must be symbols, not: #{att.inspect}" unless Symbol === att
-
-        if args.empty?
-          return _define_att(att, &blk)
+      def attr(*args, &block)
+        case [block, *args]
+        in [constraint, Symbol => name]
+          _def_undefaulted_attr(name:, constraint:)
+        in [nil, Symbol => name, fun]
+          constraint = _make_fun_or_constraint(fun)
+          _def_undefaulted_attr(name:, constraint:)
+        in [constraint, Symbol => name, {default:, **nil}]
+          _def_defaulted_attr(name:, constraint:, default:)
+        in [default, Symbol => name, fun]
+          constraint = _make_fun_or_constraint(fun)
+          _def_defaulted_attr(name:, default: default.(), constraint:)
+        in [constraint, Hash => arg]
+          _def_defaulted_attr(name: arg.keys.first, default: arg.values.first, constraint:)
+        in [nil, Symbol => name, fun, {default:, **nil}]
+          constraint = _make_fun_or_constraint(fun)
+          _def_defaulted_attr(name:, default:, constraint:)
+        in [_, Symbol => name, _, {default:, **nil}]
+          raise ArgumentError, "functional constraint default kwd and block"
         else
-          raise ArgumentError, "must not define symbolic and functional constraint" if @blk
-
-          _define_att(att, args.first)
+          raise ArgumentError, "too many arguments"
         end
       end
 
@@ -52,18 +61,42 @@ module Lab42
         _constraints["object"] << Constraint.new(name:, &blk)
       end
 
+      def defaults(**params)
+        params.each do |k,  v|
+          raise ArgumentError, "must not redefine default for key #{k.inspect}" if _defaults.has_key?(k)
+
+          _defaults[k] = v
+        end
+      end
+
       def init(&blk)
         raise ArgumentError, "init needs a block" unless blk
 
         @init = blk
       end
 
-      def _define_att(name, constraint = nil, default: None, &blk)
+      def method_missing(name, *a, **k, &b)
+        attr(name, *a, **k, &b)
+      end
+
+      def _def_defaulted_attr(name:, constraint:, default:)
         _attributes << name
+        _defaults[name] = default
+        _constraints[name] = Constraint.new(attr: name, constraint:) if constraint
+      end
 
-        # allow nil default to avoid implicit nil defaults
-        _defaults[name] = default unless default == None
-        _constraints[name] = Constraint.new(attr: name, constraint:, &blk) if constraint || blk
+      def _def_undefaulted_attr(name:, constraint:)
+        _attributes << name
+        _constraints[name] = Constraint.new(attr: name, constraint:) if constraint
+      end
+
+      def _make_fun_or_constraint(fun)
+        case fun
+        in [c, *] if Constraint == c
+          fun
+        else
+          Fn.mk_fun(fun)
+        end
       end
 
       def _attributes

data/lib/lab42/checked_class/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module Lab42
   module CheckedClass
-    VERSION = '0.1.1'
+    VERSION = '0.2.1'
   end
 end
 # SPDX-License-Identifier: AGPL-3.0-or-later

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: lab42_checked_class
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Robert Dober
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ex_aequo_base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.17
 description: 'Mutable classes with constraints and lots of boilerplate code removal.
 
   '
@@ -20,8 +34,10 @@ files:
 - LICENSE
 - README.md
 - lib/lab42/checked_class.rb
+- lib/lab42/checked_class/all.rb
 - lib/lab42/checked_class/argument_checker.rb
 - lib/lab42/checked_class/constraint.rb
+- lib/lab42/checked_class/constraint/predefined.rb
 - lib/lab42/checked_class/constraint_checker.rb
 - lib/lab42/checked_class/constraint_error.rb
 - lib/lab42/checked_class/injector.rb
@@ -40,14 +56,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.4.1
+      version: 3.4.5
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Mutable classes with constraints and lots of boilerplate code removal.
 test_files: []