shale-builder 0.2.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20d60a5e93cde01d0c61afd4c64134f950c01c8a535332fa5927321c24a40b7c
-  data.tar.gz: 70515b9f6b1c06acb11c68e2e088a13f8191c7c356ed1016ce1363ac646c5fa5
+  metadata.gz: 01baf7e6e2a1bb3af915935d777089427a91fb25bf238bb1103fe7be133bea47
+  data.tar.gz: 7bb534cd32cf4681d90f25658c4bd659e22f1173d21434f06e39997cfb12188f
 SHA512:
-  metadata.gz: 47a9851fd6ee46bbfb3d65e19965c6599e0def339cb75549d718c3bcbb113829b1d01511e7ed3825f80c9c873670efdb3f3405c2c70cf7d8a6976ba056476520
-  data.tar.gz: fac4f56502bfa4f6e6d91f108c9ef3787d8f9c72e2670a9af800035ad648533d3d7b30567e260029b3776116fbfd1810f0f3024ca9f9c3bed98b691dedf15746
+  metadata.gz: 11ea61b420ba7fd7c24412e570344b5e1f57a4385f33884c2c0ad6118f5856d4d45a58903872d0c10c1c28af8f3f5f3d9481875817fb102f0bc135159f635efa
+  data.tar.gz: 2fe221a51291db87700f2a0d5e5777924c28d9e93527d3da8f9f0548592a9bfc5d5ae1d91819348c559d8bfcae088b80aa0dd36e9b14627f3df40aaff54c4b30

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shale-builder (0.2.1)
+    shale-builder (0.2.3)
       booleans (>= 0.1)
       shale (< 2.0)
       sorbet-runtime (> 0.5)

data/lib/shale/builder/version.rb

@@ -2,6 +2,6 @@
 
 module Shale
   module Builder
-    VERSION = '0.2.1'
+    VERSION = '0.2.3'
   end
 end

data/lib/tapioca/dsl/compilers/shale.rb

@@ -37,49 +37,40 @@ module Tapioca
           attribute_names = constant.attributes.keys.sort
           attribute_names.each do |attribute_name|
             attribute = T.let(constant.attributes[attribute_name], ::Shale::Attribute)
-            non_nilable_type, nilable_type = shale_type_to_sorbet_return_type(attribute)
-            type = nilable_type
-            if attribute.collection?
-              type = "T.nilable(T::Array[#{non_nilable_type}])"
-            end
+            return_type, nilable = shale_type_to_sorbet_return_type(attribute)
             comments = T.let([], T::Array[RBI::Comment])
             if shale_builder_defined? && attribute.doc
               comments << RBI::Comment.new(T.must(attribute.doc))
             end
 
+            if attribute.collection?
+              getter_without_block_type = "T.nilable(T::Array[#{return_type}])"
+            elsif nilable
+              getter_without_block_type = "T.nilable(#{return_type})"
+            else
+              getter_without_block_type = return_type.to_s
+            end
+
             if has_shale_builder && attribute.type < ::Shale::Mapper
-              sigs = T.let([], T::Array[RBI::Sig])
-              # simple getter
-              sigs << klass.create_sig(
-                parameters: { block: 'NilClass' },
-                return_type: type,
-              )
-              # getter with block
-              sigs << klass.create_sig(
-                parameters: { block: "T.proc.params(arg0: #{non_nilable_type}).void" },
-                return_type: non_nilable_type
-              )
-              mod.create_method_with_sigs(
-                attribute.name,
-                sigs: sigs,
-                comments: comments,
-                parameters: [RBI::BlockParam.new('block')],
-              )
+              generate_mapper_getter(mod, attribute.name, return_type, getter_without_block_type, comments)
             else
-              mod.create_method(attribute.name, return_type: type, comments: comments)
+              mod.create_method(attribute.name, return_type: getter_without_block_type, comments: comments)
             end
 
-            non_nilable_type, nilable_type = shale_type_to_sorbet_setter_type(attribute)
-            type = nilable_type
+            setter_type, nilable = shale_type_to_sorbet_setter_type(attribute)
             if attribute.collection?
-              type = "T.nilable(T::Array[#{non_nilable_type}])"
+              setter_type = "T.nilable(T::Array[#{return_type}])"
+            elsif nilable
+              setter_type = "T.nilable(#{return_type})"
+            else
+              setter_type = return_type.to_s
             end
 
             # setter
             mod.create_method(
               "#{attribute.name}=",
-              parameters: [create_param('value', type: type)],
-              return_type: type,
+              parameters: [create_param('value', type: setter_type)],
+              return_type: setter_type,
               comments: comments,
             )
           end
@@ -87,6 +78,54 @@ module Tapioca
 
       end
 
