sorbet 0.4.4250 → 0.4.4253

data/lib/create-config.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative './step_interface'
+
+require 'fileutils'
+
+class Sorbet; end
+module Sorbet::Private; end
+class Sorbet::Private::CreateConfig
+  SORBET_DIR = 'sorbet'
+  SORBET_CONFIG_FILE = "#{SORBET_DIR}/config"
+
+  include Sorbet::Private::StepInterface
+
+  def self.main
+    FileUtils.mkdir_p(SORBET_DIR)
+
+    File.open(SORBET_CONFIG_FILE, 'w') do |f|
+      f.puts('--dir')
+      f.puts('.')
+    end
+  end
+
+  def self.output_file
+    SORBET_CONFIG_FILE
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  Sorbet::Private::CreateConfig.main
+end

data/lib/fetch-rbis.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# typed: false
+
+require_relative './step_interface'
+require_relative './t'
+
+require 'bundler'
+require 'fileutils'
+require 'set'
+
+class Sorbet; end
+module Sorbet::Private; end
+class Sorbet::Private::FetchRBIs
+  SORBET_DIR = 'sorbet'
+  SORBET_CONFIG_FILE = "#{SORBET_DIR}/config"
+  SORBET_RBI_LIST = "#{SORBET_DIR}/rbi_list"
+  SORBET_RBI_SORBET_TYPED = "#{SORBET_DIR}/rbi/sorbet-typed/"
+
+  XDG_CACHE_HOME = ENV['XDG_CACHE_HOME'] || "#{ENV['HOME']}/.cache"
+  RBI_CACHE_DIR = "#{XDG_CACHE_HOME}/sorbet/sorbet-typed"
+
+  SORBET_TYPED_REPO = 'https://github.com/sorbet/sorbet-typed.git'
+  SORBET_TYPED_REVISION = ENV['SRB_SORBET_TYPED_REVISION'] || 'origin/master'
+
+  HEADER = Sorbet::Private::Serialize.header(false, 'sorbet-typed')
+
+  include Sorbet::Private::StepInterface
+
+  # Ensure our cache is up-to-date
+  T::Sig::WithoutRuntime.sig {void}
+  def self.fetch_sorbet_typed
+    if !File.directory?(RBI_CACHE_DIR)
+      IO.popen(["git", "clone", SORBET_TYPED_REPO, RBI_CACHE_DIR]) {|pipe| pipe.read}
+      raise "Failed to git pull" if $?.exitstatus != 0
+    end
+
+    FileUtils.cd(RBI_CACHE_DIR) do
+      IO.popen(%w{git fetch origin}) {|pipe| pipe.read}
+      raise "Failed to git fetch" if $?.exitstatus != 0
+      IO.popen(%w{git checkout -q} + [SORBET_TYPED_REVISION]) {|pipe| pipe.read}
+      raise "Failed to git checkout" if $?.exitstatus != 0
+    end
+  end
+
+  # List of directories whose names satisfy the given Gem::Version (+ 'all/')
+  T::Sig::WithoutRuntime.sig do
+    params(
+      root: String,
+      version: Gem::Version,
+    )
+    .returns(T::Array[String])
+  end
+  def self.matching_version_directories(root, version)
+    paths = Dir.glob("#{root}/*/").select do |dir|
+      basename = File.basename(dir.chomp('/'))
+      requirements = basename.split(/[,&-]/) # split using ',', '-', or '&'
+      requirements.all? do |requirement|
+        Gem::Requirement::PATTERN =~ requirement &&
+          Gem::Requirement.create(requirement).satisfied_by?(version)
+      end
+    end
+    paths = paths.map {|dir| dir.chomp('/')}
+    all_dir = "#{root}/all"
+    paths << all_dir if Dir.exist?(all_dir)
+    paths
+  end
+
+  # List of directories in lib/ruby whose names satisfy the current RUBY_VERSION
+  T::Sig::WithoutRuntime.sig {params(ruby_version: Gem::Version).returns(T::Array[String])}
+  def self.paths_for_ruby_version(ruby_version)
+    ruby_dir = "#{RBI_CACHE_DIR}/lib/ruby"
+    matching_version_directories(ruby_dir, ruby_version)
+  end
+
+  # List of directories in lib/gemspec.name whose names satisfy gemspec.version
+  T::Sig::WithoutRuntime.sig {params(gemspec: T.untyped).returns(T::Array[String])}
+  def self.paths_for_gem_version(gemspec)
+    local_dir = "#{RBI_CACHE_DIR}/lib/#{gemspec.name}"
+    matching_version_directories(local_dir, gemspec.version)
+  end
+
+  # Copy the relevant RBIs into their repo, with matching folder structure.
+  T::Sig::WithoutRuntime.sig {params(vendor_paths: T::Array[String]).void}
+  def self.vendor_rbis_within_paths(vendor_paths)
+    vendor_paths.each do |vendor_path|
+      relative_vendor_path = vendor_path.sub(RBI_CACHE_DIR, '')
+
+      dest = "#{SORBET_RBI_SORBET_TYPED}/#{relative_vendor_path}"
+      FileUtils.mkdir_p(dest)
+
+      Dir.glob("#{vendor_path}/*.rbi").each do |rbi|
+        extra_header = "#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master#{relative_vendor_path}/#{File.basename(rbi)}
+#
+"
+        File.write("#{dest}/#{File.basename(rbi)}", HEADER + extra_header + File.read(rbi))
+      end
+    end
+  end
+
+  T::Sig::WithoutRuntime.sig {void}
+  def self.main
+    fetch_sorbet_typed
+
+    gemspecs = Bundler.load.specs.sort_by(&:name)
+
+    vendor_paths = T.let([], T::Array[String])
+    vendor_paths += paths_for_ruby_version(Gem::Version.create(RUBY_VERSION))
+    gemspecs.each do |gemspec|
+      vendor_paths += paths_for_gem_version(gemspec)
+    end
+
+    if vendor_paths.length > 0
+      vendor_rbis_within_paths(vendor_paths)
+    end
+  end
+
+  def self.output_file
+    SORBET_RBI_SORBET_TYPED
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  Sorbet::Private::FetchRBIs.main
+end

