rbs 0.2.0 → 0.6.0

data/lib/rbs/cli.rb

@@ -36,18 +36,18 @@ module RBS
       @stderr = stderr
     end
 
-    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :version, :parse]
+    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :parse]
 
     def library_parse(opts, options:)
-      opts.on("-r LIBRARY") do |lib|
+      opts.on("-r LIBRARY", "Load RBS files of the library") do |lib|
         options.libs << lib
       end
 
-      opts.on("-I DIR") do |dir|
+      opts.on("-I DIR", "Load RBS files from the directory") do |dir|
         options.dirs << dir
       end
 
-      opts.on("--no-stdlib") do
+      opts.on("--no-stdlib", "Skip loading standard library signatures") do
         options.no_stdlib = true
       end
 
@@ -55,11 +55,11 @@ module RBS
     end
 
     def parse_logging_options(opts)
-      opts.on("--log-level=LEVEL", "Specify log level (defaults to `warn`)") do |level|
+      opts.on("--log-level LEVEL", "Specify log level (defaults to `warn`)") do |level|
         RBS.logger_level = level
       end
 
-      opts.on("--log-output=OUTPUT", "Specify the file to output log (defaults to stderr)") do |output|
+      opts.on("--log-output OUTPUT", "Specify the file to output log (defaults to stderr)") do |output|
         RBS.logger_output = File.open(output, "a")
       end
 
@@ -71,17 +71,24 @@ module RBS
 
       opts = OptionParser.new
       opts.banner = <<~USAGE
-        Usage: rbs [options] COMMAND
-        Available commands: #{COMMANDS.join(", ")}
+        Usage: rbs [options...] [command...]
+
+        Available commands: #{COMMANDS.join(", ")}, version, help.
+
+        Options:
       USAGE
       library_parse(opts, options: options)
       parse_logging_options(opts)
+      opts.version = RBS::VERSION
 
       opts.order!(args)
 
       command = args.shift&.to_sym
 
-      if COMMANDS.include?(command)
+      case command
+      when :version
+        stdout.puts opts.ver
+      when *COMMANDS
         __send__ :"run_#{command}", args, options
       else
         stdout.puts opts.help
@@ -89,101 +96,151 @@ module RBS
     end
 
     def run_ast(args, options)
-      loader = EnvironmentLoader.new()
+      OptionParser.new do |opts|
+        opts.banner = <<EOB
+Usage: rbs ast [patterns...]
+
+Print JSON AST of loaded environment.
+You can specify patterns to filter declarations with the file names.
+
+Examples:
+
+  $ rbs ast
+  $ rbs ast 'basic_object.rbs'
+  $ rbs -I ./sig ast ./sig
+  $ rbs -I ./sig ast '*/models/*.rbs'
+EOB
+      end.order!(args)
 
+      patterns = args.map do |arg|
+        path = Pathname(arg)
+        if path.exist?
+          # Pathname means a directory or a file
+          path
+        else
+          # String means a `fnmatch` pattern
+          arg
+        end
+      end
+
+      loader = EnvironmentLoader.new()
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
+
+      decls = env.declarations.select do |decl|
+        name = decl.location.buffer.name
 
-      stdout.print JSON.generate(env.declarations)
+        patterns.empty? || patterns.any? do |pat|
+          case pat
+          when Pathname
+            Pathname(name).ascend.any? {|p| p == pat }
+          when String
+            name.end_with?(pat) || File.fnmatch(pat, name, File::FNM_EXTGLOB)
+          end
+        end
+      end
+
+      stdout.print JSON.generate(decls)
       stdout.flush
     end
 
     def run_list(args, options)
-      list = []
+      list = Set[]
 
       OptionParser.new do |opts|
-        opts.on("--class") { list << :class }
-        opts.on("--module") { list << :module }
-        opts.on("--interface") { list << :interface }
+        opts.banner = <<EOB
+Usage: rbs list [options...]
+
+List classes, modules, and interfaces.
+
+Examples:
+
+  $ rbs list
+  $ rbs list --class --module --interface
+
+Options:
+EOB
+        opts.on("--class", "List classes") { list << :class }
+        opts.on("--module", "List modules") { list << :module }
+        opts.on("--interface", "List interfaces") { list << :interface }
       end.order!(args)
 
-      list.push(:class, :module, :interface) if list.empty?
+      list.merge([:class, :module, :interface]) if list.empty?
 
       loader = EnvironmentLoader.new()
-
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
-      env.each_decl.sort_by {|name,| name.to_s }.each do |type_name, decl|
-        case decl
-        when AST::Declarations::Class
-          if list.include?(:class)
-            stdout.puts "#{type_name} (class)"
-          end
-        when AST::Declarations::Module
-          if list.include?(:module)
-            stdout.puts "#{type_name} (module)"
-          end
-        when AST::Declarations::Interface
-          if list.include?(:interface)
-            stdout.puts "#{type_name} (interface)"
+      if list.include?(:class) || list.include?(:module)
+        env.class_decls.each do |name, entry|
+          case entry
+          when Environment::ModuleEntry
+            if list.include?(:module)
+              stdout.puts "#{name} (module)"
+            end
+          when Environment::ClassEntry
+            if list.include?(:class)
+              stdout.puts "#{name} (class)"
+            end
           end
         end
       end
+
+      if list.include?(:interface)
+        env.interface_decls.each do |name, entry|
+          stdout.puts "#{name} (interface)"
+        end
+      end
     end
 
     def run_ancestors(args, options)
       kind = :instance
 
       OptionParser.new do |opts|
-        opts.on("--instance") { kind = :instance }
-        opts.on("--singleton") { kind = :singleton }
+        opts.banner = <<EOU
+Usage: rbs ancestors [options...] [type_name]
+
+Show ancestors of the given class or module.
+
+Examples:
+
+  $ rbs ancestors --instance String
+  $ rbs ancestors --singleton Array
+
+Options:
+EOU
+        opts.on("--instance", "Ancestors of instance of the given type_name (default)") { kind = :instance }
+        opts.on("--singleton", "Ancestors of singleton of the given type_name") { kind = :singleton }
       end.order!(args)
 
       loader = EnvironmentLoader.new()
-
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
       type_name = parse_type_name(args[0]).absolute!
 
-      if env.class?(type_name)
-        ancestor = case kind
-                   when :instance
-                     decl = env.find_class(type_name)
-                     Definition::Ancestor::Instance.new(name: type_name,
-                                                        args: Types::Variable.build(decl.type_params.each.map(&:name)))
-                   when :singleton
-                     Definition::Ancestor::Singleton.new(name: type_name)
-                   end
+      if env.class_decls.key?(type_name)
+        ancestors = case kind
+                    when :instance
+                      builder.instance_ancestors(type_name)
+                    when :singleton
+                      builder.singleton_ancestors(type_name)
+                    end
 
-        ancestors = builder.build_ancestors(ancestor)
-
-        ancestors.each do |ancestor|
+        ancestors.ancestors.each do |ancestor|
           case ancestor
           when Definition::Ancestor::Singleton
             stdout.puts "singleton(#{ancestor.name})"
-          when Definition::Ancestor::ExtensionSingleton
-            stdout.puts "singleton(#{ancestor.name} (#{ancestor.extension_name}))"
           when Definition::Ancestor::Instance
             if ancestor.args.empty?
               stdout.puts ancestor.name.to_s
             else
               stdout.puts "#{ancestor.name}[#{ancestor.args.join(", ")}]"
             end
-          when Definition::Ancestor::ExtensionInstance
-            if ancestor.args.empty?
-              stdout.puts "#{ancestor.name} (#{ancestor.extension_name})"
-            else
-              stdout.puts "#{ancestor.name}[#{ancestor.args.join(", ")}] (#{ancestor.extension_name})"
-            end
           end
         end
       else
@@ -196,10 +253,21 @@ module RBS
       inherit = true
 
       OptionParser.new do |opts|
