steep 1.5.0.pre.5 → 1.5.0

data/lib/steep/services/signature_help_provider.rb

@@ -3,7 +3,21 @@ module Steep
     class SignatureHelpProvider
       MethodCall = TypeInference::MethodCall
 
-      Item = _ = Struct.new(:method_type, :comment)
+      Item = _ = Struct.new(:method_type, :comment, :active_parameter) do
+        # @implements Item
+
+        def parameters
+          arguments = [] #: Array[String]
+          arguments.push(*method_type.type.required_positionals.map(&:to_s))
+          arguments.push(*method_type.type.optional_positionals.map {|p| "?#{p}"})
+          arguments.push("*#{self.method_type.type.rest_positionals}") if method_type.type.rest_positionals
+          arguments.push(*method_type.type.trailing_positionals.map(&:to_s))
+          arguments.push(*method_type.type.required_keywords.map {|name, param| "#{name}: #{param}" })
+          arguments.push(*method_type.type.optional_keywords.map {|name, param| "?#{name}: #{param}" })
+          arguments.push("**#{method_type.type.rest_keywords}") if method_type.type.rest_keywords
+          arguments
+        end
+      end
 
       attr_reader :source, :path, :subtyping, :typing, :buffer
 
@@ -23,12 +37,14 @@ module Steep
         return unless nodes
 
         typing = type_check!(line: line, column: column)
+        argument_nodes = [] #: Array[Parser::AST::Node]
 
         while true
           node = nodes.shift()
           parent = nodes.first
 
           node or return
+          argument_nodes << node
 
           if node.type == :send || node.type == :csend
             pos = buffer.loc_to_pos([line, column])
@@ -40,12 +56,13 @@ module Steep
                 # Given position is between open/close parens of args of send node
 
                 if parent && (parent.type == :block || parent.type == :numblock)
-                  send_node = parent.children[0]
+                  send_node = parent
                 else
                   send_node = node
                 end
 
-                return signature_help_for(send_node, typing)
+                last_argument_nodes = last_argument_nodes_for(argument_nodes: argument_nodes, line: line, column: column)
+                return signature_help_for(send_node, argument_nodes, last_argument_nodes, typing)
               end
             end
           end
@@ -58,7 +75,24 @@ module Steep
         TypeCheckService.type_check(source: source, subtyping: subtyping, constant_resolver: resolver)
       end
 
-      def signature_help_for(node, typing)
+      def last_argument_nodes_for(argument_nodes:, line:, column:)
+        return unless argument_nodes.last.children[2]  # No arguments
+        return argument_nodes if argument_nodes.size > 1  # Cursor is on the last argument
+
+        pos = buffer.loc_to_pos([line, column])
+
+        while true
+          pos -= 1
+          line, column = buffer.pos_to_loc(pos)
+          nodes = source.find_nodes(line: line, column: column)
+          return unless nodes
+
+          index = nodes.index { |n| n.type == :send || n.type == :csend }
+          return nodes[..index] if index.to_i > 0
+        end
+      end
+
+      def signature_help_for(node, argument, last_argument, typing)
         call = typing.call_of(node: node)
         context = typing.context_at(line: node.loc.expression.line, column: node.loc.expression.column)
 
@@ -82,7 +116,8 @@ module Steep
               method.method_types.each.with_index do |method_type, i|
                 defn = method_type.method_decls.to_a[0]&.method_def
 
-                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment)
+                active_parameter = active_parameter_for(defn&.type, argument, last_argument, node)
+                items << Item.new(subtyping.factory.method_type_1(method_type), defn&.comment, active_parameter)
 
                 if call.is_a?(MethodCall::Typed)
                   if method_type.method_decls.intersect?(call.method_decls)
@@ -98,6 +133,66 @@ module Steep
 
         [items, index]
       end
