tapioca 0.4.16 → 0.4.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80a1d62bade6d75e6ec3a7de5a06f96eb7bc4ea002a70a2503d74393e834e864
-  data.tar.gz: 235cd2477d3f07176bdbddd5653c7a5cff86516f81dd196a65043a5b2f7d68dc
+  metadata.gz: 832665c6f2a41c3eb5cfda2b0939b4a3f2d29eb624b64de49565b8275f461326
+  data.tar.gz: 29e1f7066050ce4f308b1dc8591dd7de236e19560618a37c9120a4835ac1b295
 SHA512:
-  metadata.gz: 23bc803e2b251dfb4ef4c82b0793336810ca9d551355ac1cd8d514c1484ef096d9b00a12cda214ce9b4b83ccf1620a32159035a5bf798a4c2d8a3e96b026e352
-  data.tar.gz: 606e2ad0e81c87e7f89b5933fa160d1b7825dee6f3f3451042ad2ec047a672041b559ed9cb79cf75aa0af7020b9aed2da85e1f52f36bb39b909f5037f8865717
+  metadata.gz: a16a1125e343398d7a2190aea74ed2fafc3b9ad5d4aaac8a2b72ae4a75cd65bdb651dcf84528189eec39296eebb42382f847221651190e611f1c7260923653ba
+  data.tar.gz: d636730273b8eb9d828de5609b73c73cb677ec0cf372a1ae5d028604ec53422cbe3c607d557c0b4070dadf704c0023cef1dfb40d09ddb61327d7793db65a0ef0

data/README.md

