steep 0.16.0 → 0.16.1

data/vendor/ruby-signature/lib/rbs/cli.rb

@@ -1,558 +0,0 @@
-require "optparse"
-
-module RBS
-  class CLI
-    class LibraryOptions
-      attr_reader :libs
-      attr_reader :dirs
-      attr_accessor :no_stdlib
-
-      def initialize()
-        @libs = []
-        @dirs = []
-        @no_stdlib = false
-      end
-
-      def setup(loader)
-        libs.each do |lib|
-          loader.add(library: lib)
-        end
-
-        dirs.each do |dir|
-          loader.add(path: Pathname(dir))
-        end
-
-        loader.no_builtin! if no_stdlib
-
-        loader
-      end
-    end
-
-    attr_reader :stdout
-    attr_reader :stderr
-
-    def initialize(stdout:, stderr:)
-      @stdout = stdout
-      @stderr = stderr
-    end
-
-    COMMANDS = [:ast, :list, :ancestors, :methods, :method, :validate, :constant, :paths, :prototype, :vendor, :version, :parse]
-
-    def library_parse(opts, options:)
-      opts.on("-r LIBRARY") do |lib|
-        options.libs << lib
-      end
-
-      opts.on("-I DIR") do |dir|
-        options.dirs << dir
-      end
-
-      opts.on("--no-stdlib") do
-        options.no_stdlib = true
-      end
-
-      opts
-    end
-
-    def parse_logging_options(opts)
-      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|
-        RBS.logger_output = File.open(output, "a")
-      end
-
-      opts
-    end
-
-    def run(args)
-      options = LibraryOptions.new
-
-      opts = OptionParser.new
-      opts.banner = <<~USAGE
-        Usage: rbs [options] COMMAND
-        Available commands: #{COMMANDS.join(", ")}
-      USAGE
-      library_parse(opts, options: options)
-      parse_logging_options(opts)
-
-      opts.order!(args)
-
-      command = args.shift&.to_sym
-
-      if COMMANDS.include?(command)
-        __send__ :"run_#{command}", args, options
-      else
-        stdout.puts opts.help
-      end
-    end
-
-    def run_ast(args, options)
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      stdout.print JSON.generate(env.declarations)
-      stdout.flush
-    end
-
-    def run_list(args, options)
-      list = []
-
-      OptionParser.new do |opts|
-        opts.on("--class") { list << :class }
-        opts.on("--module") { list << :module }
-        opts.on("--interface") { list << :interface }
-      end.order!(args)
-
-      list.push(:class, :module, :interface) if list.empty?
-
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      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)"
-          end
-        end
-      end
-    end
-
-    def run_ancestors(args, options)
-      kind = :instance
-
-      OptionParser.new do |opts|
-        opts.on("--instance") { kind = :instance }
-        opts.on("--singleton") { kind = :singleton }
-      end.order!(args)
-
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      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
-
-        ancestors = builder.build_ancestors(ancestor)
-
-        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
-        stdout.puts "Cannot find class: #{type_name}"
-      end
-    end
-
-    def run_methods(args, options)
-      kind = :instance
-      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 }
-      end.order!(args)
-
-      unless args.size == 1
-        stdout.puts "Expected one argument."
-        return
-      end
-
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      builder = DefinitionBuilder.new(env: env)
-      type_name = parse_type_name(args[0]).absolute!
-
-      if env.class?(type_name)
-        definition = case kind
-                     when :instance
-                       builder.build_instance(type_name)
-                     when :singleton
-                       builder.build_singleton(type_name)
-                     end
-
-        definition.methods.keys.sort.each do |name|
-          method = definition.methods[name]
-          if inherit || method.implemented_in == definition.declaration
-            stdout.puts "#{name} (#{method.accessibility})"
-          end
-        end
-      else
-        stdout.puts "Cannot find class: #{type_name}"
-      end
-    end
-
-    def run_method(args, options)
-      kind = :instance
-
-      OptionParser.new do |opts|
-        opts.on("--instance") { kind = :instance }
-        opts.on("--singleton") { kind = :singleton }
-      end.order!(args)
-
-      unless args.size == 2
-        stdout.puts "Expected two arguments, but given #{args.size}."
-        return
-      end
-
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      builder = DefinitionBuilder.new(env: env)
-      type_name = parse_type_name(args[0]).absolute!
-      method_name = args[1].to_sym
-
-      unless env.class?(type_name)
-        stdout.puts "Cannot find class: #{type_name}"
-        return
-      end
-
-      definition = case kind
-                   when :instance
-                     builder.build_instance(type_name)
-                   when :singleton
-                     builder.build_singleton(type_name)
-                   end
-
-      method = definition.methods[method_name]
-
-      unless method
-        stdout.puts "Cannot find method: #{method_name}"
-        return
-      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 "  accessibility: #{method.accessibility}"
-      stdout.puts "  types:"
-      separator = " "
-      for type in method.method_types
-        stdout.puts "    #{separator} #{type}"
-        separator = "|"
-      end
-    end
-
-    def run_validate(args, options)
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      builder = DefinitionBuilder.new(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
-        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
-      end
-
-      env.each_global do |name, global|
-        stdout.puts "#{Location.to_string global.location}:\tValidating global: `#{name}`..."
-        env.validate global.type, namespace: 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
-      end
-    end
-
-    def run_constant(args, options)
-      context = nil
-
-      OptionParser.new do |opts|
-        opts.on("--context CONTEXT") {|c| context = c }
-      end.order!(args)
-
-      unless args.size == 1
-        stdout.puts "Expected one argument."
-        return
-      end
-
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      env = Environment.new()
-      loader.load(env: env)
-
-      builder = DefinitionBuilder.new(env: env)
-      table = ConstantTable.new(builder: builder)
-
-      namespace = context ? Namespace.parse(context).absolute! : Namespace.root
-      stdout.puts "Context: #{namespace}"
-      name = Namespace.parse(args[0]).to_type_name
-      stdout.puts "Constant name: #{name}"
-
-      constant = table.resolve_constant_reference(name, context: namespace)
-
-      if constant
-        stdout.puts " => #{constant.name}: #{constant.type}"
-      else
-        stdout.puts " => [no constant]"
-      end
-    end
-
-    def run_version(args, options)
-      stdout.puts "ruby-signature #{VERSION}"
-    end
-
-    def run_paths(args, options)
-      loader = EnvironmentLoader.new()
-
-      options.setup(loader)
-
-      kind_of = -> (path) {
-        case
-        when path.file?
-          "file"
-        when path.directory?
-          "dir"
-        when !path.exist?
-          "absent"
-        else
-          "unknown"
-        end
-      }
-
-      if loader.stdlib_root
-        path = loader.stdlib_root
-        stdout.puts "#{path}/builtin (#{kind_of[path]}, stdlib)"
-      end
-
-      loader.paths.each do |path|
-        case path
-        when Pathname
-          stdout.puts "#{path} (#{kind_of[path]})"
-        when EnvironmentLoader::GemPath
-          stdout.puts "#{path.path} (#{kind_of[path.path]}, gem, name=#{path.name}, version=#{path.version})"
-        when EnvironmentLoader::LibraryPath
-          stdout.puts "#{path.path} (#{kind_of[path.path]}, library, name=#{path.name})"
-        end
-      end
-    end
-
-    def run_prototype(args, options)
-      format = args.shift
-
-      case format
-      when "rbi", "rb"
-        decls = run_prototype_file(format, args)
-      when "runtime"
-        require_libs = []
-        relative_libs = []
-        merge = false
-        owners_included = []
-
-        OptionParser.new do |opts|
-          opts.on("--require LIB") do |lib|
-            require_libs << lib
-          end
-          opts.on("--require-relative LIB") do |lib|
-            relative_libs << lib
-          end
-          opts.on("--merge") do
-            merge = true
-          end
-          opts.on("--method-owner CLASS") do |klass|
-            owners_included << klass
-          end
-        end.parse!(args)
-
-        loader = EnvironmentLoader.new()
-
-        options.setup(loader)
-
-        env = Environment.new()
-        loader.load(env: env)
-
-        require_libs.each do |lib|
-          require(lib)
-        end
-
-        relative_libs.each do |lib|
-          require(lib)
-        end
-
-        decls = Prototype::Runtime.new(patterns: args, env: env, merge: merge, owners_included: owners_included).decls
-      else
-        stdout.puts "Supported formats: rbi, rb, runtime"
-        exit 1
-      end
-
-      writer = Writer.new(out: stdout)
-      writer.write decls
-    end
-
-    def run_prototype_file(format, args)
-      parser = case format
-               when "rbi"
-                 Prototype::RBI.new()
-               when "rb"
-                 Prototype::RB.new()
-               end
-
-      args.each do |file|
-        parser.parse Pathname(file).read
-      end
-
-      parser.decls
-    end
-
-    def run_vendor(args, options)
-      clean = false
-      vendor_stdlib = false
-      vendor_dir = Pathname("vendor/sigs")
-
-      OptionParser.new do |opts|
-        opts.banner = <<~EOB
-        Usage: rbs vendor [options] GEMS...
-        Vendor signatures in the project directory.
-        EOB
-
-        opts.on("--[no-]clean", "Clean vendor directory (default: no)") do |v|
-          clean = v
-        end
-
-        opts.on("--[no-]stdlib", "Vendor stdlib signatures or not (default: no)") do |v|
-          vendor_stdlib = v
-        end
-
-        opts.on("--vendor-dir [DIR]", "Specify the directory for vendored signatures (default: vendor/sigs)") do |path|
-          vendor_dir = Pathname(path)
-        end
-      end.parse!(args)
-
-      stdout.puts "Vendoring signatures to #{vendor_dir}..."
-
-      vendorer = Vendorer.new(vendor_dir: vendor_dir)
-
-      if clean
-        stdout.puts "  Deleting #{vendor_dir}..."
-        vendorer.clean!
-      end
-
-      if vendor_stdlib
-        stdout.puts "  Vendoring standard libraries..."
-        vendorer.stdlib!
-      end
-
-      args.each do |gem|
-        name, version = EnvironmentLoader.parse_library(gem)
-
-        unless EnvironmentLoader.gem_sig_path(name, version)
-          stdout.puts "  ⚠️ Cannot find rubygem: name=#{name}, version=#{version} 🚨"
-        else
-          stdout.puts "  Vendoring gem: name=#{name}, version=#{version}..."
-          vendorer.gem!(name, version)
-        end
-      end
-    end
-
-    def run_parse(args, options)
-      loader = EnvironmentLoader.new()
-
-      syntax_error = false
-      args.each do |path|
-        path = Pathname(path)
-        loader.each_signature(path) do |sig_path|
-          Parser.parse_signature(sig_path.read)
-        rescue RBS::Parser::SyntaxError => ex
-          loc = ex.error_value.location
-          stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: parse error on value: (#{ex.token_str})"
-          syntax_error = true
-        rescue RBS::Parser::SemanticsError => ex
-          loc = ex.location
-          stdout.puts "#{sig_path}:#{loc.start_line}:#{loc.start_column}: #{ex.original_message}"
-          syntax_error = true
-        end
-      end
-      exit 1 if syntax_error
-    end
-
-    def parse_type_name(string)
-      Namespace.parse(string).yield_self do |namespace|
-        last = namespace.path.last
-        TypeName.new(name: last, namespace: namespace.parent)
-      end
-    end
-  end
-end