solargraph 0.60.4 → 0.62.0

data/lib/solargraph/pin/method.rb

@@ -370,6 +370,13 @@ module Solargraph
         @explicit
       end
 
+      # False for method pins synthesized from a class-body statement rather than parsed from a def.
+      #
+      # @return [Boolean]
+      def body?
+        !attribute?
+      end
+
       def attribute?
         @attribute
       end
@@ -387,6 +394,9 @@ module Solargraph
 
       def probe api_map
         attribute? ? infer_from_iv(api_map) : infer_from_return_nodes(api_map)
+      rescue FileNotFoundError
+        # @todo Necessary for pins from source maps that are not part of the workspace
+        ComplexType::UNDEFINED
       end
 
       # @return [::Array<Pin::Signature>]

data/lib/solargraph/pin/method_alias.rb

@@ -7,6 +7,10 @@ module Solargraph
     # methods from included modules.
     #
     class MethodAlias < Method
+      # @return [Boolean]
+      def body?
+        false
+      end
       # @return [::Symbol]
       attr_reader :scope
 

data/lib/solargraph/pin/parameter.rb

@@ -115,7 +115,7 @@ module Solargraph
       end
 
       def rest?
-        %i[restarg kwrestarg].include?(decl)
+        %i[restarg kwrestarg forward_args].include?(decl)
       end
 
       def block?

data/lib/solargraph/pin/reference/included_mixin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      # A mixin that a module's +self.included+ hook applies to every class
+      # that includes the module, e.g. +base.extend ClassMethods+. The closure
+      # is the hooking module and the name is the mixed-in module.
+      class IncludedMixin < Reference
+        # @return [::Symbol] :include, :prepend or :extend
+        attr_reader :keyword
+
+        # @param keyword [::Symbol] :include, :prepend or :extend
+        # @param splat [Hash{Symbol => Object}]
+        def initialize keyword:, **splat
+          super(**splat)
+          @keyword = keyword
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference.rb

@@ -8,6 +8,7 @@ module Solargraph
       autoload :Include,    'solargraph/pin/reference/include'
       autoload :Prepend,    'solargraph/pin/reference/prepend'
       autoload :Extend,     'solargraph/pin/reference/extend'
+      autoload :IncludedMixin, 'solargraph/pin/reference/included_mixin'
       autoload :Override,   'solargraph/pin/reference/override'
       autoload :TypeAlias,  'solargraph/pin/reference/type_alias'
 

data/lib/solargraph/pin.rb

@@ -38,6 +38,7 @@ module Solargraph
     autoload :Until,            'solargraph/pin/until'
     autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
+    autoload :FactoryParameter, 'solargraph/pin/factory_parameter'
     autoload :CompoundStatement,
              'solargraph/pin/compound_statement'
 