+
+      def active_parameter_for(method_type, argument_nodes, last_argument_nodes, node)
+        return unless method_type
+
+        positionals = method_type.type.required_positionals.size + method_type.type.optional_positionals.size + (method_type.type.rest_positionals ? 1 : 0) + method_type.type.trailing_positionals.size
+
+        if argument_nodes.size == 1
+          # Cursor is not on the argument (maybe on comma after argument)
+          return 0 if last_argument_nodes.nil?  # No arguments
+
+          case last_argument_nodes[-2].type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size + 1 if method_type.type.rest_positionals
+          when :kwargs
+            case last_argument_nodes[-3].type
+            when :pair
+              argname = last_argument_nodes[-3].children.first.children.first
+              if method_type.type.required_keywords[argname]
+                positionals + method_type.type.required_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.optional_keywords[argname]
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i + 1
+              elsif method_type.type.rest_keywords
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+              end
+            when :kwsplat
+              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+            end
+          else
+            pos = node.children[2...].index { |c| c.location == last_argument_nodes[-2].location }.to_i
+            if method_type.type.rest_positionals
+              [pos + 1, positionals - 1].min
+            else
+              [pos + 1, positionals].min
+            end
+          end
+        else
+          # Cursor is on the argument
+          case argument_nodes[-2].type
+          when :splat
+            method_type.type.required_positionals.size + method_type.type.optional_positionals.size if method_type.type.rest_positionals
+          when :kwargs
+            case argument_nodes[-3].type
+            when :pair
+              argname = argument_nodes[-3].children.first.children.first
+              if method_type.type.required_keywords[argname]
+                positionals + method_type.type.required_keywords.keys.index(argname).to_i
+              elsif method_type.type.optional_keywords[argname]
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.keys.index(argname).to_i
+              elsif method_type.type.rest_keywords
+                positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size
+              end
+            when :kwsplat
+              positionals + method_type.type.required_keywords.size + method_type.type.optional_keywords.size if method_type.type.rest_keywords
+            end
+          else
+            pos = node.children[2...].index { |c| c.location == argument_nodes[-2].location }.to_i
+            [pos, positionals - 1].min
+          end
+        end
+      end
     end
   end
 end

data/lib/steep/source.rb

@@ -330,13 +330,12 @@ module Steep
     def find_heredoc_nodes(line, column, position)
       each_heredoc_node() do |nodes, location|
         node = nodes[0]
+        loc = location.heredoc_body #: Parser::Source::Range
 
-        range = location.heredoc_body&.yield_self do |r|
-          r.begin_pos..r.end_pos
-        end
-
-        if range && (range === position)
-          return nodes
+        if range = loc.to_range
+          if range.begin <= position && position <= range.end
+            return nodes
+          end
         end
       end
 
@@ -344,12 +343,10 @@ module Steep
     end
 
     def find_nodes_loc(node, position, parents)
-      range = node.location.expression&.yield_self do |r|
-        r.begin_pos..r.end_pos
-      end
+      range = node.location.expression&.to_range
 
       if range
-        if range === position
+        if range.begin <= position && position <= range.end
           parents.unshift node
 
           Source.each_child_node(node) do |child|
@@ -366,9 +363,7 @@ module Steep
     def find_nodes(line:, column:)
       return [] unless node
 
-      position = (line-1).times.sum do |i|
-        node.location.expression.source_buffer.source_line(i+1).size + 1
-      end + column
+      position = buffer.loc_to_pos([line, column])
 
       if heredoc_nodes = find_heredoc_nodes(line, column, position)
         Source.each_child_node(heredoc_nodes[0]) do |child|

data/lib/steep/type_construction.rb

@@ -1950,10 +1950,6 @@ module Steep
               branch_results = [] #: Array[Pair]
 
               cond_type, constr = constr.synthesize(cond)
-              _, cond_vars = interpreter.decompose_value(cond)
-              SPECIAL_LVAR_NAMES.each do |name|
-                cond_vars.delete(name)
-              end
 
               var_name = :"_a[#{SecureRandom.alphanumeric(4)}]"
               var_cond, value_node = transform_condition_node(cond, var_name)
