steep 0.15.0 → 0.17.0

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

@@ -1,138 +0,0 @@
-module RBS
-  class VarianceCalculator
-    class Result
-      attr_reader :result
-
-      def initialize(variables:)
-        @result = {}
-        variables.each do |x|
-          result[x] = :unused
-        end
-      end
-
-      def covariant(x)
-        case result[x]
-        when :unused
-          result[x] = :covariant
-        when :contravariant
-          result[x] = :invariant
-        end
-      end
-
-      def contravariant(x)
-        case result[x]
-        when :unused
-          result[x] = :contravariant
-        when :covariant
-          result[x] = :invariant
-        end
-      end
-
-      def invariant(x)
-        result[x] = :invariant
-      end
-
-      def each(&block)
-        result.each(&block)
-      end
-
-      def include?(name)
-        result.key?(name)
-      end
-
-      def compatible?(var, with_annotation:)
-        variance = result[var]
-
-        case
-        when variance == :unused
-          true
-        when with_annotation == :invariant
-          true
-        when variance == with_annotation
-          true
-        else
-          false
-        end
-      end
-    end
-
-    attr_reader :builder
-
-    def initialize(builder:)
-      @builder = builder
-    end
-
-    def env
-      builder.env
-    end
-
-    def in_method_type(method_type:, variables:)
-      result = Result.new(variables: variables)
-
-      method_type.type.each_param do |param|
-        type(param.type, result: result, context: :contravariant)
-      end
-
-      if method_type.block
-        method_type.block.type.each_param do |param|
-          type(param.type, result: result, context: :covariant)
-        end
-        type(method_type.block.type.return_type, result: result, context: :contravariant)
-      end
-
-      type(method_type.type.return_type, result: result, context: :covariant)
-
-      result
-    end
-
-    def in_inherit(name:, args:, variables:)
-      type = Types::ClassInstance.new(name: name, args: args, location: nil)
-
-      Result.new(variables: variables).tap do |result|
-        type(type, result: result, context: :covariant)
-      end
-    end
-
-    def type(type, result:, context:)
-      case type
-      when Types::Variable
-        if result.include?(type.name)
-          case context
-          when :covariant
-            result.covariant(type.name)
-          when :contravariant
-            result.contravariant(type.name)
-          when :invariant
-            result.invariant(type.name)
-          end
-        end
-      when Types::ClassInstance, Types::Interface
-        decl = env.find_class(type.name)
-        type.args.each.with_index do |ty, i|
-          var = decl.type_params.params[i]
-          case var.variance
-          when :invariant
-            type(ty, result: result, context: :invariant)
-          when :covariant
-            type(ty, result: result, context: context)
-          when :contravariant
-            con = case context
-                  when :invariant
-                    :invariant
-                  when :covariant
-                    :contravariant
-                  when :contravariant
-                    :covariant
-                  end
-            type(ty, result: result, context: con)
-          end
-        end
-      when Types::Tuple, Types::Record, Types::Union, Types::Intersection
-        # Covariant types
-        type.each_type do |ty|
-          type(ty, result: result, context: context)
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module RBS
-  class Vendorer
-    attr_reader :vendor_dir
-
-    def initialize(vendor_dir:)
-      @vendor_dir = vendor_dir
-    end
-
-    def ensure_dir
-      unless vendor_dir.directory?
-        vendor_dir.mkpath
-      end
-
-      yield
-    end
-
-    def clean!
-      ensure_dir do
-        RBS.logger.info "Cleaning vendor root: #{vendor_dir}..."
-        vendor_dir.rmtree
-      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"
-      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}"
-
-        if sig_path&.directory?
-          gems_dir = vendor_dir + "gems"
-          gems_dir.mkpath unless gems_dir.directory?
-
-          gem_dir = gems_dir + name
-          RBS.logger.info "Vendoring gem(#{name}:#{version}): #{sig_path} => #{gem_dir}..."
-          FileUtils.copy_entry sig_path, gem_dir
-        end
-      end
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-module RBS
-  VERSION = "0.1.0"
-end

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

