rbs 0.12.2 → 0.16.0

data/lib/rbs/type_name.rb

@@ -16,14 +16,15 @@ module RBS
               when "_"
                 :interface
               else
-                raise
+                # Defaults to :class
+                :class
               end
     end
 
     def ==(other)
       other.is_a?(self.class) && other.namespace == namespace && other.name == name
     end
-    
+
     alias eql? ==
 
     def hash

data/lib/rbs/variance_calculator.rb

@@ -120,7 +120,7 @@ module RBS
 
         type.args.each.with_index do |ty, i|
           var = type_params.params[i]
-          case var.variance
+          case var&.variance
           when :invariant
             type(ty, result: result, context: :invariant)
           when :covariant
@@ -135,7 +135,7 @@ module RBS
                   when :contravariant
                     :covariant
                   else
-                    raise                    
+                    raise
                   end
             type(ty, result: result, context: con)
           end

data/lib/rbs/vendorer.rb

@@ -1,9 +1,11 @@
 module RBS
   class Vendorer
     attr_reader :vendor_dir
+    attr_reader :loader
 
-    def initialize(vendor_dir:)
+    def initialize(vendor_dir:, loader:)
       @vendor_dir = vendor_dir
+      @loader = loader
     end
 
     def ensure_dir
@@ -21,27 +23,47 @@ module RBS
       end
     end
 
-    def stdlib!()
-      ensure_dir do
-        RBS.logger.info "Vendoring stdlib: #{EnvironmentLoader::STDLIB_ROOT} => #{vendor_dir + "stdlib"}..."
-        FileUtils.copy_entry EnvironmentLoader::STDLIB_ROOT, vendor_dir + "stdlib"
+    def copy!
+      # @type var paths: Set[[Pathname, Pathname]]
+      paths = Set[]
+
+      if core_root = loader.core_root
+        RBS.logger.info "Vendoring core RBSs in #{vendor_dir + "core"}..."
+        loader.each_file(core_root, immediate: false, skip_hidden: true) do |file_path|
+          paths << [file_path, Pathname("core") + file_path.relative_path_from(core_root)]
+        end
       end
-    end
 
-    def gem!(name, version)
-      ensure_dir do
-        sig_path = EnvironmentLoader.gem_sig_path(name, version)
-        RBS.logger.debug "Checking gem signature path: name=#{name}, version=#{version}, path=#{sig_path}"
+      loader.libs.each do |lib|
+        case
+        when (spec, path = EnvironmentLoader.gem_sig_path(lib.name, lib.version))
+          dest_dir = Pathname("#{lib.name}-#{spec.version}")
+
+          RBS.logger.info "Vendoring #{lib.name}(#{spec.version}) RBSs in #{vendor_dir + dest_dir}..."
 
-        if sig_path&.directory?
-          gems_dir = vendor_dir + "gems"
-          gems_dir.mkpath unless gems_dir.directory?
+          loader.each_file(path, skip_hidden: true, immediate: false) do |file_path|
+            paths << [file_path, dest_dir + file_path.relative_path_from(path)]
+          end
 
-          gem_dir = gems_dir + name
-          RBS.logger.info "Vendoring gem(#{name}:#{version}): #{sig_path} => #{gem_dir}..."
-          FileUtils.copy_entry sig_path, gem_dir
+        when (rbs, path = loader.repository.lookup_path(lib.name, lib.version))
+          dest_dir = Pathname("#{rbs.name}-#{path.version}")
+
+          RBS.logger.info "Vendoring #{lib.name}(#{path.version}) RBSs in #{vendor_dir + dest_dir}..."
+
+          loader.each_file(path.path, skip_hidden: true, immediate: false) do |file_path|
+            paths << [file_path, dest_dir + file_path.relative_path_from(path.path)]
+          end
+        else
+          RBS.logger.error "Couldn't find RBSs for #{lib.name} (#{lib.version}); skipping..."
         end
       end
+
+      paths.each do |from, to|
+        dest = vendor_dir + to
+        dest.parent.mkpath unless dest.parent.directory?
+
+        FileUtils.copy_file(from.to_s, dest.to_s)
+      end
     end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.12.2"
+  VERSION = "0.16.0"
 end

data/lib/rbs/writer.rb

@@ -60,6 +60,8 @@ module RBS
 
     def write(decls)
       [nil, *decls].each_cons(2) do |prev, decl|
+        raise unless decl
+
         preserve_empty_line(prev, decl)
         write_decl decl
       end
@@ -68,8 +70,8 @@ module RBS
     def write_decl(decl)
       case decl
       when AST::Declarations::Class
-        super_class = if decl.super_class
-                        " < #{name_and_args(decl.super_class.name, decl.super_class.args)}"
+        super_class = if super_class = decl.super_class
+                        " < #{name_and_args(super_class.name, super_class.args)}"
                       end
         write_comment decl.comment
         write_annotation decl.annotations
@@ -77,6 +79,8 @@ module RBS
 
         indent do
           [nil, *decl.members].each_cons(2) do |prev, member|
+            raise unless member
+
             preserve_empty_line prev, member
             write_member member
           end
@@ -134,9 +138,6 @@ module RBS
 
         puts "end"
 
-      when AST::Declarations::Extension
-        RBS.logger.warn "Extension is ignored: #{decl.name}"
-
       end
     end
 
@@ -288,20 +289,29 @@ module RBS
     end
 
     def preserve_empty_line(prev, decl)
-      return unless prev
+      # @type var decl: _Located
 
-      decl = decl.comment if decl.respond_to?(:comment) && decl.comment
+      return unless prev
 
-      # When the signature is not constructed by the parser,
-      # it always inserts an empty line.
-      if !prev.location || !decl.location
-        puts
-        return
+      if (_ = decl).respond_to?(:comment)
+        if comment = (_ = decl).comment
+          decl = comment
+        end
       end
 
-      prev_end_line = prev.location.end_line
-      start_line = decl.location.start_line
-      if start_line - prev_end_line > 1
+      prev_loc = prev.location
+      decl_loc = decl.location
+
+      if prev_loc && decl_loc
+        prev_end_line = prev_loc.end_line
+        start_line = decl_loc.start_line
+
+        if start_line - prev_end_line > 1
+          puts
+        end
+      else
+        # When the signature is not constructed by the parser,
+        # it always inserts an empty line.
         puts
       end
     end

data/sig/cli.rbs

@@ -0,0 +1,58 @@
+module RBS
+  class CLI
+    class LibraryOptions
+      attr_accessor core_root: Pathname?
+
+      attr_reader libs: Array[String]
+      attr_reader dirs: Array[String]
+      attr_reader repos: Array[String]
+
+      def initialize: () -> void
+                    
+      def loader: () -> EnvironmentLoader
+    end
+
+    attr_reader stdout: IO
+    attr_reader stderr: IO
+
+    def initialize: (stdout: IO, stderr: IO) -> void
+                  
+    COMMANDS: Array[Symbol]
+
+    def library_parse: (OptionParser, options: LibraryOptions) -> void
+                     
+    def parse_logging_options: (OptionParser) -> void
+                             
+    def has_parser?: () -> bool
+                   
+    def run: (Array[String] args) -> void
+           
+    def run_ast: (Array[String], LibraryOptions) -> void
+               
+    def run_list: (Array[String], LibraryOptions) -> void
+                
+    def run_ancestors: (Array[String], LibraryOptions) -> void
+                     
+    def run_methods: (Array[String], LibraryOptions) -> void
+                   
+    def run_method: (Array[String], LibraryOptions) -> void
+                  
+    def run_validate: (Array[String], LibraryOptions) -> void
+                    
+    def run_constant: (Array[String], LibraryOptions) -> void
+                    
+    def run_paths: (Array[String], LibraryOptions) -> void
+                 
+    def run_prototype: (Array[String], LibraryOptions) -> void
+                     
+    def run_prototype_file: (String format, Array[String]) -> void
+                          
+    def run_vendor: (Array[String], LibraryOptions) -> void
+                  
+    def run_parse: (Array[String], LibraryOptions) -> void
+                 
+    def run_test: (Array[String], LibraryOptions) -> void
+                
+    def test_opt: (LibraryOptions) -> String?
+  end
+end

data/sig/constant.rbs

