data_model 0.0.1 → 0.1.0

data/lib/data_model/fixtures/string.rb

@@ -0,0 +1,77 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::String
+		extend self
+		extend T::Sig
+		include Fixtures
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:string],
+				variants: {
+					valid: "valid",
+					other_type: 22,
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:string, { optional: true }],
+				variants: {
+					valid: "valid",
+					blank: "",
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def inclusion
+			Example.new(
+				[:string, { included: ["valid"] }],
+				variants: {
+					valid: "valid",
+					outside: "invalid"
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def exclusion
+			Example.new(
+				[:string, { excluded: ["invalid"] }],
+				variants: {
+					valid: "valid",
+					inside: "invalid"
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def allow_blank
+			Example.new(
+				[:string, { allow_blank: true }],
+				variants: {
+					blank: "",
+					not_blank: "content",
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def dont_allow_blank
+			Example.new(
+				[:string, { allow_blank: false }],
+				variants: {
+					blank: ""
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/symbol.rb

@@ -0,0 +1,56 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Symbol
+		extend self
+		include Fixtures
+		extend T::Sig
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:symbol],
+				variants: {
+					valid: :valid,
+					coerce: "valid",
+					missing: nil,
+					other_type: 22
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:symbol, { optional: true }],
+				variants: {
+					missing: nil,
+					present: :valid,
+					number: 22
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def inclusion
+			Example.new(
+				[:symbol, { included: [:valid] }],
+				variants: {
+					valid: :valid,
+					outside: :outside
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def exclusion
+			Example.new(
+				[:symbol, { excluded: [:invalid] }],
+				variants: {
+					valid: :valid,
+					inside: :invalid
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/time.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Time
+		extend T::Sig
+		extend self
+		include Fixtures
+
+		sig { returns(::Time) }
+		def earliest_time
+			return ::Time.now - 1
+		end
+
+		sig { returns(::Time) }
+		def latest_time
+			return ::Time.now + 1
+		end
+
+		sig { returns(T::Hash[Symbol, Object]) }
+		def variants
+			now = ::Time.now
+
+			{
+				time: now,
+				string: [now.strftime("%H:%M:%S.%6N"), now],
+				invalid: "invalid",
+				early: earliest_time - 1,
+				late: latest_time + 1,
+				missing: nil
+			}
+		end
+
+		sig { returns(Example) }
+		def simple
+			Example.new([:time], variants:)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new([:time, { optional: true }], variants:)
+		end
+
+		sig { returns(Example) }
+		def earliest
+			Example.new([:time, { earliest: earliest_time }], variants:)
+		end
+
+		sig { returns(Example) }
+		def latest
+			Example.new([:time, { latest: latest_time }], variants:)
+		end
+	end
+end

data/lib/data_model/logging.rb

@@ -0,0 +1,23 @@
+# typed: strict
+
+require "logger"
+
+module DataModel
+	module Logging
+		extend T::Sig
+		include Kernel
+
+		sig { returns(Logger) }
+		def log
+			target = T.let(respond_to?(:name) ? self : self.class, T.any(Class, Module))
+
+			logger = Logger.new(
+				STDERR,
+				level: Logger::FATAL,
+				progname: target.name,
+			)
+
+			return @log ||= T.let(logger, T.nilable(Logger))
+		end
+	end
+end

data/lib/data_model/model.rb

@@ -1,54 +1,31 @@
-module DataModel
-	module Model
-		extend self
-
-		def defaults
-			{
-				# name of validator if a child, and validating a named property
-				property: nil,
+# typed: strict
 
-				# context passed to read and write
-				config: {},
-				types: nil,
-				children: [],
-
-				# default writer
-				write: ->(val) { val }
-			}
-		end
+module DataModel
+	class Model
+		extend T::Sig
 
-		def validate!(model)
-			model => {
-				property:, config:, types:,
-				read: Proc, write: Proc,
-				children: Array,
-			}
+		sig { params(schema: TSchema, type: Type).void }
+		def initialize(schema, type)
+			@schema = schema
+			@type = type
 		end
 
-		def read(model, data)
-			validate! model
-			invoke(model, :read, data)
-		end
+		sig { returns(TSchema) }
+		attr_reader :schema
 
-		def write(model, data)
-			validate! model
-			invoke(model, :write, data)
+		# Validate data against the model. This will return true if the data is valid,
+		# or false if it is not. If it is not valid, it will raise an exception.
+		sig { params(data: TData).returns(Error) }
+		def validate(data)
+			_, err = @type.read(data)
+			return err
 		end
 
-		private
-
-		def invoke(model, action, data)
-			fn = model.fetch(action)
-
-			case fn.arity
-			when 1
-				fn.call(data)
-			when 2
-				ctx = model.slice(:config, :types, :children)
-				fn.call(data, ctx)
-			else
-				raise "expected an arity of 1 or 2, got: #{fn.arity}"
-			end
+		# Read data with the model. This will return a tuple of [data, error]
+		sig { params(data: TData).returns([TData, Error]) }
+		def coerce(data)
+			result = @type.read(data, coerce: true)
+			return result
 		end
 	end
 end

data/lib/data_model/scanner.rb

@@ -1,67 +1,103 @@
+# typed: strict
+
+# Scan a schema into a struct that can be inspected to construct a model validator
+#
+# schema eg:
+# 	[:string, { min: 1, max: 10}]
+# 	[:tuple, { title: "coordinates" }, :double, :double]
+# 	[:hash, { open: false },
+# 		[:first_name, :string]
+# 		[:last_name, :string]]
+#
+# first param is type, which is a key lookup in the registry
+# second param is args, this is optional, but is a way to configure a type
+# rest are type params. these are used to configure a type at the point of instantiation. Think of them as generics.
+#
+# params are either
+# 	symbol, for example tuple types
+#   array, for object types to configure child properties.
 module DataModel
 	module Scanner
+		include Kernel
+		include Logging
+
+		extend T::Sig
 		extend self
 
-		def scan(schema, registry = Registry.instance)
-			start = { validator: nil, property: nil, state: :start }
-			result = schema.each_with_index.reduce(start) do |context, (token, pos)|
-				context => {state:, validator:, property:}
-				peek = schema[pos + 1]
-
-				# detect named validators, a name could be any type so cannot be detected
-				# by ruby type and state. detect name by ensuring we are at the start
-				# of scanning, and the next element is a valid type.
-				if state == :start && registry.type?(peek)
-					context.merge(
-						property: token,
-						state: :named,
-					)
-				else
-					# with the special case of a name aside, we can detect the meaning
-					# of further tokens by their type and scanner state
-					case token
-					when Symbol
-						unless [:start, :named].include?(state)
-							raise "got a symbol at pos #{pos}, but validator already defined"
-						end
-
-						unless registry.type?(token)
-							raise "expected a type in pos #{pos}, but found #{token.inspect} which is not a registered type"
-						end
-
-						context.merge(
-							validator: registry.type(token, property),
-							state: :defined,
-						)
-
-					when Hash
-						unless state == :defined
-							raise "got a hash at pos #{pos}, but state is not :defined (#{state.inspect})"
-						end
-
-						context.merge(
-							validator: validator.merge(config: token),
-							state: :configured,
-						)
-
-					when Array
-						unless [:defined, :configured].include?(state)
-							raise "#{schema.inspect} at pos #{pos}: expected (String | Hash | Symbol | Array), got #{token.class.name}"
-						end
-
-						children = token.map { |s| scan(s, registry) }
-
-						context.merge(
-							validator: validator.merge(children:),
-							state: :complete,
-						)
-					else
-						raise "got token #{token.inspect} at position #{pos} which was unexpected given the scanner was in a state of #{state}"
+		class Node < T::Struct
+			prop :type, Symbol, default: :nothing
+			prop :args, T::Hash[Symbol, Object], default: {}
+			prop :params, T::Array[Object], default: []
+		end
+
+		# Scan a schema, which is defined as a data structure, into a struct that is easier to work with.
+		# "Syntax" validations will be enforced at this level.
+		sig { params(schema: TSchema, registry: DataModel::TypeRegistry).returns(Node) }
+		def scan(schema, registry = TypeRegistry.instance)
+			# state:
+			# 	nil (start) -> :type (we have a type) -> :args (we have arguments)
+			scanned = Node.new
+			state = T.let(nil, T.nilable(Symbol))
+
+			log.debug("scanning schema: #{schema.inspect}")
+
+			for pos in (0...schema.length)
+				token = schema[pos]
+				dbg = "pos: #{pos}, token: #{token.inspect}, state: #{state.inspect}"
+				log.debug(dbg)
+
+				# detect optional args missing
+				if !token.is_a?(Hash) && state == :type
+					log.debug("detected optional args missing at (#{dbg}), moving state to :args")
+
+					# move state forward
+					state = :args
+				end
+
+				# we are just collecting params at this point
+				if state == :args
+
+					if !token.is_a?(Array) && !token.is_a?(Symbol)
+						raise "expected type params at (#{dbg}), which should be either a symbol or an array"
 					end
+
+					scanned.params << token
+					log.debug("collecting params at (#{dbg})")
+
+					next
+				end
+
+				# we can determine meaning based on type and state
+				case token
+				when Symbol
+					if !state.nil?
+						raise "got a symbol at(#{dbg}), but validator already defined"
+					end
+
+					if !registry.type?(token)
+						# TODO: need a much better error here, this is what people see when registration is not there
+						raise "expected a type in (#{dbg}), but found #{token.inspect} which is not a registered type"
+					end
+
+					scanned.type = token
+					state = :type
+					log.debug("got a symbol, determined token is a type at (#{dbg}), moving state to :type")
+
+				when Hash
+					if state != :type
+						raise "got a hash at (#{dbg}), but state is not :type (#{state.inspect})"
+					end
+
+					scanned.args = token
+					state = :args
+					log.debug("got a hash, determined token is args at (#{dbg}), moving state to :args")
+
+				else
+					raise "got token #{token.inspect} at (#{dbg}) which was unexpected given the scanner was in a state of #{state}"
 				end
 			end
 
-			result.fetch(:validator)
+			return scanned
 		end
 	end
 end

data/lib/data_model/testing/minitest.rb

@@ -0,0 +1,79 @@
+# typed: strict
+
+require "minitest/assertions"
+
+module DataModel
+	module Testing::Minitest
+		extend T::Sig
+		include Minitest::Assertions
+		include Kernel
+
+		sig { params(err: Error, type: Symbol, key: T.nilable(Symbol)).void }
+		def assert_child_model_error(err, type, key = nil)
+			assert(err.children.any?, "validate was successful, but should not have been")
+
+			for k in key ? [key] : err.children.keys
+				found = err.children[k]&.any? { |(t, _ctx)| t == type }
+				assert(found, "validation was not successful, but #{type} error was not found #{err.inspect}")
+			end
+		end
+
+		sig { params(err: Error, type: Symbol).void }
+		def assert_model_error(err, type)
+			assert(err.base.any?, "validate was successful, but should not have been")
+
+			found = err.base.any? { |(t, _ctx)| t == type }
+
+			assert(found, "validation was not successful, but #{type} error was not found #{err.inspect}")
+		end
+
+		sig { params(err: Error, type: T.nilable(Symbol), key: T.nilable(Symbol)).void }
+		def refute_child_model_error(err, type = nil, key = nil)
+			if !err.any?
+				return
+			end
+
+			if type.nil?
+				refute(err.base.any?, "validation was not successful #{err.inspect}")
+				return
+			end
+
+			for k in key ? [key] : err.children.keys
+				found = err.children[k]&.any? { |(t, _ctx)| t == type }
+				refute(found, "validation was not successful, but #{type} error was not found #{err.inspect}")
+			end
+		end
+
+		sig { params(err: Error, type: T.nilable(Symbol)).void }
+		def refute_model_error(err, type = nil)
+			if !err.any?
+				return
+			end
+
+			if type.nil?
+				refute(err.base.any?, "validation was not successful #{err.inspect}")
+				return
+			end
+
+			found = err.base.any? { |(t, _ctx)| t == type }
+
+			refute(found, "#{type} error was found #{err.inspect}")
+		end
+
+		sig { params(err: Error, type: T.nilable(Symbol)).void }
+		def refute_all_errors(err, type = nil)
+			if !err.any?
+				return
+			end
+
+			if type.nil?
+				refute(err.all.any?, "validation was not successful #{err.inspect}")
+				return
+			end
+
+			found = err.all.any? { |(t, _ctx)| t == type }
+
+			refute(found, "#{type} error was found #{err.inspect}")
+		end
+	end
+end

data/lib/data_model/testing.rb

@@ -0,0 +1,6 @@
+# typed: strict
+
+module DataModel
+	module Testing
+	end
+end

data/lib/data_model/type.rb

@@ -1,48 +1,50 @@
+# typed: strict
+
+# Mixin included on every type. Type::Generic and Type::Parent are higher level specializations.
 module DataModel
-	module Type
-		extend self
+	class Type
+		extend T::Sig
+		extend T::Helpers
 
-		def string
-			{
-				read: lambda do |val|
-					err = {}
+		abstract!
 
-					unless val.is_a? String
-						err[:root] = "#{val} is not a string, it is a #{val.class.name}"
-					end
+		TArguments = T.type_alias { T::Hash[Symbol, T.untyped] }
+		TTypeParams = T.type_alias { T::Array[Object] }
+		TTypeResult = T.type_alias { [Object, Error] }
 
-					[val, err]
-				end
-			}
+		sig { params(args: TArguments, registry: TypeRegistry).void }
+		def initialize(args, registry: TypeRegistry.instance)
+			@type_args = args
+			@type_registry = registry
 		end
 
-		def hash
-			{
-				read: lambda do |val, ctx|
-					err = {}
-					ctx => {config:, children:}
-
-					unless val.is_a? Hash
-						err[:root] = "#{val} is not a hash, it is a #{val.class.name}"
-						return [val, err]
-					end
-
-					# TODO: this needs to be wayyyy better
-					if !config[:open?] && (val.length > children.length)
-						err[:root] = "more elements found in closed hash then specified children"
-					end
-
-					children.each do |child|
-						child => {property:}
-						v, e = Model.read(child, val.fetch(property))
-
-						val = val.merge({ property => v })
-						err[property] = e
-					end
-
-					[val, err]
-				end
-			}
+		sig { returns(TArguments) }
+		attr_reader :type_args
+
+		# configure must be overridden to use params
+		sig { overridable.params(params: TTypeParams).void }
+		def configure(params); end
+
+		# invoke another type by name
+		sig { params(name: Symbol, val: Object, coerce: T::Boolean, args: Type::TArguments, params: T.nilable(TTypeParams)).returns(TTypeResult) }
+		def invoke(name, val, coerce: false, args: {}, params: nil)
+			t = instantiate(name, args:, params:)
+
+			result = t.read(val, coerce:)
+
+			return result
 		end
+
+		# instanciate another type
+		sig { params(name: Symbol, args: Type::TArguments, params: T.nilable(TTypeParams)).returns(Type) }
+		def instantiate(name, args: {}, params: nil)
+			t = @type_registry.type(name, args:, params:)
+
+			return t
+		end
+
+		# default reader
+		sig { abstract.params(data: Object, coerce: T::Boolean).returns(TTypeResult) }
+		def read(data, coerce: false); end
 	end
 end

data/lib/data_model/type_registry.rb

@@ -0,0 +1,68 @@
+# typed: strict
+
+module DataModel
+	# TypeRegistry allows for different type implementations to be used by the scanner.
+	# It also acts as an error message registry, mostly for pragmatic reasons.
+	class TypeRegistry
+		include Errors
+		extend T::Sig
+
+		# Default types that will be used if alternative type map is not given
+		sig { returns(TTypeMap) }
+		def self.default_types
+			Builtin.types
+		end
+
+		# Singleton instance that will be used globally unless instances given
+		sig { params(types: TTypeMap, errors: T.nilable(TErrorMessages)).returns(TypeRegistry) }
+		def self.instance(types: default_types, errors: nil)
+			@instance ||= T.let(new(types:, errors:), T.nilable(TypeRegistry))
+		end
+
+		# Register a type on the global instance
+		sig { params(name: Symbol, type: T.class_of(Type)).void }
+		def self.register(name, type)
+			instance.register(name, type)
+		end
+
+		# Instanciate a new type registry. Default errors will always be used, but additional
+		# errors can be registered.
+		sig { params(types: TTypeMap, errors: T.nilable(TErrorMessages)).void }
+		def initialize(types: self.class.default_types, errors: nil)
+			if errors
+				errors.each { |type, builder| register_error_message(type, &builder) }
+			end
+
+			@types = T.let({}, TTypeMap)
+			types.each { |(name, type)| register(name, type) }
+		end
+
+		# Register a type on this instance
+		sig { params(name: Symbol, type: T.class_of(Type)).void }
+		def register(name, type)
+			@types[name] = type
+		end
+
+		# Check if a type is registered
+		sig { params(name: Symbol).returns(T::Boolean) }
+		def type?(name)
+			@types.key?(name)
+		end
+
+		# Access and configure registered type
+		sig { params(name: Symbol, args: Type::TArguments, params: T.nilable(T::Array[Object])).returns(Type) }
+		def type(name, args: {}, params: nil)
+			if !type?(name)
+				raise "#{name} is not registered as a type"
+			end
+
+			t = @types.fetch(name).new(args, registry: self)
+
+			if params
+				t.configure(params)
+			end
+
+			return t
+		end
+	end
+end