@@ -2621,7 +2617,26 @@ module Steep
             # @type var as_type: AST::Node::TypeAssertion
             asserted_node, as_type = node.children
 
-            if type = as_type.type?(module_context.nesting, checker, [])
+            type = as_type.type(module_context.nesting, checker, [])
+
+            case type
+            when Array
+              type.each do |error|
+                typing.add_error(
+                  Diagnostic::Ruby::RBSError.new(
+                    error: error,
+                    node: node,
+                    location: error.location || raise
+                  )
+                )
+              end
+
+              synthesize(asserted_node, hint: hint)
+
+            when nil, RBS::ParsingError
+              synthesize(asserted_node, hint: hint)
+
+            else
               actual_type, constr = synthesize(asserted_node, hint: type)
 
               if no_subtyping?(sub_type: type, super_type: actual_type) && no_subtyping?(sub_type: actual_type, super_type: type)
@@ -2635,22 +2650,34 @@ module Steep
               end
 
               constr.add_typing(node, type: type)
-            else
-              synthesize(asserted_node, hint: hint)
             end
           end
 
-        when :block, :numblock, :send, :csend
-          synthesize_sendish(node, hint: hint, tapp: nil)
-
         when :tapp
           yield_self do
+            # @type var tapp: AST::Node::TypeApplication
             sendish, tapp = node.children
+
+            if (array = tapp.types(module_context.nesting, checker, [])).is_a?(Enumerator)
+              array.each do |error|
+                typing.add_error(
+                  Diagnostic::Ruby::RBSError.new(
+                    error: error,
+                    node: node,
+                    location: error.location || raise
+                  )
+                )
+              end
+            end
+
             type, constr = synthesize_sendish(sendish, hint: hint, tapp: tapp)
 
             constr.add_typing(node, type: type)
           end
 
+        when :block, :numblock, :send, :csend
+          synthesize_sendish(node, hint: hint, tapp: nil)
+
         when :forwarded_args, :forward_arg
           add_typing(node, type: AST::Builtin.any_type)
 
@@ -3076,26 +3103,29 @@ module Steep
 
         type_hint = deep_expand_alias(type_hint) || type_hint
 
-        procs = flatten_union(type_hint).select do |type|
-          check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success?
-        end
+        unless type_hint.is_a?(AST::Types::Any)
+          procs = flatten_union(type_hint).select do |type|
+            check_relation(sub_type: type, super_type: AST::Builtin::Proc.instance_type).success? &&
+              !type.is_a?(AST::Types::Any)
+          end
 
-        proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }
+          proc_instances, proc_types = procs.partition {|type| AST::Builtin::Proc.instance_type?(type) }
 
-        case
-        when !proc_instances.empty? && proc_types.empty?
-          # `::Proc` is given as a hint
-        when proc_types.size == 1
-          # Proc type is given as a hint
-          hint_proc = proc_types[0]  #: AST::Types::Proc
-          params_hint = hint_proc.type.params
-          return_hint = hint_proc.type.return_type
-          block_hint = hint_proc.block
-          self_hint = hint_proc.self_type
-        else
-          typing.add_error(
-            Diagnostic::Ruby::ProcHintIgnored.new(hint_type: original_hint, node: node)
-          )
+          case
+          when !proc_instances.empty? && proc_types.empty?
+            # `::Proc` is given as a hint
+          when proc_types.size == 1
+            # Proc type is given as a hint
+            hint_proc = proc_types[0]  #: AST::Types::Proc
+            params_hint = hint_proc.type.params
+            return_hint = hint_proc.type.return_type
+            block_hint = hint_proc.block
+            self_hint = hint_proc.self_type
+          else
+            typing.add_error(
+              Diagnostic::Ruby::ProcHintIgnored.new(hint_type: original_hint, node: node)
+            )
+          end
         end
       end
 

data/lib/steep/type_inference/logic_type_interpreter.rb

