boba 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f3bbf276bdafe4ad59d597cfa3d481db980d8a1cc0639066289ee72671bee01
-  data.tar.gz: ed16c9705abe9aaa2997124342b920d748aac6d131bc25b4930a4bdfd8c82e4b
+  metadata.gz: 24108e7a191602ef441626b929c5a846004c36b4af6b6c28c86384577c1b1f4e
+  data.tar.gz: 150b997c5bb280a71c228df1a4840d190a29dd8f49d3390f3f1b1999f78488c7
 SHA512:
-  metadata.gz: 3efa241e2373a7566a2f9a565366a750947854c2af1ac7d26e66b934f6b4c18835ca8c58b64ec22f107871b46a1bde563663b1d30a1fe3dea54ba9c7afe8d82c
-  data.tar.gz: 59a567e245ad5d424bfccc9c101584500235ef2a71282e65cdcba5cb6448267684bc9b6fe5e85309c56db96ec8d0e088fa3a3bc33500b12a81614e9c122ff95e
+  metadata.gz: e89404c6738c73acac5f0c0e0043a883930f6594bc9264d0f48f72ec9ab9bcf554c36163316ebd8ddc335ca3945c9c50bb20f01c2c6fdd490ccca21c072db52e
+  data.tar.gz: 42c252740c0258ff9666573bf4f73e67e1de954f86c7a7728cd302490eb34af9eabe1abf0f8956329caaca11574eaef733d127763e00314470ec0df3d6e438b7

data/lib/boba/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Boba
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

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

