data_model 0.4.0 → 0.6.0

data/lib/data_model/builtin/hash.rb

@@ -1,26 +1,73 @@
-# typed: strict
-
 module DataModel
-	# Hash type has a concept of "child types"
+	# Hash type has a concept of "child types". They can either be specified
+	# as params of nested child arrays, or in a hash notation if specific
+	# keys are not being specified
+	#
+	# This is by far the most complex built-in type
+	#
+	# Example:
+	# 	[:hash, [:name, :string], [:email, :string]] # must have two specific keys
+	# 	[:hash, [symbol: :string] # key and values must be according to type
+	# 	[:hash, [symbol: [:string, {optional: true}]]] # types can be specified long hand
 	class Builtin::Hash < Type
 		include Errors
 		include Logging
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :open, T::Boolean, default: true
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :open, :boolean, default: true
 		end
 
 		## Children
 
-		sig { override.params(params: T::Array[Object]).void }
+		# configure how hash children will be read
+		# @param params [Array] the params to configure
+		# @return [void]
 		def configure(params)
-			result = T.let({}, T::Hash[Symbol, Type])
-			@children = T.let(result, T.nilable(T::Hash[Symbol, Type]))
-
+			result = @children = {}
+			@key_value = false
 			log.debug("configuring hash children")
 
-			for child in T.cast(params, T::Array[T::Array[Object]])
+			if params.length == 1 && params.first.length == 1 && params.first.first.is_a?(Hash)
+				@key_value = true
+				log.debug("configuring hash children with {key => value} notation")
+				params = params.first.first
+
+				if params.length != 1
+					raise "expected only one key in the {key => value} notation, got #{params.length} for #{params.inspect}"
+				end
+
+				key = params.keys.first
+				value = params.values.first
+
+				if key.nil?
+					raise "schema for key is missing"
+				end
+
+				if value.nil?
+					raise "schema for value is missing"
+				end
+
+				key_node = Scanner.scan(Array(key), type_registry)
+				value_node = Scanner.scan(Array(value), type_registry)
+
+				result[:key] = type_registry.type(
+					key_node.type,
+					args: key_node.args,
+					params: key_node.params,
+				)
+
+				result[:value] = type_registry.type(
+					value_node.type,
+					args: value_node.args,
+					params: value_node.params,
+				)
+
+				return
+			end
+
+			log.debug("configuring hash children with array notation")
+			for child in params
 				name, *schema = child
 				if !name.is_a?(Symbol)
 					raise "expected name as a symbol for the first element of child schemas, got #{name.inspect} for #{child.inspect}"
@@ -31,13 +78,14 @@ module DataModel
 				end
 
 				node = Scanner.scan(schema)
-				log.debug("adding hash child -> #{name}: #{node.serialize}")
+				log.debug("adding hash child -> #{name}: #{node.to_h}")
 
 				result[name] = instantiate(node.type, args: node.args, params: node.params)
 			end
 		end
 
-		sig { returns(T::Hash[Symbol, Type]) }
+		# get the children types of this hash
+		# @return [Hash] the children types of this hash
 		def children
 			if @children.nil?
 				raise "children not configured"
@@ -48,7 +96,10 @@ module DataModel
 
 		## Read
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			errors = Error.new
@@ -59,34 +110,40 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				errors.add(missing_error(Hash))
+				errors.add(missing_error(type_name))
 				return [val, errors]
 			end
 
 			# type error, early exit
 			if !val.is_a?(Hash) && !coerce
-				errors.add(type_error(Hash, val))
+				errors.add(type_error(type_name, val))
 				return [val, errors]
 			end
 
 			# attempt coercion
 			if !val.is_a?(Hash) && coerce
 				if val.respond_to?(:to_h)
-					val = T.unsafe(val).to_h
+					val = val.to_h
 				elsif val.respond_to?(:to_hash)
 					val = Hash(val)
 				else
-					errors.add(coerce_error(Hash, val))
+					errors.add(coerce_error(type_name, val))
 					return [val, errors]
 				end
 			end
 
-			hash = T.cast(val, T::Hash[Symbol, Object])
-
 			# detect extra keys then what is defined in the schema
 			if !args.open
-				keys = children.keys
-				extra = hash.keys - keys
+				found = []
+				for child_key in children.keys
+					for val_key in val.keys
+						if val_key.to_s == child_key.to_s # doing it this way to support symbols and strings
+							found << val_key
+						end
+					end
+				end
+
+				extra = val.keys - found
 
 				if !extra.empty?
 					errors.add(extra_keys_error(extra))
@@ -95,23 +152,39 @@ module DataModel
 			end
 
 			# process children
