solargraph 0.54.0 → 0.55.0

data/lib/solargraph/source_map/clip.rb

@@ -2,8 +2,8 @@
 
 module Solargraph
   class SourceMap
-    # A static analysis tool for obtaining definitions, completions,
-    # signatures, and type inferences from a cursor.
+    # A static analysis tool for obtaining definitions, Completions,
+    # signatures, and type inferences from a Cursor.
     #
     class Clip
       # @param api_map [ApiMap]
@@ -11,7 +11,9 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block.rebind(api_map) if block.is_a?(Pin::Block)
+        block_pin = block
+        block_pin.rebind(api_map) if block_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(block_pin.receiver).contain?(cursor.range.start)
+        @in_block = nil
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
@@ -40,7 +42,7 @@ module Solargraph
         end
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)
@@ -53,10 +55,10 @@ module Solargraph
         if result.tag == 'Class'
           # HACK: Exception to return BasicObject from Class#new
           dfn = cursor.chain.define(api_map, block, locals).first
-          return ComplexType.try_parse('BasicObject') if dfn && dfn.path == 'Class#new'
+          return ComplexType.try_parse('::BasicObject') if dfn && dfn.path == 'Class#new'
         end
         return result unless result.tag == 'self'
-        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).tag)
+        cursor.chain.base.infer(api_map, block, locals)
       end
 
       # Get an array of all the locals that are visible from the cursors's

data/lib/solargraph/source_map/data.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    class Data
+      def initialize source
+        @source = source
+      end
+
+      def pins
+        generate
+        @pins || []
+      end
+
+      def locals
+        generate
+        @locals || []
+      end
+
+      private
+
+      def generate
+        return if @generated
+
+        @generated = true
+        @pins, @locals = Mapper.map(@source)
+      end
+    end
+  end
+end

data/lib/solargraph/source_map.rb

@@ -4,40 +4,41 @@ require 'yard'
 require 'solargraph/yard_tags'
 
 module Solargraph
-  # An index of pins and other ApiMap-related data for a Source.
+  # An index of Pins and other ApiMap-related data for a single Source
+  # that can be queried.
   #
   class SourceMap
     autoload :Mapper,        'solargraph/source_map/mapper'
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Data,          'solargraph/source_map/data'
 
     # @return [Source]
     attr_reader :source
 
     # @return [Array<Pin::Base>]
-    attr_reader :pins
+    def pins
+      data.pins
+    end
 
     # @return [Array<Pin::LocalVariable>]
-    attr_reader :locals
+    def locals
+      data.locals
+    end
 
     # @param source [Source]
-    # @param pins [Array<Pin::Base>]
-    # @param locals [Array<Pin::Base>]
-    def initialize source, pins, locals
-      # HACK: Keep the library from changing this
-      @source = source.dup
-      @pins = pins
-      @locals = locals
+    def initialize source
+      @source = source
+
       environ.merge Convention.for_local(self) unless filename.nil?
       self.convention_pins = environ.pins
-      @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
       @pin_select_cache = {}
     end
 
     # @param klass [Class]
     # @return [Array<Pin::Base>]
     def pins_by_class klass
-      @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
+      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
     end
 
     # A hash representing the state of the source map's API.
@@ -47,7 +48,7 @@ module Solargraph
     #
     # @return [Integer]
     def api_hash
-      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node)).hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node) + locals).hash
     end
 
     # @return [String]
@@ -117,10 +118,13 @@ module Solargraph
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
 
+    # @todo Candidate for deprecation
+    #
     # @param other_map [SourceMap]
     # @return [Boolean]
     def try_merge! other_map
       return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
+
       pins.each_index do |i|
         return false unless pins[i].try_merge!(other_map.pins[i])
       end
@@ -161,16 +165,24 @@ module Solargraph
         SourceMap.map(source)
       end
 
+      # @deprecated
       # @param source [Source]
       # @return [SourceMap]
       def map source
-        result = SourceMap::Mapper.map(source)
-        new(source, *result)
+        new(source)
       end
     end
 
     private
 
+    def pin_class_hash
+      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
+    end
+
+    def data
+      @data ||= Data.new(source)
+    end
+
     # @return [Array<Pin::Base>]
     def convention_pins
       @convention_pins || []