@@ -280,20 +280,22 @@ module Steep
         when AST::Types::Logic::ReceiverIsNil
           if receiver && arguments.size.zero?
             receiver_type = typing.type_of(node: receiver)
-            truthy_receiver, falsy_receiver = factory.partition_union(receiver_type)
+            unwrap = factory.unwrap_optional(receiver_type)
+            truthy_receiver = AST::Builtin.nil_type
+            falsy_receiver = unwrap || receiver_type
 
             truthy_env, falsy_env = refine_node_type(
               env: env,
               node: receiver,
-              truthy_type: falsy_receiver || BOT,
-              falsy_type: truthy_receiver || BOT
+              truthy_type: truthy_receiver,
+              falsy_type: falsy_receiver
             )
 
             truthy_result = Result.new(type: TRUE, env: truthy_env, unreachable: false)
-            truthy_result.unreachable! unless truthy_receiver
+            truthy_result.unreachable! if unwrap == receiver_type
 
             falsy_result = Result.new(type: FALSE, env: falsy_env, unreachable: false)
-            falsy_result.unreachable! unless falsy_receiver
+            falsy_result.unreachable! unless unwrap
 
             [truthy_result, falsy_result]
           end
@@ -500,7 +502,7 @@ module Steep
             type_case_select0(ty, klass)
           end
 
-        when AST::Types::Any, AST::Types::Top
+        when AST::Types::Any, AST::Types::Top, AST::Types::Var
           [
             [instance_type],
             [type]

data/lib/steep/type_inference/send_args.rb

@@ -681,7 +681,15 @@ module Steep
             when KeywordArgs::MissingKeyword
               missing_keywords.push(*error.keywords.to_a)
             when PositionalArgs::UnexpectedArg
-              diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
+              if error.node.type == :kwargs
+                error.node.children.each do |kwarg|
+                  if kwarg.type == :pair
+                    diagnostics << Diagnostic::Ruby::UnexpectedKeywordArgument.new(node: kwarg, params: params)
+                  end
+                end
+              else
+                diagnostics << Diagnostic::Ruby::UnexpectedPositionalArgument.new(node: error.node, params: params)
+              end
             when PositionalArgs::MissingArg
               diagnostics << Diagnostic::Ruby::InsufficientPositionalArguments.new(node: node, params: params)
             end

data/lib/steep/version.rb

@@ -1,3 +1,3 @@
 module Steep
-  VERSION = "1.5.0.pre.5"
+  VERSION = "1.5.0"
 end

data/sig/steep/ast/node/type_application.rbs

@@ -12,7 +12,7 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | nil)
+        def types: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Array[Types::t] | RBS::ParsingError | Enumerator[Diagnostic::Signature::Base, void] | nil)
 
         def types?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Array[Types::t]?
 

data/sig/steep/ast/node/type_assertion.rbs

@@ -10,7 +10,7 @@ module Steep
 
         def initialize: (RBS::Location[untyped, untyped]) -> void
 
-        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | nil)
+        def type: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> (Types::t | RBS::ParsingError | Array[Diagnostic::Signature::Base] | nil)
 
         def type?: (RBS::Resolver::context, Subtyping::Check, Array[Symbol] type_vars) -> Types::t?
 

data/sig/steep/ast/types/factory.rbs

@@ -77,13 +77,12 @@ module Steep
         # Returns a type that doesn't have `nil` in the union component
         #
         # * Returns `nil` if given type is `nil`
-        # * **Doesn't expand type alias automatically**
+        # * Expand (unfold) the type aliases automatically
         #
         # ```ruby
         # unwrap_optional(`String?`)                               # => `String`
         # unwrap_optional(`String | Integer | false | nil`)        # => `String | Integer | false`
         # unwrap_optional(`nil`)                                   # => nil
-        # unwrap_optional(`boolish`)                               # => `boolish`
         # ```
         #
         def unwrap_optional: (Types::t) -> Types::t?

data/sig/steep/diagnostic/ruby.rbs