-			log.debug("processing hash children")
-			for (name, child) in children
-				hash[name], child_errors = child.read(hash[name], coerce:)
-				log.debug("child #{name} -> #{hash[name].inspect} #{child_errors.inspect}")
-
-				if !child_errors.any?
-					log.debug("no errors, skipping")
-					next
+			if @key_value
+				log.debug("processing hash children with {key => value} notation")
+				key = children[:key]
+				value = children[:value]
+
+				for (k, v) in val.dup
+					log.debug("processing #{k} -> #{v.inspect}")
+					k, key_errors = key.read(k, coerce:)
+					v, value_errors = value.read(v, coerce:)
+
+					if !key_errors.any? && !value_errors.any?
+						log.debug("no errors")
+						val[k] = v
+					end
+
+					errors.merge_child(k, key_errors)
+					errors.merge_child(k, value_errors)
+				end
+			else
+				log.debug("processing hash children with array notation")
+				for (name, child) in children
+					val[name], child_errors = child.read(val[name], coerce:)
+					log.debug("child #{name} -> #{val[name].inspect} #{child_errors.inspect}")
+
+					if !child_errors.any?
+						log.debug("no errors, skipping")
+						next
+					end
+
+					errors.merge_child(name, child_errors)
 				end
-
-				errors.merge_child(name, child_errors)
-
-				return [val, errors]
 			end
 
-			log.debug("hash check successful")
-
 			# done
 			return [val, errors]
 		end

data/lib/data_model/builtin/integer.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# Integer type
 	class Builtin::Integer < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :min, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
-			prop :max, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
+		# Arguments for Array type.
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :min, :numeric, default: nil
+			prop :max, :numeric, default: nil
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			err = Error.new
 			args = Arguments.new(type_args)
@@ -20,12 +23,12 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				err.add(missing_error(Integer))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
 			if !val.is_a?(Integer) && !coerce