@@ -179,7 +191,7 @@ module Solargraph
     # @param pins [Array<Pin::Base>]
     # @return [Array<Pin::Base>]
     def convention_pins=(pins)
-      # unmemoizing the document_symbols in case it was called from any of convnetions
+      # unmemoizing the document_symbols in case it was called from any of conventions
       @document_symbols = nil
       @convention_pins = pins
     end

data/lib/solargraph/type_checker/checks.rb

@@ -50,6 +50,8 @@ module Solargraph
       # @param inferred [ComplexType]
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         # walk through the union expected type and see if any members
         # of the union match the inferred type
@@ -71,6 +73,8 @@ module Solargraph
       # @param expected [ComplexType]
       # @return [Boolean]
       def all_types_match? api_map, inferred, expected
+        expected = expected.downcast_to_literal_if_possible
+        inferred = inferred.downcast_to_literal_if_possible
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
         inferred.each do |inf|
           next if inf.duck_type?

data/lib/solargraph/type_checker/rules.rb

@@ -9,7 +9,8 @@ module Solargraph
         normal: 0,
         typed: 1,
         strict: 2,
-        strong: 3
+        strong: 3,
+        alpha: 4
       }.freeze
 
       # @return [Symbol]
@@ -52,6 +53,10 @@ module Solargraph
       def validate_tags?
         rank > LEVELS[:normal]
       end
+
+      def require_all_return_types_match_inferred?
+        rank >= LEVELS[:alpha]
+      end
     end
   end
 end

data/lib/solargraph/type_checker.rb

@@ -29,6 +29,7 @@ module Solargraph
       # @todo Smarter directory resolution
       @api_map = api_map || Solargraph::ApiMap.load(File.dirname(filename))
       @rules = Rules.new(level)
+      # @type [Array<Range>]
       @marked_ranges = []
     end
 
@@ -90,11 +91,11 @@ module Solargraph
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
       result = []
-      declared = pin.typify(api_map).self_to(pin.full_context.namespace)
+      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, pin.full_context.tag)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
           if pin.attribute?
-            inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+            inferred = pin.probe(api_map).self_to_type(pin.full_context)
             result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin) unless inferred.defined?
           else
             result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
@@ -106,14 +107,14 @@ module Solargraph
         end
       elsif rules.validate_tags?
         unless pin.node.nil? || declared.void? || virtual_pin?(pin) || abstract?(pin)
-          inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+          inferred = pin.probe(api_map).self_to_type(pin.full_context)
           if inferred.undefined?
             unless rules.ignore_all_undefined? || external?(pin)
               result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
             end
           else
-            unless (rules.rank > 1 ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
-              result.push Problem.new(pin.location, "Declared return type #{declared} does not match inferred type #{inferred} for #{pin.path}", pin: pin)
+            unless (rules.require_all_return_types_match_inferred? ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
+              result.push Problem.new(pin.location, "Declared return type #{declared.rooted_tags} does not match inferred type #{inferred.rooted_tags} for #{pin.path}", pin: pin)
             end
           end
         end
@@ -154,7 +155,7 @@ module Solargraph
             break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
             unless params[par.name]
               if pin.attribute?
-                inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+                inferred = pin.probe(api_map).self_to_type(pin.full_context)
                 if inferred.undefined?
                   result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
                 end
@@ -377,7 +378,7 @@ module Solargraph
                     break
                   end
                   ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                  ptype = ptype.self_to(par.context.namespace)
+                  ptype = ptype.self_to_type(par.context)
                   if ptype.nil?
                     # @todo Some level (strong, I guess) should require the param here
                   else
@@ -413,7 +414,7 @@ module Solargraph
     # @param locals [Array<Pin::LocalVariable>]
     # @param location [Location]
     # @param pin [Pin::Method]
-    # @param params [Hash{String => [nil, Hash]}]
+    # @param params [Hash{String => Hash{Symbol => String, Solargraph::ComplexType}}]
     # @param idx [Integer]
     #
     # @return [Array<Problem>]
@@ -467,13 +468,24 @@ module Solargraph
     end
 
     # @param pin [Pin::Method]
-    # @return [Hash{String => Hash{Symbol => BaseObject}}]
+    # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def param_hash(pin)
-      tags = pin.docstring.tags(:param)
-      return {} if tags.empty?
+      # @type [Hash{String => Hash{Symbol => String, ComplexType}}]
       result = {}
+      pin.parameters.each do |param|
+        type = param.typify(api_map)
+        next if type.nil? || type.undefined?
+        result[param.name.to_s] = {
+          tagged: type.tags,
+          qualified: type
+        }
+      end
+      # see if we have additional tags to pay attention to from YARD -
+      # e.g., kwargs in a **restkwargs splat
+      tags = pin.docstring.tags(:param)
       tags.each do |tag|
-        next if tag.types.nil? || tag.types.empty?
+        next if result.key? tag.name.to_s
+        next if tag.types.nil?
         result[tag.name.to_s] = {
           tagged: tag.types.join(', '),
           qualified: Solargraph::ComplexType.try_parse(*tag.types).qualify(api_map, pin.full_context.namespace)
@@ -483,15 +495,29 @@ module Solargraph
     end
 
     # @param pins [Array<Pin::Method>]
-    # @return [Hash{String => Hash{Symbol => BasicObject}}]
+    # @return [Hash{String => Hash{Symbol => String, ComplexType}}]
     def first_param_hash(pins)
-      pins.each do |pin|
+      return {} if pins.empty?
+      first_pin_type = pins.first.typify(api_map)
+      first_pin = pins.first.proxy first_pin_type
+      param_names = first_pin.parameter_names
+      results = param_hash(first_pin)
+      pins[1..].each do |pin|
         # @todo this assignment from parametric use of Hash should not lose its generic
         # @type [Hash{String => Hash{Symbol => BasicObject}}]
-        result = param_hash(pin)
-        return result unless result.empty?
+
+        # documentation of types in superclasses should fail back to
+        # subclasses if the subclass hasn't documented something
+        superclass_results = param_hash(pin)
+        superclass_results.each do |param_name, details|
+          next unless param_names.include?(param_name)
+
+          results[param_name] ||= {}
+          results[param_name][:tagged] ||= details[:tagged]
+          results[param_name][:qualified] ||= details[:qualified]
+        end
       end
-      {}
+      results
     end
 
     # @param pin [Pin::Base]
@@ -512,7 +538,7 @@ module Solargraph
       !internal? pin
     end
 
-    # @param pin [Pin::Base]
+    # @param pin [Pin::BaseVariable]
     def declared_externally? pin
       return true if pin.assignment.nil?
       chain = Solargraph::Parser.chain(pin.assignment, filename)
@@ -562,7 +588,7 @@ module Solargraph
       return [] unless pin.explicit?
       return [] if parameters.empty? && arguments.empty?
       return [] if pin.anon_splat?
-      unchecked = arguments.clone
+      unchecked = arguments.dup # creates copy of and unthaws array
       add_params = 0
       if unchecked.empty? && parameters.any? { |param| param.decl == :kwarg }
         return [Problem.new(location, "Missing keyword arguments to #{pin.path}")]
@@ -584,7 +610,8 @@ module Solargraph
                   kwargs.delete param.name.to_sym
                   settled_kwargs += 1
                 elsif param.decl == :kwarg
-                  return [] if arguments.last.links.last.is_a?(Solargraph::Source::Chain::Hash) && arguments.last.links.last.splatted?
+                  last_arg_last_link = arguments.last.links.last
+                  return [] if last_arg_last_link.is_a?(Solargraph::Source::Chain::Hash) && last_arg_last_link.splatted?
                   return [Problem.new(location, "Missing keyword argument #{param.name} to #{pin.path}")]
                 end
               end
@@ -638,7 +665,7 @@ module Solargraph
         (pin.closure && pin.closure.docstring.has_tag?('abstract'))
     end
 
-    # @param pin [Pin::Base]
+    # @param pin [Pin::Method]
     # @return [Array<Source::Chain>]
     def fake_args_for(pin)
       args = []

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.54.0'
+  VERSION = '0.55.0'
 end

data/lib/solargraph/views/environment.erb

@@ -35,11 +35,9 @@
     <li>
       Core Cache Directory: N/A <%# @todo Fix %>
     </li>
-    <% unless Solargraph::Parser.rubyvm? %>
-      <li>
-        Parser Target Version: <%= Solargraph::Parser.version %>
-      </li>
-    <% end %>
+    <li>
+      Parser Target Version: <%= Solargraph::Parser.version %>
+    </li>
     <li>
       Using Bundler: <%= ENV.key?('BUNDLE_BIN_PATH') %>
     </li>

data/lib/solargraph/workspace/config.rb

@@ -15,7 +15,7 @@ module Solargraph
       attr_reader :directory
 
       # @todo To make this strongly typed we'll need a record syntax
-      # @return [Hash{String => undefined}]
+      # @return [Hash{String => Array, Hash, Integer, nil}]
       attr_reader :raw_data
 
       # @param directory [String]
@@ -90,6 +90,7 @@ module Solargraph
 
       # A hash of options supported by the formatter
       #
+      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Hash]
       def formatter
         raw_data['formatter']
@@ -104,6 +105,7 @@ module Solargraph
 
       # The maximum number of files to parse from the workspace.
       #
+      # @sg-ignore pending https://github.com/castwide/solargraph/pull/905
       # @return [Integer]
       def max_files
         raw_data['max_files']
@@ -123,7 +125,7 @@ module Solargraph
         File.join(@directory, '.solargraph.yml')
       end
 
-      # @return [Hash{String => Array, Hash, Integer}]
+      # @return [Hash{String => Array<undefined>, Hash{String => undefined}, Integer}]
       def config_data
         workspace_config = read_config(workspace_config_path)
         global_config = read_config(global_config_path)
@@ -226,7 +228,9 @@ module Solargraph
 
       # @return [Array<String>]
       def excluded_directories
-        @raw_data['exclude']
+        # @type [Array<String>]
+        excluded = @raw_data['exclude']
+        excluded
           .select { |g| glob_is_directory?(g) }
           .map { |g| File.absolute_path(glob_to_directory(g), directory) }
       end

data/lib/solargraph/workspace.rb

@@ -45,7 +45,7 @@ module Solargraph
     # or add it to the sources if the workspace is configured to include it.
     # The source is ignored if the configuration excludes it.
     #
-    # @param source [Solargraph::Source]
+    # @param sources [Array<Solargraph::Source>]
     # @return [Boolean] True if the source was added to the workspace
     def merge *sources
       unless directory == '*' || sources.all? { |source| source_hash.key?(source.filename) }

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -6,6 +6,7 @@ module Solargraph
       module ToConstant
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::Base]
         def self.make code_object, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -16,29 +16,55 @@ module Solargraph
         def self.make code_object, name = nil, scope = nil, visibility = nil, closure = nil, spec = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,
-            gates: [code_object.namespace.to_s]
+            gates: [code_object.namespace.to_s],
+            type: code_object.namespace.is_a?(YARD::CodeObjects::ClassObject) ? :class : :module,
+            source: :yardoc,
           )
           location = object_location(code_object, spec)
           name ||= code_object.name.to_s
           return_type = ComplexType::SELF if name == 'new'
           comments = code_object.docstring ? code_object.docstring.all.to_s : ''