-        opts.on("--instance") { kind = :instance }
-        opts.on("--singleton") { kind = :singleton }
-        opts.on("--inherit") { inherit = true }
-        opts.on("--no-inherit") { inherit = false }
+        opts.banner = <<EOU
+Usage: rbs methods [options...] [type_name]
+
+Show methods defined in the class or module.
+
+Examples:
+
+  $ rbs methods --instance Kernel
+  $ rbs methods --singleton --no-inherit String
+
+Options:
+EOU
+        opts.on("--instance", "Show instance methods (default)") { kind = :instance }
+        opts.on("--singleton", "Show singleton methods") { kind = :singleton }
+        opts.on("--[no-]inherit", "Show methods defined in super class and mixed modules too") {|v| inherit = v }
       end.order!(args)
 
       unless args.size == 1
@@ -208,16 +276,14 @@ module RBS
       end
 
       loader = EnvironmentLoader.new()
-
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
       type_name = parse_type_name(args[0]).absolute!
 
-      if env.class?(type_name)
+      if env.class_decls.key?(type_name)
         definition = case kind
                      when :instance
                        builder.build_instance(type_name)
@@ -227,7 +293,7 @@ module RBS
 
         definition.methods.keys.sort.each do |name|
           method = definition.methods[name]
-          if inherit || method.implemented_in == definition.declaration
+          if inherit || method.implemented_in == type_name
             stdout.puts "#{name} (#{method.accessibility})"
           end
         end
@@ -240,8 +306,20 @@ module RBS
       kind = :instance
 
       OptionParser.new do |opts|
-        opts.on("--instance") { kind = :instance }
-        opts.on("--singleton") { kind = :singleton }
+        opts.banner = <<EOU
+Usage: rbs method [options...] [type_name] [method_name]
+
+Show the information of the method specified by type_name and method_name.
+
+Examples:
+
+  $ rbs method --instance Kernel puts
+  $ rbs method --singleton String try_convert
+
+Options:
+EOU
+        opts.on("--instance", "Show an instance method (default)") { kind = :instance }
+        opts.on("--singleton", "Show a singleton method") { kind = :singleton }
       end.order!(args)
 
       unless args.size == 2
@@ -250,17 +328,15 @@ module RBS
       end
 
       loader = EnvironmentLoader.new()
-
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
       type_name = parse_type_name(args[0]).absolute!
       method_name = args[1].to_sym
 
-      unless env.class?(type_name)
+      unless env.class_decls.key?(type_name)
         stdout.puts "Cannot find class: #{type_name}"
         return
       end
@@ -280,8 +356,8 @@ module RBS
       end
 
       stdout.puts "#{type_name}#{kind == :instance ? "#" : "."}#{method_name}"
-      stdout.puts "  defined_in: #{method.defined_in&.name&.absolute!}"
-      stdout.puts "  implementation: #{method.implemented_in.name.absolute!}"
+      stdout.puts "  defined_in: #{method.defined_in}"
+      stdout.puts "  implementation: #{method.implemented_in}"
       stdout.puts "  accessibility: #{method.accessibility}"
       stdout.puts "  types:"
       separator = " "
@@ -292,46 +368,57 @@ module RBS
     end
 
     def run_validate(args, options)
+      OptionParser.new do |opts|
+        opts.banner = <<EOU
+Usage: rbs validate
+
+Validate RBS files. It ensures the type names in RBS files are present and the type applications have correct arity.
+
+Examples:
+
+  $ rbs validate
+EOU
+      end.parse!(args)
+
       loader = EnvironmentLoader.new()
 
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
+      validator = Validator.new(env: env, resolver: TypeNameResolver.from_env(env))
 