@@ -495,7 +495,7 @@ module Steep
       # ```
       #
       # This diagnostic allows writing `raise` or `return`, by checking the type of the branch body is `bot` or not.
-      # 
+      #
       class UnreachableValueBranch < Base
         attr_reader type: AST::Types::t
 
@@ -622,6 +622,14 @@ module Steep
         def initialize: (hint_type: AST::Types::t, node: Parser::AST::Node) -> void
       end
 
+      # RBS embedded in the Ruby code has validation error
+      #
+      class RBSError < Base
+        attr_reader error: Signature::Base
+
+        def initialize: (error: Signature::Base, node: Parser::AST::Node, location: location) -> void
+      end
+
       # Argument forwarding `...` cannot be done safely, because of
       #
       # 1. The arguments are incompatible, or
@@ -654,21 +662,35 @@ module Steep
 
       ALL: Array[singleton(Base)]
 
-      type template = Hash[singleton(Base), LSPFormatter::severity]
+      type template = Hash[singleton(Base), LSPFormatter::severity?]
 
       self.@all_error: template?
+      self.@default: template?
+      self.@strict: template?
+      self.@lenient: template?
+      self.@silent: template?
+
+      # This template reports everything as an error
+      #
       def self.all_error: () -> template
 
-      self.@default: template?
+      # This template detects inconsistencies between RBS and Ruby code APIs
+      #
       def self.default: () -> template
 
-      self.@strict: template?
+      # This template helps you keeping your codebase (almost) type-safe
+      #
+      # You can start with this template to review the problems reported on the project,
+      # and you can ignore some kind of errors.
+      #
       def self.strict: () -> template
 
-      self.@lenient: template?
+      # This template detects inconsistent definition in Ruby code with respect to your RBS definition
+      #
       def self.lenient: () -> template
 
-      self.@silent: template?
+      # This template reports nothing
+      #
       def self.silent: () -> template
     end
   end

data/sig/steep/node_helper.rbs

@@ -65,5 +65,14 @@ module Steep
     def deconstruct_send_node!: (Node) -> [Node?, Symbol, Array[Node], send_loc]
 
     def test_send_node: (Node) { (Node?, Symbol, Array[Node], send_loc) -> bool } -> bool
+
+    # Deconstruct sendish node and it's associated block node
+    #
+    # Receives a sequence of node tree where the leaf node comes first.
+    # If the first node is `send`, `csend`, `super`, or `zsuper`, it is the sendish node.
+    #
+    # If the next node is a `block` or `numblock` that is associated to the *sendish node*, it is the block node.
+    #
+    def deconstruct_sendish_and_block_nodes: (*Parser::AST::Node) -> [Parser::AST::Node, Parser::AST::Node?]?
   end
 end

data/sig/steep/project/dsl.rbs

@@ -1,3 +1,5 @@
+use Steep::Diagnostic::Ruby::template
+
 module Steep
   class Project
     class DSL
@@ -71,10 +73,13 @@ module Steep
         # D = Steep::Diagnostic
         #
         # configure_code_diagnostics(D::Ruby.lenient)
+        # configure_code_diagnostics(D::Ruby.strict) do |config|
+        #   config[D::Ruby::NoMethod] = nil
+        # end
         # ```
         #
-        def configure_code_diagnostics: (Hash[untyped, untyped] hash) -> void
-                                      | () { (Hash[untyped, untyped]) -> void } -> void
+        def configure_code_diagnostics: (template hash) ?{ (template) -> void }-> void
+                                      | () { (template) -> void }-> void
 
         def collection_config: (Pathname path) -> void
 

data/sig/steep/services/completion_provider.rbs

@@ -4,6 +4,8 @@ use Steep::TypeInference::MethodCall
 module Steep
   module Services
     class CompletionProvider
+      include NodeHelper
+
       # Cursor position
       class Position
         attr_reader line: Integer
@@ -33,6 +35,14 @@ module Steep
         def initialize: (identifier: Symbol, range: Range, type: AST::Types::t) -> void
       end
 
