data_model 0.0.1 → 0.2.0

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

data/lib/data_model/version.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 module DataModel
-  VERSION = "0.0.1"
+	VERSION = "0.2.0"
 end

data/lib/data_model.rb

@@ -1,28 +1,44 @@
+# typed: strict
+
+require "logger"
+require "bigdecimal"
+require "date"
+require "time"
+
+require "bundler/setup"
 require "zeitwerk"
+require "sorbet-runtime"
 
-loader = Zeitwerk::Loader.for_gem
+loader = T.let(Zeitwerk::Loader.for_gem, Zeitwerk::Loader)
 loader.setup
 
 module DataModel
+	extend T::Sig
 	extend self
 
-	def validate(schema, data, registry: Registry.instance)
-		_, err = read(schema, data, registry:)
-		err.empty? || err.values.all?(&:empty?)
-	end
+	TSchema = T.type_alias { T::Array[Object] }
+	TData = T.type_alias { Object }
 
-	def read(schema, data, registry: Registry.instance)
-		Model.read(compiled(schema, registry:), data)
-	end
+	# an error is a tuple of [error_type, error_context], where context
+	# provides additional information about the error
+	TError = T.type_alias { [Symbol, Object] }
 
-	def write(schema, data, registry: Registry.instance)
-		Model.write(compiled(schema, registry:), data)
-	end
+	# a map of symbol => type, suitable for sending to a TypeRegistry
+	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)
+		scanned = Scanner.scan(schema, registry)
+
+		type = registry.type(
+			scanned.type,
+			args: scanned.args,
+			params: scanned.params,
+		)
+
+		model = Model.new(schema, type)
 
-	def compiled(model, registry: Registry.instance)
-		if model in Array
-			model = Scanner.scan(model, registry)
-		end
-		model
+		return model
 	end
 end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=/tmp/
+--ignore=/vendor/bundle

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end