Class: Tapioca::Compilers::DryStruct
- Inherits:
-
Dsl::Compiler
- Object
- Dsl::Compiler
- Tapioca::Compilers::DryStruct
- Extended by:
- T::Sig
- Defined in:
- lib/tapioca/dsl/compilers/dry_struct.rb
Overview
tapioca’s [custom DSL compilers](github.com/Shopify/tapioca/blob/main/README.md#writing-custom-dsl-compilers) for [dry-struct](dry-rb.org/gems/dry-struct/).
Defined Under Namespace
Classes: DryAstCompiler
Constant Summary collapse
- VERSION =
'0.0.0'
- ConstantType =
type_member {{ fixed: ::T.class_of(::Dry::Struct) }}
Class Method Summary collapse
- .env(key) ⇒ Object
- .experimental_schema_to_sorbet_type(schema) ⇒ Object
- .gather_constants ⇒ Object
- .map_to_sorbet_type(map) ⇒ Object
- .sum_to_sorbet_type(sum) ⇒ Object
- .to_sorbet_type(type, required) ⇒ Object
Instance Method Summary collapse
Class Method Details
.env(key) ⇒ Object
319 320 321 322 323 324 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 319 def self.env(key) v = ENV[key] return false if v.nil? return false if v == '0' true end |
.experimental_schema_to_sorbet_type(schema) ⇒ Object
307 308 309 310 311 312 313 314 315 316 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 307 def self.experimental_schema_to_sorbet_type(schema) return '::T::Hash[::T.untyped, ::T.untyped]' if schema.empty? sigs = schema.map do |i| sorbet_type = to_sorbet_type(i[:type], i[:required]) i[:name].is_a?(::String) ? "'#{i[:name]}' => #{sorbet_type}" : "#{i[:name]}: #{sorbet_type}" end "{ #{sigs.join(', ')} }" end |
.gather_constants ⇒ Object
231 232 233 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 231 def self.gather_constants all_classes.select { |c| c < ::Dry::Struct } end |
.map_to_sorbet_type(map) ⇒ Object
302 303 304 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 302 def self.map_to_sorbet_type(map) "::T::Hash[#{map.key}, #{map.value}]" end |
.sum_to_sorbet_type(sum) ⇒ Object
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 278 def self.sum_to_sorbet_type(sum) return '::T.untyped' if sum.include_undefined? if sum.include_nilclass? sum.delete_nilclass! if sum.size < 2 "::T.nilable(#{to_sorbet_type(sum.first, true)})" elsif (sum.types - [::TrueClass, ::FalseClass]).empty? '::T.nilable(::T::Boolean)' else "::T.nilable(::T.any(#{sum.map { |t| to_sorbet_type(t, true) }.join(', ')}))" end else if (sum.types - [::TrueClass, ::FalseClass]).empty? '::T::Boolean' elsif sum.size == 1 to_sorbet_type(sum.first, true) else "::T.any(#{sum.map { |t| to_sorbet_type(t, true) }.join(', ')})" end end end |
.to_sorbet_type(type, required) ⇒ Object
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 236 def self.to_sorbet_type(type, required) base = if type.is_a?(DryAstCompiler::Sum) sum_to_sorbet_type(type) elsif type.is_a?(DryAstCompiler::Schema) env('DRY_USE_EXPERIMENTAL_SHAPE') ? experimental_schema_to_sorbet_type(type) : '::T::Hash[::T.untyped, ::T.untyped]' elsif type.is_a?(DryAstCompiler::Map) map_to_sorbet_type(type) elsif type.is_a?(DryAstCompiler::Undefined) '::T.untyped' elsif type.is_a?(::Array) "::T::Array[#{to_sorbet_type(type[0], true)}]" elsif type == ::Hash '::T::Hash[::T.untyped, ::T.untyped]' elsif type == ::Time env('DRY_PREFER_PLAIN_TIME') ? '::Time' : '::ActiveSupport::TimeWithZone' elsif type == ::Range '::T::Range[::T.untyped]' elsif type == ::Set '::T::Set[::T.untyped]' elsif type == ::TrueClass || type == ::FalseClass '::T::Boolean' elsif type.nil? '::NilClass' else "::#{type.name}" end if base == '::T.untyped' || base == '::NilClass' base else if required base else if base.start_with?('::T.nilable') base else "::T.nilable(#{base})" end end end end |
Instance Method Details
#decorate ⇒ Object
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 |
# File 'lib/tapioca/dsl/compilers/dry_struct.rb', line 212 def decorate compiler = DryAstCompiler.new root.create_path(constant) do |klass| constant.schema.each do |s| attribute_info = compiler.visit(s.to_ast) if ::Dry::Types.const_defined?(:Maybe) && s.type.class == ::Dry::Types::Maybe sorbet_type = '::T.any(::Dry::Monads::Maybe::Some, ::Dry::Monads::Maybe::None)' else sorbet_type = self.class.to_sorbet_type(attribute_info[:type], attribute_info[:required]) end klass.create_method( attribute_info[:name].to_s, return_type: sorbet_type, ) end end end |