-				err.add(type_error(Integer, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
@@ -33,17 +36,15 @@ module DataModel
 				if val.is_a?(String) || val.is_a?(Numeric)
 					val = Integer(val)
 				elsif val.respond_to?(:to_i)
-					val = T.cast(T.unsafe(val).to_i, Integer)
+					val = val.to_i
 				end
 
 				if !val.is_a?(Integer)
-					err.add(coerce_error(Integer, val))
+					err.add(coerce_error(type_name, val))
 					return [val, err]
 				end
 			end
 
-			val = T.cast(val, Integer)
-
 			min = args.min
 			if min && val <= min
 				err.add(min_error(min, val))

data/lib/data_model/builtin/numeric.rb

@@ -0,0 +1,35 @@
+module DataModel
+	# Numeric type is :integer | :float | :decimal
+	class Builtin::Numeric < Type
+		include Errors
+
+		# Arguments for this type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+		end
+
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+
+			# optional and missing
+			if !args.optional && val.nil?
+				err.add(missing_error(type_name))
+			end
+
+			# when missing, return early
+			if val.nil?
+				return [val, err]
+			end
+
+			val, err = invoke(:or, val, params: [:integer, :float, :decimal], coerce:)
+
+			# done
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin/object.rb

@@ -0,0 +1,28 @@
+module DataModel
+	# acts as any type, the only way to fail validation is if it is nil and not present
+	class Builtin::Object < Type
+		include Errors
+
+		# Object arguments
+		class Arguments < Struct
+			# @!attribute optional
+			# 	@return [Boolean] whether or not this type is optional
+			prop :optional, :boolean, default: false
+		end
+
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+
+			if val.nil? && !args.optional
+				err.add(missing_error(type_name))
+			end
+
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin/or.rb

@@ -0,0 +1,73 @@
+module DataModel
+	# Or type, allows for value to be one of several types
+	# Types will be tried in order. The first type to succeed will be used.
+	# If all types fail, the or type fails
+	#
+	# @example
+	#   [:or, :string, [:array, :string]]
+	class Builtin::Or < Type
+		include Errors
+		include Logging
+
+		# Arguments for this type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+		end
+
+		# support either :string shorthand or [:string, {optional: true}]
+		# @param params [Array<untyped>] the params to configure this type
+		# @return [void]
+		def configure(params)
+			if params.first.is_a?(Array)
+				params = params.first
+			end
+
+			@child_types = []
+
+			nodes = params.map { |p| Scanner.scan(Array(p)) }
+			for node in nodes
+				type = instantiate(node.type, args: node.args, params: node.params)
+				@child_types << type
+			end
+		end
+
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+			child_names = @child_types.map(&:type_name)
+
+			log.debug("coerce: #{coerce} or type #{child_names} with value #{val}")
+
+			# optional and missing
+			if !args.optional && val.nil?
+				err.add(missing_error(child_names))
+			end
+
+			# when missing, return early
+			if val.nil?
+				return [val, err]
+			end
+
+			valid = false
+
+			for type in @child_types
+				val, err = type.read(val, coerce: coerce)
+				if err.empty?
+					valid = true
+					break
+				end
+			end
+
+			if !valid
+				err.add(type_error(child_names, val))
+			end
+
+			# done
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin/string.rb

@@ -1,20 +1,21 @@
-# typed: strict
-
 module DataModel
+	# Built-in type for String
 	class Builtin::String < Type
 		include Errors
 
-		TFormatter = T.type_alias { T.proc.params(val: String).returns(T::Boolean) }
-
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :allow_blank, T::Boolean, default: true
-			prop :format, T.nilable(T.any(String, Regexp, TFormatter)), default: nil
-			prop :included, T::Array[String], default: []
-			prop :excluded, T::Array[String], default: []
+		# Arguments for this type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :allow_blank, :boolean, default: true
+			prop :format, :string, default: nil
+			prop :included, [:array, :string], default: []
+			prop :excluded, [:array, :string], default: []
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			err = Error.new
@@ -25,13 +26,13 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				err.add(missing_error(String))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
 			# type error
 			if !val.is_a?(String) && !coerce
-				err.add(type_error(String, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
@@ -40,13 +41,11 @@ module DataModel
 				begin
 					val = String(val)
 				rescue TypeError
-					err.add(coerce_error(String, val))
+					err.add(coerce_error(type_name, val))
 					return [val, err]
 				end
 			end
 
-			val = T.cast(val, String)
-
 			# format
 			fmt = args.format
 			if fmt

data/lib/data_model/builtin/symbol.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# Symbol type
 	class Builtin::Symbol < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :included, T::Array[Symbol], default: []
-			prop :excluded, T::Array[Symbol], default: []
+		# Arguments for this type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :included, [:array, :symbol], default: []
+			prop :excluded, [:array, :symbol], default: []
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			err = Error.new
@@ -21,13 +24,13 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				err.add(missing_error(Symbol))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
 			# type error
 			if !val.is_a?(Symbol) && !coerce
-				err.add(type_error(Symbol, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
@@ -36,15 +39,13 @@ module DataModel
 				if val.is_a?(String)
 					val = val.intern
 				elsif val.respond_to?(:to_sym)
-					val = T.unsafe(val).to_sym
+					val = val.to_sym
 				else
-					err.add(coerce_error(Symbol, val))
+					err.add(coerce_error(type_name, val))
 					return [val, err]
 				end
 			end
 
-			val = T.cast(val, Symbol)
-
 			# inclusion
 			if args.included.any? && !args.included.include?(val)
 				err.add(inclusion_error(args.included))

data/lib/data_model/builtin/time.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# A time type
 	class Builtin::Time < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :earliest, T.nilable(::Time), default: nil
-			prop :latest, T.nilable(::Time), default: nil
+		# Arguments for this type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :earliest, [:time, { optional: true }], default: nil
+			prop :latest, [:time, { optional: true }], default: nil
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			err = Error.new
@@ -22,7 +25,7 @@ module DataModel
 
 			# missing, but not allowed, don't do any more checks
 			if val.nil?
-				err.add(missing_error(Time))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
@@ -31,26 +34,26 @@ module DataModel
 				begin
 					val = Time.parse(val)
 				rescue ArgumentError
-					err.add(type_error(Time, val))
+					err.add(type_error(type_name, val))
 					return [val, err]
 				end
 			end
 
 			# not a date, don't do any more checks
 			if !val.is_a?(Time)
-				err.add(type_error(Time, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
 			# date is before the earliest point allowed
-			if args.earliest && (val < T.must(args.earliest))
-				error = earliest_error(T.must(args.earliest), val)
+			if args.earliest && (val < args.earliest)
+				error = earliest_error(args.earliest, val)
 				err.add(error)
 			end
 
 			# date is after the latest point allowed
-			if args.latest && (val > T.must(args.latest))
-				error = latest_error(T.must(args.latest), val)
+			if args.latest && (val > args.latest)
+				error = latest_error(args.latest, val)
 				err.add(error)
 			end
 

data/lib/data_model/builtin.rb

@@ -1,22 +1,22 @@
-# typed: strict
-
 module DataModel
 	module Builtin
-		extend T::Sig
-
-		sig { returns(TTypeMap) }
+		# Hash of all builtin types, useful when instanciating a Registry
+		# @return [Hash{Symbol => Type}] the builtin types
 		def self.types
 			{
 				hash: Builtin::Hash,
+				array: Builtin::Array,
+				or: Builtin::Or,
+				object: Builtin::Object,
+				boolean: Builtin::Boolean,
+				date: Builtin::Date,
+				time: Builtin::Time,
 				string: Builtin::String,
 				symbol: Builtin::Symbol,
 				integer: Builtin::Integer,
 				decimal: Builtin::BigDecimal,
 				float: Builtin::Float,
-				boolean: Builtin::Boolean,
-				array: Builtin::Array,
-				date: Builtin::Date,
-				time: Builtin::Time
+				numeric: Builtin::Numeric
 			}
 		end
 	end