data_model 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b19c7734dd0562c0ef848b80626af66d08fbb9899b4110bf489ddb5d8920bb96
-  data.tar.gz: 9292e0267765d965788f54a37d6846a123acd045506f7451412be625193fb3e6
+  metadata.gz: 77b4364d2dc4198264ace712d5cb9f74a52120a6e878345f122091b4f10ec355
+  data.tar.gz: b886dbf46aa42f0bbfc8364cce01f959f1e4fc37849f83f3b3d0cf88521e46fa
 SHA512:
-  metadata.gz: f151b11149b2c97e93773f5857a16914ee2c85a3b83074106832ae426f43467533b79423ef5b943e6bca9b109a9db699ff06f454dda3c434f3844969c26330a2
-  data.tar.gz: 235d0c7e9f26539e997f394a449e4f0a6662cce55563aa49e29552289087bd619730d992e2f691733a730a3a4b04ae7577c84a5b5f80441b3ebcd91e633aeedf
+  metadata.gz: 57c5dbc66e6d50aae767bb6f8eb7d192bbbef1912737675bc2ff63efb3ada68f06bee62a4f291d3b47e962d59d104f103d47ac2ce76ff6e6723e3c4cee090167
+  data.tar.gz: db075c6e83530263ecd90396c989f2fffd52a2b434031102501f85464f1e8253dd5fd85ae99b4c1a82622d6f0e21b1fd5808f19809575e6db264cb70c91dbc3c

data/.rubocop.yml

@@ -9,5 +9,8 @@ AllCops:
 Style/GlobalStdStream:
   Enabled: false
 
+Metrics/ClassLength:
+  Enabled: false
+
 Lint/BooleanSymbol:
   Enabled: false

data/.shadowenv.d/.gitignore

@@ -0,0 +1,2 @@
+/.*
+!/.gitignore

data/.shadowenv.d/550-ruby.lisp

@@ -0,0 +1,37 @@
+(provide "ruby" "3.2.0")
+
+; remove any existing ruby paths and environment variables
+(when-let ((ruby-root (env/get "RUBY_ROOT")))
+ (env/remove-from-pathlist "PATH" (path-concat ruby-root "bin"))
+ (when-let ((gem-root (env/get "GEM_ROOT")))
+   (env/remove-from-pathlist "PATH" (path-concat gem-root "bin")))
+ (when-let ((gem-home (env/get "GEM_HOME")))
+   (env/remove-from-pathlist "PATH" (path-concat gem-home "bin"))))
+
+(env/set "GEM_PATH" ())
+(env/set "GEM_HOME" ())
+(env/set "RUBYOPT" ())
+
+; set base ruby environment
+(let ((version "3.2.2")
+	  (gem-version "3.2.0")
+	  (ruby-home (path-concat (env/get "HOME") ".rubies" (concat "ruby-" version))))
+ (do
+   	(env/set "RUBY_ROOT" ruby-home)
+	(env/prepend-to-pathlist "PATH" (path-concat ruby-home "bin"))
+	(env/set "RUBY_ENGINE" "ruby")
+	(env/set "RUBY_VERSION" version)
+	(env/set "GEM_ROOT" (path-concat ruby-home "lib" "ruby" "gems" gem-version))))
+
+; set gem environment
+(when-let ((gem-root (env/get "GEM_ROOT")))
+  (env/prepend-to-pathlist "GEM_PATH" gem-root)
+  (env/prepend-to-pathlist "PATH" (path-concat gem-root "bin")))
+
+; handle local gem home
+(let ((gem-home
+      (path-concat (env/get "HOME") ".gem" (env/get "RUBY_ENGINE") (env/get "RUBY_VERSION"))))
+  (do
+    (env/set "GEM_HOME" gem-home)
+    (env/prepend-to-pathlist "GEM_PATH" gem-home)
+    (env/prepend-to-pathlist "PATH" (path-concat gem-home "bin"))))

data/Gemfile.lock

@@ -68,6 +68,7 @@ GEM
     rubocop-ast (1.28.0)
       parser (>= 3.2.1.0)
     ruby-progressbar (1.13.0)
