cosmicgraph 0.49.0

data/lib/solargraph/bench.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Solargraph
+  # A container of source maps and workspace data to be cataloged in an ApiMap.
+  #
+  class Bench
+    # @return [Set<SourceMap>]
+    attr_reader :source_maps
+
+    # @return [Workspace]
+    attr_reader :workspace
+
+    # @return [Set<String>]
+    attr_reader :external_requires
+
+    # @param source_maps [Array<SourceMap>, Set<SourceMap>]
+    # @param workspace [Workspace]
+    # @param external_requires [Array<String>, Set<String>]
+    def initialize source_maps: [], workspace: Workspace.new, external_requires: []
+      @source_maps = source_maps.to_set
+      @workspace = workspace
+      @external_requires = external_requires.to_set
+    end
+  end
+end

data/lib/solargraph/cache.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+
+module Solargraph
+  module Cache
+    class << self
+      # The base directory where cached documentation is installed.
+      #
+      # @return [String]
+      def base_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        ENV['SOLARGRAPH_CACHE'] || File.join(Dir.home, '.solargraph', 'cache')
+      end
+
+      # The working directory for the current Ruby and Solargraph versions.
+      #
+      # @return [String]
+      def work_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
+      end
+
+      # @return [Array<Solargraph::Pin::Base>, nil]
+      def load *path
+        file = File.join(work_dir, *path)
+        return nil unless File.file?(file)
+        Marshal.load(File.read(file, mode: 'rb'))
+      rescue StandardError => e
+        Solargraph.logger.warn "Failed to load cached file #{file}: [#{e.class}] #{e.message}"
+        FileUtils.rm_f file
+        nil
+      end
+
+      # @return [Boolean]
+      def save *path, pins
+        return false if pins.empty?
+        file = File.join(work_dir, *path)
+        base = File.dirname(file)
+        FileUtils.mkdir_p base unless File.directory?(base)
+        ser = Marshal.dump(pins)
+        File.write file, ser, mode: 'wb'
+        true
+      end
+
+      def clear
+        FileUtils.rm_rf base_dir, secure: true
+      end
+    end
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ComplexType
+    # Methods for accessing type data.
+    #
+    module TypeMethods
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :substring
+
+      # @return [String]
+      attr_reader :tag
+
+      # @return [Array<ComplexType>]
+      attr_reader :subtypes
+
+      # @return [Boolean]
+      def duck_type?
+        @duck_type ||= name.start_with?('#')
+      end
+
+      # @return [Boolean]
+      def nil_type?
+        @nil_type = (name.casecmp('nil') == 0) if @nil_type.nil?
+        @nil_type
+      end
+
+      # @return [Boolean]
+      def parameters?
+        !substring.empty?
+      end
+
+      def void?
+        name == 'void'
+      end
+
+      def defined?
+        !undefined?
+      end
+
+      def undefined?
+        name == 'undefined'
+      end
+
+      # @return [Boolean]
+      def list_parameters?
+        substring.start_with?('<')
+      end
+
+      # @return [Boolean]
+      def fixed_parameters?
+        substring.start_with?('(')
+      end
+
+      # @return [Boolean]
+      def hash_parameters?
+        substring.start_with?('{')
+      end
+
+      # @return [Array<ComplexType>]
+      def value_types
+        @subtypes
+      end
+
+      # @return [Array<ComplexType>]
+      def key_types
+        @key_types
+      end
+
+      # @return [String]
+      def namespace
+        # if priority higher than ||=, old implements cause unnecessary check
+        @namespace ||= lambda do
+          return 'Object' if duck_type?
+          return 'NilClass' if nil_type?
+          return (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+        end.call
+      end
+
+      # @return [Symbol] :class or :instance
+      def scope
+        @scope ||= :instance if duck_type? || nil_type?
+        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
+      end
+
+      def == other
+        return false unless self.class == other.class
+        tag == other.tag
+      end
+
+      def rooted?
+        @rooted
+      end
+
+      # Generate a ComplexType that fully qualifies this type's namespaces.
+      #
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param context [String] The namespace from which to resolve names
+      # @return [ComplexType] The generated ComplexType
+      def qualify api_map, context = ''
+        return self if name == 'param'
+        return ComplexType.new([self]) if duck_type? || void? || undefined?
+        recon = (rooted? ? '' : context)
+        fqns = api_map.qualify(name, recon)
+        if fqns.nil?
+          return UniqueType::BOOLEAN if tag == 'Boolean'
+          return UniqueType::UNDEFINED
+        end
+        fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
+        ltypes = key_types.map { |t| t.qualify api_map, context }.uniq
+        rtypes = value_types.map { |t| t.qualify api_map, context }.uniq
+        if list_parameters?
+          Solargraph::ComplexType.parse("#{fqns}<#{rtypes.map(&:tag).join(', ')}>")
+        elsif fixed_parameters?
+          Solargraph::ComplexType.parse("#{fqns}(#{rtypes.map(&:tag).join(', ')})")
+        elsif hash_parameters?
+          Solargraph::ComplexType.parse("#{fqns}{#{ltypes.map(&:tag).join(', ')} => #{rtypes.map(&:tag).join(', ')}}")
+        else
+          Solargraph::ComplexType.parse(fqns)
+        end
+      end
+
+      # @yieldparam [UniqueType]
+      # @return [Enumerator<UniqueType>]
+      def each_unique_type &block
+        return enum_for(__method__) unless block_given?
+        yield self
+      end
+    end
+  end
+end

data/lib/solargraph/complex_type/unique_type.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class ComplexType
+    # An individual type signature. A complex type can consist of multiple
+    # unique types.
+    #
+    class UniqueType
+      include TypeMethods
+
+      attr_reader :all_params
+
+      # Create a UniqueType with the specified name and an optional substring.
+      # The substring is the parameter section of a parametrized type, e.g.,
+      # for the type `Array<String>`, the name is `Array` and the substring is
+      # `<String>`.
+      #
+      # @param name [String] The name of the type
+      # @param substring [String] The substring of the type
+      def initialize name, substring = ''
+        if name.start_with?('::')
+          @name = name[2..-1]
+          @rooted = true
+        else
+          @name = name
+          @rooted = false
+        end
+        @substring = substring
+        @tag = @name + substring
+        @key_types = []
+        @subtypes = []
+        @all_params = []
+        return unless parameters?
+        if @substring.start_with?('<(') && @substring.end_with?(')>')
+          subs = ComplexType.parse(substring[2..-3], partial: true)
+        else
+          subs = ComplexType.parse(substring[1..-2], partial: true)
+        end
+        if hash_parameters?
+          raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+          @key_types.concat subs[0].map { |u| ComplexType.new([u]) }
+          @subtypes.concat subs[1].map { |u| ComplexType.new([u]) }
+        else
+          @subtypes.concat subs
+        end
+        @all_params.concat @key_types
+        @all_params.concat @subtypes
+      end
+
+      def to_s
+        tag
+      end
+
+      def to_rbs
+        "#{namespace}#{parameters? ? "[#{subtypes.map { |s| s.to_rbs }.join(', ')}]" : ''}"
+      end
+  
+      def parameterized?
+        name == 'param' || all_params.any?(&:parameterized?)
+      end
+
+      def resolve_parameters definitions, context
+        new_name = if name == 'param'
+          idx = definitions.parameters.index(subtypes.first.name)
+          return ComplexType::UNDEFINED if idx.nil?
+          param_type = context.return_type.all_params[idx]
+          return ComplexType::UNDEFINED unless param_type
+          param_type.to_s
+        else
+          name
+        end
+        new_key_types = if name != 'param'
+          @key_types.map { |t| t.resolve_parameters(definitions, context) }.select(&:defined?)
+        else
+          []
+        end
+        new_subtypes = if name != 'param'
+          @subtypes.map { |t| t.resolve_parameters(definitions, context) }.select(&:defined?)
+        else
+          []
+        end
+        if name != 'param' && !(new_key_types.empty? && new_subtypes.empty?)
+          if hash_parameters?
+            UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
+          elsif parameters?
+            if @substring.start_with?'<('
+              UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
+            else
+              UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+            end
+          else
+            UniqueType.new(new_name)
+          end
+        else
+          UniqueType.new(new_name)
+        end
+
+        # idx = definitions.parameters.index(subtypes.first.name)
+        # STDERR.puts "Index: #{idx}"
+        # return ComplexType::UNDEFINED if idx.nil?
+        # param_type = context.return_type.all_params[idx]
+        # return ComplexType::UNDEFINED unless param_type
+        # ComplexType.try_parse(param_type.to_s)
+      end
+
+      def self_to dst
+        return self unless selfy?
+        new_name = (@name == 'self' ? dst : @name)
+        new_key_types = @key_types.map { |t| t.self_to dst }
+        new_subtypes = @subtypes.map { |t| t.self_to dst }
+        if hash_parameters?
+          UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
+        elsif parameters?
+          if @substring.start_with?'<('
+            UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
+          else
+            UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+          end
+        else
+          UniqueType.new(new_name)
+        end
+      end
+
+      def selfy?
+        @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
+      end
+
+      UNDEFINED = UniqueType.new('undefined')
+      BOOLEAN = UniqueType.new('Boolean')
+    end
+  end
+end

data/lib/solargraph/complex_type.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A container for type data based on YARD type tags.
+  #
+  class ComplexType
+    # @!parse
+    #   include TypeMethods
+
+    autoload :TypeMethods, 'solargraph/complex_type/type_methods'
+    autoload :UniqueType,  'solargraph/complex_type/unique_type'
+
+    # @param types [Array<UniqueType>]
+    def initialize types = [UniqueType::UNDEFINED]
+      @items = types.uniq(&:to_s)
+    end
+
+    # @param api_map [ApiMap]
+    # @param context [String]
+    # @return [ComplexType]
+    def qualify api_map, context = ''
+      types = @items.map do |t|
+        next t if ['Boolean', 'nil', 'void', 'undefined'].include?(t.name)
+        t.qualify api_map, context
+      end
+      ComplexType.new(types)
+    end
+
+    def first
+      @items.first
+    end
+
+    def to_rbs
+      ((@items.length > 1 ? '(' : '') + @items.map do |item|
+        "#{item.namespace}#{item.parameters? ? "[#{item.subtypes.map { |s| s.to_rbs }.join(', ')}]" : ''}"
+      end.join(' | ') + (@items.length > 1 ? ')' : '')).gsub(/undefined/, 'untyped')
+    end
+
+    def map &block
+      @items.map &block
+    end
+
+    # @yieldparam [UniqueType]
+    # @return [Array]
+    def each &block
+      @items.each &block
+    end
+
+    # @yieldparam [UniqueType]
+    # @return [Enumerator<UniqueType>]
+    def each_unique_type &block
+      return enum_for(__method__) unless block_given?
+
+      @items.each do |item|
+        item.each_unique_type &block
+      end
+    end
+
+    def length
+      @items.length
+    end
+
+    def [](index)
+      @items[index]
+    end
+
+    def select &block
+      @items.select &block
+    end
+    def namespace
+      # cache this attr for high frequency call
+      @namespace ||= method_missing(:namespace).to_s
+    end
+
+    def method_missing name, *args, &block
+      return if @items.first.nil?
+      return @items.first.send(name, *args, &block) if respond_to_missing?(name)
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      TypeMethods.public_instance_methods.include?(name) || super
+    end
+
+    def to_s
+      map(&:tag).join(', ')
+    end
+
+    def all? &block
+      @items.all? &block
+    end
+
+    def any? &block
+      @items.compact.any? &block
+    end
+
+    def selfy?
+      @items.any?(&:selfy?)
+    end
+
+    def parameterized?
+      any?(&:parameterized?)
+    end
+
+    def resolve_parameters definitions, context
+      result = @items.map { |i| i.resolve_parameters(definitions, context) }
+      ComplexType.parse(*result.map(&:tag))
+    end
+
+    # @param dst [String]
+    # @return [ComplexType]
+    def self_to dst
+      return self unless selfy?
+      red = reduce_class(dst)
+      result = @items.map { |i| i.self_to red }
+      ComplexType.parse(*result.map(&:tag))
+    end
+
+    def nullable?
+      @items.any?(&:nil_type?)
+    end
+
+    def all_params
+      @items.first.all_params || []
+    end
+
+    private
+
+    # @todo This is a quick and dirty hack that forces `self` keywords
+    #   to reference an instance of their class and never the class itself.
+    #   This behavior may change depending on which result is expected
+    #   from YARD conventions. See https://github.com/lsegal/yard/issues/1257
+    # @param dst [String]
+    # @return [String]
+    def reduce_class dst
+      while dst =~ /^(Class|Module)\<(.*?)\>$/
+        dst = dst.sub(/^(Class|Module)\</, '').sub(/\>$/, '')
+      end
+      dst
+    end
+
+    class << self
+      # Parse type strings into a ComplexType.
+      #
+      # @example
+      #   ComplexType.parse 'String', 'Foo', 'nil' #=> [String, Foo, nil]
+      #
+      # @note
+      #   The `partial` parameter is used to indicate that the method is
+      #   receiving a string that will be used inside another ComplexType.
+      #   It returns arrays of ComplexTypes instead of a single cohesive one.
+      #   Consumers should not need to use this parameter; it should only be
+      #   used internally.
+      #
+      # @param *strings [Array<String>] The type definitions to parse
+      # @param partial [Boolean] True if the string is part of a another type
+      # @return [ComplexType, Array, nil]
+      def parse *strings, partial: false
+        @cache ||= {}
+        unless partial
+          cached = @cache[strings]
+          return cached unless cached.nil?
+        end
+        types = []
+        key_types = nil
+        strings.each do |type_string|
+          point_stack = 0
+          curly_stack = 0
+          paren_stack = 0
+          base = String.new
+          subtype_string = String.new
+          type_string.each_char do |char|
+            if char == '='
+              #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
+            elsif char == '<'
+              point_stack += 1
+            elsif char == '>'
+              if subtype_string.end_with?('=') && curly_stack > 0
+                subtype_string += char
+              elsif base.end_with?('=')
+                raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
+                # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                types.push UniqueType.new(base[0..-2].strip)
+                key_types = types
+                types = []
+                base.clear
+                subtype_string.clear
+                next
+              else
+                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack == 0
+                point_stack -= 1
+                subtype_string += char
+              end
+              next
+            elsif char == '{'
+              curly_stack += 1
+            elsif char == '}'
+              curly_stack -= 1
+              subtype_string += char
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
+              next
+            elsif char == '('
+              paren_stack += 1
+            elsif char == ')'
+              paren_stack -= 1
+              subtype_string += char if paren_stack == 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
+              next
+            elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
+              # types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
+              types.push UniqueType.new(base.strip, subtype_string.strip)
+              base.clear
+              subtype_string.clear
+              next
+            end
+            if point_stack == 0 && curly_stack == 0 && paren_stack == 0
+              base.concat char
+            else
+              subtype_string.concat char
+            end
+          end
+          raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+          # types.push ComplexType.new([UniqueType.new(base, subtype_string)])
+          types.push UniqueType.new(base.strip, subtype_string.strip)
+        end
+        unless key_types.nil?
+          raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
+          return key_types if types.empty?
+          return [key_types, types]
+        end
+        result = partial ? types : ComplexType.new(types)
+        @cache[strings] = result unless partial
+        result
+      end
+
+      # @param strings [Array<String>]
+      # @return [ComplexType]
+      def try_parse *strings
+        parse *strings
+      rescue ComplexTypeError => e
+        Solargraph.logger.info "Error parsing complex type: #{e.message}"
+        ComplexType::UNDEFINED
+      end
+    end
+
+    VOID = ComplexType.parse('void')
+    UNDEFINED = ComplexType.parse('undefined')
+    SYMBOL = ComplexType.parse('Symbol')
+    ROOT = ComplexType.parse('Class<>')
+    NIL = ComplexType.parse('nil')
+    SELF = ComplexType.parse('self')
+    BOOLEAN = ComplexType.parse('Boolean')
+  end
+end

data/lib/solargraph/convention/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    # The base class for Conventions.
+    #
+    # A Convention provides Environs that customize ApiMaps with additional
+    # pins and other information. Subclasses should implement the `local` and
+    # `global` methods as necessary.
+    #
+    class Base
+      EMPTY_ENVIRON = Environ.new
+
+      # The Environ for a source map.
+      # Subclasses can override this method.
+      #
+      # @param source_map [SourceMap]
+      # @return [Environ]
+      def local source_map
+        EMPTY_ENVIRON
+      end
+
+      # The Environ for a YARD map.
+      # Subclasses can override this method.
+      #
+      # @param yard_map [YardMap]
+      # @return [Environ]
+      def global yard_map
+        EMPTY_ENVIRON
+      end
+    end
+  end
+end

data/lib/solargraph/convention/gemfile.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Gemfile < Base
+      def local source_map
+        return EMPTY_ENVIRON unless File.basename(source_map.filename) == 'Gemfile'
+        @environ ||= Environ.new(
+          requires: ['bundler'],
+          domains: ['Bundler::Dsl']
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/convention/gemspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Gemspec < Base
+      def local source_map
+        return EMPTY_ENVIRON unless File.basename(source_map.filename).end_with?('.gemspec')
+        @environ ||= Environ.new(
+          requires: ['rubygems'],
+          pins: [
+            Solargraph::Pin::Reference::Override.from_comment(
+              'Gem::Specification.new',
+              %(
+@yieldparam [self]
+              )
+            )
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/solargraph/convention/rakefile.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    class Rakefile < Base
+      def local source_map
+        basename = File.basename(source_map.filename)
+        return EMPTY_ENVIRON unless basename.end_with?('.rake') || basename == 'Rakefile'
+
+        @environ ||= Environ.new(
+          requires: ['rake'],
+          domains: ['Rake::DSL']
+        )
+      end
+    end
+  end
+end