shale-builder 0.8.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9599ec92d021b9ed5b62272efaabaca3a77944c4a8c9611f8ad6fbee730d6e9d
-  data.tar.gz: e8c0dfab2765c8e328fe29916f80e751748c27eb293ff8d3db7c927deb89f901
+  metadata.gz: 293665a7fae7d93488f9c8f65e0c4d1fed9cc01c629549f4d06f4163ef712b6b
+  data.tar.gz: 10bf23ea86288b0d2dc67e8730fa339a63424b1d9f003d6def9d9274007d032b
 SHA512:
-  metadata.gz: 4fee3d4b8016d6e3d334101f4fd0a4c1f7b712271603ab0ff586e5d0697eabf7ec905387efde342345f44eff5e3ef6c43e7f2e467404a6ba10b21728c9c66ff2
-  data.tar.gz: 62c613bfa8e6f0803e96995b628633a4a085b78d061c5573bd44a41ef648aae6eaf3330fe8d27b5c99098ad816260b5a3afa4dbc554c32dc2ed975714948c2cf
+  metadata.gz: 3ad60377af23996a3a6fca6b186f783c9a693261b3df56ce7a4ecf3ac32048b38b072fa0a3ece2584137767e0e1ca1d9bc5a474a026b9e00873e1d8f9fe4eca1
+  data.tar.gz: e5b06e6b2cd4d0ec52b9cfb94063052ce30902855b5b3931850dfe669869d9fc9b5734f3078b6de1dfd793af7c9e2f225c9f9bff926183cc649961ffbac35d97

