data_model 0.0.1 → 0.2.0

data/lib/data_model/errors.rb

@@ -0,0 +1,296 @@
+# typed: strict
+
+module DataModel
+	# Provide Error building functionality as a mixin
+	module Errors
+		include Kernel
+		extend T::Sig
+
+		TTemporal = T.type_alias { T.any(::Date, ::Time, ::DateTime) }
+
+		## Constructors
+
+		# Type error applies when a value is not of the expected type
+		sig { params(cls: T.class_of(Object), value: Object).returns(TError) }
+		def type_error(cls, value)
+			[:type, [cls, value]]
+		end
+
+		# Coerce error applies when a value cannot be coerced to the expected type
+		sig { params(cls: T.class_of(Object), value: Object).returns(TError) }
+		def coerce_error(cls, value)
+			[:coerce, [cls, value]]
+		end
+
+		# Missing error applies when a value is missing
+		sig { params(cls: T.class_of(Object)).returns(TError) }
+		def missing_error(cls)
+			[:missing, cls]
+		end
+
+		# Inclusion error applies when a value is not in a set of allowed values
+		sig { params(set: T::Array[T.any(Symbol, String)]).returns(TError) }
+		def inclusion_error(set)
+			[:inclusion, set]
+		end
+
+		# Exclusive error applies when a value is in a set of disallowed values
+		sig { params(set: T::Array[T.any(Symbol, String)]).returns(TError) }
+		def exclusion_error(set)
+			[:exclusion, set]
+		end
+
+		# Blank error applies when a value is blank
+		sig { returns(TError) }
+		def blank_error
+			[:blank, nil]
+		end
+
+		# Extra keys error applies when a hash has extra keys
+		sig { params(keys: T::Array[Symbol]).returns(TError) }
+		def extra_keys_error(keys)
+			[:extra_keys, keys]
+		end
+
+		# Min applies when value is less then the minimum
+		sig { params(min: Numeric, val: Numeric).returns(TError) }
+		def min_error(min, val)
+			[:min, [min, val]]
+		end
+
+		# Max applies when value is less then the minimum
+		sig { params(min: Numeric, val: Numeric).returns(TError) }
+		def max_error(min, val)
+			[:max, [min, val]]
+		end
+
+		# Earliest applies when value is earlier then earliest
+		sig { params(earliest: TTemporal, val: TTemporal).returns(TError) }
+		def earliest_error(earliest, val)
+			[:earliest, [earliest, val]]
+		end
+
+		# Latest applies when value is earlier then earliest
+		sig { params(latest: TTemporal, val: TTemporal).returns(TError) }
+		def latest_error(latest, val)
+			[:latest, [latest, val]]
+		end
+
+		# Format applies when value does not match a format
+		sig { params(format: Object, val: String).returns(TError) }
+		def format_error(format, val)
+			[:format, [format, val]]
+		end
+
+		## Messages
+
+		# Generate a message for a type error
+		sig { params(cls: T.class_of(Object), value: Object).returns(String) }
+		def type_error_message(cls, value)
+			"#{value.inspect} is not a #{cls.name}, it is a #{value.class.name}"
+		end
+
+		# Generate a message for a coerce error
+		sig { params(cls: T.class_of(Object), value: Object).returns(String) }
+		def coerce_error_message(cls, value)
+			"cannot be coerced to #{cls.name}, it is a #{value.class.name}"
+		end
+
+		# Generate a message for a missing error
+		sig { params(cls: T.class_of(Object)).returns(String) }
+		def missing_error_message(cls)
+			"missing value, expected a #{cls.name}"
+		end
+
+		# Generate a message for an inclusion error
+		sig { params(set: T::Array[Symbol]).returns(String) }
+		def inclusion_error_message(set)
+			"must be one of #{set.join(', ')}"
+		end
+
+		# Generate a message for an exclusion error
+		sig { params(set: T::Array[Symbol]).returns(String) }
+		def exclusion_error_message(set)
+			"must not be one of #{set.join(', ')}"
+		end
+
+		# Generate a message for a blank error
+		sig { returns(String) }
+		def blank_error_message
+			"cannot be blank"
+		end
+
+		# Generate a message for an extra keys error
+		sig { params(keys: T::Array[Symbol]).returns(String) }
+		def extra_keys_error_message(keys)
+			"more elements found in closed hash then specified children: #{keys.join(', ')}"
+		end
+
+		# Generate a message for a min error
+		sig { params(min: Numeric, val: Numeric).returns(String) }
+		def min_error_message(min, val)
+			"value is less than the minimum of #{min}, it is #{val}"
+		end
+
+		# Generate a message for a min error
+		sig { params(max: Numeric, val: Numeric).returns(String) }
+		def max_error_message(max, val)
+			"value is more than the maximum of #{max}, it is #{val}"
+		end
+
+		# Generate a message for a value that occurs earlier then the specified earliest point
+		sig { params(earliest: TTemporal, val: TTemporal).returns(String) }
+		def early_error_message(earliest, val)
+			"value #{val} is before #{earliest}"
+		end
+
+		# Generate a message for a value that occurs later then the specified latest  point
+		sig { params(latest: TTemporal, val: TTemporal).returns(String) }
+		def late_error_message(latest, val)
+			"value #{val} is after #{latest}"
+		end
+
+		# Generate a message for a value that does not match the format
+		sig { params(format: Object, val: String).returns(String) }
+		def format_error_message(format, val)
+			"value #{val} does not match format #{format}"
+		end
+
+		## API
+		# TODO: split this file
+
+		TErrorMessageBuilder = T.type_alias { T.proc.params(ctx: T.untyped).returns(String) }
+
+		# Register a custom error message for use with custom errors
+		sig { params(type: Symbol, block: TErrorMessageBuilder).void }
+		def register_error_message(type, &block)
+			error_message_builders[type] = block
+		end
+
+		TErrorMessages = T.type_alias { T::Hash[Symbol, TErrorMessageBuilder] }
+		TClassValueCtx = T.type_alias { [T.class_of(Object), Object] }
+		TClassCtx = T.type_alias { T.class_of(Object) }
+		TSetCtx = T.type_alias { T::Array[Symbol] }
+		TWithinCtx = T.type_alias { [Numeric, Numeric] }
+		TWithinTemporalCtx = T.type_alias { [TTemporal, TTemporal] }
+		TFormatCtx = T.type_alias { [Object, String] }
+
+		# Get the error message builders
+		sig { returns(TErrorMessages) }
+		def error_message_builders
+			if @error_messages.nil?
+				@error_messages ||= T.let({}, T.nilable(TErrorMessages))
+
+				# wire up defaults
+
+				register_error_message(:type) do |ctx|
+					cls, val = T.let(ctx, TClassValueCtx)
+					type_error_message(cls, val)
+				end
+
+				register_error_message(:coerce) do |ctx|
+					cls, val = T.let(ctx, TClassValueCtx)
+					coerce_error_message(cls, val)
+				end
+
+				register_error_message(:missing) do |ctx|
+					cls = T.let(ctx, TClassCtx)
+					missing_error_message(cls)
+				end
+
+				register_error_message(:inclusion) do |ctx|
+					set = T.let(ctx, TSetCtx)
+					inclusion_error_message(set)
+				end
+
+				register_error_message(:exclusion) do |ctx|
+					set = T.let(ctx, TSetCtx)
+					exclusion_error_message(set)
+				end
+
+				register_error_message(:extra_keys) do |ctx|
+					set = T.let(ctx, TSetCtx)
+					extra_keys_error_message(set)
+				end
+
+				register_error_message(:min) do |ctx|
+					min, val = T.let(ctx, TWithinCtx)
+					min_error_message(min, val)
+				end
+
+				register_error_message(:max) do |ctx|
+					max, val = T.let(ctx, TWithinCtx)
+					max_error_message(max, val)
+				end
+
+				register_error_message(:earliest) do |ctx|
+					earliest, val = T.let(ctx, TWithinTemporalCtx)
+					early_error_message(earliest, val)
+				end
+
+				register_error_message(:latest) do |ctx|
+					latest, val = T.let(ctx, TWithinTemporalCtx)
+					late_error_message(latest, val)
+				end
+
+				register_error_message(:blank) do
+					blank_error_message
+				end
+
+				register_error_message(:format) do |ctx|
+					format, val = T.let(ctx, TFormatCtx)
+					format_error_message(format, val)
+				end
+			end
+
+			@error_messages
+		end
+
+		# Build the error message for a given error
+		sig { params(error: TError).returns(String) }
+		def error_message(error)
+			type = T.let(error[0], Symbol)
+			ctx = T.let(error[1], T.untyped)
+
+			builder = error_message_builders[type]
+
+			if builder.nil?
+				raise "no error message builder for #{type}"
+			end
+
+			builder.call(ctx)
+		end
+
+		# TODO: separate builders from other use cases for this mixin
+		# Build error messages from error object
+		sig { params(error: Error).returns(T::Hash[Symbol, T::Array[String]]) }
+		def error_messages(error)
+			error.to_h.transform_values do |error_list|
+				error_list.map { |e| error_message(e) }
+			end
+		end
+
+		sig { params(error: Error, from: T.class_of(Object), to: T.class_of(Object)).void }
+		def set_error_class(error, from, to)
+			error.transform_context do |ctx, type|
+				case type
+				when :type, :coerce
+					cls, val = T.cast(ctx, TClassValueCtx)
+					if cls == from
+						[to, val]
+					else
+						[cls, val]
+					end
+				when :missing
+					if ctx == from
+						[to, val]
+					else
+						[cls, val]
+					end
+				else
+					[cls, val]
+				end
+			end
+		end
+	end
+end

