data_model 0.3.0 → 0.5.0

data/lib/data_model/fixtures/date.rb

@@ -1,22 +1,20 @@
-# typed: strict
-
 module DataModel
+	# Provides fixtures for testing date types
 	module Fixtures::Date
-		extend T::Sig
-		extend self
 		include Fixtures
+		extend self
 
-		sig { returns(::Date) }
+		# @return [Date] a date that is used by the #earliest example
 		def earliest_date
 			return ::Date.today - 1
 		end
 
-		sig { returns(::Date) }
+		# @return [Date] a date that is used by the #latest example
 		def latest_date
 			return ::Date.today + 1
 		end
 
-		sig { returns(T::Hash[Symbol, Object]) }
+		# @return [Hash{Symbol => untyped}] the variants used by each example
 		def variants
 			today = ::Date.today
 
@@ -30,22 +28,26 @@ module DataModel
 			}
 		end
 
-		sig { returns(Example) }
+		# A simple date schema
+		# @return [Example] the example
 		def simple
 			Example.new([:date], variants:)
 		end
 
-		sig { returns(Example) }
+		# A date schema that is optional
+		# @return [Example] the example
 		def optional
 			Example.new([:date, { optional: true }], variants:)
 		end
 
-		sig { returns(Example) }
+		# A date schema that has a restriction on the earliest date
+		# @return [Example] the example
 		def earliest
 			Example.new([:date, { earliest: earliest_date }], variants:)
 		end
 
-		sig { returns(Example) }
+		# A date schema that has a restriction on the latest date
+		# @return [Example] the example
 		def latest
 			Example.new([:date, { latest: latest_date }], variants:)
 		end

data/lib/data_model/fixtures/example.rb

@@ -1,21 +1,21 @@
-# typed: strict
-
 module DataModel
+	# A simple abstraction to handle test data
 	class Fixtures::Example
-		extend T::Sig
-
-		sig { params(schema: TSchema, variants: T::Hash[::Symbol, Object]).void }
+		# @param schema [Array] the schema
+		# @param variants [Hash{Symbol => untyped}] the variants used by each example
+		# @return [Schema] the schema
 		def initialize(schema, variants:)
 			@schema = schema
 			@variants = variants
 		end
 
-		sig { returns(Model) }
+		# @return [Model] the model
 		def model
 			DataModel.define(@schema)
 		end
 
-		sig { params(type: Symbol).returns([Model, Object]) }
+		# @param type [Symbol] the variant to use
+		# @return [Array(Model, untyped)] a tuple of [model, variant]
 		def [](type)
 			if !@variants.key?(type)
 				raise "#{type} is not a defined variant: #{@variants}"

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