boba 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c38ab860f2d0913aef856dc5903505a28fdfe971c30be7d116c3f8b1b6f1b366
-  data.tar.gz: 16b5fb166214dfd6157efb1c481a4667616ee937c1746d620aef892b457f39be
+  metadata.gz: 24108e7a191602ef441626b929c5a846004c36b4af6b6c28c86384577c1b1f4e
+  data.tar.gz: 150b997c5bb280a71c228df1a4840d190a29dd8f49d3390f3f1b1999f78488c7
 SHA512:
-  metadata.gz: 7a1bed23004b75855101c0c05628d12d3aba8f6f808856402032069310195e3699035659c43337630efbf9d2ac796243ba7c57e83ab633a873e728caab642433
-  data.tar.gz: 4542bcfde6d1e4f0dd9538dafde159bab762844d18cfa746468ea71831a846953c3f3d6182eed33253736633f8a5f221f1f0d3519f8201159afa2e2830fb368a
+  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.9"
+  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

@@ -47,8 +47,6 @@ module Tapioca
       # end
       # ~~~
       class Shrine < Tapioca::Dsl::Compiler
-        include RBIHelper
-
         InstanceMethodModuleName = "ShrineGeneratedMethods"
         ClassMethodModuleName = "ShrineGeneratedClassMethods"
 
@@ -149,11 +147,16 @@ module Tapioca
           end
         end
 
-        #: (UnboundMethod | Method method_obj) -> Array[RBI::TypedParam]
+        # 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.filter_map do |(type, name)|
+          method_obj.parameters.each_with_index.filter_map do |(type, name), index|
             name_str = name.to_s
-            name_str = "arg" if name_str.empty?
+            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")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boba
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Angellist
@@ -55,6 +55,7 @@ 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
@@ -67,9 +68,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/angellist/boba/issues
-  changelog_uri: https://github.com/angellist/boba/blob/0.1.9/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.9
+  source_code_uri: https://github.com/angellist/boba/tree/0.1.10
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: