lab42_basic_constraints 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c88af59f506668cbc7c56fffc54c3430f31a0ebf5ad7d697dd3aadebf6ef5192
-  data.tar.gz: 84bedc52d927607fbdbc5d108d56d23ab02d8931fb939567a06ece934c9903a5
+  metadata.gz: 672bcf05278d0a451a503939dd0ebf0f69b95914be02d466c0024717747fab76
+  data.tar.gz: d398d43d6dcbb335df544545e4b6c1ea4795c7a4b086725e9fcb4595f87b3c48
 SHA512:
-  metadata.gz: 27926e413ebcf7801f572816d6fe5d23ad340d972526ca4d25246e927d118e7073d789b6f167c61c569067097c0bf761b1a707d151320d30400bbb19558e3113
-  data.tar.gz: f49c25cdf9c96bc9e0da08d7e7783774dd0c511a814a0431360bdb88a208c836cf15d6b35beb3469558ed93a5674377d56993b1b509e4cb9fe13260f65a20632
+  metadata.gz: 98c2067be96925b8724360ed748b91fcb606ecce255867f1da5e11958148cf55006e61a6d1f9397d47c66e552698d9b9131475389dbad69c2c128ab57dabca52
+  data.tar.gz: 7839dd0e966966d27cd560bb9b28d43b1181ca1547f116058a6923176aa04ae0a5bc81fa6a812fa75372fb2fc57951f7a4966e0c45461dbd6af0aee7e93d379d

data/README.md

@@ -17,27 +17,46 @@ Given That we alias `Lab42::BasicConstraints` to `BC`
   require "lab42/basic_constraints/alias"
 ```
 
+Given
+```ruby
+    let :all_basic_constraints do
+      %i[
+       all_digits_string alphanumeric_string
+       bool
+       date date_time day
+       hour
+       int
+       lowercase_string
+       minute month
+       non_negative_int non_negative_number number
+       positive_int positive_number
+       second string
+       uppercase_string
+       year
+      ]
+    end
+    let :all_parametrized_constraints do
+      %i[ int_range limited_string ]
+    end
+    
+```
 Then All Basic Constraints can be listed by means of `BC.all_constraints`
 
 ```ruby
-    all_basic_constraints = %i[
-     all_digits_string alphanumeric_string
-     bool
-     date date_time day
-     hour
-     lowercase_string
-     minute month
-     non_empty_string non_negative_float non_negative_int non_negative_number
-     positive_float positive_int positive_number
-     second
-     time
-     uppercase_string
-     year
-    ]
-
-    expect( BC.all_constraints ).to eq(all_basic_constraints)
+
+    expect( Set.new(BC.all_constraints) ).to eq(Set.new(all_basic_constraints + all_parametrized_constraints))
+```
+
+And they are implemented of course
+```ruby
+  all_basic_constraints.each do | constraint_name |
+    expect( BC.from_symbol(constraint_name) ).to be_a(BC::Constraint)
+  end
+  expect( BC.int_range(min: 0) ).to be_a(BC::Constraint)
+  expect( BC.limited_string(max: 10) ).to be_a(BC::Constraint)
 ```
 
+
 ## So we got the ball, now use it!
 
 The ball, BTW, is a `Lab42::Result` see [lab42_result gem](https://rubygems.org/gems/lab42_result/) for more info
@@ -74,17 +93,12 @@ Example: Constraints with and without defaults
 
 ```
 
-A detailed description of all constraints can be found
-[here](speculations/constraints.md)
-
-## Context We are still in Beta and therefor
-
-Example: Some constraints are not yet implemented
-
+Example: Avoiding the Exception, à la `Hash#fetch` 
 ```ruby
-    expect{ BC.all_digits_string }.to raise_error(NotImplementedError)
+    expect( BC.from_symbol(:positive_number).default{42} ).to eq(42)
 ```
 
+
 ## Context Time's a Sticky Wicket
 
 ... but as defaults are defined for runtime that shall really help us with that
@@ -112,9 +126,39 @@ Example: Illegal Dates
 ```ruby
     d.("2020-00-01") in [raised, message ]
     expect( raised ).to eq(error)
-    expect( message ).to eq("2020-00-01 is not a legal date")
+    expect( message ).to eq(%{"2020-00-01" is not a legal date})
+```
+
+## Context Equality More Of A Tricky Sticker
+
+And Most Surprisingly
+
+```ruby
+    expect(BC.bool).not_to eq(BC.bool) 
 ```
 
