data_model 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b19c7734dd0562c0ef848b80626af66d08fbb9899b4110bf489ddb5d8920bb96
-  data.tar.gz: 9292e0267765d965788f54a37d6846a123acd045506f7451412be625193fb3e6
+  metadata.gz: c330ccaea1eb4d6a39ae646d1bfc1adea6fcea63398c393ca9daea37ad6c9345
+  data.tar.gz: 9ca8082aa99dd38e6c9838d089201be698713a2af312492d9f8d5c6d0512dddb
 SHA512:
-  metadata.gz: f151b11149b2c97e93773f5857a16914ee2c85a3b83074106832ae426f43467533b79423ef5b943e6bca9b109a9db699ff06f454dda3c434f3844969c26330a2
-  data.tar.gz: 235d0c7e9f26539e997f394a449e4f0a6662cce55563aa49e29552289087bd619730d992e2f691733a730a3a4b04ae7577c84a5b5f80441b3ebcd91e633aeedf
+  metadata.gz: e0b248691f742a60fe78029b5793cd00afd383457f3cd16610a56bb096e2cb37db0ad7c1cb064ec9fef4ffd6750b07857f8f2f4d44db3c06cf57ab342d6759c2
+  data.tar.gz: c5438f427c94cf00c3f4f64ed4078c80211f705d2646ad6489dcf4ae4c34165fa420498755e2131b2c0185cd84a57c582c7bac77a489f01f4cfa4d23a4bd2297

data/.rubocop.yml

@@ -3,11 +3,20 @@ inherit_from: "https://raw.githubusercontent.com/mbriggs/configs/main/dotfiles/r
 AllCops:
   SuggestExtensions: false
   Exclude:
-    - 'bin/**/*'
-    - 'sorbet/**/*'
+    - "bin/**/*"
+    - "sorbet/**/*"
 
 Style/GlobalStdStream:
   Enabled: false
 
+Style/HashSyntax:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
 Lint/BooleanSymbol:
   Enabled: false
+
+Lint/UnusedMethodArgument:
+  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/.solargraph.yml

@@ -0,0 +1,22 @@
+---
+include:
+- "**/*.rb"
+exclude:
+- spec/**/*
+- test/**/*
+- vendor/**/*
+- ".bundle/**/*"
+require: []
+domains: []
+reporters:
+- rubocop
+- require_not_found
+formatter:
+  rubocop:
+    cops: safe
+    except: []
+    only: []
+    extra_args: []
+require_paths: []
+plugins: []
+max_files: 5000

data/Gemfile.lock

@@ -1,17 +1,24 @@
 PATH
   remote: .
   specs:
-    data_model (0.3.0)
-      sorbet
+    data_model (0.4.0)
       zeitwerk
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.0.5)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
     ast (2.4.2)
     coderay (1.1.3)
+    concurrent-ruby (1.2.2)
+    csv (3.2.6)
     diff-lcs (1.5.0)
     ffi (1.15.5)
+    fileutils (1.7.1)
     formatador (1.1.0)
     guard (2.18.0)
       formatador (>= 0.2.4)
@@ -25,10 +32,14 @@ GEM
     guard-rake (1.0.0)
       guard
       rake
+    i18n (1.13.0)
+      concurrent-ruby (~> 1.0)
     json (2.6.3)