-          pin = Pin::Method.new(
-            location: location,
-            closure: closure,
-            name: name,
-            comments: comments,
-            scope: scope || code_object.scope,
-            visibility: visibility || code_object.visibility,
-            # @todo Might need to convert overloads to signatures
-            parameters: [],
-            explicit: code_object.is_explicit?,
-            return_type: return_type
-          )
-          pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          final_scope = scope || code_object.scope
+          final_visibility = visibility || code_object.visibility
+          if code_object.is_alias?
+            origin_code_object = code_object.namespace.aliases[code_object]
+            pin = Pin::MethodAlias.new(
+              name: name,
+              location: location,
+              original: origin_code_object.name.to_s,
+              closure: closure,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              parameters: [],
+              source: :yardoc,
+            )
+          else
+            pin = Pin::Method.new(
+              location: location,
+              closure: closure,
+              name: name,
+              comments: comments,
+              scope: final_scope,
+              visibility: final_visibility,
+              # @todo Might need to convert overloads to signatures
+              explicit: code_object.is_explicit?,
+              return_type: return_type,
+              attribute: code_object.is_attribute?,
+              parameters: [],
+              source: :yardoc,
+            )
+            pin.parameters.concat get_parameters(code_object, location, comments, pin)
+          end
+          logger.debug { "ToMethod.make: Just created method pin: #{pin.inspect}" }
           pin
         end
 
         class << self