+However in many cases the name and the default say a lot about a constraint's behavior
+
+Given
+```ruby
+    let(:natural) {BC.non_negative_int}
+    let(:def42) {BC.non_negative_int.set_default(42)}
+```
+
+Then we can compare as follows
+```ruby
+    expect( natural.name ).to eq(BC.non_negative_int.name)
+    expect( natural.default ).to eq(0)
+    expect( def42.name ).to eq(BC.non_negative_int.name)
+    expect( def42.default ).to eq(42)
+```
+
+## Detailed Description of all Constraints
+
+[date_and_time_constraints](date_and_time_constraints.md )
+[div_constraints](div_constraints.md )
+[string_constraints](string_constraints.md )
+
 # LICENSE
 
 Copyright 2020 Robert Dober robert.dober@gmail.com

data/lib/lab42/basic_constraints.rb

@@ -2,37 +2,37 @@ require_relative "basic_constraints/implementation.rb"
 module Lab42
   module BasicConstraints extend self
     Constraints = {
-       all_digits_string: :not_yet_implemented,
-       alphanumeric_string: :not_yet_implemented,
+       all_digits_string: :all_digits_string,
+       alphanumeric_string: :alphanumeric_string,
 
        bool: ->(x){[false, true].include? x},
 
        date: :date,
-       date_time: :not_yet_implemented,
-       day: :not_yet_implemented,
+       date_time: :date_time,
+       day: :day,
 
-       hour: :not_yet_implemented,
+       hour: :hour,
 
-       lowercase_string: :not_yet_implemented,
+       int: Integer,
+       int_range: :int_range,
 
-       minute: :not_yet_implemented,
-       month: :not_yet_implemented,
+       limited_string: :limited_string,
+       lowercase_string: :lowercase_string,
+
+       minute: :minute,
+       month: :month,
     
-       non_empty_string: :not_yet_implemented,
-       non_negative_float: :not_yet_implemented,
        non_negative_int: :non_negative_int,
+       non_negative_number: :non_negative_number,
+       number: Numeric,
 
-       non_negative_number: :not_yet_implemented,
-
-       positive_float: :not_yet_implemented,
-       positive_int: :not_yet_implemented,
+       positive_int: :positive_int,
        positive_number: :positive_number,
 
-       second: :not_yet_implemented,
-
-       time: :not_yet_implemented,
+       second: :second,
+       string: String,
 
-       uppercase_string: :not_yet_implemented,
+       uppercase_string: :uppercase_string,
 
        year: :year
     }
@@ -49,6 +49,8 @@ module Lab42
         Constraint.new(name, &cons)
       when Symbol
         Implementation.send(cons, *args, **kwds)
+      when Class
+        Constraint.new(name){ cons === _1 }
       end
     end
 

data/lib/lab42/basic_constraints/constraint.rb

@@ -5,18 +5,24 @@ module Lab42
     ConstraintError = Class.new RuntimeError
     MissingDefaultError = Class.new RuntimeError
     class Constraint
+      attr_reader :default, :name
 
       def call value
         return Result.ok if @constraint.(value)
         Result.error("#{_show value} is not a legal #{@name}", error: Lab42::BasicConstraints::ConstraintError)
       end
 
-      def default
-        case @default
-        when Proc
-          @default.()
+      def default &blk
+        if @has_default
+          case @default
+          when Proc
+            @default.()
+          else
+            @default
+          end
         else
-          @default
+          return blk.() if blk
+          raise Lab42::BasicConstraints::MissingDefaultError, "Constraint #{name} has no predefined default"
         end
       end
 
@@ -27,6 +33,7 @@ module Lab42
           else
             blk
           end
+        @has_default = true
         self
       end
 
@@ -35,6 +42,8 @@ module Lab42
         case value
         when NilClass
           "nil"
+        when String
+          value.inspect
         else
           value
         end
@@ -42,9 +51,11 @@ module Lab42
 
       def initialize name, &blk
         @constraint = blk
-        @default = -> {raise Lab42::BasicConstraints::MissingDefaultError, "Constraint #{name} has no predefined default"}
+        @has_default = false
+        @default = -> {}
         @name = name
       end
     end
   end
 end
+require_relative "constraints/int"

data/lib/lab42/basic_constraints/constraints/int.rb

@@ -0,0 +1,19 @@
+require_relative "../helpers/range_helper.rb"
+module Lab42
+  module BasicConstraints
+    class Constraint
+      class IntConstraint < Constraint
+
+        private
+        def initialize name, range: nil, min: nil, max: nil
+          super(name)
+          range = Helpers::RangeHelper.make_range!(range: range, min: min, max: max)
+          @constraint = -> (value) {
+            Integer === value && range === value
+          }
+        end
+      end
+    end
+  end
+end
+

data/lib/lab42/basic_constraints/helpers/range_helper.rb

