rbs 1.3.3 → 1.6.0

data/lib/rbs/prototype/rb.rb

@@ -319,9 +319,16 @@ module RBS
                          const_to_name(node.children[0])
                        end
 
+          value_node = node.children.last
+          type = if value_node.nil?
+                  # Give up type prediction when node is MASGN.
+                  Types::Bases::Any.new(location: nil)
+                else
+                  node_type(value_node)
+                end
           decls << AST::Declarations::Constant.new(
             name: const_name,
-            type: node_type(node.children.last),
+            type: type,
             location: nil,
             comment: comments[node.first_lineno - 1]
           )

data/lib/rbs/prototype/runtime.rb

@@ -87,7 +87,7 @@ module RBS
             unless const_name(mix)
               RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
             else
-              module_name = module_full_name = to_type_name(const_name(mix))
+              module_name = module_full_name = to_type_name(const_name(mix), full_name: true)
               if module_full_name.namespace == type_name.namespace
                 module_name = TypeName.new(name: module_full_name.name, namespace: Namespace.empty)
               end

data/lib/rbs/repository.rb

@@ -55,13 +55,8 @@ module RBS
       end
 
       def find_best_version(version)
-        return latest_version unless version
-
-        if v = version_names.reverse.bsearch {|v| v <= version ? true : false }
-          versions[v]
-        else
-          oldest_version
-        end
+        best_version = Repository.find_best_version(version, version_names)
+        versions[best_version]
       end
 
       def empty?
@@ -89,6 +84,17 @@ module RBS
       end
     end
 
+    def self.find_best_version(version, candidates)
+      candidates = candidates.sort
+      return candidates.last || raise unless version
+
+      if v = candidates.reverse.bsearch {|v| v <= version ? true : false }
+        v
+      else
+        candidates.first or raise
+      end
+    end
+
     def add(dir)
       dirs << dir
 

data/lib/rbs/type_alias_dependency.rb

@@ -0,0 +1,88 @@
+module RBS
+  class TypeAliasDependency
+    attr_reader :env
+
+    # Direct dependencies corresponds to a directed graph
+    # with vertices as types and directions based on assignment of types
+    attr_reader :direct_dependencies
+    # A hash which stores the transitive closure
+    # of the directed graph
+    attr_reader :dependencies
+
+    def initialize(env:)
+      @env = env
+    end
+
+    # Check if an alias type definition is circular & prohibited
+    def circular_definition?(alias_name)
+      # Construct transitive closure, if not constructed already
+      transitive_closure() unless @dependencies
+
+      # Check for recursive type alias
+      @dependencies[alias_name][alias_name]
+    end
+
+    def build_dependencies
+      return if @direct_dependencies
+
+      # Initialize hash(a directed graph)
+      @direct_dependencies = {}
+      # Initialize dependencies as an empty hash
+      @dependencies = {}
+      # Iterate over alias declarations inserted into environment
+      env.alias_decls.each do |name, entry|
+        # Construct a directed graph by recursively extracting type aliases
+        @direct_dependencies[name] = direct_dependency(entry.decl.type)
+        # Initialize dependencies with an empty hash
+        @dependencies[name] = {}
+      end
+    end
+
+    def transitive_closure
+      # Construct a graph of direct dependencies
+      build_dependencies()
+      # Construct transitive closure by using DFS(recursive technique)
+      @direct_dependencies.each_key do |name|
+        dependency(name, name)
+      end
+    end
+
+    private
+
+    # Constructs directed graph recursively
+    def direct_dependency(type, result = Set[])
+      case type
+      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Optional
+        # Iterate over nested types & extract type aliases recursively
+        type.each_type do |nested_type|
+          direct_dependency(nested_type, result)
+        end
+      when RBS::Types::Alias
+        # Append type name if the type is an alias
+        result << type.name
+      end
+
+      result
+    end
+
+    # Recursive function to construct transitive closure
+    def dependency(start, vertex, nested = nil)
+      if (start == vertex)
+        if (@direct_dependencies[start].include?(vertex) || nested)
+          # Mark a vertex as connected to itself
+          # if it is connected as an edge || a path(traverse multiple edges)
+          @dependencies[start][vertex] = true
+        end
+      else
+        # Mark a pair of vertices as connected while recursively performing DFS
+        @dependencies[start][vertex] = true
+      end
+
+      # Iterate over the direct dependencies of the vertex
+      @direct_dependencies[vertex]&.each do |type_name|
+        # Invoke the function unless it is already checked
+        dependency(start, type_name, start == type_name) unless @dependencies[start][type_name]
+      end
+    end
+  end
+end

data/lib/rbs/validator.rb

@@ -53,5 +53,13 @@ module RBS
         validate_type(type, context: context)
       end
     end
+
+    def validate_type_alias(entry:)
+      @type_alias_dependency ||= TypeAliasDependency.new(env: env)
+      if @type_alias_dependency.circular_definition?(entry.decl.name)
+        location = entry.decl.location or raise
+        raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: location)
+      end
+    end
   end
 end

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "1.3.3"
+  VERSION = "1.6.0"
 end

data/lib/rbs.rb

@@ -44,6 +44,8 @@ require "rbs/factory"
 require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
+require "rbs/type_alias_dependency"
+require "rbs/collection"
 
 begin
   require "rbs/parser"

data/sig/builtin_names.rbs

@@ -37,5 +37,6 @@ module RBS
     Regexp: Name
     TrueClass: Name
     FalseClass: Name
+    Numeric: Name
   end
 end

data/sig/cli.rbs

@@ -2,6 +2,7 @@ module RBS
   class CLI
     class LibraryOptions
       attr_accessor core_root: Pathname?
+      attr_accessor config_path: Pathname?
 
       attr_reader libs: Array[String]
       attr_reader dirs: Array[String]
@@ -63,6 +64,10 @@ module RBS
 
     def run_test: (Array[String], LibraryOptions) -> void
 
+    def run_collection: (Array[String], LibraryOptions) -> void
+
     def test_opt: (LibraryOptions) -> String?
+
+    def collection_options: (Array[String]) -> OptionParser
   end
 end

data/sig/collection/cleaner.rbs

@@ -0,0 +1,13 @@
+module RBS
+  module Collection
+    class Cleaner
+      attr_reader lock: Config
+
+      def initialize: (lockfile_path: Pathname) -> void
+
+      def clean: () -> void
+
+      def needed?: (String gem_name, String version) -> bool
+    end
+  end
+end

data/sig/collection/collections.rbs

@@ -0,0 +1,112 @@
+module RBS
+  module Collection
+    module Sources
+      def self.from_config_entry: (source_entry) -> _Source
+
+      interface _Source
+        def has?: (Config::gem_entry) -> boolish
+        def versions: (Config::gem_entry) -> Array[String]
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def to_lockfile: () -> source_entry
+      end
+
+      type source_entry = Git::source_entry
+                            | Stdlib::source_entry
+                            | Rubygems::source_entry
+
+      class Git
+        METADATA_FILENAME: String
+
+        type source_entry = {
+          'type' => 'git',
+          'name' => String,
+          'remote' => String,
+          'revision' => String,
+          'repo_dir' => String?,
+        }
+
+        class CommandError < StandardError
+        end
+
+        attr_reader name: String
+        attr_reader remote: String
+        attr_reader repo_dir: String
+
+        def initialize: (name: String, revision: String, remote: String, repo_dir: String?) -> untyped
+
+        def has?: (Config::gem_entry) -> bool
+
+        def versions: (Config::gem_entry) -> Array[String]
+
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def _install: (dest: Pathname , config_entry: Config::gem_entry) -> void
+
+        def setup!: (revision: String) -> void
+
+        def need_to_fetch?: (String revision ) -> bool
+
+        def git_dir: () -> Pathname
+
+        def gem_repo_dir: () -> Pathname
+
+        def with_revision: [T] () { () -> T } -> T
+
+        def resolved_revision: () -> String
+
+        def resolve_revision: () -> String
+
+        def git: (*String cmd) -> String
+
+        def sh!: (*String cmd) -> String
+
+        def format_config_entry: (Config::gem_entry) -> String
+      end
+
+      # signatures that are bundled in rbs gem under the stdlib/ directory
+      class Stdlib
+        type source_entry =  {
+          'type' => 'stdlib',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        def has?: (Config::gem_entry) -> bool
+
+        def versions: (Config::gem_entry) -> Array[String]
+
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def gem_dir: (Config::gem_entry) -> Pathname
+      end
+
+      # sig/ directory
+      class Rubygems
+        type source_entry = {
+          'type' => 'rubygems',
+        }
+
+        # polyfill of singleton module
+        def self.instance: () -> instance
+
+        def has?: (Config::gem_entry) -> boolish
+        def versions: (Config::gem_entry) -> Array[String]
+        def install: (dest: Pathname, config_entry: Config::gem_entry, stdout: CLI::_IO) -> void
+        def to_lockfile: () -> source_entry
+
+        private
+
+        def gem_sig_path: (Config::gem_entry) -> [Gem::Specification, Pathname]?
+      end
+    end
+  end
+end

data/sig/collection/config.rbs

@@ -0,0 +1,69 @@
+module RBS
+  module Collection
+    # This class represent the configration file.
+    class Config
+      class LockfileGenerator
+        attr_reader config: Config
+        attr_reader lock: Config?
+        attr_reader lock_path: Pathname
+        attr_reader gemfile_lock: Bundler::LockfileParser
+
+        def self.generate: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
+
+        def initialize: (config_path: Pathname, gemfile_lock_path: Pathname, with_lockfile: boolish) -> void
+
+        def generate: () -> Config
+
+        private
+
+        def assign_gem: (gem_name: String, version: String?) -> void
+
+        def upsert_gem: (gem_entry? old, gem_entry new) -> void
+
+        def gemfile_lock_gems: () { (untyped) -> void } -> void
+
+        def remove_ignored_gems!: () -> void
+
+        def find_source: (gem_name: String) -> untyped
+
+        def find_best_version: (version: String?, versions: Array[String]) -> Gem::Version
+      end
+
+      PATH: Pathname
+
+      type gem_entry = {
+        'name' => String,
+        'version' => String?,
+        'ignore' => boolish,
+        'source' => Sources::source_entry?
+      }
+
+      @config_path: Pathname
+
+      def self.generate_lockfile: (config_path: Pathname, gemfile_lock_path: Pathname, ?with_lockfile: boolish) -> Config
+
+      def self.from_path: (Pathname path) -> Config
+
+      def self.lockfile_of: (Pathname config_path) -> Config?
+
+      def self.to_lockfile_path: (Pathname config_path) -> Pathname
+
+      # config_path is necessary to resolve relative repo_path
+      def initialize: (untyped data, config_path: Pathname) -> void
+
+      def add_gem: (untyped gem) -> untyped
+
+      def gem: (String gem_name) -> untyped
+
+      def repo_path: () -> Pathname
+
+      def sources: () -> Array[Sources::_Source]
+
+      def dump_to: (Pathname) -> void
+
+      def gems: () -> Array[untyped]
+
+      def check_rbs_availability!: () -> void
+    end
+  end
+end

data/sig/collection/installer.rbs

@@ -0,0 +1,15 @@
+module RBS
+  module Collection
+    class Installer
+      attr_reader lockfile: Config
+      attr_reader stdout: CLI::_IO
+
+      def initialize: (lockfile_path: Pathname, ?stdout: CLI::_IO) -> void
+      def install_from_lockfile: () -> void
+
+      private
+
+      def source_for: (Config::gem_entry) -> Sources::_Source
+    end
+  end
+end

data/sig/collection.rbs

@@ -0,0 +1,4 @@
+module RBS
+  module Collection
+  end
+end

data/sig/environment_loader.rbs

@@ -78,6 +78,9 @@ module RBS
     def add: (path: Pathname) -> void
            | (library: String, version: String?) -> void
 
+    # Add repository path and libraries via rbs_collection.lock.yaml.
+    def add_collection: (Collection::Config collection_config) -> void
+
     # This is helper function to test if RBS for a library is available or not.
     # 
     def has_library?: (library: String, version: String?) -> bool

data/sig/errors.rbs

@@ -196,4 +196,13 @@ module RBS
 
     def mixin_name: () -> String
   end
+
+  class RecursiveTypeAliasError < LoadingError
+    attr_reader alias_names: Array[TypeName]
+    attr_reader location: Location
+
+    def initialize: (alias_names: Array[TypeName], location: Location) -> void
+
+    def name: () -> String
+  end
 end