data/lib/solargraph/plugin/active_support.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class ActiveSupport < Base
+      ATTRIBUTE_NAME = /\A[_A-Za-z]\w*\z/
+
+      def addon
+        return EMPTY_ADDON unless gem_names.include?('activesupport')
+
+        Addon.new(pins: classmethod_pins + attribute_pins)
+      end
+
+      private
+
+      def classmethod_pins
+        pins_by_class(Pin::Reference::Include).map do |inc|
+          Pin::Reference::Extend.new(name: "#{inc.name}::ClassMethods", closure: inc.closure)
+        end
+      end
+
+      def attribute_pins
+        source_maps.flat_map { |map| map.calls(:class_attribute, :mattr_accessor, :cattr_accessor, :mattr_reader, :cattr_reader, :mattr_writer, :cattr_writer, :config_accessor) }
+                   .select { |call| call.closure.is_a?(Pin::Namespace) }
+                   .flat_map { |call| generate_call_pins(call) }
+                   .compact
+      end
+
+      # @param call [SourceMap::Call]
+      def generate_call_pins call
+        options = option_hash(call.chain.links.last.arguments.last)
+        method_names = call.chain.links.last.arguments.select(&:literal?).map { |arg| arg.links.last.value }.compact
+                           .grep(ATTRIBUTE_NAME)
+        case call.chain.links.last.word
+        when 'class_attribute'
+          class_suffixes = ['', '=']
+          class_suffixes.push '?' if options[:instance_predicate]
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          instance_suffixes.push '?' if options[:instance_accessor] && options[:instance_predicate]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_accessor', 'cattr_accessor', 'config_accessor'
+          class_suffixes = ['', '=']
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_reader', 'cattr_reader'
+          class_suffixes = ['']
+          instance_suffixes = []
+          instance_suffixes.push '' if options[:instance_accessor] && options[:instance_reader]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        when 'mattr_writer', 'cattr_writer'
+          class_suffixes = ['=']
+          instance_suffixes = []
+          instance_suffixes.push '=' if options[:instance_accessor] && options[:instance_writer]
+          method_names.flat_map { |name| method_pins(name, class_suffixes, instance_suffixes, call) }
+        else
+          []
+        end
+      end
+
+      def option_hash args
+        defaults = {
+          instance_reader: true,
+          instance_writer: true,
+          instance_accessor: true,
+          instance_predicate: true
+        }
+        kwargs = Parser::ParserGem::NodeMethods.convert_hash(args.node)
+                                               .select { |_, val| val.literal? }
+                                               .transform_values { |val| val.links.last.value }
+        return defaults unless kwargs.is_a?(Hash)
+        defaults.merge(kwargs)
+      end
+
+      # @param call [SourceMap::Call]
+      # @param name [String]
+      # @param class_suffixes [Array<String>]
+      # @param instance_suffixes [Array<String>]
+      def method_pins name, class_suffixes, instance_suffixes, call
+        comments = call.source_map.source.comments_for(call.chain.node)
+        location = Solargraph::Location.new(call.closure.filename, Solargraph::Range.from_node(call.chain.node))
+        class_suffixes.map do |sfx|
+          Pin::Method.new(name: "#{name}#{sfx}", closure: call.closure, scope: :class, attribute: true, location: location, comments: comments).tap do |pin|
+            next unless sfx == '='
+            pin.parameters.push Pin::Parameter.new(name: 'value', closure: pin)
+          end
+        end +
+          instance_suffixes.map do |sfx|
+            Pin::Method.new(name: "#{name}#{sfx}", closure: call.closure, scope: :instance, attribute: true, location: location, comments: comments).tap do |pin|
+              next unless sfx == '='
+              pin.parameters.push Pin::Parameter.new(name: 'value', closure: pin)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/addon.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class Addon
+      attr_reader :gem_names, :pins
+
+      # @param gem_names [Array<String>]
+      # @param pins [Array<Pin::Base>]
+      def initialize gem_names: [], pins: []
+        @gem_names = gem_names
+        @pins = pins
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Solargraph
+  module Plugin
+    class Base
+      extend Forwardable
+
+      attr_reader :panel
+
+      def_delegators :@panel, :pins, :pins_by_class, :pins_by_path, :gem_names, :source_maps
+
+      # @param panel [Panel]
+      def initialize panel
+        @panel = panel
+      end
+
+      # @return [Addon]
+      def addon
+        EMPTY_ADDON
+      end
+    end
+  end
+end

data/lib/solargraph/plugin/panel.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    class Panel
+      attr_reader :source_maps, :live_map, :gem_names
+
+      def initialize source_maps: [], live_map: nil, gem_names: []
+        @source_maps = source_maps
+        @live_map = live_map
+        @gem_names = gem_names
+      end
+
+      def pins
+        @pins ||= source_maps.flat_map(&:pins)
+      end
+
+      def pins_by_class klass
+        pin_class_hash[klass] || []
+      end
+
+      def pins_by_path path
+        pin_path_hash[path] || []
+      end
+
+      private
+
+      def pin_class_hash
+        @pin_class_hash ||= pins.to_set.classify(&:class)
+      end
+
+      def pin_path_hash
+        @pin_path_hash ||= pins.to_set.classify(&:path)
+      end
+    end
+  end
+end

data/lib/solargraph/plugin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Plugin
+    autoload :Addon, 'solargraph/plugin/addon'
+    autoload :Base, 'solargraph/plugin/base'
+    autoload :Panel, 'solargraph/plugin/panel'
+    autoload :ActiveSupport, 'solargraph/plugin/active_support'
+
+    EMPTY_ADDON = Addon.new.freeze
+
+    def self.registry
+      @registry ||= Set.new
+    end
+
+    def self.register klass
+      registry.add klass
+    end
+
+    def self.unregister klass
+      registry.delete klass
+    end
+
+    Plugin.register ActiveSupport
+  end
+end

data/lib/solargraph/rbs_collection.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # The RBS collection declared by a project's rbs_collection.lock.yaml.
+  #
+  class RbsCollection
+    attr_reader :lockfile
+
+    def initialize lockfile
+      @lockfile = File.expand_path(lockfile) if lockfile
+    end
+
+    # @param metagem [Metagem]
+    # @return [Array<Pin::Base>]
+    def load metagem
+      key = best_key(metagem)
+      return [] unless key
+      mem_cache[key] ||= RbsMap::Path.pins(gem_path_map[key])
+    end
+
+    def gem_keys
+      gem_path_map.keys
+    end
+
+    # The names of the stdlib signature sets declared by the collection.
+    #
+    # +rbs collection install+ resolves these to the signatures which ship
+    # with the rbs gem instead of copying them into the collection directory,
+    # so they can never be located by a gem name/version lookup.
+    #
+    # @return [Array<String>]
+    def stdlib_names
+      @stdlib_names ||= raw_data[:gems].select { |gem| gem.dig(:source, :type).to_s == 'stdlib' }
+                                       .map { |gem| gem[:name].to_s }.uniq
+    end
+
+    private
+
+    def gem_path_map
+      @gem_path_map ||= raw_data[:gems].to_h { |gem| ["#{gem[:name]}-#{gem[:version]}", gem_source_path(gem)] }
+    end
+
+    # The versions available in the collection for each gem name.
+    #
+    # @return [Hash{String => Array<String>}]
+    def versions_by_name
+      @versions_by_name ||= raw_data[:gems].group_by { |gem| gem[:name].to_s }
+                                           .transform_values { |gems| gems.map { |gem| gem[:version].to_s } }
+    end
+
+    def best_key metagem
+      key = "#{metagem.name}-#{metagem.version}"
+      return key if gem_path_map.key?(key)
+
+      full_key = "#{metagem.name}-#{metagem.version}."
+      zero_key = "#{metagem.name}-0"
+      found = gem_path_map.find { |key, _| full_key.start_with?("#{key}.") } ||
+              gem_path_map.find { |key, _| key == zero_key }
+      found&.first || closest_key(metagem)
+    end
+
+    # Signature collections version their directories independently from the
+    # gems they describe. gem_rbs_collection, for example, provides
+    # +actionpack/6.0+ for every Rails 6 and 7 release and +devise/4.9+ for
+    # Devise 4 and 5. When no directory matches a gem's version, fall back to
+    # the closest version the collection provides for that gem, preferring the
+    # highest one that does not exceed the gem's version.
+    #
+    # @param metagem [Metagem]
+    # @return [String, nil]
+    def closest_key metagem
+      versions = versions_by_name[metagem.name.to_s]
+      return nil if versions.nil? || versions.empty?
+      return "#{metagem.name}-#{versions.first}" if versions.size == 1
+      parsed = versions.map { |version| [version, parse_version(version)] }
+      usable = parsed.compact
+      gem_version = parse_version(metagem.version)
+      chosen = if gem_version
+                 usable.reject { |_, parsed_version| parsed_version > gem_version }.max_by { |_, parsed_version| parsed_version }
+               end
+      chosen ||= usable.min_by { |_, parsed_version| parsed_version }
+      chosen ||= parsed.first
+      "#{metagem.name}-#{chosen[0]}"
+    end
+
+    # @param value [Object]
+    # @return [Gem::Version, nil]
+    def parse_version value
+      Gem::Version.new value.to_s
+    rescue ArgumentError
+      nil
+    end
+
+    # @param gem_hash [Hash]
+    def gem_source_path gem_hash
+      root_path = gem_hash.dig(:source, :path) || raw_data[:path]
+      return unless root_path
+      gem_path = File.join(root_path, gem_hash[:name], gem_hash[:version])
+      File.expand_path(gem_path, File.dirname(lockfile))
+    end
+
+    def gem_rbs_collection_path
+      @gem_rbs_collection_path ||= File.expand_path(raw_data[:path]) if raw_data[:path]
+    end
+
+    # @return [Hash]
+    def raw_data
+      @raw_data ||= if lockfile && File.file?(lockfile)
+                      YAML.load_file(lockfile, symbolize_names: true)
+                    else
+                      { gems: [] }
+                    end
+    end
+
+    def mem_cache
+      @mem_cache ||= {}
+    end
+  end
+end

data/lib/solargraph/rbs_map/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module RbsMap
+    class Base
+      def pins
+        @pins ||= RbsMap::Conversions.new(loader: loader).pins
+      end
+
+      # @return [RBS::Repository]
+      def repository
+        @repository ||= RBS::Repository.new(no_stdlib: true)
+      end
+
+      # @return [RBS::EnvironmentLoader]
+      def loader
+        @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
+      end
+
+      # @param path [String]
+      # @return [Array<Pin::Base>]
+      def path_pins path
+        pins.select { |p| p.path == path }
+      end
+
+      def self.pins(...)
+        new(...).pins
+      end
+    end
+  end
+end