From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on dcvr.yhbt.net X-Spam-Level: X-Spam-ASN: AS4713 221.184.0.0/13 X-Spam-Status: No, score=-1.5 required=3.0 tests=AWL,BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI, RCVD_IN_BL_SPAMCOP_NET,RCVD_IN_DNSWL_MED,RCVD_IN_SBL_CSS,SPF_HELO_NONE, SPF_PASS shortcircuit=no autolearn=no autolearn_force=no version=3.4.2 Received: from neon.ruby-lang.org (neon.ruby-lang.org [221.186.184.75]) by dcvr.yhbt.net (Postfix) with ESMTP id EF7FB1F463 for ; Wed, 11 Sep 2019 21:26:05 +0000 (UTC) Received: from neon.ruby-lang.org (localhost [IPv6:::1]) by neon.ruby-lang.org (Postfix) with ESMTP id 30F8F120AB2; Thu, 12 Sep 2019 06:25:40 +0900 (JST) Received: from o1678948x4.outbound-mail.sendgrid.net (o1678948x4.outbound-mail.sendgrid.net [167.89.48.4]) by neon.ruby-lang.org (Postfix) with ESMTPS id 8782B120A99 for ; Thu, 12 Sep 2019 06:25:35 +0900 (JST) Received: by filter0104p3las1.sendgrid.net with SMTP id filter0104p3las1-23346-5D796649-5A 2019-09-11 21:25:30.020537568 +0000 UTC m=+99182.043738913 Received: from herokuapp.com (unknown [54.242.45.138]) by ismtpd0030p1iad2.sendgrid.net (SG) with ESMTP id hNntCsncRh-HEtPrvPJPrg for ; Wed, 11 Sep 2019 21:25:29.937 +0000 (UTC) Date: Wed, 11 Sep 2019 21:25:30 +0000 (UTC) From: merch-redmine@jeremyevans.net Message-ID: References: Mime-Version: 1.0 X-Redmine-MailingListIntegration-Message-Ids: 70463 X-Redmine-Project: ruby-trunk X-Redmine-Issue-Id: 16157 X-Redmine-Issue-Author: Dan0042 X-Redmine-Sender: jeremyevans0 X-Mailer: Redmine X-Redmine-Host: bugs.ruby-lang.org X-Redmine-Site: Ruby Issue Tracking System X-Auto-Response-Suppress: All Auto-Submitted: auto-generated X-SG-EID: =?us-ascii?Q?RVE3t853K5scBhbmJHUzZTFFeVC=2FZSUmHZ0Dc+26wcEi2CTgsF1oz0wTSSxGGN?= =?us-ascii?Q?BIA+bcy5TQpZdpOAK3lHgeMHnZje7vVD924nvf1?= =?us-ascii?Q?FjIYyNMc5KbRXyyAzdiQ02OM=2F+8rONEZ+GQFA6N?= =?us-ascii?Q?KzCI4Z8KQtsAMAndJoIv4KHUoEe+gajz79S7qSk?= =?us-ascii?Q?yal+EMmO+zrfWPrNbLGjRJvU44ScxS5BsEg=3D=3D?= To: ruby-core@ruby-lang.org X-ML-Name: ruby-core X-Mail-Count: 94909 Subject: [ruby-core:94909] [Ruby master Misc#16157] What is the correct and *portable* way to do generic delegation? X-BeenThere: ruby-core@ruby-lang.org X-Mailman-Version: 2.1.15 Precedence: list Reply-To: Ruby developers List-Id: Ruby developers List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: ruby-core-bounces@ruby-lang.org Sender: "ruby-core" Issue #16157 has been updated by jeremyevans0 (Jeremy Evans). After discussion with some other committers, I have an alternative approach in https://github.com/ruby/ruby/pull/2449. This allows you to do the following: ```ruby class Foo def foo(*args, &block) bar(*args, &block) end pass_keywords :foo if respond_to?(:pass_keywords, true) end ``` Then if you call `foo` with keywords, keywords will be passed to `bar`. This should allow for more backwards compatible behavior with older versions of Ruby. Using a modified version of your example: ```ruby class Proxy < BasicObject def initialize(target) @target = target end def method_missing(*a, &b) @target.send(*a, &b) rescue $! end pass_keywords(:method_missing) if respond_to?(:pass_keywords, true) end class Test def noarg() end def noarg_o(**o) o end def arg(a) a end def arg_o(a, **o) [a,o] end def opt_arg(a=nil) a end def opt_arg_o(a=nil, **o) [a,o] end def args(*a) a end def args_o(*a, **o) [a, o] end end e = Object.new def e.write(*args) $stdout.print("warn! ") end $stderr = e opt = {} hash = {k:42} proxy = Proxy.new(Test.new) %i'noarg arg opt_arg args'.each do |m| [m, :"#{m}_o"].each do |meth| p ["#{meth}(opt)", proxy.send(meth, opt)] p ["#{meth}(hash)", proxy.send(meth, hash)] p ["#{meth}(**hash)", proxy.send(meth, **opt)] p ["#{meth}(**opt)", proxy.send(meth, **opt)] p ["#{meth}(hash, **opt)", proxy.send(meth, hash, **opt)] p ["#{meth}(hash, **hash)", proxy.send(meth, hash, **hash)] end end ``` Here's a table describing the differences and warnings (differences in ArgumentError messages are ignored). All differences are due to empty keyword splats not being passed as positional arguments in 2.7, and I would consider them at least undesired behavior in 2.6, if not an outright bug. ``` Code 2.6 2.7-pass_keywords ----------------------------------------------------------------------------- | noarg(opt) | # | # | noarg(hash) | # | # d| noarg(**opt) | # | nil | noarg(**hash) | # | # | noarg(hash, **opt) | # | # | noarg(hash, **hash) | # | # w | noarg_o(opt) | opt | opt w | noarg_o(hash) | hash | hash | noarg_o(**opt) | opt | opt | noarg_o(**hash) | hash | hash | noarg_o(hash, **opt) | # | # | noarg_o(hash, **hash) | # | # | arg(opt) | opt | opt | arg(hash) | hash | hash w | arg(**opt) | opt | opt | arg(**hash) | opt | hash d| arg(hash, **opt) | # | hash | arg(hash, **hash) | # | # | arg_o(opt) | [opt, opt] | [opt, opt] | arg_o(hash) | [hash, opt] | [hash, opt] w | arg_o(**opt) | [opt, opt] | [opt, opt] w | arg_o(**hash) | [hash, opt] | [hash, opt] | arg_o(hash, **opt) | [hash, opt] | [hash, opt] | arg_o(hash, **hash) | [hash, hash] | [hash, hash] | opt_arg(opt) | opt | opt | opt_arg(hash) | hash | hash d| opt_arg(**opt) | opt | nil | opt_arg(**hash) | hash | hash d| opt_arg(hash, **opt) | #| hash | opt_arg(hash, **hash) | #| # w | opt_arg_o(opt) | [nil, opt] | [nil, opt] w | opt_arg_o(hash) | [nil, hash] | [nil, hash] | opt_arg_o(**opt) | [nil, opt] | [nil, opt] | opt_arg_o(**hash) | [nil, hash] | [nil, hash] | opt_arg_o(hash, **opt) | [hash, opt] | [hash, opt] | opt_arg_o(hash, **hash) | [hash, hash] | [hash, hash] | args(opt) | [opt] | [opt] | args(hash) | [hash] | [hash] d| args(**opt) | [opt] | [] | args(**hash) | [hash] | [hash] d| args(hash, **opt) | [hash, opt] | [hash] | args(hash, **hash) | [hash, hash] | [hash, hash] w | args_o(opt) | [[], opt] | [[], opt] w | args_o(hash) | [[], hash] | [[], hash] | args_o(**hash) | [[], opt] | [[], opt] | args_o(**opt) | [[], opt] | [[], opt] | args_o(hash, **opt) | [[hash], opt] | [[hash], opt] | args_o(hash, **hash) | [[hash], hash] | [[hash], hash] ``` Every time a warning is issued, behavior is the same in 2.7 as in 2.6. For each warning, here will be the behavior in 3.0: ``` Code 2.6 & 2.7 3.0 ------------------------------------------------------- w | noarg_o(opt) | opt | # w | noarg_o(hash) | hash | # w | arg(**opt) | opt | # w | arg_o(**opt) | [opt, opt] | # w | arg_o(**hash) | [hash, opt] | # w | opt_arg_o(opt) | [nil, opt] | [opt, opt] w | opt_arg_o(hash) | [nil, hash] | [hash, opt] w | args_o(opt) | [[], opt] | [[opt], opt] w | args_o(hash) | [[], hash] | [[hash], opt] ``` ---------------------------------------- Misc #16157: What is the correct and *portable* way to do generic delegation? https://bugs.ruby-lang.org/issues/16157#change-81522 * Author: Dan0042 (Daniel DeLorme) * Status: Open * Priority: Normal * Assignee: ---------------------------------------- With the keyword argument changes in 2.7 we must now specify keyword arguments explicitly when doing generic delegation. But this change is not compatible with 2.6, where it adds an empty hash to the argument list of methods that do not need/accept keyword arguments. To illustrate the problem: ```ruby class ProxyWithoutKW < BasicObject def initialize(target) @target = target end def method_missing(*a, &b) @target.send(*a, &b) end end class ProxyWithKW < BasicObject def initialize(target) @target = target end def method_missing(*a, **o, &b) @target.send(*a, **o, &b) end end class Test def args(*a) a end def arg(a) a end def opts(**o) o end end # 2.6 2.7 3.0 ProxyWithoutKW.new(Test.new).args(42) # [42] [42] [42] ok ProxyWithoutKW.new(Test.new).arg(42) # 42 42 42 ok ProxyWithoutKW.new(Test.new).opts(k: 42) # {:k=>42} {:k=>42} +warn [{:k=>42}] incompatible with >= 2.7 ProxyWithKW.new(Test.new).args(42) # [42, {}] [42] [42] incompatible with <= 2.6 ProxyWithKW.new(Test.new).arg(42) # error 42 42 incompatible with <= 2.6 ProxyWithKW.new(Test.new).opts(k: 42) # {:k=>42} {:k=>42} +warn {:k=>42} must ignore warning? cannot use pass_positional_hash in 2.6 ``` I don't know how to solve this, so I'm asking for the **official** correct way to write portable delegation code. And by **portable** I mean code that can be used in gems that target ruby 2.6 and above. -- https://bugs.ruby-lang.org/