rbs 1.5.1 → 1.7.0.beta.1

data/lib/rbs/locator.rb

@@ -172,16 +172,19 @@ module RBS
 
     def find_in_loc(pos, location:, array:)
       if test_loc(pos, location: location)
-        if location.is_a?(Location::WithChildren)
-          location.optional_children.each do |key, range|
-            if range === pos
-              array.unshift(key)
-              return true
+        if location.is_a?(Location)
+          location.each_optional_key do |key|
+            if loc = location[key]
+              if loc.range === pos
+                array.unshift(key)
+                return true
+              end
             end
           end
 
-          location.required_children.each do |key, range|
-            if range === pos
+          location.each_required_key do |key|
+            loc = location[key] or raise
+            if loc.range === pos
               array.unshift(key)
               return true
             end

data/lib/rbs/parser_aux.rb

@@ -0,0 +1,24 @@
+module RBS
+  class Parser
+    def self.parse_type(source, line: 1, column: 0, variables: [])
+      _parse_type(buffer(source), line, column, variables)
+    end
+
+    def self.parse_method_type(source, line: 1, column: 0, variables: [])
+      _parse_method_type(buffer(source), line, column, variables)
+    end
+
+    def self.parse_signature(source, line: 1, column: 0)
+      _parse_signature(buffer(source), line, column)
+    end
+
+    def self.buffer(source)
+      case source
+      when String
+        Buffer.new(content: source, name: "a.rbs")
+      when Buffer
+        source
+      end
+    end
+  end
+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/types.rb

@@ -1,4 +1,3 @@
-
 module RBS
   module Types
     module NoFreeVariables
@@ -434,7 +433,7 @@ module RBS
         return "{ }" if self.fields.empty?
 
         fields = self.fields.map do |key, type|
-          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) && !key.match?(Parser::KEYWORDS_RE)
+          if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) && !Parser::KEYWORDS.key?(key)
             "#{key}: #{type}"
           else
             "#{key.inspect} => #{type}"
@@ -691,7 +690,7 @@ module RBS
 
         def to_s
           if name
-            if /\A#{Parser::KEYWORDS_RE}\z/.match?(name)
+            if Parser::KEYWORDS.key?(name)
               "#{type} `#{name}`"
             else
               "#{type} #{name}"

data/lib/rbs/validator.rb

@@ -56,7 +56,10 @@ module RBS
 
     def validate_type_alias(entry:)
       @type_alias_dependency ||= TypeAliasDependency.new(env: env)
-      raise RecursiveTypeAliasError.new(alias_names: [entry.decl.name], location: entry.decl.location) if @type_alias_dependency.circular_definition?(entry.decl.name)
+      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.5.1"
+  VERSION = "1.7.0.beta.1"
 end

data/lib/rbs/writer.rb

@@ -232,8 +232,10 @@ module RBS
     def method_name(name)
       s = name.to_s
 
-      if [:tOPERATOR, :kAMP, :kHAT, :kSTAR, :kLT, :kEXCLAMATION, :kSTAR2, :kBAR].include?(Parser::PUNCTS[s]) ||
-          (/\A[a-zA-Z_]\w*[?!=]?\z/.match?(s) && !/\Aself\??\z/.match?(s))
+      case s
+      when /\A(_?)[A-Za-z_]\w*(\?|!|=)?\Z/
+        s
+      when *%w(|  ^  &  <=>  ==  ===  =~  >   >=  <   <=   <<  >> +  -  *  /  %   **   ~   +@  -@  []  []=  ` ! != !~)
         s
       else
         "`#{s}`"

data/lib/rbs.rb

@@ -12,7 +12,6 @@ require "strscan"
 require "rbs/char_scanner"
 require "rbs/errors"
 require "rbs/buffer"
-require "rbs/location"
 require "rbs/namespace"
 require "rbs/type_name"
 require "rbs/types"
@@ -45,13 +44,11 @@ require "rbs/repository"
 require "rbs/ancestor_graph"
 require "rbs/locator"
 require "rbs/type_alias_dependency"
+require "rbs/collection"
 
-begin
-  require "rbs/parser"
-rescue LoadError
-  STDERR.puts "Missing parser Ruby code? Running `rake parser` may solve the issue"
-  raise
-end
+require "rbs/extension"
+require "rbs/parser_aux"
+require "rbs/location_aux"
 
 module RBS
   class <<self

data/rbs.gemspec

@@ -30,7 +30,8 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|bin)/}) }
   end
-  spec.files << "lib/rbs/parser.rb"
+  spec.extensions = %w{ext/rbs/extension/extconf.rb}
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/sig/ancestor_builder.rbs

@@ -82,7 +82,7 @@ module RBS
       def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
                             TypeName,
                             included_modules: Array[Definition::Ancestor::Instance]?,
-                         included_interfaces:Array[Definition::Ancestor::Instance]?,
+                         included_interfaces: Array[Definition::Ancestor::Instance]?,
                            prepended_modules: Array[Definition::Ancestor::Instance]?,
                             extended_modules: Array[Definition::Ancestor::Instance]?,
                          extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
@@ -91,7 +91,7 @@ module RBS
                              TypeName,
                              align_params: Substitution?,
                          included_modules: Array[Definition::Ancestor::Instance]?,
-                      included_interfaces:Array[Definition::Ancestor::Instance]?,
+                      included_interfaces: Array[Definition::Ancestor::Instance]?,
                         prepended_modules: Array[Definition::Ancestor::Instance]?,
                          extended_modules: Array[Definition::Ancestor::Instance]?,
                       extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void

data/sig/annotation.rbs

@@ -10,9 +10,9 @@ module RBS
     #
     class Annotation
       attr_reader string: String
-      attr_reader location: Location?
+      attr_reader location: Location[untyped, untyped]?
 
-      def initialize: (string: String, location: Location?) -> void
+      def initialize: (string: String, location: Location[untyped, untyped]?) -> void
 
       def ==: (untyped other) -> bool
 

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