@@ -0,0 +1,188 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Draper)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Draper` decorates RBI files for `Draper::Decorator`
+      # subclasses and the source classes they decorate, provided by the `draper` gem.
+      # https://github.com/drapergem/draper
+      #
+      # The compiler emits a typed `object` / `model` / underscored-source-name accessor
+      # for every decorator, plus a typed `decorate` instance method on the source class.
+      #
+      # For example, with the following classes:
+      # ~~~rb
+      # class Post < ActiveRecord::Base
+      # end
+      #
+      # class PostDecorator < Draper::Decorator
+      # end
+      # ~~~
+      #
+      # This compiler will generate the following RBI for the decorator:
+      # ~~~rbi
+      # class PostDecorator
+      #   include DraperGeneratedInstanceMethods
+      #
+      #   module DraperGeneratedInstanceMethods
+      #     sig { returns(::Post) }
+      #     def model; end
+      #
+      #     sig { returns(::Post) }
+      #     def object; end
+      #
+      #     sig { returns(::Post) }
+      #     def post; end
+      #   end
+      # end
+      # ~~~
+      #
+      # And the following RBI for the source class:
+      # ~~~rbi
+      # class Post
+      #   include DraperGeneratedDecoratableMethods
+      #
+      #   module DraperGeneratedDecoratableMethods
+      #     sig { params(options: T.untyped).returns(::PostDecorator) }
+      #     def decorate(options = T.unsafe(nil)); end
+      #   end
+      # end
+      # ~~~
+      #
+      # ## Why `delegate_all` is not supported
+      #
+      # `delegate_all` forwards every public instance method of the source class via
+      # `method_missing`. Reflecting that into RBI requires emitting one explicit method
+      # per name — Sorbet ignores `method_missing` for type inference, and there is no
+      # other annotation that lets us say "this class has all the methods of that one"
+      # without the `is_a?` lie of declaring `class PostDecorator < Post`.
+      #
+      # Mirroring AR's full instance method set per decorator turned out to be wildly
+      # noisy in practice (several thousand lines per decorator on real models, mostly
+      # AR-internal methods like `__callbacks` and `_before_commit_callbacks` that no
+      # one calls through a decorator). Argument and return types also collapse to
+      # `T.untyped`, so the noise doesn't even buy strong typing.
+      #
+      # The recommended pattern is therefore to access the source through the typed
+      # `object` accessor — `decorator.object.title` carries the typing produced by
+      # Tapioca's `ActiveRecordColumns` compiler, with no per-decorator bloat.
+      #
+      # Concretely, with `Post#title` (a string column):
+      # ~~~rb
+      # post = Post.new(title: "post 1")
+      # post.title              # ✓ Sorbet sees ::String (from ActiveRecordColumns)
+      #
+      # decorator = post.decorate
+      # decorator.title         # ✗ Sorbet errors — even with `delegate_all`, no
+      #                         #   `title` is declared on PostDecorator
+      # decorator.object.title  # ✓ Sorbet sees ::String (via the typed `object`)
+      # ~~~
+      class Draper < Tapioca::Dsl::Compiler
+        InstanceMethodModuleName = "DraperGeneratedInstanceMethods"
+        DecoratableMethodModuleName = "DraperGeneratedDecoratableMethods"
+
+        ConstantType = type_member { { fixed: T.class_of(Object) } }
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            decorators = gather_decorators
+            decorators + gather_decoratables(decorators)
+          end
+
+          private
+
+          # Decorator subclasses with an inferable `object_class` (e.g. `PostDecorator`).
+          # Filters out anonymous classes and abstract bases like `ApplicationDecorator`
+          # which have no `decorates` call. Uses Draper's own `object_class?` predicate.
+          #: -> Array[singleton(::Draper::Decorator)]
+          def gather_decorators
+            descendants_of(::Draper::Decorator).select do |klass|
+              klass.name && klass.object_class?
+            end
+          end
+
+          # Source classes (e.g. `Post`) whose Draper-inferred decorator matches one of
+          # the gathered decorators. The inference check ensures we only emit
+          # `Source#decorate` when this decorator is the one Draper would actually
+          # return at runtime, avoiding conflicting return-type RBIs when multiple
+          # decorators target the same source.
+          #: (Array[singleton(::Draper::Decorator)] decorators) -> Array[Class[top]]
+          def gather_decoratables(decorators)
+            decorators.filter_map do |decorator|
+              source = decorator.object_class
+              source if source.is_a?(Class) &&
+                source < ::Draper::Decoratable &&
+                T.unsafe(source).decorator_class? == decorator
+            end
+          end
+        end
+
+        # @override
+        #: -> void
+        def decorate
+          if constant.is_a?(Class) && constant < ::Draper::Decorator
+            decorate_decorator(T.cast(constant, T.class_of(::Draper::Decorator)))
+          else
+            decorate_decoratable(T.unsafe(constant))
+          end
+        end
+
+        private
+
+        #: (singleton(::Draper::Decorator) decorator) -> void
+        def decorate_decorator(decorator)
+          object_class = decorator.object_class
+          object_class_name = "::#{object_class.name}"
+
+          # Each accessor is gated on `method_defined?` so the generated RBI never
+          # claims a method that Draper hasn't actually installed at runtime. `object`
+          # / `model` are stable Draper APIs but the underscore alias is a Draper
+          # convention; the runtime check keeps the compiler robust if any of these
+          # change in a future Draper release.
+          root.create_path(decorator) do |klass|
+            instance_module = RBI::Module.new(InstanceMethodModuleName)
+
+            if decorator.method_defined?(:object)
+              instance_module.create_method("object", return_type: object_class_name)
+            end
+            if decorator.method_defined?(:model)
+              instance_module.create_method("model", return_type: object_class_name)
+            end
+
+            underscore_name = object_class.name.to_s.underscore
+            if underscore_name != "object" && underscore_name != "model" &&
+                decorator.method_defined?(underscore_name.to_sym)
+              instance_module.create_method(underscore_name, return_type: object_class_name)
+            end
+
+            klass << instance_module
+            klass.create_include(InstanceMethodModuleName)
+          end
+        end
+
+        #: (Class[top] source) -> void
+        def decorate_decoratable(source)
+          decorator = T.unsafe(source).decorator_class
+          decorator_class_name = "::#{decorator.name}"
+
+          root.create_path(source) do |klass|
+            decoratable_module = RBI::Module.new(DecoratableMethodModuleName)
+            decoratable_module.create_method(
+              "decorate",
+              parameters: [create_opt_param("options", type: "T.untyped", default: "T.unsafe(nil)")],
+              return_type: decorator_class_name,
+            )
+
+            klass << decoratable_module
+            klass.create_include(DecoratableMethodModuleName)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# typed: strict
+# frozen_string_literal: true
+
+return unless defined?(Shrine)
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::Shrine` decorates RBI files for classes that include
+      # a `Shrine::Attachment` module provided by the `shrine` gem.
+      # https://github.com/shrinerb/shrine
+      #
+      # For example, with the following model:
+      # ~~~rb
+      # class Photo < ActiveRecord::Base
+      #   include ImageUploader::Attachment(:image)
+      # end
+      # ~~~
+      #
+      # This compiler will generate the following RBI:
+      # ~~~rbi
+      # class Photo
+      #   include ShrineGeneratedMethods
+      #   extend ShrineGeneratedClassMethods
+      #
+      #   module ShrineGeneratedClassMethods
+      #     sig { params(options: T.untyped).returns(::Shrine::Attacher) }
+      #     def image_attacher(**options); end
+      #   end
+      #
+      #   module ShrineGeneratedMethods
+      #     sig { returns(T.nilable(::Shrine::UploadedFile)) }
+      #     def image; end
+      #
+      #     sig { params(value: T.untyped).returns(T.untyped) }
+      #     def image=(value); end
+      #
+      #     sig { params(options: T.untyped).returns(T.nilable(::Shrine::Attacher)) }
+      #     def image_attacher(**options); end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def image_changed?; end
+      #
+      #     sig { params(args: T.untyped, options: T.untyped).returns(T.nilable(String)) }
+      #     def image_url(*args, **options); end
+      #   end
+      # end
+      # ~~~
+      class Shrine < Tapioca::Dsl::Compiler
+        InstanceMethodModuleName = "ShrineGeneratedMethods"
+        ClassMethodModuleName = "ShrineGeneratedClassMethods"
+
+        ConstantType = type_member { { fixed: T.class_of(Object) } }
+
+        class << self
+          # @override
+          #: -> Enumerable[Module[top]]
+          def gather_constants
+            all_classes.select do |klass|
+              klass.ancestors.any? { |ancestor| ancestor.is_a?(::Shrine::Attachment) }
+            end
+          end
+        end
+
+        # @override
+        #: -> void
+        def decorate
+          attachments = shrine_attachments(constant)
+          return if attachments.empty?
+
+          root.create_path(constant) do |klass|
+            instance_module = RBI::Module.new(InstanceMethodModuleName)
+            class_module = RBI::Module.new(ClassMethodModuleName)
+
+            attachments.each do |attachment|
+              name = attachment.attachment_name
+
+              # Filter to methods that follow shrine's naming convention (<name> or <name>= or <name>_*).
+              # This excludes method overrides like `reload` from the ActiveRecord plugin.
+              attachment.instance_methods(false).sort
+                .filter { |m| m == name || m == :"#{name}=" || m.start_with?("#{name}_") }
+                .each do |method_name|
+                method_obj = attachment.instance_method(method_name)
+                instance_module.create_method(
+                  method_name.to_s,
+                  parameters: compile_parameters(method_obj),
+                  return_type: return_type_for(name, method_name),
+                )
+              end
+
+              # Class method from entity plugin:
+              #   .<name>_attacher - returns a class-level attacher instance
+              next unless constant.respond_to?(:"#{name}_attacher")
+
+              class_method_obj = constant.method(:"#{name}_attacher")
+              class_module.create_method(
+                "#{name}_attacher",
+                parameters: compile_parameters(class_method_obj),
+                return_type: "::Shrine::Attacher",
+              )
+            end
+
+            klass << instance_module
+            klass.create_include(InstanceMethodModuleName)
+            klass << class_module
+            klass.create_extend(ClassMethodModuleName)
+          end
+        end
+
+        private
+
+        #: (singleton(Object) klass) -> Array[::Shrine::Attachment]
+        def shrine_attachments(klass)
+          klass.ancestors
+            .filter_map { |ancestor| ancestor if ancestor.is_a?(::Shrine::Attachment) }
+            .sort_by(&:attachment_name)
+        end
+
+        # Maps a dynamically discovered method name to its return type.
+        #
+        # Known method patterns (from shrine's entity/model plugins) are given
+        # specific return types. Methods that don't match any known pattern
+        # (e.g. those added by third-party shrine plugins) fall back to
+        # T.untyped so they still appear in the generated RBI.
+        #
+        #   #<name>           -> entity plugin: returns the attached file
+        #   #<name>_url       -> entity plugin: returns the URL to the file
+        #   #<name>_attacher  -> entity plugin: returns the Attacher instance
+        #   #<name>=          -> model plugin:  assigns a file (setter)
+        #   #<name>_changed?  -> model plugin:  checks if attachment changed
+        #
+        #: (Symbol attachment_name, Symbol method_name) -> String?
+        def return_type_for(attachment_name, method_name)
+          case method_name
+          when attachment_name
+            "T.nilable(::Shrine::UploadedFile)"
+          when :"#{attachment_name}_url"
+            "T.nilable(::String)"
+          when :"#{attachment_name}_attacher"
+            "T.nilable(::Shrine::Attacher)"
+          when /=$/
+            nil
+          when /\?$/
+            "T::Boolean"
+          else
+            "T.untyped"
+          end
+        end
+
+        # Compiles a `Method` / `UnboundMethod#parameters` into the `RBI::TypedParam`
+        # array expected by `RBI::Scope#create_method`. Argument types default to
+        # `T.untyped` since shrine plugins don't carry sigs. Anonymous parameter names
+        # — including empty names and the special tokens `:*`, `:**`, `:&` — are
+        # replaced with `_arg{index}` so the generated RBI is syntactically valid.
+        #: ((Method | UnboundMethod) method_obj) -> Array[RBI::TypedParam]
+        def compile_parameters(method_obj)
+          method_obj.parameters.each_with_index.filter_map do |(type, name), index|
+            name_str = name.to_s
+            name_str = "_arg#{index}" unless name_str.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+            case type
+            when :req
+              create_param(name_str, type: "T.untyped")
+            when :opt
+              create_opt_param(name_str, type: "T.untyped", default: "T.unsafe(nil)")
+            when :rest
+              create_rest_param(name_str, type: "T.untyped")
+            when :keyreq
+              create_kw_param(name_str, type: "T.untyped")
+            when :key
+              create_kw_opt_param(name_str, type: "T.untyped", default: "T.unsafe(nil)")
+            when :keyrest
+              create_kw_rest_param(name_str, type: "T.untyped")
+            when :block
+              create_block_param(name_str, type: "T.untyped")
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - Angellist
@@ -55,20 +55,22 @@ files:
 - lib/tapioca/dsl/compilers/active_record_columns_persisted.rb
 - lib/tapioca/dsl/compilers/active_record_relation_types.rb
 - lib/tapioca/dsl/compilers/attr_json.rb
+- lib/tapioca/dsl/compilers/draper.rb
 - lib/tapioca/dsl/compilers/flag_shih_tzu.rb
 - lib/tapioca/dsl/compilers/kaminari.rb
 - lib/tapioca/dsl/compilers/money_rails.rb
 - lib/tapioca/dsl/compilers/noticed.rb
 - lib/tapioca/dsl/compilers/paperclip.rb
+- lib/tapioca/dsl/compilers/shrine.rb
 - lib/tapioca/dsl/compilers/state_machines_extended.rb
 homepage: https://github.com/angellist/boba
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.1.8/History.md
+  changelog_uri: https://github.com/angellist/boba/blob/0.1.10/History.md
   homepage_uri: https://github.com/angellist/boba
-  source_code_uri: https://github.com/angellist/boba/tree/0.1.8
+  source_code_uri: https://github.com/angellist/boba/tree/0.1.10
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: