data_model 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77b4364d2dc4198264ace712d5cb9f74a52120a6e878345f122091b4f10ec355
-  data.tar.gz: b886dbf46aa42f0bbfc8364cce01f959f1e4fc37849f83f3b3d0cf88521e46fa
+  metadata.gz: f3a30187193b436d7dd863a4b2fe28d8baf21428d6fd936cb67555e9792786a7
+  data.tar.gz: e44e496aaf29d7ecd8dfd5633aae5275bb67a1ecfb821f7a64137f9532c36cca
 SHA512:
-  metadata.gz: 57c5dbc66e6d50aae767bb6f8eb7d192bbbef1912737675bc2ff63efb3ada68f06bee62a4f291d3b47e962d59d104f103d47ac2ce76ff6e6723e3c4cee090167
-  data.tar.gz: db075c6e83530263ecd90396c989f2fffd52a2b434031102501f85464f1e8253dd5fd85ae99b4c1a82622d6f0e21b1fd5808f19809575e6db264cb70c91dbc3c
+  metadata.gz: 9fd5b20f3a87909ef221656b6b541413f1201759e08cc51af148fbd18037c0b54b0253e2e21f51adf4503d4b61d1dbe4e5a929a62310574964e9214875d772a8
+  data.tar.gz: 47c5090b016f7ac15162c74e62464da01b1a4c170ae52db0f28f63d71a7686f7acd3063624b8c2ec5813d76fa826af56a1b4649d85162d220877e8053ff63890

data/.rubocop.yml

@@ -3,14 +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/.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,25 @@
 PATH
   remote: .
   specs:
-    data_model (0.3.0)
-      sorbet
+    data_model (0.5.0)
       zeitwerk
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activesupport (7.0.6)
+      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.7)
     diff-lcs (1.5.0)
+    erubi (1.12.0)
     ffi (1.15.5)
+    fileutils (1.7.1)
     formatador (1.1.0)
     guard (2.18.0)
       formatador (>= 0.2.4)
@@ -25,63 +33,93 @@ GEM
     guard-rake (1.0.0)
       guard
       rake
+    i18n (1.14.1)
+      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)
-    lumberjack (1.2.8)
+    logger (1.5.3)
+    lumberjack (1.2.9)
     method_source (1.0.0)
-    minitest (5.18.0)
+    minitest (5.19.0)
     nenv (0.3.0)
     netrc (0.11.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
     parallel (1.23.0)
-    parser (3.2.2.1)
+    parser (3.2.2.3)
       ast (~> 2.4.1)
+      racc
+    prettier_print (1.2.1)
     pry (0.14.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
+    racc (1.7.1)
     rainbow (3.1.1)
     rake (13.0.6)
     rb-fsevent (0.11.2)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbi (0.0.16)
+    rbi (0.0.17)
       ast
-      parser (>= 2.6.4.0)
+      parser (>= 3.0.0)
       sorbet-runtime (>= 0.5.9204)
-      unparser
-    regexp_parser (2.8.0)
-    rexml (3.2.5)
-    rubocop (1.50.2)
+      unparser (>= 0.5.6)
+    rbs (3.1.3)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.55.1)
       json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
-      parser (>= 3.2.0.0)
+      parser (>= 3.2.2.3)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.28.0, < 2.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.28.0)
+    rubocop-ast (1.29.0)
       parser (>= 3.2.1.0)
     ruby-progressbar (1.13.0)
-    rufo (0.16.1)
+    rufo (0.16.2)
+    securerandom (0.2.2)
     shellany (0.0.1)
-    sorbet (0.5.10795)
-      sorbet-static (= 0.5.10795)
-    sorbet-runtime (0.5.10795)
-    sorbet-static (0.5.10795-universal-darwin-22)
-    sorbet-static-and-runtime (0.5.10795)
-      sorbet (= 0.5.10795)
-      sorbet-runtime (= 0.5.10795)
-    spoom (1.2.1)
+    sorbet (0.5.10950)
+      sorbet-static (= 0.5.10950)
+    sorbet-runtime (0.5.10950)
+    sorbet-static (0.5.10950-universal-darwin-22)
+    sorbet-static-and-runtime (0.5.10950)
+      sorbet (= 0.5.10950)
+      sorbet-runtime (= 0.5.10950)
+    spoom (1.2.2)
+      erubi (>= 1.10.0)
       sorbet (>= 0.5.10187)
       sorbet-runtime (>= 0.5.9204)
+      syntax_tree (>= 6.1.1)
       thor (>= 0.19.2)
-    tapioca (0.11.5)
+    steep (1.5.2)
+      activesupport (>= 5.1)
+      concurrent-ruby (>= 1.1.10)
+      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 (>= 3.1.0)
+      securerandom (>= 0.1)
+      strscan (>= 1.0.0)
+      terminal-table (>= 2, < 4)
+    strscan (3.0.6)
+    syntax_tree (6.1.1)
+      prettier_print (>= 1.2.0)
+    tapioca (0.11.8)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
@@ -90,16 +128,20 @@ GEM
       spoom (~> 1.2.0, >= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
-    thor (1.2.1)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    thor (1.2.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.4.2)
-    unparser (0.6.7)
+    unparser (0.6.8)
       diff-lcs (~> 1.3)
       parser (>= 3.2.0)
     yard (0.9.34)
     yard-sorbet (0.8.1)
       sorbet-runtime (>= 0.5)
       yard (>= 0.9)
-    zeitwerk (2.6.7)
+    zeitwerk (2.6.11)
 
 PLATFORMS
   arm64-darwin-22
@@ -112,8 +154,8 @@ DEPENDENCIES
   rake
   rubocop
   rufo
-  sorbet-runtime
+  steep
   tapioca
 
 BUNDLED WITH
-   2.4.12
+   2.4.18

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"
@@ -44,7 +43,7 @@ Gem::Specification.new do |spec|
 	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 "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))