data/lib/find-gem-rbis.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# typed: false
+
+require_relative './step_interface'
+require_relative './t'
+
+require 'bundler'
+require 'fileutils'
+require 'set'
+require 'digest'
+
+class Sorbet; end
+module Sorbet::Private; end
+class Sorbet::Private::FindGemRBIs
+  XDG_CACHE_HOME = ENV['XDG_CACHE_HOME'] || "#{ENV['HOME']}/.cache"
+  RBI_CACHE_DIR = "#{XDG_CACHE_HOME}/sorbet/gem-rbis/"
+  GEM_DIR = 'rbi'
+
+  HEADER = Sorbet::Private::Serialize.header(false, 'find-gem-rbis')
+
+  include Sorbet::Private::StepInterface
+
+  # List of rbi folders in the gem's source
+  T::Sig::WithoutRuntime.sig {params(gemspec: T.untyped).returns(T.nilable(String))}
+  def self.paths_within_gem_sources(gemspec)
+    gem_rbi = "#{gemspec.full_gem_path}/#{GEM_DIR}"
+    gem_rbi if Dir.exist?(gem_rbi)
+  end
+
+  T::Sig::WithoutRuntime.sig {void}
+  def self.main
+    FileUtils.mkdir_p(RBI_CACHE_DIR) unless Dir.exist?(RBI_CACHE_DIR)
+    output_file = File.exist?('Gemfile.lock') ? RBI_CACHE_DIR + Digest::MD5.hexdigest(File.read('Gemfile.lock')) : nil
+    return unless output_file
+    gemspecs = Bundler.load.specs.sort_by(&:name)
+
+    gem_source_paths = T.let([], T::Array[String])
+    gemspecs.each do |gemspec|
+      gem_source_paths << paths_within_gem_sources(gemspec)
+    end
+
+    File.write(output_file, gem_source_paths.compact.join("\n"))
+  end
+
+  def self.output_file
+    nil
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  Sorbet::Private::FindGemRBIs.main
+end