@@ -1,269 +0,0 @@
-module RBS
-  class Writer
-    attr_reader :out
-
-    def initialize(out:)
-      @out = out
-    end
-
-    def write_annotation(annotations, level:)
-      prefix = " " * level
-
-      annotations.each do |annotation|
-        string = annotation.string
-        case
-        when string !~ /\}/
-          out.puts "#{prefix}%a{#{string}}"
-        when string !~ /\)/
-          out.puts "#{prefix}%a(#{string})"
-        when string !~ /\]/
-          out.puts "#{prefix}%a[#{string}]"
-        when string !~ /\>/
-          out.puts "#{prefix}%a<#{string}>"
-        when string !~ /\|/
-          out.puts "#{prefix}%a|#{string}|"
-        end
-      end
-    end
-
-    def write_comment(comment, level:)
-      if comment
-        prefix = " " * level
-        comment.string.lines.each do |line|
-          line = " #{line}" unless line.chomp.empty?
-          out.puts "#{prefix}##{line}"
-        end
-      end
-    end
-
-    def write(decls)
-      [nil, *decls].each_cons(2) do |prev, decl|
-        preserve_empty_line(prev, decl)
-        write_decl decl
-      end
-    end
-
-    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)}"
-                      end
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "class #{name_and_params(decl.name, decl.type_params)}#{super_class}"
-
-        [nil, *decl.members].each_cons(2) do |prev, member|
-          preserve_empty_line prev, member
-          write_member member
-        end
-
-        out.puts "end"
-
-      when AST::Declarations::Module
-        self_type = if decl.self_type
-                      " : #{decl.self_type}"
-                    end
-
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "module #{name_and_params(decl.name, decl.type_params)}#{self_type}"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
-          end
-          write_member member
-        end
-        out.puts "end"
-      when AST::Declarations::Constant
-        write_comment decl.comment, level: 0
-        out.puts "#{decl.name}: #{decl.type}"
-
-      when AST::Declarations::Global
-        write_comment decl.comment, level: 0
-        out.puts "#{decl.name}: #{decl.type}"
-
-      when AST::Declarations::Alias
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "type #{decl.name} = #{decl.type}"
-
-      when AST::Declarations::Interface
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "interface #{name_and_params(decl.name, decl.type_params)}"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
-          end
-          write_member member
-        end
-        out.puts "end"
-
-      when AST::Declarations::Extension
-        write_comment decl.comment, level: 0
-        write_annotation decl.annotations, level: 0
-        out.puts "extension #{name_and_args(decl.name, decl.type_params)} (#{decl.extension_name})"
-        decl.members.each.with_index do |member, index|
-          if index > 0
-            out.puts
-          end
-          write_member member
-        end
-        out.puts "end"
-      end
-    end
-
-    def name_and_params(name, params)
-      if params.empty?
-        "#{name}"
-      else
-        ps = params.each.map do |param|
-          s = ""
-          if param.skip_validation
-            s << "unchecked "
-          end
-          case param.variance
-          when :invariant
-            # nop
-          when :covariant
-            s << "out "
-          when :contravariant
-            s << "in "
-          end
-          s + param.name.to_s
-        end
-
-        "#{name}[#{ps.join(", ")}]"
-      end
-    end
-
-    def name_and_args(name, args)
-      if name && args
-        if args.empty?
-          "#{name}"
-        else
-          "#{name}[#{args.join(", ")}]"
-        end
-      end
-    end
-
-    def write_member(member)
-      case member
-      when AST::Members::Include
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  include #{name_and_args(member.name, member.args)}"
-      when AST::Members::Extend
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  extend #{name_and_args(member.name, member.args)}"
-      when AST::Members::Prepend
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  prepend #{name_and_args(member.name, member.args)}"
-      when AST::Members::AttrAccessor
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:accessor, member)}"
-      when AST::Members::AttrReader
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:reader, member)}"
-      when AST::Members::AttrWriter
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        out.puts "  #{attribute(:writer, member)}"
-      when AST::Members::Public
-        out.puts "  public"
-      when AST::Members::Private
-        out.puts "  private"
-      when AST::Members::Alias
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        new_name = member.singleton? ? "self.#{member.new_name}" : member.new_name
-        old_name = member.singleton? ? "self.#{member.old_name}" : member.old_name
-        out.puts "  alias #{new_name} #{old_name}"
-      when AST::Members::InstanceVariable
-        write_comment member.comment, level: 2
-        out.puts "  #{member.name}: #{member.type}"
-      when AST::Members::ClassInstanceVariable
-        write_comment member.comment, level: 2
-        out.puts "  self.#{member.name}: #{member.type}"
-      when AST::Members::ClassVariable
-        write_comment member.comment, level: 2
-        out.puts "  #{member.name}: #{member.type}"
-      when AST::Members::MethodDefinition
-        write_comment member.comment, level: 2
-        write_annotation member.annotations, level: 2
-        write_def member
-      end
-    end
-
-    def method_name(name)
-      s = name.to_s
-
-      if /\A#{Parser::KEYWORDS_RE}\z/.match?(s)
-        "`#{s}`"
-      else
-        s
-      end
-    end
-
-    def write_def(member)
-      name = case member.kind
-             when :instance
-               "#{method_name(member.name)}"
-             when :singleton_instance
-               "self?.#{method_name(member.name)}"
-             when :singleton
-               "self.#{method_name(member.name)}"
-             end
-
-      attrs = member.attributes.empty? ? "" : member.attributes.join(" ") + " "
-      prefix = "  #{attrs}def #{name}:"
-      padding = " " * (prefix.size-1)
-
-      out.print prefix
-
-      member.types.each.with_index do |type, index|
-        if index > 0
-          out.print padding
-          out.print "|"
-        end
-        out.puts " #{type}"
-      end
-    end
-
-    def attribute(kind, attr)
-      var = case attr.ivar_name
-            when nil
-              ""
-            when false
-              "()"
-            else
-              "(#{attr.ivar_name})"
-            end
-      "attr_#{kind} #{attr.name}#{var}: #{attr.type}"
-    end
-
-    def preserve_empty_line(prev, decl)
-      return unless prev
-
-      decl = decl.comment if decl.respond_to?(:comment) && decl.comment
-
-      # When the signature is not constructed by the parser,
-      # it always inserts an empty line.
-      if !prev.location || !decl.location
-        out.puts
-        return
-      end
-
-      prev_end_line = prev.location.end_line
-      start_line = decl.location.start_line
-      if start_line - prev_end_line > 1
-        out.puts
-      end
-    end
-  end
-end