+    rufo (0.16.1)
     shellany (0.0.1)
     sorbet (0.5.10795)
       sorbet-static (= 0.5.10795)
@@ -110,6 +111,7 @@ DEPENDENCIES
   minitest
   rake
   rubocop
+  rufo
   sorbet-runtime
   tapioca
 

data/data_model.gemspec

@@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
 	spec.add_development_dependency "minitest"
 	spec.add_development_dependency "rake"
 	spec.add_development_dependency "rubocop"
+	spec.add_development_dependency "rufo"
 	spec.add_development_dependency "sorbet-runtime"
 	spec.add_development_dependency "tapioca"
 

data/lib/data_model/error.rb

@@ -4,6 +4,7 @@ module DataModel
 	# Error is a class that holds errors.
 	class Error
 		extend T::Sig
+		include Errors
 
 		TErrorList = T.type_alias { T::Array[TError] }
 		TErrorMap = T.type_alias { T::Hash[Symbol, TErrorList] }
@@ -86,22 +87,9 @@ module DataModel
 			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
+		sig { params(registry: Registry).returns(T::Hash[Symbol, T::Array[String]]) }
+		def to_messages(registry: Registry.instance)
+			return registry.error_messages(self)
 		end
 	end
 end

data/lib/data_model/errors.rb

@@ -5,6 +5,7 @@ module DataModel
 	module Errors
 		include Kernel
 		extend T::Sig
+		extend self
 
 		TTemporal = T.type_alias { T.any(::Date, ::Time, ::DateTime) }
 
@@ -156,141 +157,80 @@ module DataModel
 			"value #{val} does not match format #{format}"
 		end
 
-		## API
-		# TODO: split this file
+		# Builders
 
 		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] }
+		TWithinTemporalCtx = T.type_alias { [Errors::TTemporal, Errors::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|
+		def self.error_messages
+			return {
+				type: lambda do |ctx|
 					cls, val = T.let(ctx, TClassValueCtx)
 					type_error_message(cls, val)
-				end
+				end,
 
-				register_error_message(:coerce) do |ctx|
+				coerce: lambda do |ctx|
 					cls, val = T.let(ctx, TClassValueCtx)
-					coerce_error_message(cls, val)
-				end
+					type_error_message(cls, val)
+				end,
 
-				register_error_message(:missing) do |ctx|
+				missing: lambda do |ctx|
 					cls = T.let(ctx, TClassCtx)
 					missing_error_message(cls)
-				end
+				end,
 
-				register_error_message(:inclusion) do |ctx|
+				inclusion: lambda do |ctx|
 					set = T.let(ctx, TSetCtx)
 					inclusion_error_message(set)
-				end
+				end,
 
-				register_error_message(:exclusion) do |ctx|
+				exclusion: lambda do |ctx|
 					set = T.let(ctx, TSetCtx)
 					exclusion_error_message(set)
-				end
+				end,
 
-				register_error_message(:extra_keys) do |ctx|
+				extra_keys: lambda do |ctx|
 					set = T.let(ctx, TSetCtx)
 					extra_keys_error_message(set)
-				end
+				end,
 
-				register_error_message(:min) do |ctx|
+				min: lambda do |ctx|
 					min, val = T.let(ctx, TWithinCtx)
 					min_error_message(min, val)
-				end
+				end,
 
-				register_error_message(:max) do |ctx|
+				max: lambda do |ctx|
 					max, val = T.let(ctx, TWithinCtx)
 					max_error_message(max, val)
-				end
+				end,
 
-				register_error_message(:earliest) do |ctx|
+				earliest: lambda do |ctx|
 					earliest, val = T.let(ctx, TWithinTemporalCtx)
 					early_error_message(earliest, val)
-				end
+				end,
 
-				register_error_message(:latest) do |ctx|
+				latest: lambda do |ctx|
 					latest, val = T.let(ctx, TWithinTemporalCtx)
 					late_error_message(latest, val)
-				end
+				end,
 
-				register_error_message(:blank) do
+				blank: lambda do
 					blank_error_message
-				end
+				end,
 
-				register_error_message(:format) do |ctx|
+				format: lambda 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/registry.rb

@@ -0,0 +1,114 @@
+# 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) }
+		def self.default_types
+			Builtin.types
+		end
+
+		sig { returns(Errors::TErrorMessages) }
+		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) }
+		def self.instance(types: default_types, errors: default_error_messages)
+			@instance ||= T.let(new(types:, errors:), T.nilable(Registry))
+		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: Errors::TErrorMessages).void }
+		def initialize(types: self.class.default_types, errors: self.class.default_error_messages)
+			@error_messages = T.let(nil, T.nilable(Errors::TErrorMessages))
+			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
+
+		## API
+
+		# Register a custom error message for use with custom errors
+		sig { params(type: Symbol, block: Errors::TErrorMessageBuilder).void }
+		def register_error_message(type, &block)
+			error_message_builders[type] = block
+		end
+
+		# Get the error message builders
+		sig { returns(Errors::TErrorMessages) }
+		def error_message_builders
+			if @error_messages.nil?
+				@error_messages ||= T.let({}, T.nilable(Errors::TErrorMessages))
+			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
+
+		# 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
+	end
+end