@@ -0,0 +1,29 @@
+module Lab42
+  module BasicConstraints
+    module Helpers
+      module RangeHelper extend self
+
+        def make_range(range: nil, min: nil, max: nil)
+          return unless range || min || max
+          raise ArgumentError, "cannot provide min or max with range" if
+          range && (min || max)
+          range || _make_min_max_range(min, max) 
+        end
+
+        def make_range!(range: nil, min: nil, max: nil)
+          make_range(range: range, min: min, max: max)
+            .tap do |range|
+              raise ArgumentError, "Must provide either range or min or max" unless range
+            end
+        end
+
+        private
+        def _make_min_max_range(min, max)
+          min ||= 0
+          max ||= Float::INFINITY
+          min..max
+        end
+      end
+    end
+  end
+end

data/lib/lab42/basic_constraints/implementation.rb

@@ -1,9 +1,38 @@
 require_relative "constraint" 
+require_relative "helpers/range_helper"
 module Lab42
   module BasicConstraints
 
     module Implementation extend self
 
+      IntConstraints = {
+        day: 1..31,
+        hour: 0..23,
+        minute: 0..59,
+        month: 1..12,
+        second: 0..59
+      }
+      IntConstraints.each do |constraint_name, constraint_range|
+        define_method constraint_name do 
+          Constraint::IntConstraint.new(constraint_name, range: constraint_range)
+        end
+      end
+
+      def int_range(range: nil, min: nil, max: nil)
+        Constraint::IntConstraint.new(:int_range, range: range, min: min, max: max)
+      end
+
+      StringConstraints = {
+        all_digits_string: %r{\A\d*\z},
+        alphanumeric_string: %r{\A[[:alnum:]]*\z}
+      }
+
+      StringConstraints.each do |constraint_name, constraint_rgx|
+        define_method constraint_name do |size: nil, min: nil, max: nil|
+          _regex_constraint(constraint_name, constraint_rgx, size: size, min: min, max: max)
+        end
+      end
+
       def date default: nil
         require "date"
         Constraint.new(:date) do |value|
@@ -14,22 +43,55 @@ module Lab42
         end
       end
 
-      def non_negative_int
-        Constraint.new :non_negative_int do |value|
-          Integer === value && value >= 0
+      def date_time default: nil
+        require "date"
+        Constraint.new(:date_time) do |value|
+          DateTime.parse(value) rescue false
         end
+          .set_default default do
+          DateTime.now.iso8601
+        end
+      end
+
+      def limited_string size: nil, min: nil, max: nil
+        size_range = Helpers::RangeHelper.make_range!(range: size, min: min, max: max)
+        Constraint.new(:limited_string) do |value|
+          String === value && size_range === value.size
+        end
+      end
+
+      def lowercase_string
+        Constraint.new :lowercase_string do |value|
+          String === value && value.downcase == value
+        end
+      end
+
+      def non_negative_int
+        Constraint::IntConstraint.new(:non_negative_int, min: 0)
           .set_default(0)
       end
 
+      def non_negative_number
+        Constraint.new :non_negative_number do |value|
+          Numeric === value && !(Complex === value) && value >= 0
+        end
+      end
+
+      def positive_int
+        Constraint::IntConstraint.new(:positive_int, min: 1)
+          .set_default(1)
+      end
+
       def positive_number
         Constraint.new :positive_number do |value|
-          Integer === value && value > 0 ||
-            Float === value && value > 0.0
+          Numeric === value && value > 0
         end
       end
 
-      def not_yet_implemented
-        raise NotImplementedError
+      def uppercase_string
+        Constraint.new :uppercase_string do |value|
+          String === value && value.upcase == value
+        end
       end
 
       def year
@@ -40,6 +102,22 @@ module Lab42
             Time.now.utc.year
           end
       end
+
+
+      private
+
+      def _regex_constraint(name, rgx, size: nil, min: nil, max: nil)
+        range_size = Helpers::RangeHelper.make_range(range: size, min: min, max: max)
+        if range_size
+          Constraint.new(name) do |value|
+            String === value && range_size === value.size && rgx === value
+          end
+        else
+          Constraint.new(name) do |value|
+            String === value && rgx === value
+          end
+        end
+      end
     end
   end
 end

data/lib/lab42/basic_constraints/version.rb

@@ -1,5 +1,5 @@
 module Lab42
   module BasicConstraints
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_basic_constraints
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Dober
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-18 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lab42_result
@@ -91,6 +91,8 @@ files:
 - lib/lab42/basic_constraints.rb
 - lib/lab42/basic_constraints/alias.rb
 - lib/lab42/basic_constraints/constraint.rb
+- lib/lab42/basic_constraints/constraints/int.rb
+- lib/lab42/basic_constraints/helpers/range_helper.rb
 - lib/lab42/basic_constraints/implementation.rb
 - lib/lab42/basic_constraints/version.rb
 homepage: https://bitbucket.org/robertdober/lab42_basic_constraints