data/lib/gem-generator-tracepoint.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+# typed: true
+
+class Sorbet; end
+module Sorbet::Private; end
+
+require_relative './t'
+require_relative './step_interface'
+require_relative './require_everything'
+require_relative './gem-generator-tracepoint/tracer'
+require_relative './gem-generator-tracepoint/tracepoint_serializer'
+
+require 'set'
+
+# TODO switch the Struct handling to:
+#
+# class Subclass < Struct(:key1, :key2)
+# end
+#
+# generating:
+#
+# TemporaryStruct = Struct(:key1, :key2)
+# class Subclass < TemporaryStruct
+# end
+#
+# instead of manually defining every getter/setter
+
+module Sorbet::Private
+  module GemGeneratorTracepoint
+    OUTPUT = 'sorbet/rbi/gems/'
+
+    include Sorbet::Private::StepInterface
+
+    T::Sig::WithoutRuntime.sig {params(output_dir: String).void}
+    def self.main(output_dir = OUTPUT)
+      trace_results = Tracer.trace do
+        Sorbet::Private::RequireEverything.require_everything
+      end
+
+      FileUtils.rm_r(output_dir) if Dir.exist?(output_dir)
+      TracepointSerializer.new(trace_results).serialize(output_dir)
+    end
+
+    def self.output_file
+      OUTPUT
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  Sorbet::Private::GemGeneratorTracepoint.main
+end