@@ -0,0 +1,21 @@
+module RBS
+  class Constant
+    type constant_entry = Environment::ClassEntry
+                        | Environment::ModuleEntry
+                        | Environment::SingleEntry[TypeName, AST::Declarations::Constant]
+
+    attr_reader name: TypeName
+
+    attr_reader type: Types::t
+
+    attr_reader entry: constant_entry
+
+    def initialize: (name: TypeName, type: Types::t, entry: constant_entry) -> void
+
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    def hash: () -> Integer
+  end
+end

data/sig/constant_table.rbs

@@ -0,0 +1,30 @@
+module RBS
+  class ConstantTable
+    attr_reader definition_builder: DefinitionBuilder
+    attr_reader constant_scopes_cache: Hash[TypeName, Array[Namespace]]
+    attr_reader resolver: TypeNameResolver
+    attr_reader env(): Environment
+
+    def initialize: (builder: DefinitionBuilder) -> void
+
+    def absolute_type: (Types::t, context: Array[Namespace]) -> Types::t
+
+    def absolute_type_name: (TypeName, context: Array[Namespace], location: Location?) -> TypeName
+
+    def name_to_constant: (TypeName) -> Constant?
+
+    def split_name: (TypeName) -> Array[Symbol]
+
+    def resolve_constant_reference: (TypeName name, context: Array[Namespace]) -> Constant?
+
+    def resolve_constant_reference_context: (Symbol, context: Array[Namespace]) -> Constant?
+
+    def resolve_constant_reference_inherit: (Symbol, scopes: Array[Namespace], ?no_object: boolish) -> Constant?
+
+    def constant_scopes: (TypeName) -> Array[Namespace]
+
+    def constant_scopes_module: (TypeName, scopes: Array[Namespace]) -> Array[Namespace]
+
+    def constant_scopes0: (TypeName, ?scopes: Array[Namespace]) -> Array[Namespace]
+  end
+end

data/sig/declarations.rbs

@@ -2,7 +2,7 @@ module RBS
   module AST
     module Declarations
       type t = Class | Module | Interface | Constant | Global | Alias
-      
+
       class Base
       end
 
@@ -14,7 +14,7 @@ module RBS
           attr_reader variance: variance
           attr_reader skip_validation: bool
 
-          def initialize: (name: Symbol, variance: variance, skip_validation: bool) -> void
+          def initialize: (name: Symbol, variance: variance, skip_validation: boolish) -> void
 
           include _ToJson
         end

data/sig/definition.rbs

@@ -18,7 +18,7 @@ module RBS
       class TypeDef
         attr_reader type: MethodType
         attr_reader member: method_member
-        attr_reader defined_in: TypeName?
+        attr_reader defined_in: TypeName
         attr_reader implemented_in: TypeName?
 
         def initialize: (type: MethodType, member: method_member, defined_in: TypeName?, implemented_in: TypeName?) -> void
@@ -28,7 +28,7 @@ module RBS
         def annotations: () -> Array[AST::Annotation]
 
         def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName?, ?implemented_in: TypeName?) -> TypeDef
-        
+
         def overload?: () -> bool
       end
 

data/sig/definition_builder.rbs

@@ -29,14 +29,14 @@ module RBS
 
     attr_reader env: Environment
     attr_reader type_name_resolver: TypeNameResolver
-    
+
     attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
     attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
     attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
 
     attr_reader one_instance_cache: Hash[TypeName, Definition]
     attr_reader one_singleton_cache: Hash[TypeName, Definition]
-    
+
     attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
     attr_reader singleton_ancestor_cache: Hash[TypeName, Definition::SingletonAncestors]
 
@@ -48,7 +48,7 @@ module RBS
     def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
 
     def one_instance_ancestors: (TypeName) -> OneAncestors
-                                
+
     def one_singleton_ancestors: (TypeName) -> OneAncestors
 
     def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
@@ -61,6 +61,8 @@ module RBS
 
     def ensure_namespace!: (Namespace, location: Location?) -> void
 
+    def build_singleton: (TypeName) -> Definition
+                       
     def build_instance: (TypeName) -> Definition
 
     def build_interface: (TypeName) -> Definition
@@ -69,7 +71,7 @@ module RBS
 
     def build_one_singleton: (TypeName) -> Definition
 