+          include Logging
+
           private
 
           # @param code_object [YARD::CodeObjects::Base]
@@ -59,7 +85,8 @@ module Solargraph
                 name: arg_name(a),
                 presence: nil,
                 decl: arg_type(a),
-                asgn_code: a[1]
+                asgn_code: a[1],
+                source: :yardoc,
               )
             end
           end

data/lib/solargraph/yard_map/mapper/to_namespace.rb

@@ -6,6 +6,7 @@ module Solargraph
       module ToNamespace
         extend YardMap::Helpers
 
+        # @param code_object [YARD::CodeObjects::NamespaceObject]
         def self.make code_object, spec, closure = nil
           closure ||= Solargraph::Pin::Namespace.new(
             name: code_object.namespace.to_s,

data/lib/solargraph/yard_map/mapper.rb

@@ -12,6 +12,7 @@ module Solargraph
       def initialize code_objects, spec = nil
         @code_objects = code_objects
         @spec = spec
+        # @type [Array<Solargraph::Pin::Base>]
         @pins = []
         @namespace_pins = {}
       end

data/lib/solargraph/yardoc.rb

@@ -35,7 +35,7 @@ module Solargraph
     # @param gemspec [Gem::Specification]
     # @return [String]
     def path_for(gemspec)
-      File.join(Solargraph::Cache.work_dir, 'gems', "#{gemspec.name}-#{gemspec.version}.yardoc")
+      File.join(Solargraph::Cache.base_dir, "yard-#{YARD::VERSION}", "#{gemspec.name}-#{gemspec.version}.yardoc")
     end
 
     # Load a gem's yardoc and return its code objects.

data/lib/solargraph.rb

@@ -42,6 +42,7 @@ module Solargraph
   autoload :Logging,          'solargraph/logging'
   autoload :TypeChecker,      'solargraph/type_checker'
   autoload :Environ,          'solargraph/environ'
+  autoload :Equality,         'solargraph/equality'
   autoload :Convention,       'solargraph/convention'
   autoload :Parser,           'solargraph/parser'
   autoload :RbsMap,           'solargraph/rbs_map'

data/solargraph.gemspec

@@ -24,10 +24,10 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 3.0'
 
   s.add_runtime_dependency 'backport', '~> 1.2'
-  s.add_runtime_dependency 'benchmark'
+  s.add_runtime_dependency 'benchmark', '~> 0.4'
   s.add_runtime_dependency 'bundler', '~> 2.0'
   s.add_runtime_dependency 'diff-lcs', '~> 1.4'
-  s.add_runtime_dependency 'jaro_winkler', '~> 1.6'
+  s.add_runtime_dependency 'jaro_winkler', '~> 1.6', '>= 1.6.1'
   s.add_runtime_dependency 'kramdown', '~> 2.3'
   s.add_runtime_dependency 'kramdown-parser-gfm', '~> 1.1'
   s.add_runtime_dependency 'logger', '~> 1.6'
@@ -35,19 +35,19 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'ostruct', '~> 0.6'
   s.add_runtime_dependency 'parser', '~> 3.0'
   s.add_runtime_dependency 'rbs', '~> 3.3'
-  s.add_runtime_dependency 'reverse_markdown', '>= 2.0', '< 4'
+  s.add_runtime_dependency 'reverse_markdown', '~> 3.0'
   s.add_runtime_dependency 'rubocop', '~> 1.38'
   s.add_runtime_dependency 'thor', '~> 1.0'
   s.add_runtime_dependency 'tilt', '~> 2.0'
   s.add_runtime_dependency 'yard', '~> 0.9', '>= 0.9.24'
   s.add_runtime_dependency 'yard-solargraph', '~> 0.1'
 
-  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry', '~> 0.15'
   s.add_development_dependency 'public_suffix', '~> 3.1'
   s.add_development_dependency 'rake', '~> 13.2'
   s.add_development_dependency 'rspec', '~> 3.5'
   s.add_development_dependency 'simplecov', '~> 0.14'
   s.add_development_dependency 'webmock', '~> 3.6'
   # work around missing yard dependency needed as of Ruby 3.5
-  s.add_development_dependency 'irb'
+  s.add_development_dependency 'irb', '~> 1.15'
 end