data/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.0] - 2026-04-24
+
+[Diff](https://github.com/Verseth/ruby-shale-builder/compare/v0.8.5...v0.9.0)
+
+### Changes
+- Add `memoize:` optional keyword arg to complex getters to preserve the already existing object instead of overriding it
+
+## [0.8.5] - 2025-10-27
+
+[Diff](https://github.com/Verseth/ruby-shale-builder/compare/v0.8.3...v0.8.5)
+
+### Changes
+- Fix the tapioca compiler behaviour with `T.untyped`
+
 ## [0.8.3] - 2025-10-24
 
 [Diff](https://github.com/Verseth/ruby-shale-builder/compare/v0.8.2...v0.8.3)

data/Gemfile.lock

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

data/README.md

@@ -145,6 +145,47 @@ non-primitive types have been overridden to accept blocks.
 When a block is given to such a getter, it instantiates an empty object
 of its type and yields it to the block.
 
+#### Overriding
+
+By default if you call the builder method with a block a second time
+it will override the previous object with a new one
+
+```rb
+transaction = Transaction.build do |t|
+    t.amount do |a|
+        a.value = 2.3
+        a.currency = 'PLN'
+    end
+    t.amount do |a|
+        a.value = 10
+    end
+end
+
+transaction.amount.value #=> 10
+transaction.amount.currency #=> nil
+```
+
+#### Memoization
+
+You can change the behaviour of builder methods
+so that they preserve existing objects when called a second time.
+You do that by using the `memoize: true` keyword argument.
+
+```rb
+transaction = Transaction.build do |t|
+    t.amount do |a|
+        a.value = 2.3
+        a.currency = 'PLN'
+    end
+    t.amount(memoize: true) do |a|
+        a.value = 10
+    end
+end
+
+transaction.amount.value #=> 10
+transaction.amount.currency #=> 'PLN'
+```
+
 ### Collections
 
 Whenever you call a getter with a block for a collection attribute, the built object will be appended to the array.

data/lib/shale/builder/version.rb

@@ -2,6 +2,6 @@
 
 module Shale
   module Builder
-    VERSION = '0.8.4'
+    VERSION = '0.9.0'
   end
 end

data/lib/shale/builder.rb

@@ -130,27 +130,27 @@ module Shale
 
         if collection
           @builder_methods_module.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-            def #{name}                           # def clients
-              return super unless block_given?    #   return super unless block_given?
-                                                  #
-              arr = self.#{name} ||= []           #   arr = self.clients ||= []
-              object = #{shale_mapper}.new                #   object = Client.new
-              yield(object)                       #   yield(object)
-              arr << object                       #   arr << object
-              object                              #   object
-            end                                   # end
+            def #{name}
+              return super unless block_given?
+
+              arr = self.#{name} ||= []
+              object = #{shale_mapper}.new
+              yield(object)
+              arr << object
+              object
+            end
           RUBY
           return
         end
 
         @builder_methods_module.class_eval <<~RUBY, __FILE__, __LINE__ + 1
-          def #{name}                                   # def amount
-            return super unless block_given?            #   return super unless block_given?
-                                                        #
-            object = #{shale_mapper}.new                        #   object = Amount.new
-            yield(object)                               #   yield(object)
-            self.#{name} = object                       #   self.amount = object
-          end                                           # end
+          def #{name}(memoize: false)
+            return super() unless block_given?
+
+            object = (memoize && self.#{name}) || #{shale_mapper}.new
+            yield(object)
+            self.#{name} = object
+          end
         RUBY
       end
 

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

@@ -18,7 +18,8 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig { override.returns(T::Enumerable[Module]) }
+        # @override
+        #: -> T::Enumerable[Module]
         def gather_constants
           # Collect all the classes that inherit from Shale::Mapper
           all_classes.select { |c| c < ::Shale::Mapper }
@@ -27,7 +28,8 @@ module Tapioca
 
       SHALE_ATTRIBUTE_MODULE = 'ShaleAttributeMethods'
 
-      sig { override.void }
+      # @override
+      #: -> void
       def decorate
         # Create a RBI definition for each class that inherits from Shale::Mapper
         root.create_path(constant) do |klass|
@@ -50,9 +52,9 @@ module Tapioca
             end
 
             if attribute.collection?
-              getter_without_block_type = "T.nilable(T::Array[#{return_type}])"
+              getter_without_block_type = wrap_nilable_type(wrap_array_type(return_type))
             elsif nilable
-              getter_without_block_type = "T.nilable(#{return_type})"
+              getter_without_block_type = wrap_nilable_type(return_type)
             else
               getter_without_block_type = return_type.to_s
             end
@@ -64,9 +66,9 @@ module Tapioca
               setter_type, nilable = shale_type_to_sorbet_setter_type(attribute)
             end
             if attribute.collection?
-              setter_type_str = "T.nilable(T::Array[#{setter_type}])"
+              setter_type_str = wrap_nilable_type(wrap_array_type(setter_type))
             elsif nilable
-              setter_type_str = "T.nilable(#{setter_type})"
+              setter_type_str = wrap_nilable_type(setter_type)
             else
               setter_type_str = setter_type.to_s
             end
@@ -92,48 +94,64 @@ 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
+      #: (untyped type) -> String
+      def wrap_nilable_type(type)
+        return "T.nilable(#{type})" if type != T.untyped
+
+        T.unsafe(type).to_s
+      end
+
+      #: (untyped type) -> String
+      def wrap_array_type(type)
+        "T::Array[#{type}]"
       end
+
+      #: (RBI::Scope mod, String method_name, Object type, String getter_without_block_type, Array[RBI::Comment] comments) -> void
       def generate_mapper_getter(mod, method_name, type, getter_without_block_type, comments)
         if mod.respond_to?(:create_sig)
           mod = T.unsafe(mod)
           # for tapioca < 0.16.0
-          sigs = T.let([], T::Array[RBI::Sig])
+          sigs = [] #: Array[RBI::Sig]
 
           # simple getter
           sigs << mod.create_sig(
-            parameters: { block: 'NilClass' },
+            parameters: {
+              memoize: 'FalseClass',
+              block: 'NilClass',
+            },
             return_type: getter_without_block_type,
           )
           # getter with block
           sigs << mod.create_sig(
-            parameters: { block: "T.proc.params(arg0: #{type}).void" },
+            parameters: {
+              memoize: 'T::Boolean',
+              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')],
+            parameters: [
+              RBI::KwOptParam.new('memoize', 'false'),
+              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_kw_opt_param('memoize', 'false')
 
             method.add_sig do |sig|
+              sig.add_param('memoize', 'FalseClass')
               sig.add_param('block', 'NilClass')
               sig.return_type = getter_without_block_type
             end
 
             method.add_sig do |sig|
+              sig.add_param('memoize', 'T::Boolean')
               sig.add_param('block', "T.proc.params(arg0: #{type}).void")
               sig.return_type = type.to_s
             end
@@ -143,51 +161,45 @@ module Tapioca
 
       private
 
-      sig { params(klass: Class).returns(T.nilable(T::Boolean)) }
+      #: (Class klass) -> bool?
       def includes_shale_builder(klass)
         return false unless defined?(::Shale::Builder)
 
         klass < ::Shale::Builder
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def shale_builder_defined? = Boolean(defined?(::Shale::Builder))
 
       # Maps Shale return types to Sorbet types
-      SHALE_RETURN_TYPES_MAP = T.let(
-        {
-          ::Shale::Type::Value    => T.untyped,
-          ::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,
-        }.tap do |h|
-          h[::Shale::Type::Decimal] = BigDecimal if defined?(::Shale::Type::Decimal)
-        end.freeze,
-        T::Hash[Class, Object],
-      )
+      SHALE_RETURN_TYPES_MAP = {
+        ::Shale::Type::Value    => T.untyped,
+        ::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,
+      }.tap do |h|
+        h[::Shale::Type::Decimal] = BigDecimal if defined?(::Shale::Type::Decimal)
+      end.freeze #: Hash[Class, Object]
 
       # Maps Shale setter types to Sorbet types
-      SHALE_SETTER_TYPES_MAP = T.let(
-        {
-          ::Shale::Type::Value    => T.untyped,
-          ::Shale::Type::String   => String,
-          ::Shale::Type::Float    => Float,
-          ::Shale::Type::Integer  => Integer,
-          ::Shale::Type::Time     => Time,
-          ::Shale::Type::Date     => Date,
-          ::Shale::Type::Boolean  => Object,
-        }.tap do |h|
-          if defined?(::Shale::Type::Decimal)
-            h[::Shale::Type::Decimal] = T.any(BigDecimal, String, Float, Integer, NilClass)
-          end
-        end.freeze,
-        T::Hash[Class, Object],
-      )
+      SHALE_SETTER_TYPES_MAP = {
+        ::Shale::Type::Value    => T.untyped,
+        ::Shale::Type::String   => String,
+        ::Shale::Type::Float    => Float,
+        ::Shale::Type::Integer  => Integer,
+        ::Shale::Type::Time     => Time,
+        ::Shale::Type::Date     => Date,
+        ::Shale::Type::Boolean  => Object,
+      }.tap do |h|
+        if defined?(::Shale::Type::Decimal)
+          h[::Shale::Type::Decimal] = T.any(BigDecimal, String, Float, Integer, NilClass)
+        end
+      end.freeze #: Hash[Class, Object]
 
-      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
+      #: (::Shale::Attribute attribute) -> [Object, bool]
       def shale_type_to_sorbet_return_type(attribute)
         return_type = SHALE_RETURN_TYPES_MAP[attribute.type]
         return complex_shale_type_to_sorbet_return_type(attribute) unless return_type
@@ -196,7 +208,7 @@ module Tapioca
         [return_type, true]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
+      #: (::Shale::Attribute attribute) -> [Object, bool]
       def complex_shale_type_to_sorbet_return_type(attribute)
         return attribute.type, true unless attribute.type.respond_to?(:return_type)
 
@@ -204,7 +216,7 @@ module Tapioca
         [return_type_string, false]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
+      #: (::Shale::Attribute attribute) -> [Object, bool]
       def shale_type_to_sorbet_setter_type(attribute)
         setter_type = SHALE_SETTER_TYPES_MAP[attribute.type]
         return complex_shale_type_to_sorbet_setter_type(attribute) unless setter_type
@@ -213,7 +225,7 @@ module Tapioca
         [setter_type, true]
       end
 
-      sig { params(attribute: ::Shale::Attribute).returns([Object, T::Boolean]) }
+      #: (::Shale::Attribute attribute) -> [Object, bool]
       def complex_shale_type_to_sorbet_setter_type(attribute)
         if attribute.type.respond_to?(:setter_type)
           setter_type_string = attribute.type.setter_type

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shale-builder
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Mateusz Drewniak