+      class KeywordArgumentItem
+        attr_reader identifier: String
+
+        attr_reader range: Range
+
+        def initialize: (identifier: String, range: Range) -> void
+      end
+
       class LocalVariableItem
         attr_reader identifier: Symbol
 
@@ -169,6 +179,7 @@ module Steep
       end
 
       type item = InstanceVariableItem
+                | KeywordArgumentItem
                 | LocalVariableItem
                 | ConstantItem
                 | SimpleMethodNameItem
@@ -216,6 +227,8 @@ module Steep
 
       def items_for_rbs: (position: Position, buffer: RBS::Buffer) -> Array[item]
 
+      def items_for_following_keyword_arguments: (String text, index: Integer, line: Integer, column: Integer, items: Array[item]) -> void
+
       def method_items_for_receiver_type: (AST::Types::t, include_private: bool, prefix: String, position: Position, items: Array[item]) -> void
 
       def word_name?: (String name) -> bool
@@ -226,12 +239,13 @@ module Steep
 
       def instance_variable_items_for_context: (TypeInference::Context context, position: Position, prefix: String, items: Array[item]) -> void
 
+      def keyword_argument_items_for_method: (call_node: Parser::AST::Node, send_node: Parser::AST::Node, position: Position, prefix: String, items: Array[item]) -> void
+
       def index_for: (String, line: Integer, column: Integer) -> Integer
 
       def disallowed_method?: (Symbol name) -> bool
 
       def unwrap_optional: (AST::Types::t) -> AST::Types::t
-
     end
   end
 end

data/sig/steep/services/signature_help_provider.rbs

@@ -10,7 +10,11 @@ module Steep
 
         attr_reader comment: RBS::AST::Comment?
 
-        def initialize: (RBS::MethodType, RBS::AST::Comment?) -> void
+        attr_reader active_parameter: Integer?
+
+        def initialize: (RBS::MethodType, RBS::AST::Comment?, Integer?) -> void
+
+        def parameters: () -> Array[String]
       end
 
       attr_reader source: Source
@@ -31,7 +35,13 @@ module Steep
 
       private
 
-      def signature_help_for: (Parser::AST::Node, Typing) -> [Array[Item], Integer?]?
+      def active_parameter_for: (RBS::MethodType?, Array[Parser::AST::Node], Array[Parser::AST::Node]?, Parser::AST::Node) -> Integer?
+
+      def arguments_for: (RBS::MethodType) -> Array[String]
+
+      def last_argument_nodes_for: (argument_nodes: Array[Parser::AST::Node], line: Integer, column: Integer) -> Array[Parser::AST::Node]?
+
+      def signature_help_for: (Parser::AST::Node, Array[Parser::AST::Node], Array[Parser::AST::Node]?, Typing) -> [Array[Item], Integer?]?
 
       def type_check!: (line: Integer, column: Integer) -> Typing
     end

data/sig/steep/signature/validator.rbs

@@ -38,7 +38,7 @@ module Steep
 
       def validate_type_application: (RBS::Types::t) -> void
 
-      def validate_type: (RBS::Types::t `type`) -> untyped
+      def validate_type: (RBS::Types::t `type`) -> void
 
       def ancestor_to_type: (RBS::Definition::Ancestor::t ancestor) -> (AST::Types::Name::Interface | AST::Types::Name::Instance)
 
@@ -69,7 +69,7 @@ module Steep
       def validate_one_alias: (RBS::TypeName name, ?RBS::Environment::TypeAliasEntry entry) -> void
 
       def validate_one_class_decl: (RBS::TypeName) -> void
-                                 
+
       def validate_one_class_alias: (RBS::TypeName, RBS::Environment::ClassAliasEntry | RBS::Environment::ModuleAliasEntry) -> void
 
       def validate_alias: () -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 1.5.0.pre.5
+  version: 1.5.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -782,9 +782,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.10
 signing_key: