grape_sorbet 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afca4010268efe01d37b64b7cfd4bbd7f6266779a3a135ab04fe14869ab71daf
-  data.tar.gz: ee494b0147c0b9d32ae90a5a1fba81218687b26396131a56ff9a1bb16306d693
+  metadata.gz: 06c4417253642117e5cc111ec8c478d5c86b12abaff504778c0dc9ca031f0e45
+  data.tar.gz: c93127be9f1ac682c30080c0e5614a37d9470168172cfcc64b44e25d61203fa9
 SHA512:
-  metadata.gz: 122aa7dab2572d6df1cfc79a3ec7a80b652f5ad7d5d51d87b0e9077385e3fb8041fd75b190f76ce4c58b4f1aea575dd1194d505b21c5d9ff32d80b9fca1aa33a
-  data.tar.gz: 4eb298722d0e14cb745a20917899825463fd50d6b87b0e1d9541566c9bc5961effec782c7ec767cacc9bcf37536596e0f885c3ae9eb5bdf60717f32d1833c341
+  metadata.gz: 7c85f6e88f351c4ff58e8fd922f025b41cd38b05d9f773c42c0647128ff2bb525ce359791b21e5462c1119db943e5cee88502b9903236ddd45ef3c06d39c62c5
+  data.tar.gz: f504e9a4a9ee21cb7464802207cace234dfe270bd01e61f388eefc261ba39db8b96730f25d002f8fe4fc98daae75f22aaf678e0c594e16d138cf5eb10c0d0bb6

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.0.5 (2024-06-24)
+
+- Ignore anonymous helpers
+
+## 0.0.4 (2024-06-24)
+
+- Update `grape.rbi`
+
 ## 0.0.3 (2024-06-05)
 
 - Better support for callbacks

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    grape_sorbet (0.0.3)
+    grape_sorbet (0.0.5)
       activesupport
       grape (~> 2.0)
       sorbet-runtime (~> 0.5.10741)

data/README.md

@@ -1,6 +1,7 @@
 # grape_sorbet
 
 [![Build Status](https://github.com/thatch-health/grape_sorbet/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/thatch-health/grape_sorbet/actions?query=branch%3Amain)
+[![Gem Version ](https://img.shields.io/gem/v/grape_sorbet.svg?style=flat)](https://rubygems.org/gems/grape_sorbet)
 
 grape_sorbet is a gem that provides hand written signatures and a Tapioca DSL compiler that makes it more pleasant to use the [Grape](https://github.com/ruby-grape/grape) API framework in Ruby projects that use the [Sorbet](https://sorbet.org/) typechecker.
 
@@ -9,12 +10,11 @@ grape_sorbet is a gem that provides hand written signatures and a Tapioca DSL co
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add r --github=https://github.com/thatch-health/grape_sorbet
+    $ bundle add grape_sorbet
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install specific_install
-    $ gem specific_install https://github.com/thatch-health/grape_sorbet.git
+    $ gem install grape_sorbet
 
 After installing the gem, make sure to run `bundle exec tapioca gem grape_sorbet` in your project to import the hand written signatures.
 

data/lib/grape_sorbet/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module GrapeSorbet
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

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

@@ -137,14 +137,10 @@ module Tapioca
         def create_endpoint_class
           superclass = "::Grape::Endpoint"
 
-          helper_mods = constant.namespace_stackable(:helpers)
-
-          if helper_mods.any? { |mod| mod.name.nil? }
-            raise "Cannot compile Grape API with anonymous helpers"
-          end
+          named_helper_mods = constant.namespace_stackable(:helpers).reject { |mod| mod.name.nil? }
 
           api.create_class(EndpointClassName, superclass_name: superclass) do |klass|
-            helper_mods.each do |mod|
+            named_helper_mods.each do |mod|
               klass.create_include(mod.name)
             end
           end

data/rbi/grape.rbi

@@ -2,102 +2,127 @@
 # frozen_string_literal: true
 
 module Grape
-  module DSL::Desc
-    # grape evaluates config_block in the context of a dynamically created module that implements the DSL it exposes
-    # at runtime. There's no good way to represent this statically, so block is just typed as T.untyped to prevent
-    # Sorbet from complaining that the DSL methods don't exist.
-    sig do
-      params(
-        description: String,
-        options: T.nilable(T::Hash[Symbol, T.untyped]),
-        config_block: T.nilable(T.proc.bind(T.untyped).void),
-      ).void
+  module DSL
+    module Desc
+      # grape evaluates config_block in the context of a dynamically created module that implements the DSL it exposes
+      # at runtime. There's no good way to represent this statically, so block is just typed as T.untyped to prevent
+      # Sorbet from complaining that the DSL methods don't exist.
+      sig do
+        params(
+          description: String,
+          options: T.nilable(T::Hash[Symbol, T.untyped]),
+          config_block: T.nilable(T.proc.bind(T.untyped).void),
+        ).void
+      end
+      def desc(description, options = T.unsafe(nil), &config_block); end
     end
-    def desc(description, options = T.unsafe(nil), &config_block); end
-  end
 
-  module DSL::RequestResponse::ClassMethods
-    sig { params(args: T.untyped, block: T.proc.bind(Grape::Endpoint).void).void }
-    def rescue_from(*args, &block); end
-  end
+    module Helpers
+      module BaseHelper
+        sig { params(name: Symbol, block: T.proc.bind(Grape::Validations::ParamsScope).void).void }
+        def params(name, &block); end
+      end
 
-  module DSL::Routing::ClassMethods
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
+      module ClassMethods
+        sig { params(new_modules: T.untyped, block: T.nilable(T.proc.bind(Grape::DSL::Helpers::BaseHelper).void)).void }
+        def helpers(*new_modules, &block); end
+      end
     end
-    def delete(*args, &block); end
 
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
+    module RequestResponse
+      module ClassMethods
+        sig { params(args: T.untyped, block: T.proc.bind(Grape::Endpoint).void).void }
+        def rescue_from(*args, &block); end
+      end
     end
-    def get(*args, &block); end
 
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
-    end
-    def options(*args, &block); end
+    module Routing
+      module ClassMethods
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def delete(*args, &block); end
 
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
-    end
-    def patch(*args, &block); end
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def get(*args, &block); end
 
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
-    end
-    def post(*args, &block); end
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def options(*args, &block); end
 
-    # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
-    sig do
-      params(
-        args: T.untyped,
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
-    end
-    def put(*args, &block); end
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def patch(*args, &block); end
+
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def post(*args, &block); end
+
+        # @shim: https://github.com/ruby-grape/grape/blob/v2.0.0/lib/grape/dsl/routing.rb#L148-L154
+        sig do
+          params(
+            args: T.untyped,
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def put(*args, &block); end
+
+        sig do
+          params(
+            methods: T.any(Symbol, String, T::Array[String]),
+            paths: T.nilable(T.any(String, T::Array[String])),
+            route_options: T.nilable(T::Hash[Symbol, T.untyped]),
+            block: T.nilable(T.proc.bind(Grape::Endpoint).void),
+          ).void
+        end
+        def route(methods, paths = T.unsafe(nil), route_options = T.unsafe(nil), &block); end
 
-    sig do
-      params(
-        methods: T.any(Symbol, String, T::Array[String]),
-        paths: T.nilable(T.any(String, T::Array[String])),
-        route_options: T.nilable(T::Hash[Symbol, T.untyped]),
-        block: T.nilable(T.proc.bind(Grape::Endpoint).void),
-      ).void
+        sig do
+          params(
+            param: Symbol,
+            options: T.nilable(T::Hash[Symbol, T.untyped]),
+            block: T.nilable(T.proc.bind(T.class_of(Grape::API::Instance)).void),
+          ).void
+        end
+        def route_param(param, options = T.unsafe(nil), &block); end
+      end
     end
-    def route(methods, paths = T.unsafe(nil), route_options = T.unsafe(nil), &block); end
 
-    sig do
-      params(
-        param: Symbol,
-        options: T.nilable(T::Hash[Symbol, T.untyped]),
-        block: T.nilable(T.proc.bind(T.class_of(Grape::API::Instance)).void),
-      ).void
+    module Validations
+      module ClassMethods
+        sig { params(block: T.proc.bind(Grape::Validations::ParamsScope).void).void }
+        def params(&block); end
+      end
     end
-    def route_param(param, options = T.unsafe(nil), &block); end
   end
 
-  module DSL::Validations::ClassMethods
-    sig { params(block: T.proc.bind(Grape::Validations::ParamsScope).void).void }
-    def params(&block); end
+  class Endpoint
+    sig { returns(Grape::Request) }
+    def request; end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grape_sorbet
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Thatch Health, Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-05 00:00:00.000000000 Z
+date: 2024-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.13
 signing_key:
 specification_version: 4
 summary: Sorbet signatures and Tapioca DSL compiler for Grape.