-      env.each_decl do |name, decl|
-        case decl
-        when AST::Declarations::Class, AST::Declarations::Module
-          stdout.puts "#{Location.to_string decl.location}:\tValidating class/module definition: `#{name}`..."
-          builder.build_instance(decl.name.absolute!).each_type do |type|
-            env.validate type, namespace: Namespace.root
-          end
-          builder.build_singleton(decl.name.absolute!).each_type do |type|
-            env.validate type, namespace: Namespace.root
-          end
-        when AST::Declarations::Interface
-          stdout.puts "#{Location.to_string decl.location}:\tValidating interface: `#{name}`..."
-          builder.build_interface(decl.name.absolute!, decl).each_type do |type|
-            env.validate type, namespace: Namespace.root
-          end
+      env.class_decls.each_key do |name|
+        stdout.puts "Validating class/module definition: `#{name}`..."
+        builder.build_instance(name).each_type do |type|
+          validator.validate_type type, context: [Namespace.root]
+        end
+        builder.build_singleton(name).each_type do |type|
+          validator.validate_type type, context: [Namespace.root]
+        end
+      end
+
+      env.interface_decls.each_key do |name|
+        stdout.puts "Validating interface: `#{name}`..."
+        builder.build_interface(name).each_type do |type|
+          validator.validate_type type, context: [Namespace.root]
         end
       end
 
-      env.each_constant do |name, const|
-        stdout.puts "#{Location.to_string const.location}:\tValidating constant: `#{name}`..."
-        env.validate const.type, namespace: name.namespace
+      env.constant_decls.each do |name, const|
+        stdout.puts "Validating constant: `#{name}`..."
+        validator.validate_type const.decl.type, context: const.context
       end
 
-      env.each_global do |name, global|
-        stdout.puts "#{Location.to_string global.location}:\tValidating global: `#{name}`..."
-        env.validate global.type, namespace: Namespace.root
+      env.global_decls.each do |name, global|
+        stdout.puts "Validating global: `#{name}`..."
+        validator.validate_type global.decl.type, context: [Namespace.root]
       end
 
-      env.each_alias do |name, decl|
-        stdout.puts "#{Location.to_string decl.location}:\tValidating alias: `#{name}`..."
-        env.validate decl.type, namespace: name.namespace
+      env.alias_decls.each do |name, decl|
+        stdout.puts "Validating alias: `#{name}`..."
+        validator.validate_type decl.decl.type, context: decl.context
       end
     end
 
@@ -339,7 +426,20 @@ module RBS
       context = nil
 
       OptionParser.new do |opts|
-        opts.on("--context CONTEXT") {|c| context = c }
+        opts.banner = <<EOU
+Usage: rbs constant [options...] [name]
+
+Resolve constant based on RBS.
+
+Examples:
+
+  $ rbs constant ::Object
+  $ rbs constant UTF_8
+  $ rbs constant --context=::Encoding UTF_8
+
+Options:
+EOU
+        opts.on("--context CONTEXT", "Name of the module where the constant resolution starts") {|c| context = c }
       end.order!(args)
 
       unless args.size == 1
@@ -351,8 +451,7 @@ module RBS
 
       options.setup(loader)
 
-      env = Environment.new()
-      loader.load(env: env)
+      env = Environment.from_loader(loader).resolve_type_names
 
       builder = DefinitionBuilder.new(env: env)
       table = ConstantTable.new(builder: builder)
@@ -362,7 +461,7 @@ module RBS
       name = Namespace.parse(args[0]).to_type_name
       stdout.puts "Constant name: #{name}"
 
-      constant = table.resolve_constant_reference(name, context: namespace)
+      constant = table.resolve_constant_reference(name, context: namespace.ascend.to_a)
 
       if constant
         stdout.puts " => #{constant.name}: #{constant.type}"
@@ -371,11 +470,20 @@ module RBS
       end
     end
 
-    def run_version(args, options)
-      stdout.puts "ruby-signature #{VERSION}"
-    end
-
     def run_paths(args, options)
+      OptionParser.new do |opts|
+        opts.banner = <<EOU
+Usage: rbs paths
+
+Show paths to directories where the RBS files are loaded from.
+
+Examples:
+
+  $ rbs paths
+  $ tbs -r set paths
+EOU
+      end.parse!(args)
+
       loader = EnvironmentLoader.new()
 
       options.setup(loader)
@@ -423,16 +531,30 @@ module RBS
         owners_included = []
 
         OptionParser.new do |opts|
