data_model 0.4.0 → 0.5.0

data/lib/data_model/fixtures/float.rb

@@ -1,12 +1,11 @@
-# typed: strict
-
 module DataModel
+	# Test data for float schemas
 	module Fixtures::Float
 		include Fixtures
-		extend T::Sig
 		extend self
 
-		sig { returns(Example) }
+		# a simple float example
+		# @return [Example] the example
 		def simple
 			Example.new(
 				[:float],
@@ -18,7 +17,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a float example that is optional
+		# @return [Example] the example
 		def optional
 			Example.new(
 				[:float, { optional: true }],
@@ -28,7 +28,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a float example where the minimum value is 5
+		# @return [Example] the example
 		def min
 			Example.new(
 				[:float, { min: 5 }],
@@ -39,7 +40,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a float example where the maximum value is 5
+		# @return [Example] the example
 		def max
 			Example.new(
 				[:float, { max: 5.0 }],

data/lib/data_model/fixtures/hash.rb

@@ -1,14 +1,11 @@
-# typed: strict
-
 module DataModel
+	# Test data for hash schemas
 	module Fixtures::Hash
 		include Fixtures
-		extend T::Sig
 		extend self
 
-		TContact = T.type_alias { T::Hash[Symbol, T.untyped] }
-
-		sig { returns(TContact) }
+		# hash data conforming to the contact schema
+		# @return [Hash{Symbol => String}] the hash
 		def example_contact
 			{
 				first_name: "foo",
@@ -17,7 +14,20 @@ module DataModel
 			}
 		end
 
-		sig { returns(Example) }
+		# alternate hash syntax for when you want to type keys and values
+		# @return [Example] the example
+		def dictionary
+			Example.new(
+				[:hash, [symbol: :string]],
+				variants: {
+					valid: { foo: "bar" },
+					invalid: { foo: 123 }
+				},
+			)
+		end
+
+		# hash contact example
+		# @return [Example] the example
 		def contact
 			Example.new(
 				[:hash,
@@ -28,14 +38,15 @@ module DataModel
 					valid: example_contact,
 					missing: nil,
 					coercible: example_contact.to_a,
-					missing_email: example_contact.tap { |h| T.cast(h, TContact).delete(:email) },
+					missing_email: example_contact.tap { |h| h.delete(:email) },
 					invalid_field: example_contact.merge(email: 123),
 					other_type: []
 				},
 			)
 		end
 
-		sig { returns(Example) }
+		# hash contact example that is optional
+		# @return [Example] the example
 		def optional_contact
 			Example.new(
 				[:hash, { optional: true },
@@ -49,7 +60,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# hash contact example that is closed to extra keys
+		# @return [Example] the example
 		def closed_contact
 			Example.new(
 				[:hash, { open: false },

data/lib/data_model/fixtures/integer.rb

@@ -1,12 +1,11 @@
-# typed: strict
-
 module DataModel
+	# Test data for integer schemas
 	module Fixtures::Integer
 		include Fixtures
-		extend T::Sig
 		extend self
 
-		sig { returns(Example) }
+		# simple integer example
+		# @return [Hash{Symbol => untyped}] the variants used by each example
 		def simple
 			Example.new(
 				[:integer],
@@ -18,7 +17,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# integer example that is optional
+		# @return [Example] the example
 		def optional
 			Example.new(
 				[:integer, { optional: true }],
@@ -28,7 +28,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# integer example that has a minimum value
+		# @return [Example] the example
 		def min
 			Example.new(
 				[:integer, { min: 5 }],
@@ -39,7 +40,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# integer example that has a maximum value
+		# @return [Example] the example
 		def max
 			Example.new(
 				[:integer, { max: 5 }],

data/lib/data_model/fixtures/numeric.rb

@@ -0,0 +1,31 @@
+require "bigdecimal/util"
+
+module DataModel
+	# test fixtures for object type
+	module Fixtures::Numeric
+		extend self
+		include Fixtures
+
+		def variants
+			{
+				missing: nil,
+				integer: 1,
+				float: 1.0,
+				decimal: 1.0.to_d,
+				string: ["1", 1]
+			}
+		end
+
+		# a simple numeric example
+		# @return [Example] the example
+		def simple
+			Example.new([:numeric], variants:)
+		end
+
+		# a numeric example that is optional
+		# @return [Example] the example
+		def optional
+			Example.new([:numeric, { optional: true }], variants:)
+		end
+	end
+end

data/lib/data_model/fixtures/object.rb

@@ -0,0 +1,27 @@
+module DataModel
+	# test fixtures for object type
+	module Fixtures::Object
+		extend self
+		include Fixtures
+
+		def variants
+			{
+				missing: nil,
+				integer: 1,
+				string: "string"
+			}
+		end
+
+		# a simple object example
+		# @return [Example] the example
+		def simple
+			Example.new([:object], variants:)
+		end
+
+		# a object example that is optional
+		# @return [Example] the example
+		def optional
+			Example.new([:object, { optional: true }], variants:)
+		end
+	end
+end

data/lib/data_model/fixtures/or.rb

@@ -0,0 +1,29 @@
+module DataModel
+	# test fixtures for object type
+	module Fixtures::Or
+		extend self
+		include Fixtures
+
+		def variants
+			{
+				missing: nil,
+				integer: 1,
+				int_array: [1],
+				string: ["1", 1],
+				float: 1.0
+			}
+		end
+
+		# a simple numeric example, integer or integer array
+		# @return [Example] the example
+		def simple
+			Example.new([:or, :integer, [:array, :integer]], variants:)
+		end
+
+		# a numeric example that is optional
+		# @return [Example] the example
+		def optional
+			Example.new([:or, { optional: true }, :integer, [:array, :integer]], variants:)
+		end
+	end
+end

data/lib/data_model/fixtures/string.rb

@@ -1,12 +1,11 @@
-# typed: strict
-
 module DataModel
+	# Test data for string schemas
 	module Fixtures::String
 		extend self
-		extend T::Sig
 		include Fixtures
 
-		sig { returns(Example) }
+		# a simple string example
+		# @return [Example] the example
 		def simple
 			Example.new(
 				[:string],
@@ -18,7 +17,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# an email string example
+		# @return [Example] the example
 		def email
 			Example.new(
 				[:string, { format: "@" }],
@@ -29,29 +29,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
-		def email_regexp
-			Example.new(
-				[:string, { format: /@/ }],
-				variants: {
-					valid: "foo@bar.com",
-					invalid: "invalid"
-				},
-			)
-		end
-
-		sig { returns(Example) }
-		def email_proc
-			Example.new(
-				[:string, { format: ->(val) { val.match?(/@/) } }],
-				variants: {
-					valid: "foo@bar.com",
-					invalid: "invalid"
-				},
-			)
-		end
-
-		sig { returns(Example) }
+		# a string example that is optional
+		# @return [Example] the example
 		def optional
 			Example.new(
 				[:string, { optional: true }],
@@ -63,7 +42,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a string example where "valid" is the only allowed String
+		# @return [Example] the example
 		def inclusion
 			Example.new(
 				[:string, { included: ["valid"] }],
@@ -74,7 +54,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a string example where "invalid" is the only disallowed String
+		# @return [Example] the example
 		def exclusion
 			Example.new(
 				[:string, { excluded: ["invalid"] }],
@@ -85,7 +66,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a string example where blank strings are allowed
+		# @return [Example] the example
 		def allow_blank
 			Example.new(
 				[:string, { allow_blank: true }],
@@ -97,7 +79,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a string example where blank strings are not allowed
+		# @return [Example] the example
 		def dont_allow_blank
 			Example.new(
 				[:string, { allow_blank: false }],

data/lib/data_model/fixtures/symbol.rb

@@ -1,12 +1,11 @@
-# typed: strict
-
 module DataModel
+	# Test data around symbol schemas
 	module Fixtures::Symbol
 		extend self
 		include Fixtures
-		extend T::Sig
 
-		sig { returns(Example) }
+		# a simple symbol example
+		# @return [Example] the example
 		def simple
 			Example.new(
 				[:symbol],
@@ -19,7 +18,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a symbol example that is optional
+		# @return [Example] the example
 		def optional
 			Example.new(
 				[:symbol, { optional: true }],
@@ -31,7 +31,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a symbol example where :valid is the only allowed Symbol
+		# @return [Example] the example
 		def inclusion
 			Example.new(
 				[:symbol, { included: [:valid] }],
@@ -42,7 +43,8 @@ module DataModel
 			)
 		end
 
-		sig { returns(Example) }
+		# a symbol example where :invalid is the only disallowed Symbol
+		# @return [Example] the example
 		def exclusion
 			Example.new(
 				[:symbol, { excluded: [:invalid] }],

data/lib/data_model/fixtures/time.rb

@@ -1,22 +1,20 @@
-# typed: strict
-
 module DataModel
+	# Test data around time schemas
 	module Fixtures::Time
-		extend T::Sig
-		extend self
 		include Fixtures
+		extend self
 
-		sig { returns(::Time) }
+		# @return [Time] a time that is used by the #earliest example
 		def earliest_time
 			return ::Time.now - 1
 		end
 
-		sig { returns(::Time) }
+		# @return [Time] a time that is used by the #latest example
 		def latest_time
 			return ::Time.now + 1
 		end
 
-		sig { returns(T::Hash[Symbol, Object]) }
+		# @return [Hash{Symbol => untyped}] the variants used by each example
 		def variants
 			now = ::Time.now
 
@@ -30,22 +28,26 @@ module DataModel
 			}
 		end
 
-		sig { returns(Example) }
+		# A simple time schema
+		# @return [Example] the example
 		def simple
 			Example.new([:time], variants:)
 		end
 
-		sig { returns(Example) }
+		# A time schema that is optional
+		# @return [Example] the example
 		def optional
 			Example.new([:time, { optional: true }], variants:)
 		end
 
-		sig { returns(Example) }
+		# A time schema that has a restriction on the earliest time
+		# @return [Example] the example
 		def earliest
 			Example.new([:time, { earliest: earliest_time }], variants:)
 		end
 
-		sig { returns(Example) }
+		# A time schema that has a restriction on the latest time
+		# @return [Example] the example
 		def latest
 			Example.new([:time, { latest: latest_time }], variants:)
 		end

data/lib/data_model/logging.rb

@@ -1,15 +1,12 @@
-# typed: strict
-
 require "logger"
 
 module DataModel
+	# Provides a logger for classes that include it
 	module Logging
-		extend T::Sig
-		include Kernel
-
-		sig { returns(Logger) }
+		# Get a logger
+		# @return [Logger] the logger for this class
 		def log
-			target = T.let(respond_to?(:name) ? self : self.class, T.any(Class, Module))
+			target = respond_to?(:name) ? self : self.class
 
 			logger = Logger.new(
 				STDERR,
@@ -17,7 +14,7 @@ module DataModel
 				progname: target.name,
 			)
 
-			return @log ||= T.let(logger, T.nilable(Logger))
+			return @log ||= logger
 		end
 	end
 end

data/lib/data_model/model.rb

@@ -1,28 +1,31 @@
-# typed: strict
-
 module DataModel
+	# A model is a schema and a type. It is the primary interface for interacting
+	# with the data_model gem.
 	class Model
-		extend T::Sig
-
-		sig { params(schema: TSchema, type: Type).void }
+		# Create a new model.
+		# @param schema [Array] the schema to define
+		# @param type [Type] the type to use
+		# @return [void]
 		def initialize(schema, type)
 			@schema = schema
 			@type = type
 		end
 
-		sig { returns(TSchema) }
+		# @return [Array] the schema configured
 		attr_reader :schema
 
 		# 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) }
+		# @param data [Hash] the data to validate
+		# @return [Boolean] true if the data is valid, false if it is not
 		def validate(data)
 			_, err = @type.read(data)
 			return err
 		end
 
 		# Read data with the model. This will return a tuple of [data, error]
-		sig { params(data: TData).returns([TData, Error]) }
+		# @param data [Hash] the data to read
+		# @return [Array] a tuple of [data, error]
 		def coerce(data)
 			result = @type.read(data, coerce: true)
 			return result

data/lib/data_model/registry.rb

@@ -1,61 +1,71 @@
-# typed: strict
-
 module DataModel
 	# Registry allows for different type implementations to be used by the scanner.
 	# It also acts as an error message registry, mostly for pragmatic reasons.
 	class Registry
-		extend T::Sig
-
 		# Default types that will be used if alternative type map is not given
-		sig { returns(TTypeMap) }
+		# @return [Hash] the default type map
 		def self.default_types
 			Builtin.types
 		end
 
-		sig { returns(Errors::TErrorMessages) }
+		# Default error messages that will be used if alternative error messages are not given
+		# @return [Hash] the default error messages
 		def self.default_error_messages
 			Errors.error_messages
 		end
 
 		# Singleton instance that will be used globally unless instances given
-		sig { params(types: TTypeMap, errors: Errors::TErrorMessages).returns(Registry) }
+		# @param types [Hash] the type map to use
+		# @param errors [Hash] the error message map to use
+		# @return [Registry] the singleton instance
 		def self.instance(types: default_types, errors: default_error_messages)
-			@instance ||= T.let(new(types:, errors:), T.nilable(Registry))
+			@instance ||= new(types:, errors:)
 		end
 
 		# Register a type on the global instance
-		sig { params(name: Symbol, type: T.class_of(Type)).void }
+		# @param name [Symbol] the name of the type
+		# @param type [Type] the type to register
+		# @return [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: Errors::TErrorMessages).void }
+		# @param types [Hash] the type map to use
+		# @param errors [Hash] the error message map to use
+		# @return [Registry] the new instance
 		def initialize(types: self.class.default_types, errors: self.class.default_error_messages)
-			@error_messages = T.let(nil, T.nilable(Errors::TErrorMessages))
+			@error_messages = nil
+
 			if errors
 				errors.each { |type, builder| register_error_message(type, &builder) }
 			end
 
-			@types = T.let({}, TTypeMap)
+			@types = {}
 			types.each { |(name, type)| register(name, type) }
 		end
 
 		# Register a type on this instance
-		sig { params(name: Symbol, type: T.class_of(Type)).void }
+		# @param name [Symbol] the name of the Type
+		# @param type [Type] the type to register
+		# @return [void]
 		def register(name, type)
 			@types[name] = type
 		end
 
 		# Check if a type is registered
-		sig { params(name: Symbol).returns(T::Boolean) }
+		# @param name [Symbol] the name of the type
+		# @return [Boolean] whether the type is registered
 		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) }
+		# @param name [Symbol] the name of the Type
+		# @param args [Hash] the arguments to pass to the Type
+		# @param params [Array] the parameters to configure the Type with
+		# @return [Type] the configured type
 		def type(name, args: {}, params: nil)
 			if !type?(name)
 				raise "#{name} is not registered as a type"
@@ -73,26 +83,30 @@ module DataModel
 		## API
 
 		# Register a custom error message for use with custom errors
-		sig { params(type: Symbol, block: Errors::TErrorMessageBuilder).void }
+		# @param type [Symbol] the type of error to register
+		# @param block [Proc] the block to use to build the error message, shoudl take the error context and return a string
+		# @return [void]
 		def register_error_message(type, &block)
 			error_message_builders[type] = block
 		end
 
 		# Get the error message builders
-		sig { returns(Errors::TErrorMessages) }
+		# @return [Hash] the error message builders
 		def error_message_builders
 			if @error_messages.nil?
-				@error_messages ||= T.let({}, T.nilable(Errors::TErrorMessages))
+				@error_messages ||= {}
 			end
 
 			@error_messages
 		end
 
 		# Build the error message for a given error
-		sig { params(error: TError).returns(String) }
+		# @param error [Error] the error to build the message for
+		# @return [String] the error message
+		# @raise [RuntimeError] if no error message builder is registered for the error type
 		def error_message(error)
-			type = T.let(error[0], Symbol)
-			ctx = T.let(error[1], T.untyped)
+			type = error[0]
+			ctx = error[1]
 
 			builder = error_message_builders[type]
 
@@ -104,7 +118,8 @@ module DataModel
 		end
 
 		# Build error messages from error object
-		sig { params(error: Error).returns(T::Hash[Symbol, T::Array[String]]) }
+		# @param error [Error] the error to build the messages for
+		# @return [Hash] the error messages
 		def error_messages(error)
 			error.to_h.transform_values do |error_list|
 				error_list.map { |e| error_message(e) }