data/lib/data_model/fixtures/array.rb

@@ -0,0 +1,61 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Array
+		extend self
+		extend T::Sig
+		include Fixtures
+
+		sig { returns(Example) }
+		def string_array
+			Example.new(
+				[:array, :string],
+				variants: {
+					strings: ["a", "b", "c"],
+					string: ["a", ["a"]],
+					number: [1, ["1"]],
+					missing: nil,
+					numbers: [[1, 2, 3], ["1", "2", "3"]],
+					other_type: Object.new
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def wrapping_string_array
+			Example.new(
+				[:array, { wrap_single_value: true }, :string],
+				variants: {
+					strings: ["a", "b", "c"],
+					string: ["a", ["a"]],
+					number: [1, ["1"]],
+					missing: nil,
+					numbers: [[1, 2, 3], ["1", "2", "3"]],
+					other_type: Object.new
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional_string_array
+			Example.new(
+				[:array, { optional: true }, :string],
+				variants: {
+					strings: ["a", "b", "c"],
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def array_optional_string
+			Example.new(
+				[:array, [:string, { optional: true }]],
+				variants: {
+					optional_strings: ["a", nil, "c"],
+					numbers: [1, nil, 3]
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/big_decimal.rb

@@ -0,0 +1,55 @@
+# typed: strict
+
+require "bigdecimal/util"
+
+module DataModel
+	module Fixtures::BigDecimal
+		include Fixtures
+		extend T::Sig
+		extend self
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:decimal],
+				variants: {
+					valid: 5.to_d,
+					missing: nil,
+					string: ["5", 5.to_d]
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:decimal, { optional: true }],
+				variants: {
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def min
+			Example.new(
+				[:decimal, { min: 5 }],
+				variants: {
+					bigger: 6.to_d,
+					smaller: 4.to_d
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def max
+			Example.new(
+				[:decimal, { max: 5 }],
+				variants: {
+					bigger: 6.to_d,
+					smaller: 4.to_d
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/boolean.rb

@@ -0,0 +1,35 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Boolean
+		extend T::Sig
+		extend self
+		include Fixtures
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:boolean],
+				variants: {
+					true: true,
+					false: false,
+					string: ["true", true],
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:boolean, { optional: true }],
+				variants: {
+					true: true,
+					false: false,
+					string: "true",
+					missing: nil
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/date.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Date
+		extend T::Sig
+		extend self
+		include Fixtures
+
+		sig { returns(::Date) }
+		def earliest_date
+			return ::Date.today - 1
+		end
+
+		sig { returns(::Date) }
+		def latest_date
+			return ::Date.today + 1
+		end
+
+		sig { returns(T::Hash[Symbol, Object]) }
+		def variants
+			today = ::Date.today
+
+			{
+				date: today,
+				string: [today.to_s, today],
+				invalid: "invalid",
+				early: earliest_date - 1,
+				late: latest_date + 1,
+				missing: nil
+			}
+		end
+
+		sig { returns(Example) }
+		def simple
+			Example.new([:date], variants:)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new([:date, { optional: true }], variants:)
+		end
+
+		sig { returns(Example) }
+		def earliest
+			Example.new([:date, { earliest: earliest_date }], variants:)
+		end
+
+		sig { returns(Example) }
+		def latest
+			Example.new([:date, { latest: latest_date }], variants:)
+		end
+	end
+end

data/lib/data_model/fixtures/example.rb

@@ -0,0 +1,29 @@
+# typed: strict
+
+module DataModel
+	class Fixtures::Example
+		extend T::Sig
+
+		sig { params(schema: TSchema, variants: T::Hash[::Symbol, Object]).void }
+		def initialize(schema, variants:)
+			@schema = schema
+			@variants = variants
+		end
+
+		sig { returns(Model) }
+		def model
+			DataModel.define(@schema)
+		end
+
+		sig { params(type: Symbol).returns([Model, Object]) }
+		def [](type)
+			if !@variants.key?(type)
+				raise "#{type} is not a defined variant: #{@variants}"
+			end
+
+			result = @variants.fetch(type)
+
+			return [model, result]
+		end
+	end
+end

data/lib/data_model/fixtures/float.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Float
+		include Fixtures
+		extend T::Sig
+		extend self
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:float],
+				variants: {
+					valid: 5.0,
+					missing: nil,
+					string: ["5", 5.0]
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:float, { optional: true }],
+				variants: {
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def min
+			Example.new(
+				[:float, { min: 5 }],
+				variants: {
+					bigger: 6.0,
+					smaller: 4.0
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def max
+			Example.new(
+				[:float, { max: 5.0 }],
+				variants: {
+					bigger: 6.0,
+					smaller: 4.0
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/hash.rb

@@ -0,0 +1,66 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Hash
+		include Fixtures
+		extend T::Sig
+		extend self
+
+		TContact = T.type_alias { T::Hash[Symbol, T.untyped] }
+
+		sig { returns(TContact) }
+		def example_contact
+			{
+				first_name: "foo",
+				last_name: "bar",
+				email: "foo@bar.com"
+			}
+		end
+
+		sig { returns(Example) }
+		def contact
+			Example.new(
+				[:hash,
+					[:first_name, :string],
+					[:last_name, :string, { optional: true }],
+					[:email, :string]],
+				variants: {
+					valid: example_contact,
+					missing: nil,
+					coercible: example_contact.to_a,
+					missing_email: example_contact.tap { |h| T.cast(h, TContact).delete(:email) },
+					invalid_field: example_contact.merge(email: 123),
+					other_type: []
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional_contact
+			Example.new(
+				[:hash, { optional: true },
+					[:first_name, :string],
+					[:last_name, :string, { optional: true }],
+					[:email, :string]],
+				variants: {
+					valid: example_contact,
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def closed_contact
+			Example.new(
+				[:hash, { open: false },
+					[:first_name, :string],
+					[:last_name, :string, { optional: true }],
+					[:email, :string]],
+				variants: {
+					valid: example_contact,
+					extra_keys: example_contact.merge(extra: "keys")
+				},
+			)
+		end
+	end
+end

data/lib/data_model/fixtures/integer.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+module DataModel
+	module Fixtures::Integer
+		include Fixtures
+		extend T::Sig
+		extend self
+
+		sig { returns(Example) }
+		def simple
+			Example.new(
+				[:integer],
+				variants: {
+					valid: 5,
+					missing: nil,
+					string: ["5", 5]
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def optional
+			Example.new(
+				[:integer, { optional: true }],
+				variants: {
+					missing: nil
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def min
+			Example.new(
+				[:integer, { min: 5 }],
+				variants: {
+					bigger: 6,
+					smaller: 4
+				},
+			)
+		end
+
+		sig { returns(Example) }
+		def max
+			Example.new(
+				[:integer, { max: 5 }],
+				variants: {
+					bigger: 6,
+					smaller: 4
+				},
+			)
+		end
+	end
+end