-          opts.on("--require LIB") do |lib|
+          opts.banner = <<EOU
+Usage: rbs prototype runtime [options...] [pattern...]
+
+Generate RBS prototype based on runtime introspection.
+It loads Ruby code specified in [options] and generates RBS prototypes for classes matches to [pattern]. 
+
+Examples:
+
+  $ rbs prototype runtime String
+  $ rbs prototype runtime --require set Set
+  $ rbs prototype runtime -R lib/rbs RBS::*
+
+Options:
+EOU
+          opts.on("-r", "--require LIB", "Load library using `require`") do |lib|
             require_libs << lib
           end
-          opts.on("--require-relative LIB") do |lib|
+          opts.on("-R", "--require-relative LIB", "Load library using `require_relative`") do |lib|
             relative_libs << lib
           end
-          opts.on("--merge") do
+          opts.on("--merge", "Merge generated prototype RBS with existing RBS") do
             merge = true
           end
-          opts.on("--method-owner CLASS") do |klass|
+          opts.on("--method-owner CLASS", "Generate method prototypes if the owner of the method is [CLASS]") do |klass|
             owners_included << klass
           end
         end.parse!(args)
@@ -441,28 +563,61 @@ module RBS
 
         options.setup(loader)
 
-        env = Environment.new()
-        loader.load(env: env)
+        env = Environment.from_loader(loader).resolve_type_names
 
         require_libs.each do |lib|
           require(lib)
         end
 
         relative_libs.each do |lib|
-          require(lib)
+          eval("require_relative(lib)", binding, "rbs")
         end
 
         decls = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included).decls
       else
-        stdout.puts "Supported formats: rbi, rb, runtime"
+        stdout.puts <<EOU
+Usage: rbs prototype [generator...] [args...]
+
+Generate prototype of RBS files.
+Supported generators are rb, rbi, runtime.
+
+Examples:
+
+  $ rbs prototype rb foo.rb
+  $ rbs prototype rbi foo.rbi
+  $ rbs prototype runtime String
+EOU
         exit 1
       end
 
-      writer = Writer.new(out: stdout)
-      writer.write decls
+      if decls
+        writer = Writer.new(out: stdout)
+        writer.write decls
+      else
+        exit 1
+      end
     end
 
     def run_prototype_file(format, args)
+      opts = OptionParser.new
+      opts.banner = <<EOU
+Usage: rbs prototype #{format} [options...] [files...]
+
+Generate RBS prototype from source code.
+It parses specified Ruby code and and generates RBS prototypes. 
+
+Examples:
+
+  $ rbs prototype rb lib/foo.rb
+  $ rbs prototype rbi sorbet/rbi/foo.rbi
+EOU
+      opts.parse!(args)
+
+      if args.empty?
+        stdout.puts opts
+        return nil
+      end
+
       parser = case format
                when "rbi"
                  Prototype::RBI.new()
@@ -483,9 +638,19 @@ module RBS
       vendor_dir = Pathname("vendor/sigs")
 
       OptionParser.new do |opts|
-        opts.banner = <<~EOB
-        Usage: rbs vendor [options] GEMS...
-        Vendor signatures in the project directory.
+        opts.banner = <<-EOB
+Usage: rbs vendor [options...] [gems...]
+
+Vendor signatures in the project directory.
+This command ignores the RBS loading global options, `-r` and `-I`.
+
+Examples:
+
+  $ rbs vendor
+  $ rbs vendor --vendor-dir=sig
+  $ rbs vendor --no-stdlib
+
+Options:
         EOB
 
         opts.on("--[no-]clean", "Clean vendor directory (default: no)") do |v|
@@ -528,6 +693,18 @@ module RBS
     end
 
     def run_parse(args, options)
+      OptionParser.new do |opts|
+        opts.banner = <<-EOB
+Usage: rbs parse [files...]
+
+Parse given RBS files and print syntax errors.
+
+Examples:
+
+  $ rbs parse sig/app/models.rbs sig/app/controllers.rbs
+        EOB
+      end.parse!(args)
+
       loader = EnvironmentLoader.new()
 
       syntax_error = false
@@ -545,6 +722,7 @@ module RBS
           syntax_error = true
         end
       end
+
       exit 1 if syntax_error
     end