+      sig do
+        params(
+          mod: RBI::Scope,
+          method_name: String,
+          type: Object,
+          getter_without_block_type: String,
+          comments: T::Array[RBI::Comment],
+        ).void
+      end
+      def generate_mapper_getter(mod, method_name, type, getter_without_block_type, comments)
+        if mod.respond_to?(:create_sig)
+          # for tapioca < 0.16.0
+          sigs = T.let([], T::Array[RBI::Sig])
+
+          # simple getter
+          sigs << mod.create_sig(
+            parameters: { block: 'NilClass' },
+            return_type: getter_without_block_type,
+          )
+          # getter with block
+          sigs << mod.create_sig(
+            parameters: { block: "T.proc.params(arg0: #{type}).void" },
+            return_type: type.to_s
+          )
+          mod.create_method_with_sigs(
+            method_name,
+            sigs: sigs,
+            comments: comments,
+            parameters: [RBI::BlockParam.new('block')],
+          )
+        else
+          # for tapioca >= 0.16.0
+          mod.create_method(method_name, comments: comments) do |method|
+            method.add_block_param('block')
+
+            method.add_sig do |sig|
+              sig.add_param('block', 'NilClass')
+              sig.return_type = getter_without_block_type
+            end
+
+            method.add_sig do |sig|
+              sig.add_param('block', "T.proc.params(arg0: #{type}).void")
+              sig.return_type = type.to_s
+            end
+          end
+        end
+      end
+
       private
 
       sig { params(klass: Class).returns(T.nilable(T::Boolean)) }
@@ -99,7 +138,22 @@ module Tapioca
       sig { returns(T::Boolean) }
       def shale_builder_defined? = Boolean(defined?(::Shale::Builder))
 
-      SHALE_TYPES_MAP = T.let(
+      # Maps Shale return types to Sorbet types
+      SHALE_RETURN_TYPES_MAP = T.let(
+        {
+          ::Shale::Type::Value    => Object,
+          ::Shale::Type::String   => String,
+          ::Shale::Type::Float    => Float,
+          ::Shale::Type::Integer  => Integer,
+          ::Shale::Type::Time     => Time,
+          ::Shale::Type::Date     => Date,
+          ::Shale::Type::Boolean  => T::Boolean,
+        }.freeze,
+        T::Hash[Class, Object],
+      )
+
+      # Maps Shale setter types to Sorbet types
+      SHALE_SETTER_TYPES_MAP = T.let(
         {
           ::Shale::Type::Value    => Object,
           ::Shale::Type::String   => String,
@@ -107,46 +161,47 @@ module Tapioca
           ::Shale::Type::Integer  => Integer,
           ::Shale::Type::Time     => Time,
           ::Shale::Type::Date     => Date,
+          ::Shale::Type::Boolean  => Object,
         }.freeze,
-        T::Hash[Class, Class],
+        T::Hash[Class, Object],
       )
 
-      sig { params(attribute: ::Shale::Attribute).returns([String, String]) }
+      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
       def shale_type_to_sorbet_return_type(attribute)
-        return_type = SHALE_TYPES_MAP[attribute.type]
+        return_type = SHALE_RETURN_TYPES_MAP[attribute.type]
         return complex_shale_type_to_sorbet_return_type(attribute) unless return_type
-        return [T.must(return_type.name), T.must(return_type.name)] if attribute.collection? || attribute.default.is_a?(return_type)
+        return return_type, false if attribute.collection? || return_type.is_a?(Module) && attribute.default.is_a?(return_type)
 
-        [T.must(return_type.name), "T.nilable(#{return_type.name})"]
+        [return_type, true]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([String, String]) }
+      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
       def complex_shale_type_to_sorbet_return_type(attribute)
-        return [T.cast(attribute.type.to_s, String), "T.nilable(#{attribute.type})"] unless attribute.type.respond_to?(:return_type)
+        return attribute.type, true unless attribute.type.respond_to?(:return_type)
 
         return_type_string = attribute.type.return_type.to_s
-        [return_type_string, return_type_string]
+        [return_type_string, false]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([String, String]) }
+      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
       def shale_type_to_sorbet_setter_type(attribute)
-        setter_type = SHALE_TYPES_MAP[attribute.type]
+        setter_type = SHALE_SETTER_TYPES_MAP[attribute.type]
         return complex_shale_type_to_sorbet_setter_type(attribute) unless setter_type
-        return [T.must(setter_type.name), T.must(setter_type.name)] if attribute.collection? || attribute.default.is_a?(setter_type)
+        return setter_type, false if attribute.collection? || setter_type.is_a?(Module) && attribute.default.is_a?(setter_type)
 
-        [T.must(setter_type.name), "T.nilable(#{setter_type.name})"]
+        [setter_type, true]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([String, String]) }
+      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
       def complex_shale_type_to_sorbet_setter_type(attribute)
         if attribute.type.respond_to?(:setter_type)
-          setter_type_string = attribute.type.setter_type.to_s
-          [setter_type_string, setter_type_string]
+          setter_type_string = attribute.type.setter_type
+          [setter_type_string, false]
         elsif attribute.type.respond_to?(:return_type)
-          return_type_string = attribute.type.return_type.to_s
-          [return_type_string, return_type_string]
+          return_type_string = attribute.type.return_type
+          [return_type_string, false]
         else
-          [T.cast(attribute.type.to_s, String), "T.nilable(#{attribute.type})"]
+          [attribute.type, true]
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shale-builder
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Mateusz Drewniak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-16 00:00:00.000000000 Z
+date: 2025-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: booleans