+    language_server-protocol (3.17.0.3)
     listen (3.8.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
+    logger (1.5.3)
     lumberjack (1.2.8)
     method_source (1.0.0)
     minitest (5.18.0)
@@ -53,6 +64,7 @@ GEM
       parser (>= 2.6.4.0)
       sorbet-runtime (>= 0.5.9204)
       unparser
+    rbs (3.1.0)
     regexp_parser (2.8.0)
     rexml (3.2.5)
     rubocop (1.50.2)
@@ -68,6 +80,8 @@ GEM
     rubocop-ast (1.28.0)
       parser (>= 3.2.1.0)
     ruby-progressbar (1.13.0)
+    rufo (0.16.1)
+    securerandom (0.2.2)
     shellany (0.0.1)
     sorbet (0.5.10795)
       sorbet-static (= 0.5.10795)
@@ -80,6 +94,22 @@ GEM
       sorbet (>= 0.5.10187)
       sorbet-runtime (>= 0.5.9204)
       thor (>= 0.19.2)
+    steep (1.4.0)
+      activesupport (>= 5.1)
+      concurrent-ruby (>= 1.2.2)
+      csv (>= 3.0.9)
+      fileutils (>= 1.1.0)
+      json (>= 2.1.0)
+      language_server-protocol (>= 3.15, < 4.0)
+      listen (~> 3.0)
+      logger (>= 1.3.0)
+      parser (>= 3.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rbs (>= 2.8.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
+      terminal-table (>= 2, < 4)
+    strscan (3.0.6)
     tapioca (0.11.5)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
@@ -89,7 +119,11 @@ GEM
       spoom (~> 1.2.0, >= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
     thor (1.2.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.4.2)
     unparser (0.6.7)
       diff-lcs (~> 1.3)
@@ -110,7 +144,8 @@ DEPENDENCIES
   minitest
   rake
   rubocop
-  sorbet-runtime
+  rufo
+  steep
   tapioca
 
 BUNDLED WITH

data/Rakefile

@@ -2,10 +2,6 @@
 
 require "minitest/test_task"
 
-Minitest::TestTask.create # named test, sensible defaults
-
-# or more explicitly:
-
 Minitest::TestTask.create(:test) do |t|
 	t.libs << "test"
 	t.libs << "lib"
@@ -13,8 +9,6 @@ Minitest::TestTask.create(:test) do |t|
 	t.test_globs = ["test/**/*_test.rb"]
 end
 
-task default: :test
-
 require "rubocop/rake_task"
 RuboCop::RakeTask.new
 

data/Steepfile

@@ -0,0 +1,27 @@
+# D = Steep::Diagnostic
+#
+# target :lib do
+#   signature "sig"
+#
+#   check "lib"                       # Directory name
+#   check "Gemfile"                   # File name
+#   check "app/models/**/*.rb"        # Glob
+#   # ignore "lib/templates/*.rb"
+#
+#   # library "pathname", "set"       # Standard libraries
+#   # library "strong_json"           # Gems
+#   
+#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+#   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+#   #   hash[D::Ruby::NoMethod] = :information
+#   # end
+# end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname", "set"       # Standard libraries
+# end

data/data_model.gemspec

@@ -35,7 +35,6 @@ Gem::Specification.new do |spec|
 	spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 
-	spec.add_dependency "sorbet"
 	spec.add_dependency "zeitwerk"
 
 	spec.add_development_dependency "guard"
@@ -43,7 +42,8 @@ Gem::Specification.new do |spec|
 	spec.add_development_dependency "minitest"
 	spec.add_development_dependency "rake"
 	spec.add_development_dependency "rubocop"
-	spec.add_development_dependency "sorbet-runtime"
+	spec.add_development_dependency "rufo"
+	spec.add_development_dependency "steep"
 	spec.add_development_dependency "tapioca"
 
 	# For more information and examples about making a new gem, check out our

data/lib/data_model/boolean.rb

@@ -1,5 +1,3 @@
-# typed: strict
-
 module DataModel
 	# fills in for lack of boolean type in ruby
 	class Boolean

data/lib/data_model/builtin/array.rb

@@ -1,47 +1,49 @@
-# typed: strict
-
 module DataModel
+	# Array is a type that contains a list of other types.
+	#
+	# @example
+	# 	[:array, :string] # shorthand
+	# 	[:array, [:string, {optional: true}]]
 	class Builtin::Array < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :wrap_single_value, T::Boolean, default: false
-			prop :min, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
-			prop :max, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
-			prop :length, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
+		# Arguments for Array type.
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :wrap_single_value, :boolean, default: false
+			prop :min, :integer, default: nil
+			prop :max, :integer, default: nil
+			prop :length, :integer, default: nil
 		end
 
-		# support either :string shorthand or [:string, {optional: true}]
-		sig { override.params(params: T::Array[Object]).void }
+		# get the child Type
+		# @return [Type] the child type
+		attr_reader :child_type
+
+		# configure how children will be read
+		# @param params [Array] the params to configure
+		# @return [void]
 		def configure(params)
 			if params.first.is_a?(Array)
 				params = params.first
 			end
 
-			params = T.cast(params, TSchema)
 			node = Scanner.scan(params)
 			type = instantiate(node.type, args: node.args, params: node.params)
 
-			@child_type = T.let(type, T.nilable(Type))
+			@child_type = type
 		end
 
-		sig { returns(Type) }
-		def child_type
-			if @child_type.nil?
-				raise "children not configured"
-			end
-
-			return @child_type
-		end
-
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			err = Error.new
 
 			if val.nil? && !args.optional
-				err.add(missing_error(Array))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
@@ -50,14 +52,19 @@ module DataModel
 			end
 
 			if !val.is_a?(Array)
-				err.add(type_error(Array, val))
+				err.add(type_error(type_name, val))
+				return [val, err]
+			end
+
+			# no child type configured, allow any array
+			if child_type.nil?
 				return [val, err]
 			end
 
 			coerced = []
 
 			for i in 0...val.length
-				child_val = T.let(val[i], Object)
+				child_val = val[i]
 				child, child_err = child_type.read(child_val, coerce:)
 				if child_err
 					err.merge_child(i.to_s.to_sym, child_err)

data/lib/data_model/builtin/big_decimal.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# A BigDecimal type.
 	class Builtin::BigDecimal < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :min, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
-			prop :max, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
+		# Arguments for BigDecimal type.
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :min, :numeric, default: nil
+			prop :max, :numeric, default: nil
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			err = Error.new
 			args = Arguments.new(type_args)
@@ -20,30 +23,28 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				err.add(missing_error(BigDecimal))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
 			if !val.is_a?(BigDecimal) && !coerce
-				err.add(type_error(BigDecimal, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
 			if !val.is_a?(BigDecimal) && coerce
 				if val.is_a?(String) || val.is_a?(Numeric)
-					val = BigDecimal(T.unsafe(val))
+					val = BigDecimal(val)
 				elsif val.respond_to?(:to_d)
-					val = T.cast(T.unsafe(val).to_d, BigDecimal)
+					val = val.to_d
 				end
 
 				if !val.is_a?(BigDecimal)
-					err.add(coerce_error(BigDecimal, val))
+					err.add(coerce_error(type_name, val))
 					return [val, err]
 				end
 			end
 
-			val = T.cast(val, BigDecimal)
-
 			min = args.min
 			if min && val <= min
 				err.add(min_error(min, val))

data/lib/data_model/builtin/boolean.rb

@@ -1,19 +1,22 @@
-# typed: strict
-
 module DataModel
+	# Boolean type
 	class Builtin::Boolean < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
+		# Arguments for the boolean type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			err = Error.new
 
 			if val.nil?
-				err.add(missing_error(DataModel::Boolean))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
@@ -27,7 +30,7 @@ module DataModel
 			end
 
 			if !val.is_a?(TrueClass) && !val.is_a?(FalseClass)
-				err.add(type_error(Boolean, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 

data/lib/data_model/builtin/date.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# A date type
 	class Builtin::Date < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :earliest, T.nilable(::Date), default: nil
-			prop :latest, T.nilable(::Date), default: nil
+		# Arguments for the date type
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :earliest, [:date, { optional: true }], default: nil
+			prop :latest, [:date, { optional: true }], default: nil
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			args = Arguments.new(type_args)
 			err = Error.new
@@ -22,7 +25,7 @@ module DataModel
 
 			# missing, but not allowed, don't do any more checks
 			if val.nil?
-				err.add(missing_error(Date))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
@@ -31,26 +34,26 @@ module DataModel
 				begin
 					val = Date.parse(val)
 				rescue ArgumentError
-					err.add(type_error(Date, val))
+					err.add(type_error(type_name, val))
 					return [val, err]
 				end
 			end
 
 			# not a date, don't do any more checks
 			if !val.is_a?(Date)
-				err.add(type_error(Date, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
 			# date is before the earliest point allowed
 			if args.earliest && (val < args.earliest)
-				error = earliest_error(T.must(args.earliest), val)
+				error = earliest_error(args.earliest, val)
 				err.add(error)
 			end
 
 			# date is after the latest point allowed
 			if args.latest && (val > args.latest)
-				error = latest_error(T.must(args.latest), val)
+				error = latest_error(args.latest, val)
 				err.add(error)
 			end
 

data/lib/data_model/builtin/float.rb

@@ -1,16 +1,19 @@
-# typed: strict
-
 module DataModel
+	# A float type.
 	class Builtin::Float < Type
 		include Errors
 
-		class Arguments < T::Struct
-			prop :optional, T::Boolean, default: false
-			prop :min, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
-			prop :max, T.nilable(T.any(Integer, Float, Rational, BigDecimal)), default: nil
+		# Arguments for the float type.
+		class Arguments < Struct
+			prop :optional, :boolean, default: false
+			prop :min, :numeric, default: nil
+			prop :max, :numeric, default: nil
 		end
 
-		sig { override.params(val: Object, coerce: T::Boolean).returns(TTypeResult) }
+		# read a value, and validate it
+		# @param val [Object] the value to read
+		# @param coerce [Boolean] whether to coerce the value
+		# @return [Array(Object, Error)] the result of reading the value
 		def read(val, coerce: false)
 			err = Error.new
 			args = Arguments.new(type_args)
@@ -20,12 +23,12 @@ module DataModel
 			end
 
 			if !args.optional && val.nil?
-				err.add(missing_error(Float))
+				err.add(missing_error(type_name))
 				return [val, err]
 			end
 
 			if !val.is_a?(Float) && !coerce
-				err.add(type_error(Float, val))
+				err.add(type_error(type_name, val))
 				return [val, err]
 			end
 
@@ -33,17 +36,15 @@ module DataModel
 				if val.is_a?(String) || val.is_a?(Numeric)
 					val = Float(val)
 				elsif val.respond_to?(:to_f)
-					val = T.cast(T.unsafe(val).to_f, Float)
+					val = val.to_f
 				end
 
 				if !val.is_a?(Float)
-					err.add(coerce_error(Float, val))
+					err.add(coerce_error(type_name, val))
 					return [val, err]
 				end
 			end
 
-			val = T.cast(val, Float)
-
 			min = args.min
 			if min && val <= min
 				err.add(min_error(min, val))