saphyr 0.4.2.beta → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d172fb9555ca86f1b02e7aebfd3fb9ff0de38c016e3ff70c04a362d6a919d479
-  data.tar.gz: 838664f628c9ffa0fb948ce2812bf973664c4485b9322baf5fbe7f1f4894b2e4
+  metadata.gz: 9d491ec052216eb7db303fa4fb65b6a558ecbb2c39a24663a43ae85eb616da14
+  data.tar.gz: a07b8137c7e853c0e9625a18760139a220a1be4fdf5271365f81cd2459e288a5
 SHA512:
-  metadata.gz: e2fb9ef59ea455da2490aee2a58f0a1af564ac71aa7ea246cf2e94bf1d7e5c934541aaffcd68b715d8622f257482b934ce74c947e6d8bc4911c28c83085075da
-  data.tar.gz: f5112099c3cd3a1d5d034717a3f72b7abad3af7133d5a1081c289371d4e390b9fe88dc99ed07b329b703829780e5535dff0a2234d4a49030ea4a3fde91bce48d
+  metadata.gz: a816ea8a58c18ae02e599f077f40ce54081e84e8a12ea47e9e3734ce410e238c2562105bc4fd55cf9facfba94477d5856cf708877514eb369f5ffdd85413d7f1
+  data.tar.gz: bf4a796653f788a49f80bb2b1344d87a059e20a98c8fbd9ed8cd87d13062c228c153c62a8097204f252e69157611cd6d59b6b36b601fbd566b8a9bd0a8c24ff5

data/CHANGELOG

@@ -1,13 +1,16 @@
-No changelog update during all the beta development phase.
+-----------------------------------------------------------------
+Version: 0.5.0 - 2025-05-21
+
+- Refactor the way we validate field type
+  Adding EXPECTED_TYPES to field_base to automate the check
+- Add :default option to field
 
 -----------------------------------------------------------------
 Version: 0.4.2.beta - 2025-05-06
------------------------------------------------------------------
 
 - Fix CVE-2024-47220 upgrade webrick to ~> 1.8.2
 
 -----------------------------------------------------------------
 Version: 0.1.0.beta - 2023-08-30
------------------------------------------------------------------
 
 - Initial release

data/lib/saphyr/asserts/base_assert.rb

@@ -6,7 +6,7 @@ module Saphyr
         value.is_a? TrueClass or value.is_a? FalseClass
       end
 
-      def assert_class klass, value, errors, error_code=Fields::FieldBase::ERR_TYPE
+      def assert_class(klass, value, errors, error_code=Fields::FieldBase::ERR_TYPE)
         klass = [klass] unless klass.is_a? Array
         test = false
         klass.each do |k|
@@ -24,7 +24,7 @@ module Saphyr
         test
       end
 
-      def assert_eq opt_value, value, errors, error_code=Fields::FieldBase::ERR_EQ
+      def assert_eq(opt_value, value, errors, error_code=Fields::FieldBase::ERR_EQ)
         return nil if opt_value.nil?
         unless value == opt_value
           errors << {
@@ -39,7 +39,7 @@ module Saphyr
         true
       end
 
-      def assert_in opt_values, value, errors, error_code=Fields::FieldBase::ERR_IN
+      def assert_in(opt_values, value, errors, error_code=Fields::FieldBase::ERR_IN)
         return nil if opt_values.nil?
         unless opt_values.include? value
           errors << {
@@ -53,6 +53,19 @@ module Saphyr
         end
         true
       end
+
+      def assert_not_empty(value, errors, error_code=Fields::FieldBase::ERR_NOT_EMPTY)
+        if value.empty?
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+            }
+          }
+          return false
+        end
+        true
+      end
     end
   end
 end

data/lib/saphyr/asserts/error_constants.rb

@@ -5,6 +5,7 @@ module Saphyr
       # Base
       ERR_NOT_NULLABLE = 'not-nullable'
       ERR_BAD_FORMAT = 'bad-format'
+      ERR_NOT_EMPTY = 'not-empty'
       ERR_TYPE = 'type'
       ERR_IN = 'in'
       ERR_EQ = 'eq'

data/lib/saphyr/engine.rb

@@ -41,7 +41,7 @@ module Saphyr
       # lookup into the global schemas.
       # @param name [Symbol] The name of the schema.
       # @return [Saphyr::Schema]
-      # @rmaise [Saphyr::Error] if no schema was found.
+      # @raise [Saphyr::Error] if no schema was found.
       def find_schema(name)
         @validators.each do |validator|
           schema = validator.find_schema name
@@ -171,20 +171,25 @@ module Saphyr
           end
 
           unless data.key? name
-            next unless @ctx.schema.strict?
-            if field.required?
-              @ctx.errors << {
-                path: field_path,
-                errors: [
-                  {
-                    type: 'strict_mode:missing_in_data',
-                    data: {
-                      field: name,
+            if field.default?
+              data[name] = field.opts[:default]
+            else
+              next unless @ctx.schema.strict?
+              if field.required?
+                @ctx.errors << {
+                  path: field_path,
+                  errors: [
+                    {
+                      type: 'strict_mode:missing_in_data',
+                      data: {
+                        field: name,
+                      }
                     }
-                  }
-                ],
-              }
+                  ],
+                }
+              end
             end
+
             next
           end
 

data/lib/saphyr/fields/array_field.rb

@@ -3,7 +3,7 @@ module Saphyr
 
     class ArrayField < FieldBase
       PREFIX = 'array'
-
+      EXPECTED_TYPES = Array
       AUTHORIZED_OPTIONS = [:len, :min, :max, :of_type, :of_schema, :opts]
 
       REQUIRED_ONE_OF_OPTIONS = [:of_type, :of_schema]
@@ -34,7 +34,6 @@ module Saphyr
       private 
 
         def do_validate(ctx, name, value, errors)
-          return unless assert_class Array, value, errors
           assert_size_len @opts[:len], value, errors
           assert_size_min @opts[:min], value, errors
           assert_size_max @opts[:max], value, errors

data/lib/saphyr/fields/b64_field.rb

@@ -0,0 +1,74 @@
+require 'base64'
+
+module Saphyr
+  module Fields
+
+    # The +B64+ field type
+    #
+    # Allowed options is: +:strict+ (boolean)
+    #
+    # When in strict mode (:strict == true):
+    # - Line breaks are not allowed
+    # - Padding must be correct
+    #
+    # Not in strict mode (:strict == false):
+    # - Line breaks are allowed
+    # - Padding is not required
+    class B64Field < FieldBase
+      PREFIX = 'b64'
+      EXPECTED_TYPES = String
+
+      AUTHORIZED_OPTIONS = [:strict]     # :strict = true / false
+
+      FORMAT_REGEXP = /^(?:[A-Za-z0-9+\/]*[\r\n|\n]*)*(?:[=]{1,2})?$/
+
+      def initialize(opts={})
+        if opts[:strict].nil?
+          opts[:strict] = true
+        else
+          unless [true, false].include? opts[:strict]
+            raise Saphyr::Error.new "Bad B64 strict option must be a boolean"
+          end
+        end
+        super opts
+      end
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          begin
+            if @opts[:strict]
+              # NOTE: When in strict mode
+              # - Line breaks are not allowed
+              # - Padding must be correct (length % 4 == 0)
+              # In this case, we use Base64.strict_decode64 because it's a way
+              # faster than using regexp. An invalid base64 string will raise an error.
+              Base64.strict_decode64 value
+            else
+              # NOTE: When not in strict mode
+              # - Line breaks are allowed (like in PEM or EMAIL)
+              # - Padding is not required
+              # But, we can't use Base64.decode64 because it will not raise an error
+              # for a string like this one : 'not-b54**str'.
+              # (and obviously it's not a valid base64 format)
+              unless FORMAT_REGEXP.match? value
+                add_error value, errors
+              end
+            end
+          rescue
+            add_error value, errors
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields/boolean_field.rb

@@ -6,13 +6,12 @@ module Saphyr
     # Allowed options are: +:eq+.
     class BooleanField < FieldBase
       PREFIX = 'boolean'
-
+      EXPECTED_TYPES = [TrueClass, FalseClass]
       AUTHORIZED_OPTIONS = [:eq]
 
       private
 
         def do_validate(ctx, name, value, errors)
-          return unless assert_class [TrueClass, FalseClass], value, errors
           assert_eq @opts[:eq], value, errors
         end
     end

data/lib/saphyr/fields/datetime_field.rb

@@ -0,0 +1,39 @@
+require 'date'
+
+module Saphyr
+  module Fields
+
+    # The +DateTime+ field type.
+    #
+    # Allowed options is: +:format+
+    class DateTimeField < FieldBase
+      PREFIX = 'datetime'
+      EXPECTED_TYPES = String
+      AUTHORIZED_OPTIONS = [:format]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          begin
+            if @opts[:format].nil?
+              DateTime.parse value
+            else
+              DateTime.strptime value, @opts[:format]
+            end
+          rescue
+            add_error value, errors
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields/email_field.rb

@@ -0,0 +1,28 @@
+require 'uri'
+
+module Saphyr
+  module Fields
+
+    # The +email+ field type
+    #
+    # No options are allowed.
+    class EmailField < FieldBase
+      PREFIX = 'email'
+      EXPECTED_TYPES = String
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          unless value =~ ::URI::MailTo::EMAIL_REGEXP
+            errors << {
+              type: err('invalid'),
+              data: {
+                _val: value
+              }
+            }
+          end
+        end
+    end
+  end
+end

data/lib/saphyr/fields/field_base.rb

@@ -17,13 +17,18 @@ module Saphyr
 
       # Every field type has the +:required+ and +:nullable+ options.
       # @api private
-      DEFAULT_OPT_VALUES = {required: true, nullable: false}.freeze
+      DEFAULT_OPT_VALUES = {required: true, nullable: false, default: :_none_}.freeze
       # @api private
       DEFAULT_OPTS = DEFAULT_OPT_VALUES.keys.freeze
 
       # NOTE: 
       # Override following constants to manage options
 
+      # List of expected classes for the field. It can be an array of class names, or
+      # a single class name. EX: [TrueClass, FalseClass] or Integer.
+      # @note Overriding this class constant is mandatory.
+      EXPECTED_TYPES = nil
+
       # List of authorized options.
       # @note Override this class constant if you want to use this feature.
       AUTHORIZED_OPTIONS = []
@@ -55,8 +60,10 @@ module Saphyr
       # @note Override this class constant if you want to use this feature.
       NOT_SUP_OR_EQUALS_OPTIONS = []
 
-
       def initialize(opts={})
+        if expected_types.nil?
+          raise Saphyr::Error.new "The 'EXPECTED_TYPES' constant must be defined"
+        end
         if opts.key? :required
           unless assert_boolean opts[:required]
             raise Saphyr::Error.new "Option ':required' must be a Boolean"
@@ -67,10 +74,21 @@ module Saphyr
             raise Saphyr::Error.new "Option ':nullable' must be a Boolean"
           end
         end
+        if opts.key? :default
+          unless assert_class expected_types, opts[:default], []
+            raise Saphyr::Error.new "Option ':default' bad type. Expecting: '#{self.class::EXPECTED_TYPES.to_s}', got: '#{opts[:default].class.name}'"
+          end
+        end
 
-        unless authorized_options.size == 0
+        if authorized_options.size == 0
           opts.keys.each do |opt|
-            next if  opt == :required or opt == :nullable
+            unless [:required, :nullable, :default].include? opt
+              raise Saphyr::Error.new "Options are not allowed for this field type: '#{opt}'"
+            end
+          end
+        else
+          opts.keys.each do |opt|
+            next if opt == :required or opt == :nullable or opt == :default
             unless authorized_options.include? opt
               raise Saphyr::Error.new "Unauthorized option: #{opt}"
             end
@@ -151,6 +169,12 @@ module Saphyr
 
       # -----
 
+      # Get the +EXPECTED_TYPES+ options
+      # @return [Array]
+      def expected_types
+        self.class::EXPECTED_TYPES
+      end
+
       # Get the +AUTHORIZED_OPTIONS+ options
       # @return [Array]
       def authorized_options
@@ -212,6 +236,10 @@ module Saphyr
         @opts[:nullable]
       end
 
+      def default?
+        @opts[:default] != :_none_
+      end
+
       # -----
 
       # Check if the field value is valid.
@@ -221,6 +249,7 @@ module Saphyr
       def validate(ctx, name, value)
         # NOTE: Nullable is handle by the engine.
         errors = []
+        return errors unless assert_class self.class::EXPECTED_TYPES, value, errors
         do_validate ctx, name, value, errors
         errors
       end

data/lib/saphyr/fields/float_field.rb

@@ -6,7 +6,7 @@ module Saphyr
     # Allowed options are: +:eq, :gt, :gte, :lt, :lte, :in+.
     class FloatField < FieldBase
       PREFIX = 'float'
-
+      EXPECTED_TYPES = Float
       AUTHORIZED_OPTIONS = [:eq, :gt, :gte, :lt, :lte, :in]
 
       EXCLUSIVE_OPTIONS = [
@@ -36,7 +36,6 @@ module Saphyr
       private
 
         def do_validate(ctx, name, value, errors)
-          return unless assert_class Float, value, errors
           assert_eq @opts[:eq], value, errors
           assert_numeric_gt @opts[:gt], value, errors
           assert_numeric_gte @opts[:gte], value, errors

data/lib/saphyr/fields/integer_field.rb

@@ -6,7 +6,7 @@ module Saphyr
     # Allowed options are: +:eq, :gt, :gte, :lt, :lte, :in+.
     class IntegerField < FieldBase
       PREFIX = 'integer'
-
+      EXPECTED_TYPES = Integer
       AUTHORIZED_OPTIONS = [:eq, :gt, :gte, :lt, :lte, :in]
 
       EXCLUSIVE_OPTIONS = [
@@ -36,7 +36,6 @@ module Saphyr
       private
 
         def do_validate(ctx, name, value, errors)
-          return unless assert_class Integer, value, errors
           assert_eq @opts[:eq], value, errors
           assert_numeric_gt @opts[:gt], value, errors
           assert_numeric_gte @opts[:gte], value, errors

data/lib/saphyr/fields/ip_field.rb

@@ -0,0 +1,53 @@
+module Saphyr
+  module Fields
+
+    # The +IP+ field type
+    #
+    # Allowed options is: +:kind in (:any, :ipv4, :ipv6)+
+    #
+    # - +:any+ : can be an ipv4 or ipv6 (default)
+    # - +:ipv4+ : must be an ipv4
+    # - +:ipv6+ : must be an ipv6
+    class IpField < FieldBase
+      PREFIX = 'ip'
+      EXPECTED_TYPES = String
+      AUTHORIZED_OPTIONS = [:kind]
+
+      def initialize(opts={})
+        if opts[:kind].nil?
+          opts[:kind] = :any
+        else
+          unless [:any, :ipv4, :ipv6].include? opts[:kind]
+            raise Saphyr::Error.new 'Bad IP kind option must be one of :any, :ipv4, :ipv6'
+          end
+        end
+        super opts
+      end
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          begin
+            ip = IPAddr.new value
+            if @opts[:kind] == :ipv4 and not ip.ipv4?
+              add_error value, errors
+            elsif @opts[:kind] == :ipv6 and not ip.ipv6?
+              add_error value, errors
+            end
+          rescue
+            add_error value, errors
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields/iso_country_field.rb

@@ -0,0 +1,103 @@
+module Saphyr
+  module Fields
+
+    # The +IsoCountry+ field type (ISO-3166-1 alpha 2/3).
+    #
+    # Allowed options is: +:alpha with possible values: 2 or 3+
+    #
+    # - +2+ : Mean ISO-3166-1 alpha-2 (defulat)
+    # - +3+ : Mean ISO-3166-1 alpha-3
+    class IsoCountryField < FieldBase
+      PREFIX = 'iso-country'
+      EXPECTED_TYPES = String
+      AUTHORIZED_OPTIONS = [:alpha]
+
+      ALPHA_2 = [
+        'AF', 'AX', 'AL', 'DZ', 'AS', 'AD', 'AO', 'AI', 'AQ', 'AG',
+        'AR', 'AM', 'AW', 'AU', 'AT', 'AZ', 'BS', 'BH', 'BD', 'BB',
+        'BY', 'BE', 'BZ', 'BJ', 'BM', 'BT', 'BO', 'BQ', 'BA', 'BW',
+        'BV', 'BR', 'IO', 'BN', 'BG', 'BF', 'BI', 'CV', 'KH', 'CM',
+        'CA', 'KY', 'CF', 'TD', 'CL', 'CN', 'CX', 'CC', 'CO', 'KM',
+        'CG', 'CD', 'CK', 'CR', 'CI', 'HR', 'CU', 'CW', 'CY', 'CZ',
+        'DK', 'DJ', 'DM', 'DO', 'EC', 'EG', 'SV', 'GQ', 'ER', 'EE',
+        'SZ', 'ET', 'FK', 'FO', 'FJ', 'FI', 'FR', 'GF', 'PF', 'TF',
+        'GA', 'GM', 'GE', 'DE', 'GH', 'GI', 'GR', 'GL', 'GD', 'GP',
+        'GU', 'GT', 'GG', 'GN', 'GW', 'GY', 'HT', 'HM', 'VA', 'HN',
+        'HK', 'HU', 'IS', 'IN', 'ID', 'IR', 'IQ', 'IE', 'IM', 'IL',
+        'IT', 'JM', 'JP', 'JE', 'JO', 'KZ', 'KE', 'KI', 'KP', 'KR',
+        'KW', 'KG', 'LA', 'LV', 'LB', 'LS', 'LR', 'LY', 'LI', 'LT',
+        'LU', 'MO', 'MG', 'MW', 'MY', 'MV', 'ML', 'MT', 'MH', 'MQ',
+        'MR', 'MU', 'YT', 'MX', 'FM', 'MD', 'MC', 'MN', 'ME', 'MS',
+        'MA', 'MZ', 'MM', 'NA', 'NR', 'NP', 'NL', 'NC', 'NZ', 'NI',
+        'NE', 'NG', 'NU', 'NF', 'MK', 'MP', 'NO', 'OM', 'PK', 'PW',
+        'PS', 'PA', 'PG', 'PY', 'PE', 'PH', 'PN', 'PL', 'PT', 'PR',
+        'QA', 'RE', 'RO', 'RU', 'RW', 'BL', 'SH', 'KN', 'LC', 'MF',
+        'PM', 'VC', 'WS', 'SM', 'ST', 'SA', 'SN', 'RS', 'SC', 'SL',
+        'SG', 'SX', 'SK', 'SI', 'SB', 'SO', 'ZA', 'GS', 'SS', 'ES',
+        'LK', 'SD', 'SR', 'SJ', 'SE', 'CH', 'SY', 'TW', 'TJ', 'TZ',
+        'TH', 'TL', 'TG', 'TK', 'TO', 'TT', 'TN', 'TR', 'TM', 'TC',
+        'TV', 'UG', 'UA', 'AE', 'GB', 'US', 'UM', 'UY', 'UZ', 'VU',
+        'VE', 'VN', 'VG', 'VI', 'WF', 'EH', 'YE', 'ZM', 'ZW'
+      ]
+
+      ALPHA_3 = [
+        'AFG', 'ALA', 'ALB', 'DZA', 'ASM', 'AND', 'AGO', 'AIA', 'ATA', 'ATG',
+        'ARG', 'ARM', 'ABW', 'AUS', 'AUT', 'AZE', 'BHS', 'BHR', 'BGD', 'BRB',
+        'BLR', 'BEL', 'BLZ', 'BEN', 'BMU', 'BTN', 'BOL', 'BES', 'BIH', 'BWA',
+        'BVT', 'BRA', 'IOT', 'BRN', 'BGR', 'BFA', 'BDI', 'CPV', 'KHM', 'CMR',
+        'CAN', 'CYM', 'CAF', 'TCD', 'CHL', 'CHN', 'CXR', 'CCK', 'COL', 'COM',
+        'COG', 'COD', 'COK', 'CRI', 'CIV', 'HRV', 'CUB', 'CUW', 'CYP', 'CZE',
+        'DNK', 'DJI', 'DMA', 'DOM', 'ECU', 'EGY', 'SLV', 'GNQ', 'ERI', 'EST',
+        'SWZ', 'ETH', 'FLK', 'FRO', 'FJI', 'FIN', 'FRA', 'GUF', 'PYF', 'ATF',
+        'GAB', 'GMB', 'GEO', 'DEU', 'GHA', 'GIB', 'GRC', 'GRL', 'GRD', 'GLP',
+        'GUM', 'GTM', 'GGY', 'GIN', 'GNB', 'GUY', 'HTI', 'HMD', 'VAT', 'HND',
+        'HKG', 'HUN', 'ISL', 'IND', 'IDN', 'IRN', 'IRQ', 'IRL', 'IMN', 'ISR',
+        'ITA', 'JAM', 'JPN', 'JEY', 'JOR', 'KAZ', 'KEN', 'KIR', 'PRK', 'KOR',
+        'KWT', 'KGZ', 'LAO', 'LVA', 'LBN', 'LSO', 'LBR', 'LBY', 'LIE', 'LTU',
+        'LUX', 'MAC', 'MDG', 'MWI', 'MYS', 'MDV', 'MLI', 'MLT', 'MHL', 'MTQ',
+        'MRT', 'MUS', 'MYT', 'MEX', 'FSM', 'MDA', 'MCO', 'MNG', 'MNE', 'MSR',
+        'MAR', 'MOZ', 'MMR', 'NAM', 'NRU', 'NPL', 'NLD', 'NCL', 'NZL', 'NIC',
+        'NER', 'NGA', 'NIU', 'NFK', 'MKD', 'MNP', 'NOR', 'OMN', 'PAK', 'PLW',
+        'PSE', 'PAN', 'PNG', 'PRY', 'PER', 'PHL', 'PCN', 'POL', 'PRT', 'PRI',
+        'QAT', 'REU', 'ROU', 'RUS', 'RWA', 'BLM', 'SHN', 'KNA', 'LCA', 'MAF',
+        'SPM', 'VCT', 'WSM', 'SMR', 'STP', 'SAU', 'SEN', 'SRB', 'SYC', 'SLE',
+        'SGP', 'SXM', 'SVK', 'SVN', 'SLB', 'SOM', 'ZAF', 'SGS', 'SSD', 'ESP',
+        'LKA', 'SDN', 'SUR', 'SJM', 'SWE', 'CHE', 'SYR', 'TWN', 'TJK', 'TZA',
+        'THA', 'TLS', 'TGO', 'TKL', 'TON', 'TTO', 'TUN', 'TUR', 'TKM', 'TCA',
+        'TUV', 'UGA', 'UKR', 'ARE', 'GBR', 'USA', 'UMI', 'URY', 'UZB', 'VUT',
+        'VEN', 'VNM', 'VGB', 'VIR', 'WLF', 'ESH', 'YEM', 'ZMB', 'ZWE'
+      ]
+
+      def initialize(opts={})
+        if opts[:alpha].nil?
+          opts[:alpha] = 2
+        else
+          if opts[:alpha] != 2 and opts[:alpha] != 3
+            raise Saphyr::Error.new 'Bad county alpha option must be : 2 or 3'
+          end
+        end
+        super opts
+      end
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          if @opts[:alpha] == 2
+            add_error value, errors unless ALPHA_2.include? value
+          else
+            add_error value, errors unless ALPHA_3.include? value
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields/iso_lang_field.rb

@@ -0,0 +1,114 @@
+module Saphyr
+  module Fields
+
+    # The +IsoLang+ field type (ISO-639-1/2).
+    #
+    # Allowed options is: +:version with possible values: 1 or 2+
+    #
+    # - +1+ : Mean ISO-639-1 (default)
+    # - +2+ : Mean ISO-639-2
+    class IsoLangField < FieldBase
+      PREFIX = 'iso-lang'
+      EXPECTED_TYPES = String
+      AUTHORIZED_OPTIONS = [:version]
+
+      VERSION_1 = [
+        'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an', 'ar', 'as', 'av', 'ay', 'az',
+        'ba', 'be', 'bg', 'bh', 'bi', 'bm', 'bn', 'bo', 'br', 'bs', 'ca', 'ce',
+        'ch', 'co', 'cr', 'cs', 'cu', 'cv', 'cy', 'da', 'de', 'dv', 'dz', 'ee',
+        'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'ff', 'fi', 'fj', 'fo', 'fr',
+        'fy', 'ga', 'gd', 'gl', 'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'ho', 'hr',
+        'ht', 'hu', 'hy', 'hz', 'ia', 'id', 'ie', 'ig', 'ii', 'ik', 'io', 'is',
+        'it', 'iu', 'ja', 'jv', 'ka', 'kg', 'ki', 'kj', 'kk', 'kl', 'km', 'kn',
+        'ko', 'kr', 'ks', 'ku', 'kv', 'kw', 'ky', 'la', 'lb', 'lg', 'li', 'ln',
+        'lo', 'lt', 'lu', 'lv', 'mg', 'mh', 'mi', 'mk', 'ml', 'mn', 'mr', 'ms',
+        'mt', 'my', 'na', 'nb', 'nd', 'ne', 'ng', 'nl', 'nn', 'no', 'nr', 'nv',
+        'ny', 'oc', 'oj', 'om', 'or', 'os', 'pa', 'pi', 'pl', 'ps', 'pt', 'qu',
+        'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sc', 'sd', 'se', 'sg', 'si', 'sk',
+        'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su', 'sv', 'sw', 'ta',
+        'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr', 'ts', 'tt', 'tw',
+        'ty', 'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi',
+        'yo', 'za', 'zh', 'zu'
+      ]
+
+      VERSION_2 = [
+        'aar', 'abk', 'ace', 'ach', 'ada', 'ady', 'afa', 'afh', 'afr', 'ain', 'aka',
+        'akk', 'alb', 'ale', 'alg', 'alt', 'amh', 'ang', 'anp', 'apa', 'ara', 'arc',
+        'arg', 'arm', 'arn', 'arp', 'art', 'arw', 'asm', 'ast', 'ath', 'aus', 'ava',
+        'ave', 'awa', 'aym', 'aze', 'bad', 'bai', 'bak', 'bal', 'bam', 'ban', 'baq',
+        'bas', 'bat', 'bej', 'bel', 'bem', 'ben', 'ber', 'bho', 'bih', 'bik', 'bin',
+        'bis', 'bla', 'bnt', 'bos', 'bra', 'bre', 'btk', 'bua', 'bug', 'bul', 'bur',
+        'byn', 'cad', 'cai', 'car', 'cat', 'cau', 'ceb', 'cel', 'cha', 'chb', 'che',
+        'chg', 'chi', 'chk', 'chm', 'chn', 'cho', 'chp', 'chr', 'chu', 'chv', 'chy',
+        'cmc', 'cnr', 'cop', 'cor', 'cos', 'cpe', 'cpf', 'cpp', 'cre', 'crh', 'crp',
+        'csb', 'cus', 'cze', 'dak', 'dan', 'dar', 'day', 'del', 'den', 'dgr', 'din',
+        'div', 'doi', 'dra', 'dsb', 'dua', 'dum', 'dut', 'dyu', 'dzo', 'efi', 'egy',
+        'eka', 'elx', 'eng', 'enm', 'epo', 'est', 'ewe', 'ewo', 'fan', 'fao', 'fat',
+        'fij', 'fil', 'fin', 'fiu', 'fon', 'fre', 'frm', 'fro', 'frr', 'frs', 'fry',
+        'ful', 'fur', 'gaa', 'gay', 'gba', 'gem', 'geo', 'ger', 'gez', 'gil', 'gla',
+        'gle', 'glg', 'glv', 'gmh', 'goh', 'gon', 'gor', 'got', 'grb', 'grc', 'gre',
+        'grn', 'gsw', 'guj', 'gwi', 'hai', 'hat', 'hau', 'haw', 'heb', 'her', 'hil',
+        'him', 'hin', 'hit', 'hmn', 'hmo', 'hrv', 'hsb', 'hun', 'hup', 'iba', 'ibo',
+        'ice', 'ido', 'iii', 'ijo', 'iku', 'ile', 'ilo', 'ina', 'inc', 'ind', 'ine',
+        'inh', 'ipk', 'ira', 'iro', 'ita', 'jav', 'jbo', 'jpn', 'jpr', 'jrb', 'kaa',
+        'kab', 'kac', 'kal', 'kam', 'kan', 'kar', 'kas', 'kau', 'kaw', 'kaz', 'kbd',
+        'kha', 'khi', 'khm', 'kho', 'kik', 'kin', 'kir', 'kmb', 'kok', 'kom', 'kon',
+        'kor', 'kos', 'kpe', 'krc', 'krl', 'kro', 'kru', 'kua', 'kum', 'kur', 'kut',
+        'lad', 'lah', 'lam', 'lao', 'lat', 'lav', 'lez', 'lim', 'lin', 'lit', 'lol',
+        'loz', 'ltz', 'lua', 'lub', 'lug', 'lui', 'lun', 'luo', 'lus', 'mac', 'mad',
+        'mag', 'mah', 'mai', 'mak', 'mal', 'man', 'mao', 'map', 'mar', 'mas', 'may',
+        'mdf', 'mdr', 'men', 'mga', 'mic', 'min', 'mis', 'mkh', 'mlg', 'mlt', 'mnc',
+        'mni', 'mno', 'moh', 'mon', 'mos', 'mul', 'mun', 'mus', 'mwl', 'mwr', 'myn',
+        'myv', 'nah', 'nai', 'nap', 'nau', 'nav', 'nbl', 'nde', 'ndo', 'nds', 'nep',
+        'new', 'nia', 'nic', 'niu', 'nno', 'nob', 'nog', 'non', 'nor', 'nqo', 'nso',
+        'nub', 'nwc', 'nya', 'nym', 'nyn', 'nyo', 'nzi', 'oci', 'oji', 'ori', 'orm',
+        'osa', 'oss', 'ota', 'oto', 'paa', 'pag', 'pal', 'pam', 'pan', 'pap', 'pau',
+        'peo', 'per', 'phi', 'phn', 'pli', 'pol', 'pon', 'por', 'pra', 'pro', 'pus',
+        'qaa', 'que', 'raj', 'rap', 'rar', 'roa', 'roh', 'rom', 'rum', 'run', 'rup',
+        'rus', 'sad', 'sag', 'sah', 'sai', 'sal', 'sam', 'san', 'sas', 'sat', 'scn',
+        'sco', 'sel', 'sem', 'sga', 'sgn', 'shn', 'sid', 'sin', 'sio', 'sit', 'sla',
+        'slo', 'slv', 'sma', 'sme', 'smi', 'smj', 'smn', 'smo', 'sms', 'sna', 'snd',
+        'snk', 'sog', 'som', 'son', 'sot', 'spa', 'srd', 'srn', 'srp', 'srr', 'ssa',
+        'ssw', 'suk', 'sun', 'sus', 'sux', 'swa', 'swe', 'syc', 'syr', 'tah', 'tai',
+        'tam', 'tat', 'tel', 'tem', 'ter', 'tet', 'tgk', 'tgl', 'tha', 'tib', 'tig',
+        'tir', 'tiv', 'tkl', 'tlh', 'tli', 'tmh', 'tog', 'ton', 'tpi', 'tsi', 'tsn',
+        'tso', 'tuk', 'tum', 'tup', 'tur', 'tut', 'tvl', 'twi', 'tyv', 'udm', 'uga',
+        'uig', 'ukr', 'umb', 'und', 'urd', 'uzb', 'vai', 'ven', 'vie', 'vol', 'vot',
+        'wak', 'wal', 'war', 'was', 'wel', 'wen', 'wln', 'wol', 'xal', 'xho', 'yao',
+        'yap', 'yid', 'yor', 'ypk', 'zap', 'zbl', 'zen', 'zgh', 'zha', 'znd', 'zul',
+        'zun', 'zxx', 'zza'
+      ]
+
+      def initialize(opts={})
+        if opts[:version].nil?
+          opts[:version] = 1
+        else
+          if opts[:version] != 1 and opts[:version] != 2
+            raise Saphyr::Error.new 'Bad language akpha option must be : 2 or 3'
+          end
+        end
+        super opts
+      end
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_not_empty value, errors
+          if @opts[:version] == 1
+            add_error value, errors unless VERSION_1.include? value
+          else
+            add_error value, errors unless VERSION_2.include? value
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields/schema_field.rb

@@ -3,9 +3,8 @@ module Saphyr
 
     class SchemaField < FieldBase
       PREFIX = 'schema'
-
+      EXPECTED_TYPES = Hash
       AUTHORIZED_OPTIONS = [:name]
-
       REQUIRED_OPTIONS = [:name]
 
       private

data/lib/saphyr/fields/string_field.rb

@@ -6,7 +6,7 @@ module Saphyr
     # Allowed options are: +:eq, :len, :min, :max, :in, :regexp+.
     class StringField < FieldBase
       PREFIX = 'string'
-
+      EXPECTED_TYPES = String
       AUTHORIZED_OPTIONS = [:eq, :len, :min, :max, :in, :regexp]
 
       EXCLUSIVE_OPTIONS = [
@@ -28,7 +28,6 @@ module Saphyr
       private
 
         def do_validate(ctx, name, value, errors)
-          return unless assert_class String, value, errors
           assert_eq @opts[:eq], value, errors
           assert_size_len @opts[:len], value, errors
           assert_size_min @opts[:min], value, errors

data/lib/saphyr/fields/uri_field.rb

@@ -0,0 +1,29 @@
+require 'uri'
+
+module Saphyr
+  module Fields
+
+    # The +URI+ field type
+    #
+    # No options are allowed.
+    class UriField < FieldBase
+      PREFIX = 'uri'
+      EXPECTED_TYPES = String
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          begin
+            URI.parse value
+          rescue URI::InvalidURIError
+            errors << {
+              type: err('invalid'),
+              data: {
+                _val: value
+              }
+            }
+          end
+        end
+    end
+  end
+end

data/lib/saphyr/fields/url_field.rb

@@ -0,0 +1,36 @@
+require 'uri'
+
+module Saphyr
+  module Fields
+
+    # The +URL+ field type
+    #
+    # No options are allowed.
+    class UrlField < FieldBase
+      PREFIX = 'url'
+      EXPECTED_TYPES = String
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          begin
+            uri = URI.parse value
+            unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+              add_error value, errors
+            end
+          rescue URI::InvalidURIError
+            add_error value, errors
+          end
+        end
+
+        def add_error(value, errors)
+          errors << {
+            type: err('invalid'),
+            data: {
+              _val: value
+            }
+          }
+        end
+    end
+  end
+end

data/lib/saphyr/fields.rb

@@ -1,7 +1,6 @@
 module Saphyr
   module Fields
     require_relative './fields/field_base'
-
     require_relative './fields/array_field'
     require_relative './fields/schema_field'
 
@@ -9,5 +8,13 @@ module Saphyr
     require_relative './fields/integer_field'
     require_relative './fields/float_field'
     require_relative './fields/boolean_field'
+    require_relative './fields/email_field'
+    require_relative './fields/uri_field'
+    require_relative './fields/url_field'
+    require_relative './fields/b64_field'
+    require_relative './fields/ip_field'
+    require_relative './fields/iso_country_field'
+    require_relative './fields/iso_lang_field'
+    require_relative './fields/datetime_field'
   end
 end

data/lib/saphyr/helpers/format.rb

@@ -98,6 +98,13 @@ module Saphyr
             return 'Conditional field not allowed'
           end
 
+          # ------------------------------------
+          # Not Empty
+          # ------------------------------------
+          if type.end_with? 'not-empty'
+            return 'Cannot be empty'
+          end
+
           # ------------------------------------
           # Not Nullable
           # ------------------------------------
@@ -105,6 +112,14 @@ module Saphyr
             return 'Not nullable'
           end
 
+          # ------------------------------------
+          # Common
+          # ------------------------------------
+          # invalid
+          if type.end_with? 'invalid'
+            return "Invalid format, got: '#{data[:_val]}'"
+          end
+
           'unknown'
         end
       end

data/lib/saphyr/validator.rb

@@ -95,7 +95,7 @@ module Saphyr
     # -----
 
     # Validate an already parsed JSON document.
-    # @param [Hash | Array] The data to validate.
+    # @param data [Hash | Array] The data to validate.
     # @return [Boolean] Wheter the validation was successful or failed.
     def validate(data)
       @ctx = Saphyr::Engine::Context.new [self], get_config, data, nil, '//'
@@ -119,7 +119,7 @@ module Saphyr
     end
 
     # Get a field from the data to validate.
-    # @param [String | Symbol] The field name
+    # @param field [String | Symbol] The field name
     # @return The field value
     def get(field)
       data = @ctx.data_to_validate

data/lib/saphyr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Saphyr
-  VERSION = "0.4.2.beta"
+  VERSION = '0.6.0'
 end

data/lib/saphyr.rb

@@ -157,4 +157,12 @@ Saphyr.register do
   field_type :integer, Saphyr::Fields::IntegerField
   field_type :float, Saphyr::Fields::FloatField
   field_type :boolean, Saphyr::Fields::BooleanField
+  field_type :email, Saphyr::Fields::EmailField
+  field_type :uri, Saphyr::Fields::UriField
+  field_type :url, Saphyr::Fields::UrlField
+  field_type :b64, Saphyr::Fields::B64Field
+  field_type :ip, Saphyr::Fields::IpField
+  field_type :iso_country, Saphyr::Fields::IsoCountryField
+  field_type :iso_lang, Saphyr::Fields::IsoLangField
+  field_type :datetime, Saphyr::Fields::DateTimeField
 end

data/rdoc/02_Field_Types.md

@@ -4,7 +4,7 @@ By default the `Saphyr` library is including many field types.
 
 ## Common options
 
-All field type have the common `:required`, `:nullable`.
+All field type have the common `:required`, `:nullable` and `:default` options.
 
 ## String
 
@@ -15,16 +15,14 @@ Here is an example with all possible options for `:string` type:
 ```ruby
 class MyValidator < Saphyr::Validator
   field :name,      :string
-  field :name,      :string,  eq: 'v1.1'
-  field :name,      :string,  min: 5, max: 50
-  field :name,      :string,  max: 50
-  field :name,      :string,  len: 15
-  field :name,      :string,  len: 15, regexp: /^[a-f0-9]+$/
-  field :name,      :string,  regexp: /^[A-Z0-9]{15}$/
-  field :name,      :string,  in: ['jpg', 'png', 'gif']
-
-
-  field :location,  :string,  required: false, min: 10
+  field :version,   :string,  eq: 'v1.1'               # Field name can be a
+  field "fname",    :string,  min: 5, max: 50          # Symbol or a String
+  field "lname",    :string,  max: 50
+  field "info",     :string,  len: 15
+  field :hexa,      :string,  len: 15, regexp: /^[a-f0-9]+$/
+  field :nid,       :string,  regexp: /^[A-Z0-9]{15}$/
+  field :extension, :string,  in: ['jpg', 'png', 'gif']
+  field :location,  :string,  required: false, min: 10, default: 'here'
   field :info,      :string,  nullable: true, max: 1024
 end
 ```
@@ -33,7 +31,6 @@ end
 - If you use `:len` option then you cannot use `:min` and `:max` options
 - If you use `:in` option then you cannot use any of the other options
 
-
 ## Integer
 
 Authorized options for the `:integer` type: `[:eq, :gt, :gte, :lt, :lte, :in]`
@@ -42,15 +39,14 @@ Here is an example with all possible options for `:integer` type:
 
 ```ruby
 class MyValidator < Saphyr::Validator
-  field :count,  :integer
-  field :count,  :integer,  eq: 'v1.1'
-  field :count,  :integer,  gt: 0
-  field :count,  :integer,  lt: 50
-  field :count,  :integer,  gte: 5, lte: 50
-  field :count,  :integer,  in: ['jpg', 'png', 'gif']
-
-  field :count,  :integer,  required: false, gte: 10
-  field :count,  :integer,  nullable: true, lte: 1024
+  field :id,       :integer,  gt: 0
+  field :nb,       :integer
+  field :version,  :integer,  eq: '101'
+  field :value,    :integer,  lt: 50
+  field :range,    :integer,  gte: 5, lte: 50
+  field :velocity, :integer,  in: [10, 20, 30, 40]
+  field :count,    :integer,  required: false, gte: 10, default: 20
+  field :round,    :integer,  nullable: true, lte: 1024
 end
 ```
 
@@ -65,15 +61,14 @@ Here is an example with all possible options for `:float` type:
 
 ```ruby
 class MyValidator < Saphyr::Validator
-  field :price,  :float
-  field :price,  :float,  eq: 15.1
-  field :price,  :float,  gt: 0
-  field :price,  :float,  lt: 50
-  field :price,  :float,  gte: 5, lte: 50
-  field :price,  :float,  in: ['jpg', 'png', 'gif']
-
-  field :price,  :float,  required: false, gte: 10
-  field :price,  :float,  nullable: true, lte: 1024
+  field :value,     :float
+  field :velocity,  :float,  eq: 15.1
+  field :x_axis,    :float,  gt: 0.0
+  field :y_axis,    :float,  lt: 50
+  field :z_axis,    :float,  gte: 5, lte: 50
+  field :focale,    :float,  in: [3.14, 1.618, 6.35]
+  field :price,     :float,  required: false, gte: 10, default: 22.2
+  field :discount,  :float,  nullable: true, lte: 1024
 end
 ```
 
@@ -88,12 +83,120 @@ Here is an example with all possible options for `:boolean` type:
 
 ```ruby
 class MyValidator < Saphyr::Validator
-  field :active,  :boolean
-  field :active,  :boolean,  eq: true
-  field :active,  :boolean,  eq: false
+  field :payed,   :boolean
+  field :valid,   :boolean,  eq: true
+  field :option,  :boolean,  eq: false
+  field :active,     :boolean,  required: false, default: true
+  field :processed,  :boolean,  nullable: true
+end
+```
+
+## Email
+
+No options allowed for the `:email` type.
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :email,  :email
+end
+```
+
+## URI and URL
+
+No options allowed for the `:uri` and `:url` types.
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :email,    :uri       # valid@email.com
+  field :isbn,     :uri       # urn:isbn:0451450523
+  field :location, :uri       # https://example.com/page.html
+
+  field :site,     :url       # http://www.test.com/
+  field :blog,     :url       # http://test.com/page.html
+end
+```
+
+## Base64
+
+Authorized options for the `:b64` type: `[:strict]`
+
+Here is an example with all possible options for `:b64` type:
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :content,  :b64                    # By default :strict == true
+  field :text,     :b64,  strict: false
+end
+```
+
+In strict mode `:strict == true`:
+
+- Line breaks are not allowed
+- Padding must be correct (length % 4 == 0)
+
+Not in strict mode `:strict == false`:
 
-  field :active,  :boolean,  required: false
-  field :active,  :boolean,  nullable: true
+- Line breaks are allowed
+- Padding is not required
+
+## IP
+
+Authorized options for the `:ip` type: `[:kind]`
+
+Here is an example with all possible options for `:ip` type:
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :web1,   :ip                 # Can be ipv4 or ipv6
+  field :db,     :ip,  kind: :ipv4   # Must be an ipv4
+  field :cache,  :ip,  kind: :ipv6   # Must be an ipv6
+end
+```
+
+## Country (ISO-3166-1 alpha 2/3)
+
+Authorized options for the `:iso_country` type: `[:alpha]`
+
+Here is an example with all possible options for `:iso_country` type:
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :country1,  :iso_country              # Default : ISO-3166-1 alpha-2
+  field :country2,  :iso_country, alpha: 2
+  field :country3,  :iso_country, alpha: 3
+end
+```
+
+- `:alpha = 2` : Mean ISO-3166-1 alpha-2
+- `:alpha = 3` : Mean ISO-3166-1 alpha-3
+
+## Language (ISO-639-1, ISO-639-2)
+
+Authorized options for the `:iso_lang` type: `[:version]`
+
+Here is an example with all possible options for `:iso_lang` type:
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :lang1,  :iso_lang                 # Default : ISO-639-1
+  field :lang2,  :iso_lang, version: 1
+  field :lang3,  :iso_lang, version: 2
+end
+```
+
+- `:version = 1` : Mean ISO-639-1
+- `:version = 2` : Mean ISO-639-2
+
+## DateTime
+
+Authorized options for the `:datetime` type: `[:format]`
+
+Here is an example with all possible options for `:format` type:
+
+```ruby
+class MyValidator < Saphyr::Validator
+  field :datetime1,  :datetime            # Any valid format
+  field :datetime2,  :datetime, format: '%d/%m/%Y %H:%M:%S'
 end
 ```
 
@@ -127,7 +230,7 @@ class MyValidator < Saphyr::Validator
   #                             |                                  |
   # Size of array must be: 1 >= s <= 10                            |
   #                                                                |
-  #               This 'opts' are for the element of array, ie: 'string'
+  #               This 'opts' are for the elements of the array, ie: 'string' type
 end
 ```
 
@@ -147,7 +250,7 @@ data = {
 class MyValidator < Saphyr::Validator
   schema :tag do
     field :id,     :integer,  gt: 0
-    field :label,  :string,   min: 5, max: 30
+    field :label,  :string,   min: 2, max: 30
   end
 
   field :code,  :string,  min: 5,  max: 10

data/rdoc/04_Define_Custom_Field_Type.md

@@ -0,0 +1,47 @@
+# How To Define a Field Type
+
+It's possible to define your own custom type.
+
+You can take inspiration from `lib/saphyr/fields/*_field.rb`.
+
+Here is an example:
+
+## Define custom B62 field
+
+```ruby
+class B62Field < Saphyr::Fields::FieldBase
+  PREFIX = 'b62'
+  EXPECTED_TYPES = String
+  AUTHORIZED_OPTIONS = [:len, :min, :max]
+
+  EXCLUSIVE_OPTIONS = [
+    [ :len, [:min, :max] ],      # It mean if you use 'len' then you
+  ]                              # you can't use 'min' or 'max' and vice versa
+
+  private
+
+    def do_validate(ctx, name, value, errors)
+      assert_size_len @opts[:len], value, errors
+      assert_size_min @opts[:min], value, errors
+      assert_size_max @opts[:max], value, errors
+      assert_string_regexp /^[a-zA-Z0-9]+$/, value, errors, ERR_BAD_FORMAT
+    end
+end
+```
+
+## Register the custom type
+
+```ruby
+Saphyr.register do
+  field_type :b62, B62Field
+end
+```
+
+## Use the custom type in a validator
+
+```ruby
+class ItemValidator < Saphyr::Validator
+  field :id,     :integer,  gte: 1
+  field :uuid,   :b62,      min: 10, max: 100
+end
+```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: saphyr
 version: !ruby/object:Gem::Version
-  version: 0.4.2.beta
+  version: 0.6.0
 platform: ruby
 authors:
 - odelbos
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-06 00:00:00.000000000 Z
+date: 2025-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -50,6 +50,7 @@ extra_rdoc_files:
 - rdoc/01_Define_Schema.md
 - rdoc/02_Field_Types.md
 - rdoc/03_Strict_Mode.md
+- rdoc/04_Define_Custom_Field_Type.md
 files:
 - CHANGELOG
 - LICENSE
@@ -63,12 +64,20 @@ files:
 - lib/saphyr/engine.rb
 - lib/saphyr/fields.rb
 - lib/saphyr/fields/array_field.rb
+- lib/saphyr/fields/b64_field.rb
 - lib/saphyr/fields/boolean_field.rb
+- lib/saphyr/fields/datetime_field.rb
+- lib/saphyr/fields/email_field.rb
 - lib/saphyr/fields/field_base.rb
 - lib/saphyr/fields/float_field.rb
 - lib/saphyr/fields/integer_field.rb
+- lib/saphyr/fields/ip_field.rb
+- lib/saphyr/fields/iso_country_field.rb
+- lib/saphyr/fields/iso_lang_field.rb
 - lib/saphyr/fields/schema_field.rb
 - lib/saphyr/fields/string_field.rb
+- lib/saphyr/fields/uri_field.rb
+- lib/saphyr/fields/url_field.rb
 - lib/saphyr/helpers.rb
 - lib/saphyr/helpers/format.rb
 - lib/saphyr/schema.rb
@@ -77,6 +86,7 @@ files:
 - rdoc/01_Define_Schema.md
 - rdoc/02_Field_Types.md
 - rdoc/03_Strict_Mode.md
+- rdoc/04_Define_Custom_Field_Type.md
 homepage: https://github.com/odelbos/saphyr
 licenses:
 - MIT
@@ -91,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="