data_model 0.0.1 → 0.2.0

data/lib/data_model/builtin/hash.rb

@@ -0,0 +1,119 @@
+# typed: strict
+
+module DataModel
+	# Hash type has a concept of "child types"
+	class Builtin::Hash < Type
+		include Errors
+		include Logging
+
+		class Arguments < T::Struct
+			prop :optional, T::Boolean, default: false
+			prop :open, T::Boolean, default: true
+		end
+
+		## Children
+
+		sig { override.params(params: T::Array[Object]).void }
+		def configure(params)
+			result = T.let({}, T::Hash[Symbol, Type])
+			@children = T.let(result, T.nilable(T::Hash[Symbol, Type]))
+
+			log.debug("configuring hash children")
+
+			for child in T.cast(params, T::Array[T::Array[Object]])
+				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}"
+				end
+
+				if schema.nil? || schema.empty?
+					raise "schema for #{name} is missing"
+				end
+
+				node = Scanner.scan(schema)
+				log.debug("adding hash child -> #{name}: #{node.serialize}")
+
+				result[name] = instantiate(node.type, args: node.args, params: node.params)
+			end
+		end
+
+		sig { returns(T::Hash[Symbol, Type]) }
+		def children
+			if @children.nil?
+				raise "children not configured"
+			end
+
+			return @children
+		end
+
+		## Read
+
+		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			errors = Error.new
+
+			# early positive exit for optional & missing
+			if args.optional && val.nil?
+				return [val, errors]
+			end
+
+			if !args.optional && val.nil?
+				errors.add(missing_error(Hash))
+				return [val, errors]
+			end
+
+			# type error, early exit
+			if !val.is_a?(Hash) && !coerce
+				errors.add(type_error(Hash, 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
+				elsif val.respond_to?(:to_hash)
+					val = Hash(val)
+				else
+					errors.add(coerce_error(Hash, 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
+
+				if !extra.empty?
+					errors.add(extra_keys_error(extra))
+					return [val, errors]
+				end
+			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
+				end
+
+				errors.merge_child(name, child_errors)
+
+				return [val, errors]
+			end
+
+			log.debug("hash check successful")
+
+			# done
+			return [val, errors]
+		end
+	end
+end

data/lib/data_model/builtin/integer.rb

@@ -0,0 +1,64 @@
+# typed: strict
+
+module DataModel
+	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
+		end
+
+		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(val, coerce: false)
+			err = Error.new
+			args = Arguments.new(type_args)
+
+			if args.optional && val.nil?
+				return [val, err]
+			end
+
+			if !args.optional && val.nil?
+				err.add(missing_error(Integer))
+				return [val, err]
+			end
+
+			if !val.is_a?(Integer) && !coerce
+				err.add(type_error(Integer, val))
+				return [val, err]
+			end
+
+			if !val.is_a?(Integer) && coerce
+				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)
+				end
+
+				if !val.is_a?(Integer)
+					err.add(coerce_error(Integer, val))
+					return [val, err]
+				end
+			end
+
+			val = T.cast(val, Integer)
+
+			min = args.min
+			if min && val <= min
+				err.add(min_error(min, val))
+
+				return [val, err]
+			end
+
+			max = args.max
+			if max && val <= max
+				err.add(max_error(max, val))
+
+				return [val, err]
+			end
+
+			[val, err]
+		end
+	end
+end

data/lib/data_model/builtin/string.rb

@@ -0,0 +1,88 @@
+# typed: strict
+
+module DataModel
+	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: []
+		end
+
+		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+
+			# optional & missing
+			if args.optional && val.nil?
+				return [val, err]
+			end
+
+			if !args.optional && val.nil?
+				err.add(missing_error(String))
+				return [val, err]
+			end
+
+			# type error
+			if !val.is_a?(String) && !coerce
+				err.add(type_error(String, val))
+				return [val, err]
+			end
+
+			# attempt coercion
+			if !val.is_a?(String) && coerce
+				begin
+					val = String(val)
+				rescue TypeError
+					err.add(coerce_error(String, val))
+					return [val, err]
+				end
+			end
+
+			val = T.cast(val, String)
+
+			# format
+			fmt = args.format
+			if fmt
+				case fmt
+				when String
+					if !val.match?(fmt)
+						err.add(format_error(fmt, val))
+					end
+				when Regexp
+					if !val.match?(fmt)
+						err.add(format_error(fmt, val))
+					end
+				when Proc
+					if !fmt.call(val)
+						err.add(format_error("<Custom Proc>", val))
+					end
+				end
+			end
+
+			# inclusion
+			if args.included.any? && !args.included.include?(val)
+				err.add(inclusion_error(args.included))
+			end
+
+			# exclusion
+			if args.excluded.any? && args.excluded.include?(val)
+				err.add(exclusion_error(args.excluded))
+			end
+
+			# allow blank
+			if !args.allow_blank && val.empty?
+				err.add(blank_error)
+			end
+
+			# done
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin/symbol.rb

@@ -0,0 +1,64 @@
+# typed: strict
+
+module DataModel
+	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: []
+		end
+
+		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+
+			# optional & missing
+			if args.optional && val.nil?
+				return [val, err]
+			end
+
+			if !args.optional && val.nil?
+				err.add(missing_error(Symbol))
+				return [val, err]
+			end
+
+			# type error
+			if !val.is_a?(Symbol) && !coerce
+				err.add(type_error(Symbol, val))
+				return [val, err]
+			end
+
+			# attempt coercion
+			if !val.is_a?(Symbol) && coerce
+				if val.is_a?(String)
+					val = val.intern
+				elsif val.respond_to?(:to_sym)
+					val = T.unsafe(val).to_sym
+				else
+					err.add(coerce_error(Symbol, 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))
+				return [val, err]
+			end
+
+			# exclusion
+			if args.excluded.any? && args.excluded.include?(val)
+				err.add(exclusion_error(args.excluded))
+				return [val, err]
+			end
+
+			# done
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin/time.rb

@@ -0,0 +1,60 @@
+# typed: strict
+
+module DataModel
+	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
+		end
+
+		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(val, coerce: false)
+			args = Arguments.new(type_args)
+			err = Error.new
+
+			# missing, but allowed, don't do any more checks
+			if val.nil? && args.optional
+				return [val, err]
+			end
+
+			# missing, but not allowed, don't do any more checks
+			if val.nil?
+				err.add(missing_error(Time))
+				return [val, err]
+			end
+
+			# coercion is enabled, and the value is a string, try to parse it
+			if val.is_a?(String) && coerce
+				begin
+					val = Time.parse(val)
+				rescue ArgumentError
+					err.add(type_error(Time, 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))
+				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)
+				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)
+				err.add(error)
+			end
+
+			return [val, err]
+		end
+	end
+end

data/lib/data_model/builtin.rb

@@ -0,0 +1,23 @@
+# typed: strict
+
+module DataModel
+	module Builtin
+		extend T::Sig
+
+		sig { returns(TTypeMap) }
+		def self.types
+			{
+				hash: Builtin::Hash,
+				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
+			}
+		end
+	end
+end

data/lib/data_model/error.rb

@@ -0,0 +1,107 @@
+# typed: strict
+
+module DataModel
+	# Error is a class that holds errors.
+	class Error
+		extend T::Sig
+
+		TErrorList = T.type_alias { T::Array[TError] }
+		TErrorMap = T.type_alias { T::Hash[Symbol, TErrorList] }
+
+		sig { void }
+		def initialize
+			@base = T.let([], TErrorList)
+			@children = T.let({}, TErrorMap)
+		end
+
+		# errors related to the object as a whole
+		sig { returns(TErrorList) }
+		def base
+			return @base
+		end
+
+		# errors related children
+		sig { returns(TErrorMap) }
+		def children
+			return @children
+		end
+
+		# all errors
+		sig { returns(TErrorMap) }
+		def all
+			return children.merge(base:)
+		end
+
+		alias to_h all
+
+		# Returns true if any errors are present.
+		sig { params(blk: T.nilable(T.proc.params(error: TError).returns(T::Boolean))).returns(T::Boolean) }
+		def any?(&blk)
+			if !blk
+				return !@base.empty? || !@children.empty?
+			end
+
+			any = T.let(false, T::Boolean)
+
+			for error_list in all.values
+				any = error_list.any?(&blk)
+				if any
+					break
+				end
+			end
+
+			return any
+		end
+
+		sig { returns(T::Boolean) }
+		def empty?
+			!any?
+		end
+
+		# Add an error to the error list.
+		sig { params(err: TError, child: T.nilable(T.any(Symbol, T::Array[Symbol]))).void }
+		def add(err, child: nil)
+			if child.is_a?(Array)
+				child = child.join(".").to_sym
+			end
+
+			if child == :base
+				raise "child errors may not be named :base"
+			end
+
+			errs = child ? @children[child] ||= [] : @base
+			errs.push(err)
+		end
+
+		sig { params(name: Symbol, child: Error).void }
+		def merge_child(name, child)
+			if !child.any?
+				return
+			end
+
+			for (key, error_list) in child.all
+				for error in error_list
+					add(error, child: [name, key])
+				end
+			end
+		end
+
+		sig { params(blk: T.proc.params(context: Object, type: Symbol).returns(Object)).void }
+		def transform_context(&blk)
+			for error in @base
+				key, context = error
+				error[1] = blk.call(context, key)
+			end
+		end
+
+		sig { params(blk: T.proc.params(context: Object, type: Symbol).returns(Object)).void }
+		def transform_child_context(&blk)
+			for error_list in @children.values
+				for error in error_list
+					key, context = error
+					error[1] = blk.call(context, key)
+				end
+			end
+		end
+	end
+end