-    def merge_definitions: (TypeName, 
+    def merge_definitions: (TypeName,
                             Array[[Definition::Ancestor::t, Definition]],
                             entry: Environment::ModuleEntry | Environment::ClassEntry,
                             self_type: Definition::self_type,
@@ -92,4 +94,3 @@ module RBS
     def expand_alias: (TypeName) -> Types::t
   end
 end
-

data/sig/environment_loader.rbs

@@ -1,4 +1,104 @@
 module RBS
+  # EnvironmentLoader is an object to load RBS files from filesystem.
+  # 
+  # Set up your configuration through repository and `#add` method.
+  # 
+  #   # Set up the repository to load library RBSs from.
+  #   repo = RBS::Repository.default
+  #   repo.add(Pathname("vendor/rbs/gem-rbs"))
+  #   repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # 
+  #   loader = RBS::EnvironmentLoader.new(repository: repo)
+  # 
+  #   # Add libraries to load RBS files.
+  #   loader.add(library: "minitest")
+  #   loader.add(library: "rbs", version: "1.0.0")
+  # 
+  #   # Add dirs to load RBS files from.
+  #   loader.add(path: Pathname("sig"))
+  # 
+  #   # Load RBSs into an environment.
+  #   environment = RBS::Environment.new()
+  #   loader.load(env: environment)
+  # 
   class EnvironmentLoader
+    class UnknownLibraryError < StandardError
+      attr_reader library: Library
+
+      def initialize: (lib: Library) -> void
+    end
+
+    class Library < Struct[String | String?]
+      attr_reader name: String
+      attr_reader version: String?
+
+      def initialize: (name: String, version: String?) -> void
+    end
+
+    DEFAULT_CORE_ROOT: Pathname
+
+    attr_reader core_root: Pathname?
+    attr_reader repository: Repository
+
+    attr_reader libs: Array[Library]
+    attr_reader dirs: Array[Pathname]
+
+    # The source where the RBS comes from.
+    # 
+    # `:core` means it is part of core library.
+    # `Library` means it is from library.
+    # `Pathname` means it is loaded from a directory.
+    # 
+    type source = :core
+                | Library
+                | Pathname
+
+    # Accepts two optional keyword arguments.
+    # 
+    # `core_root` is the path to the directory with RBSs for core classes.
+    # The default value is the core library included in RBS gem. (EnvironmentLoader::DEFAULT_CORE_ROOT)
+    # Passing `nil` means it skips loading core class definitions.
+    # 
+    # `repository` is the repository for library classes.
+    # The default value is repository only with stdlib classes. (Repository.new)
+    # 
+    def initialize: (?core_root: Pathname?, ?repository: Repository) -> void
+    
+    # Add a path or library to load RBSs from.
+    # 
+    # `path` can be a file or a directory.
+    # All `.rbs` files from the given directory will be loaded.
+    # Specifying a file will load the file regardless the extension of the file is.
+    # 
+    # `library` can be a name of a gem.
+    # Specifying `nil` to `version` will load any version available.
+    # It first tries to load RBS files from gem with specified version.
+    # If RBS files cannot be found in the gem, it tries to load RBSs from repository.
+    # 
+    def add: (path: Pathname) -> void
+           | (library: String, version: String?) -> void
+
+    # This is helper function to test if RBS for a library is available or not.
+    # 
+    def has_library?: (library: String, version: String?) -> bool
+
+    # Add all declarations to environment.
+    # 
+    # Raises `UnknownLibraryError` if RBS cannot be loaded from a library.
+    # 
+    # Returns an array of tuples of the declaration, path to the file, and the source.
+    # 
+    def load: (env: Environment) -> Array[[AST::Declarations::t, Pathname, source]]
+
+    # Returns a pair of spec and path for a gem with RBS.
+    # Returns nil if the gem is not installed, or the gem doesn't provide RBS.
+    # 
+    def self.gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
+
+    def each_decl: () { (AST::Declarations::t, Buffer, source, Pathname) -> void } -> void
+                 
+    def each_dir: { (source, Pathname) -> void } -> void
+                
+    def each_file: (Pathname path, immediate: boolish, skip_hidden: boolish) { (Pathname) -> void } -> void
   end
 end