@@ -1,3 +1,5 @@
+> :warning: **Note**: This software is currently under active development. The API and interface should be considered unstable until a v1.0.0 release.
+
 # Tapioca
 
 ![Build Status](https://github.com/Shopify/tapioca/workflows/CI/badge.svg)
@@ -14,7 +16,7 @@ For gems that have a normal default `require` and load all of their constants th
 
 For example, suppose you are using the class `BetterHtml::Parser` exported from the `better_html` gem. Just doing a `require "better_html"` (which is the default require) does not load that type:
 
-```ruby
+```shell
 $ bundle exec pry
 [1] pry(main)> require 'better_html'
 => true
@@ -110,7 +112,7 @@ This will generate DSL RBIs for specified constants (or for all handled constant
 - `--prerequire [file]`: A file to be required before `Bundler.require` is called.
 - `--postrequire [file]`: A file to be required after `Bundler.require` is called.
 - `--out [directory]`: The output directory for generated RBI files, default to `sorbet/rbi/gems`.
-- `--generate-command [command]`: The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
+- `--generate-command [command]`: **[DEPRECATED]** The command to run to regenerate RBI files (used in header comment of the RBI files), defaults to the current command.
 - `--typed-overrides [gem:level]`: Overrides typed sigils for generated gem RBIs for gem `gem` to level `level` (`level` can be one of `ignore`, `false`, `true`, `strict`, or `strong`, see [the Sorbet docs](https://sorbet.org/docs/static#file-level-granularity-strictness-levels) for more details).
 
 ## Contributing

data/exe/tapioca

@@ -1,6 +1,21 @@
 #! /usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative "../lib/tapioca"
+require 'sorbet-runtime'
 
-Tapioca::Cli.start(ARGV)
+begin
+  T::Configuration.default_checked_level = :never
+  # Suppresses errors caused by T.cast, T.let, T.must, etc.
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  # Suppresses errors caused by incorrect parameter ordering
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  # Need this rescue so that if another gem has
+  # already set the checked level by the time we
+  # get to it, we don't fail outright.
+  nil
+end
+
+require_relative "../lib/tapioca/internal"
+
+Tapioca::Cli::Main.start(ARGV)

data/lib/tapioca.rb

@@ -17,31 +17,5 @@ module Tapioca
   class Error < StandardError; end
 end
 
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
-
-require "tapioca/loader"
-require "tapioca/constant_locator"
-require "tapioca/config"
-require "tapioca/config_builder"
-require "tapioca/generator"
-require "tapioca/cli"
-require "tapioca/gemfile"
-require "tapioca/compilers/sorbet"
-require "tapioca/compilers/requires_compiler"
-require "tapioca/compilers/symbol_table_compiler"
-require "tapioca/compilers/symbol_table/symbol_generator"
-require "tapioca/compilers/symbol_table/symbol_loader"
-require "tapioca/compilers/todos_compiler"
-require "tapioca/compilers/dsl_compiler"
+require "tapioca/compilers/dsl/base"
 require "tapioca/version"

data/lib/tapioca/cli.rb

@@ -4,112 +4,5 @@
 require 'thor'
 
 module Tapioca
-  class Cli < Thor
-    include(Thor::Actions)
-
-    class_option :prerequire,
-                  aliases: ["--pre", "-b"],
-                  banner: "file",
-                  desc: "A file to be required before Bundler.require is called"
-    class_option :postrequire,
-                  aliases: ["--post", "-a"],
-                  banner: "file",
-                  desc: "A file to be required after Bundler.require is called"
-    class_option :outdir,
-                  aliases: ["--out", "-o"],
-                  banner: "directory",
-                  desc: "The output directory for generated RBI files"
-    class_option :generate_command,
-                  aliases: ["--cmd", "-c"],
-                  banner: "command",
-                  desc: "The command to run to regenerate RBI files"
-    class_option :exclude,
-                  aliases: ["-x"],
-                  type: :array,
-                  banner: "gem [gem ...]",
-                  desc: "Excludes the given gem(s) from RBI generation"
-    class_option :typed_overrides,
-                  aliases: ["--typed", "-t"],
-                  type: :hash,
-                  banner: "gem:level [gem:level ...]",
-                  desc: "Overrides for typed sigils for generated gem RBIs"
-
-    map T.unsafe(%w[--version -v] => :__print_version)
-
-    desc "init", "initializes folder structure"
-    def init
-      create_file(Config::SORBET_CONFIG, skip: true) do
-        <<~CONTENT
-          --dir
-          .
-        CONTENT
-      end
-      create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
-        <<~CONTENT
-          # typed: false
-          # frozen_string_literal: true
-
-          # Add your extra requires here
-        CONTENT
-      end
-    end
-
-    desc "require", "generate the list of files to be required by tapioca"
-    def require
-      Tapioca.silence_warnings do
-        generator.build_requires
-      end
-    end
-
-    desc "todo", "generate the list of unresolved constants"
-    def todo
-      Tapioca.silence_warnings do
-        generator.build_todos
-      end
-    end
-
-    desc "dsl [constant...]", "generate RBIs for dynamic methods"
-    option :generators,
-      type: :array,
-      aliases: ["--gen", "-g"],
-      banner: "generator [generator ...]",
-      desc: "Only run supplied DSL generators"
-    def dsl(*constants)
-      Tapioca.silence_warnings do
-        generator.build_dsl(constants)
-      end
-    end
-
-    desc "generate [gem...]", "generate RBIs from gems"
-    def generate(*gems)
-      Tapioca.silence_warnings do
-        generator.build_gem_rbis(gems)
-      end
-    end
-
-    desc "sync", "sync RBIs to Gemfile"
-    def sync
-      Tapioca.silence_warnings do
-        generator.sync_rbis_with_gemfile
-      end
-    end
-
-    desc "--version, -v", "show version"
-    def __print_version
-      puts "Tapioca v#{Tapioca::VERSION}"
-    end
-
-    no_commands do
-      def self.exit_on_failure?
-        true
-      end
-
-      def generator
-        current_command = T.must(current_command_chain.first)
-        @generator ||= Generator.new(
-          ConfigBuilder.from_options(current_command, options)
-        )
-      end
-    end
-  end
+  module Cli; end
 end

data/lib/tapioca/cli/main.rb

@@ -0,0 +1,146 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Cli
+    class Main < Thor
+      include(Thor::Actions)
+
+      class_option :prerequire,
+                    aliases: ["--pre", "-b"],
+                    banner: "file",
+                    desc: "A file to be required before Bundler.require is called"
+      class_option :postrequire,
+                    aliases: ["--post", "-a"],
+                    banner: "file",
+                    desc: "A file to be required after Bundler.require is called"
+      class_option :outdir,
+                    aliases: ["--out", "-o"],
+                    banner: "directory",
+                    desc: "The output directory for generated RBI files"
+      class_option :generate_command,
+                    aliases: ["--cmd", "-c"],
+                    banner: "command",
+                    desc: "The command to run to regenerate RBI files"
+      class_option :exclude,
+                    aliases: ["-x"],
+                    type: :array,
+                    banner: "gem [gem ...]",
+                    desc: "Excludes the given gem(s) from RBI generation"
+      class_option :typed_overrides,
+                    aliases: ["--typed", "-t"],
+                    type: :hash,
+                    banner: "gem:level [gem:level ...]",
+                    desc: "Overrides for typed sigils for generated gem RBIs"
+
+      map T.unsafe(%w[--version -v] => :__print_version)
+
+      desc "init", "initializes folder structure"
+      def init
+        create_config
+        create_post_require
+        generate_binstub
+      end
+
+      desc "require", "generate the list of files to be required by tapioca"
+      def require
+        Tapioca.silence_warnings do
+          generator.build_requires
+        end
+      end
+
+      desc "todo", "generate the list of unresolved constants"
+      def todo
+        Tapioca.silence_warnings do
+          generator.build_todos
+        end
+      end
+
+      desc "dsl [constant...]", "generate RBIs for dynamic methods"
+      option :generators,
+        type: :array,
+        aliases: ["--gen", "-g"],
+        banner: "generator [generator ...]",
+        desc: "Only run supplied DSL generators"
+      option :verify,
+        type: :boolean,
+        default: false,
+        desc: "Verifies RBIs are up-to-date"
+      option :quiet,
+        aliases: ["-q"],
+        type: :boolean,
+        desc: "Supresses file creation output"
+      def dsl(*constants)
+        Tapioca.silence_warnings do
+          generator.build_dsl(constants, should_verify: options[:verify], quiet: options[:quiet])
+        end
+      end
+
+      desc "generate [gem...]", "generate RBIs from gems"
+      def generate(*gems)
+        Tapioca.silence_warnings do
+          generator.build_gem_rbis(gems)
+        end
+      end
+
+      desc "sync", "sync RBIs to Gemfile"
+      def sync
+        Tapioca.silence_warnings do
+          generator.sync_rbis_with_gemfile
+        end
+      end
+
+      desc "--version, -v", "show version"
+      def __print_version
+        puts "Tapioca v#{Tapioca::VERSION}"
+      end
+
+      private
+
+      def create_config
+        create_file(Config::SORBET_CONFIG, skip: true) do
+          <<~CONTENT
+            --dir
+            .
+          CONTENT
+        end
+      end
+
+      def create_post_require
+        create_file(Config::DEFAULT_POSTREQUIRE, skip: true) do
+          <<~CONTENT
+            # typed: false
+            # frozen_string_literal: true
+
+            # Add your extra requires here
+          CONTENT
+        end
+      end
+
+      def generate_binstub
+        bin_stub_exists = File.exist?("bin/tapioca")
+        installer = Bundler::Installer.new(Bundler.root, Bundler.definition)
+        spec = Bundler.definition.specs.find { |s| s.name == "tapioca" }
+        installer.generate_bundler_executable_stubs(spec, { force: true })
+        if bin_stub_exists
+          shell.say_status(:force, "bin/tapioca", :yellow)
+        else
+          shell.say_status(:create, "bin/tapioca", :green)
+        end
+      end
+
+      no_commands do
+        def self.exit_on_failure?
+          true
+        end
+
+        def generator
+          current_command = T.must(current_command_chain.first)
+          @generator ||= Generator.new(
+            ConfigBuilder.from_options(current_command, options)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -371,7 +371,6 @@ module Tapioca
           return unless signature
 
           return_type = signature.return_type
-          return if T::Types::Simple === return_type && T::Generic === return_type.raw_type
           return if return_type == T::Private::Types::Void || return_type == T::Private::Types::NotTyped
 
           return_type.to_s
@@ -382,10 +381,11 @@ module Tapioca
           signature = T::Private::Methods.signature_for_method(column_type.method(method))
           return unless signature
 
-          arg_type = signature.arg_types.first.last
-          return if T::Types::Simple === arg_type && T::Generic === arg_type.raw_type
+          # Arg types is an array [name, type] entries, so we desctructure the type of
+          # first argument to get the first argument type
+          _, first_argument_type = signature.arg_types.first
 
-          arg_type.to_s
+          first_argument_type.to_s
         end
 
         sig { params(type: String).returns(String) }

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

@@ -60,7 +60,7 @@ module Tapioca
 
             model.create_module(module_name) do |mod|
               scope_method_names.each do |scope_method|
-                generate_scope_method(scope_method, mod)
+                generate_scope_method(scope_method.to_s, mod)
               end
             end
 

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

@@ -123,7 +123,7 @@ module Tapioca
         # Compile a Ruby method return type into a Parlour type
         sig do
           params(method_def: T.any(Method, UnboundMethod))
-            .returns(String)
+            .returns(T.nilable(String))
         end
         def compile_method_return_type_to_parlour(method_def)
           signature = T::Private::Methods.signature_for_method(method_def)

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

@@ -62,33 +62,99 @@ module Tapioca
       # end
       # ~~~
       class Protobuf < Base
+        # Parlour doesn't support type members out of the box, so adding the
+        # ability to do that here. This should be upstreamed.
+        class TypeMember < Parlour::RbiGenerator::RbiObject
+          extend T::Sig
+
+          sig { params(other: Object).returns(T::Boolean) }
+          def ==(other)
+            TypeMember === other && name == other.name
+          end
+
+          sig do
+            override
+              .params(indent_level: Integer, options: Parlour::RbiGenerator::Options)
+              .returns(T::Array[String])
+          end
+          def generate_rbi(indent_level, options)
+            [options.indented(indent_level, "#{name} = type_member")]
+          end
+
+          sig do
+            override
+              .params(others: T::Array[Parlour::RbiGenerator::RbiObject])
+              .returns(T::Boolean)
+          end
+          def mergeable?(others)
+            others.all? { |other| self == other }
+          end
+
+          sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+          def merge_into_self(others); end
+
+          sig { override.returns(String) }
+          def describe
+            "Type Member (#{name})"
+          end
+        end
+
+        class Field < T::Struct
+          prop :name, String
+          prop :type, String
+          prop :init_type, String
+          prop :default, String
+
+          extend T::Sig
+
+          sig { returns(Parlour::RbiGenerator::Parameter) }
+          def to_init
+            Parlour::RbiGenerator::Parameter.new("#{name}:", type: init_type, default: default)
+          end
+        end
+
         extend T::Sig
 
         sig do
           override.params(
             root: Parlour::RbiGenerator::Namespace,
-            constant: T.class_of(Google::Protobuf::MessageExts)
+            constant: Module
           ).void
         end
         def decorate(root, constant)
-          descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
-          return unless descriptor.any?
-
           root.path(constant) do |klass|
-            descriptor.each do |desc|
-              create_descriptor_method(klass, desc)
+            if constant == Google::Protobuf::RepeatedField
+              create_type_members(klass, "Elem")
+            elsif constant == Google::Protobuf::Map
+              create_type_members(klass, "Key", "Value")
+            else
+              descriptor = T.let(T.unsafe(constant).descriptor, Google::Protobuf::Descriptor)
+              fields = descriptor.map { |desc| create_descriptor_method(klass, desc) }
+              fields.sort_by!(&:name)
+
+              create_method(klass, "initialize", parameters: fields.map!(&:to_init))
             end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          classes = T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class])
-          classes.select { |c| c < Google::Protobuf::MessageExts && !c.singleton_class? }
+          marker = Google::Protobuf::MessageExts::ClassMethods
+          results = T.cast(ObjectSpace.each_object(marker).to_a, T::Array[Module])
+          results.any? ? results + [Google::Protobuf::RepeatedField, Google::Protobuf::Map] : []
         end
 
         private
 
+        sig { params(klass: Parlour::RbiGenerator::Namespace, names: String).void }
+        def create_type_members(klass, *names)
+          klass.create_extend("T::Generic")
+
+          names.each do |name|
+            klass.children << TypeMember.new(klass.generator, name)
+          end
+        end
+
         sig do
           params(
             descriptor: Google::Protobuf::FieldDescriptor
@@ -113,30 +179,80 @@ module Tapioca
           end
         end
 
+        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(Field) }
+        def field_of(descriptor)
+          if descriptor.label == :repeated
+            # Here we're going to check if the submsg_name is named according to
+            # how Google names map entries.
+            # https://github.com/protocolbuffers/protobuf/blob/f82e26/ruby/ext/google/protobuf_c/defs.c#L1963-L1966
+            if descriptor.submsg_name.to_s.end_with?("_MapEntry_#{descriptor.name}")
+              key = descriptor.subtype.lookup('key')
+              value = descriptor.subtype.lookup('value')
+
+              key_type = type_of(key)
+              value_type = type_of(value)
+              type = "Google::Protobuf::Map[#{key_type}, #{value_type}]"
+
+              default_args = [key.type.inspect, value.type.inspect]
+              default_args << value_type if %i[enum message].include?(value.type)
+
+              Field.new(
+                name: descriptor.name,
+                type: type,
+                init_type: "T.any(#{type}, T::Hash[#{key_type}, #{value_type}])",
+                default: "Google::Protobuf::Map.new(#{default_args.join(', ')})"
+              )
+            else
+              elem_type = type_of(descriptor)
+              type = "Google::Protobuf::RepeatedField[#{elem_type}]"
+
+              default_args = [descriptor.type.inspect]
+              default_args << elem_type if %i[enum message].include?(descriptor.type)
+
+              Field.new(
+                name: descriptor.name,
+                type: type,
+                init_type: "T.any(#{type}, T::Array[#{elem_type}])",
+                default: "Google::Protobuf::RepeatedField.new(#{default_args.join(', ')})"
+              )
+            end
+          else
+            type = type_of(descriptor)
+
+            Field.new(
+              name: descriptor.name,
+              type: type,
+              init_type: type,
+              default: "nil"
+            )
+          end
+        end
+
         sig do
           params(
             klass: Parlour::RbiGenerator::Namespace,
             desc: Google::Protobuf::FieldDescriptor,
-          ).void
+          ).returns(Field)
         end
         def create_descriptor_method(klass, desc)
-          name = desc.name
-          type = type_of(desc)
+          field = field_of(desc)
 
           create_method(
             klass,
-            name,
-            return_type: type
+            field.name,
+            return_type: field.type
           )
 
           create_method(
             klass,
-            "#{name}=",
+            "#{field.name}=",
             parameters: [
-              Parlour::RbiGenerator::Parameter.new("value", type: type),
+              Parlour::RbiGenerator::Parameter.new("value", type: field.type),
             ],
-            return_type: type
+            return_type: field.type
           )
+
+          field
         end
       end
     end