data/lib/data_model/scanner.rb

@@ -32,8 +32,8 @@ module DataModel
 
 		# 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)
+		sig { params(schema: TSchema, registry: DataModel::Registry).returns(Node) }
+		def scan(schema, registry = Registry.instance)
 			# state:
 			# 	nil (start) -> :type (we have a type) -> :args (we have arguments)
 			scanned = Node.new

data/lib/data_model/type.rb

@@ -12,8 +12,8 @@ module DataModel
 		TTypeParams = T.type_alias { T::Array[Object] }
 		TTypeResult = T.type_alias { [Object, Error] }
 
-		sig { params(args: TArguments, registry: TypeRegistry).void }
-		def initialize(args, registry: TypeRegistry.instance)
+		sig { params(args: TArguments, registry: Registry).void }
+		def initialize(args, registry: Registry.instance)
 			@type_args = args
 			@type_registry = registry
 		end

data/lib/data_model/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module DataModel
-	VERSION = "0.3.0"
+	VERSION = "0.4.0"
 end

data/lib/data_model.rb

@@ -27,8 +27,8 @@ module DataModel
 	TTypeMap = T.type_alias { T::Hash[Symbol, T.class_of(Type)] }
 
 	# Scan a schema and create a data model, which is a configured type.
-	sig { params(schema: TSchema, registry: TypeRegistry).returns(Model) }
-	def define(schema, registry: TypeRegistry.instance)
+	sig { params(schema: TSchema, registry: Registry).returns(Model) }
+	def define(schema, registry: Registry.instance)
 		scanned = Scanner.scan(schema, registry)
 
 		type = registry.type(
@@ -44,6 +44,6 @@ module DataModel
 
 	sig { params(name: Symbol, type: T.class_of(Type)).void }
 	def register_global_type(name, type)
-		TypeRegistry.register(name, type)
+		Registry.register(name, type)
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_model
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Matt Briggs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-11 00:00:00.000000000 Z
+date: 2023-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rufo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +160,8 @@ files:
 - ".editorconfig"
 - ".rubocop.yml"
 - ".ruby-version"
+- ".shadowenv.d/.gitignore"
+- ".shadowenv.d/550-ruby.lisp"
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -179,11 +195,11 @@ files:
 - lib/data_model/fixtures/time.rb
 - lib/data_model/logging.rb
 - lib/data_model/model.rb
+- lib/data_model/registry.rb
 - lib/data_model/scanner.rb
 - lib/data_model/testing.rb
 - lib/data_model/testing/minitest.rb
 - lib/data_model/type.rb
-- lib/data_model/type_registry.rb
 - lib/data_model/version.rb
 - sorbet/config
 - sorbet/rbi/annotations/rainbow.rbi
@@ -217,7 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Define a model for your data

data/lib/data_model/type_registry.rb

@@ -1,68 +0,0 @@
-# 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