Ruby

Cuando una invocación de método aprueba un Hash en el último argumento, y cuando no pasa ninguna palabra clave, y cuando el método invocado acepta las palabras clave, se emite una advertencia. Para continuar tratando el hash como palabras clave, y un operador de salpicadura doble para evitar la advertencia y asegurar comportamiento correcto en Ruby 3.

    def foo(key: 42); end; foo({key: 42})   # advertido
    def foo(**kw);    end; foo({key: 42})   # advertido
    def foo(key: 42); end; foo(**{key: 42}) # OK
    def foo(**kw);    end; foo(**{key: 42}) # OK

Cuando una invocación a un método pasa palabras clave a un método que acepta palabras clave, pero no pasa suficientes argumentos posicionales requeridos, las palabras clave se tratan como un argumento posicional final obligatorio y se emite una advertencia. Para evitar la advertencia y garantizar un comportamiento correcto en Ruby 3, pase el argumento como un hash en lugar de palabras clave.

    def foo(h, **kw); end; foo(key: 42)      # advertencia
    def foo(h, key: 42); end; foo(key: 42)   # advertencia
    def foo(h, **kw); end; foo({key: 42})    # OK
    def foo(h, key: 42); end; foo({key: 42}) # OK

When a method accepts specific keywords but not a keyword splat, and a hash or keywords splat is passed to the method that includes both Symbol and non-Symbol keys, the hash will continue to be split, and a warning will be emitted. You will need to update the calling code to pass separate hashes to ensure correct behavior in Ruby 3.

    def foo(h={}, key: 42); end; foo("key" => 43, key: 42)   # warned
    def foo(h={}, key: 42); end; foo({"key" => 43, key: 42}) # warned
    def foo(h={}, key: 42); end; foo({"key" => 43}, key: 42) # OK

Si un método no acepta palabras clave, y se invoca con palabras clave, las palabras clave aún son tratadas como hash posicionales, sin advertir. Este comportamiento continuará funcionando en Ruby 3.

    def foo(opt={});  end; foo( key: 42 )   # Correcto

Se conceden distintos de símbolos como claves de argumento con palabra clave si el método aceptar palabras clave arbitrarias.

    def foo(**kw); p kw; end; foo("str" => 1) #=> {"str"=>1}

**nil se permite en las definiciones de métodos para indicar explícitamente que el método no acepta palabras clave. Llamar a dicho método con palabras clave dará como resultado un ArgumentError.

    def foo(h, **nil); end; foo(key: 1)       # ArgumentError
    def foo(h, **nil); end; foo(**{key: 1})   # ArgumentError
    def foo(h, **nil); end; foo("str" => 1)   # ArgumentError
    def foo(h, **nil); end; foo({key: 1})     # OK
    def foo(h, **nil); end; foo({"str" => 1}) # OK

Passing an empty keyword splat to a method that does not accept keywords no longer passes an empty hash, unless the empty hash is necessary for a required parameter, in which case a warning will be emitted. Remove the double splat to continue passing a positional hash.

    h = {}; def foo(*a) a end; foo(**h) # []
    h = {}; def foo(a) a end; foo(**h)  # {} y avisando
    h = {}; def foo(*a) a end; foo(h)   # [{}]
    h = {}; def foo(a) a end; foo(h)    # {}