data/lib/gem-generator-tracepoint/tracepoint_serializer.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+# typed: true
+
+require_relative '../serialize'
+require_relative '../real_stdlib'
+
+require 'set'
+require 'fileutils'
+
+
+module Sorbet::Private
+  module GemGeneratorTracepoint
+    ClassDefinition = Struct.new(:id, :klass, :defs)
+
+    class TracepointSerializer
+      SPECIAL_METHOD_NAMES = %w[! ~ +@ ** -@ * / % + - << >> & | ^ < <= => > >= == === != =~ !~ <=> [] []= `]
+
+      # These methods don't match the signatures of their parents, so if we let
+      # them monkeypatch, they won't be subtypes anymore. Just don't support the
+      # bad monkeypatches.
+      BAD_METHODS = [
+        ['activesupport', 'Time', :to_s],
+        ['activesupport', 'Time', :initialize],
+      ]
+
+      HEADER = Sorbet::Private::Serialize.header('true', 'gems')
+
+      T::Sig::WithoutRuntime.sig {params(files: T::Hash, delegate_classes: T::Hash).void}
+      def initialize(files:, delegate_classes:)
+        @files = files
+        @delegate_classes = delegate_classes
+
+        @anonymous_map = {}
+        @prev_anonymous_id = 0
+      end
+
+      T::Sig::WithoutRuntime.sig {params(output_dir: String).void}
+      def serialize(output_dir)
+        gem_class_defs = preprocess(@files)
+
+        FileUtils.mkdir_p(output_dir) unless gem_class_defs.empty?
+
+        gem_class_defs.each do |gem, klass_ids|
+          File.open("#{File.join(output_dir, gem[:gem])}.rbi", 'w') do |f|
+            f.write(HEADER)
+            f.write("#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/#{gem[:gem]}/all/#{gem[:gem]}.rbi
+#
+")
+            f.write("# #{gem[:gem]}-#{gem[:version]}\n")
+            klass_ids.each do |klass_id, class_def|
+              klass = class_def.klass
+
+              f.write("#{Sorbet::Private::RealStdlib.real_is_a?(klass, Class) ? 'class' : 'module'} #{class_name(klass)}")
+              f.write(" < #{class_name(klass.superclass)}") if Sorbet::Private::RealStdlib.real_is_a?(klass, Class) && ![Object, nil].include?(klass.superclass)
+              f.write("\n")
+
+              rows = class_def.defs.map do |item|
+                case item[:type]
+                when :method
+                  if !valid_method_name?(item[:method])
+                    # warn("Invalid method name: #{klass}.#{item[:method]}")
+                    next
+                  end
+                  if BAD_METHODS.include?([gem[:gem], class_name(klass), item[:method]])
+                    next
+                  end
+                  begin
+                    method = item[:singleton] ? klass.method(item[:method]) : klass.instance_method(item[:method])
+                    "#{generate_method(method, !item[:singleton])}"
+                  rescue NameError
+                  end
+                when :include, :extend
+                  name = class_name(item[item[:type]])
+                  "  #{item[:type]} #{name}"
+                end
+              end
+              rows = rows.compact.sort
+              f.write(rows.join("\n"))
+              f.write("\n") if !rows.empty?
+              f.write("end\n")
+            end
+          end
+        end
+      end
+
+      private
+
+      def preprocess(files)
+        gem_class_defs = files_to_gem_class_defs(files)
+        filter_unused(gem_class_defs)
+      end
+
+      def files_to_gem_class_defs(files)
+        # Transform tracer output into hash of gems to class definitions
+        files.each_with_object({}) do |(path, defined), gem_class_defs|
+          gem = gem_from_location(path)
+          if gem.nil?
+            warn("Can't find gem for #{path}") unless path.start_with?(Dir.pwd)
+            next
+          end
+          next if gem[:gem] == 'ruby'
+          # We're currently ignoring bundler, because we can't easily pin
+          # everyone to the same version of bundler in tests and in CI.
+          # There is an RBI for bundler in sorbet-typed.
+          next if gem[:gem] == 'bundler'
+
+          gem_class_defs[gem] ||= {}
+          defined.each do |item|
+            klass = item[:module]
+            klass_id = Sorbet::Private::RealStdlib.real_object_id(klass)
+            class_def = gem_class_defs[gem][klass_id] ||= ClassDefinition.new(klass_id, klass, [])
+            class_def.defs << item unless item[:type] == :module
+          end
+        end
+      end
+
+      def filter_unused(gem_class_defs)
+        used = detect_used(gem_class_defs)
+
+        gem_class_defs.each_with_object({}) do |(gem, klass_defs), hsh|
+          hsh[gem] = klass_defs.select do |klass_id, klass_def|
+            klass = klass_def.klass
+
+            # Unused anon classes
+            next if !((Sorbet::Private::RealStdlib.real_is_a?(klass, Module) && !Sorbet::Private::RealStdlib.real_name(klass).nil?) || used?(klass_id, used))
+
+            # Anon delegate classes
+            next if Sorbet::Private::RealStdlib.real_is_a?(klass, Class) && klass.superclass == Delegator && !klass.name
+
+            # TODO should this be here?
+            # next if [Object, BasicObject, Hash].include?(klass)
+            true
+          end
+        end
+      end
+
+      def detect_used(gem_class_defs)
+        # subclassed, included, or extended
+        used = {}
+
+        gem_class_defs.each do |gem, klass_ids|
+          klass_ids.each do |klass_id, class_def|
+            klass = class_def.klass
+
+            # only add an anon module if it's used as a superclass of a non-anon module, or is included/extended by a non-anon module
+            used_value = Sorbet::Private::RealStdlib.real_is_a?(klass, Module) && !Sorbet::Private::RealStdlib.real_name(klass).nil? ? true : Sorbet::Private::RealStdlib.real_object_id(klass) # if non-anon, set it to true
+            (used[Sorbet::Private::RealStdlib.real_object_id(klass.superclass)] ||= Set.new) << used_value if Sorbet::Private::RealStdlib.real_is_a?(klass, Class)
+            # otherwise link to next anon class
+            class_def.defs.each do |item|
+              (used[item[item[:type]].object_id] ||= Set.new) << used_value if [:extend, :include].include?(item[:type])
+            end
+          end
+        end
+
+        used
+      end
+
+      def used?(klass, used)
+        used_by = used[klass] || []
+        used_by.any? { |user| user == true || used?(user, used) }
+      end
+
+      def generate_method(method, instance, spaces = 2)
+        # method.parameters is an array of:
+        # a      [:req, :a]
+        # b = 1  [:opt, :b]
+        # c:     [:keyreq, :c]
+        # d: 1   [:key, :d]
+        # *e     [:rest, :e]
+        # **f    [:keyrest, :f]
+        # &g     [:block, :g]
+        prefix = ' ' * spaces
+        parameters = method.parameters.map.with_index do |(type, name), index|
+          name = "arg#{index}" if name.nil? || name.empty?
+          case type
+          when :req
+            name
+          when :opt
+            "#{name} = nil"
+          when :keyreq
+            "#{name}:"
+          when :key
+            "#{name}: nil"
+          when :rest
+            "*#{name}"
+          when :keyrest
+            "**#{name}"
+          when :block
+            "&#{name}"
+          else
+            raise "Unknown parameter type: #{type}"
+          end
+        end
+        parameters = parameters.join(', ')
+        parameters = "(#{parameters})" unless parameters.empty?
+        "#{prefix}def #{instance ? '' : 'self.'}#{method.name}#{parameters}; end"
+      end
+
+      def anonymous_id
+        @prev_anonymous_id += 1
+      end
+
+      def gem_from_location(location)
+        match =
+          location&.match(/^.*\/(ruby)\/([\d.]+)\//) || # ruby stdlib
+          location&.match(/^.*\/(site_ruby)\/([\d.]+)\//) || # rubygems
+          location&.match(/^.*\/gems\/(?:ruby-)?[\d.]+(?:\/bundler)?\/gems\/([^\/]+)-([^-\/]+)\//i) # gem
+        if match.nil?
+          # uncomment to generate files for methods outside of gems
+          # {
+          #   path: location,
+          #   gem: location.gsub(/[\/\.]/, '_'),
+          #   version: '1.0.0',
+          # }
+          nil
+        else
+          {
+            path: match[0],
+            gem: match[1],
+            version: match[2],
+          }
+        end
+      end
+
+      def class_name(klass)
+        klass = @delegate_classes[Sorbet::Private::RealStdlib.real_object_id(klass)] || klass
+        name = Sorbet::Private::RealStdlib.real_name(klass) if Sorbet::Private::RealStdlib.real_is_a?(klass, Module)
+
+        # class/module has no name; it must be anonymous
+        if name.nil? || name == ""
+          middle = Sorbet::Private::RealStdlib.real_is_a?(klass, Class) ? klass.superclass : klass.class
+          id = @anonymous_map[Sorbet::Private::RealStdlib.real_object_id(klass)] ||= anonymous_id
+          return "Anonymous_#{class_name(middle).gsub('::', '_')}_#{id}"
+        end
+
+        # if the name doesn't only contain word characters and ':', or any part doesn't start with a capital, Sorbet doesn't support it
+        if name !~ /^[\w:]+$/ || !name.split('::').all? { |part| part =~ /^[A-Z]/ }
+          # warn("Invalid class name: #{name}")
+          id = @anonymous_map[Sorbet::Private::RealStdlib.real_object_id(klass)] ||= anonymous_id
+          return "InvalidName_#{name.gsub(/[^\w]/, '_').gsub(/0x([0-9a-f]+)/, '0x00')}_#{id}"
+        end
+
+        name
+      end
+
+      def valid_method_name?(symbol)
+        string = symbol.to_s
+        return true if SPECIAL_METHOD_NAMES.include?(string)
+        string =~ /^[[:word:]]+[?!=]?$/
+      end
+    end
+  end
+end