October 2024 - ruby-core - ml.ruby-lang.org

[ruby-core:119532] [Ruby master Feature#16986] Anonymous Struct literal
by Eregon (Benoit Daloze) 15 Oct '24

15 Oct '24

Issue #16986 has been updated by Eregon (Benoit Daloze). That's pretty slow and inefficient as it creates a new Struct subclass for every Hash it's applied to. The core idea of this proposal is to make it syntax and disallow **h to make sure that doesn't happen. This example could be a decent use case for OpenStruct, but that would need to be fixed perf-wise first, which is hard because of compatibility concerns: https://github.com/ruby/ostruct/issues/51 Wrapping it in your own OpenStruct-like wrapper would likely be the best for now. ---------------------------------------- Feature #16986: Anonymous Struct literal https://bugs.ruby-lang.org/issues/16986#change-110146 * Author: ko1 (Koichi Sasada) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract How about introducing anonymous Struct literal such as `${a: 1, b: 2}`? It is almost the same as `Struct.new(:a, :b).new(1, 2)`. # Proposal ## Background In many cases, people use hash objects to represent a set of values such as `person = {name: "ko1", country: 'Japan'}` and access its values through `person[:name]` and so on. It is not easy to write (three characters `[:]`!), and it easily introduces misspelling (`person[:nama]` doesn't raise an error). If we make a `Struct` object by doing `Person = Struct.new(:name, :age)` and `person = Person.new('ko1', 'Japan')`, we can access its values through `person.name` naturally. However, it costs coding. And in some cases, we don't want to name the class (such as `Person`). Using `OpenStruct` (`person = OpenStruct.new(name: "ko1", country: "Japan")`), we can access it through `person.name`, but we can extend the fields unintentionally, and the performance is not good. Of course, we can define a class `Person` with attr_readers. But it takes several lines. To summarize the needs: * Easy to write * Doesn't require declaring the class * Accessible through `person.name` format * Limited fields * Better performance ## Idea Introduce new literal syntax for an anonymous Struct such as: `${ a: 1, b: 2 }`. Similar to Hash syntax (with labels), but with `$` prefix to distinguish. Anonymous structs which have the same member in the same order share their class. ```ruby s1 = ${a: 1, b: 2, c: 3} s2 = ${a: 1, b: 2, c: 3} assert s1 == s2 s3 = ${a: 1, c: 3, b: 2} s4 = ${d: 4} assert_equal false, s1 == s3 assert_equal false, s1 == s4 ``` ## Note Unlike Hash literal syntax, this proposal only allows `label: expr` notation. No `${**h}` syntax. This is because if we allow to splat a Hash, it can be a vulnerability by splatting outer-input Hash. Thanks to this spec, we can specify anonymous Struct classes at compile time. We don't need to find or create Struct classes at runtime. ## Implementatation https://github.com/ruby/ruby/pull/3259 # Discussion ## Notation Matz said he thought about `{|a: 1, b: 2 |}` syntax. ## Performance Surprisingly, Hash is fast and Struct is slow. ```ruby Benchmark.driver do |r| r.prelude <<~PRELUDE st = Struct.new(:a, :b).new(1, 2) hs = {a: 1, b: 2} class C attr_reader :a, :b def initialize() = (@a = 1; @b = 2) end ob = C.new PRELUDE r.report "ob.a" r.report "hs[:a]" r.report "st.a" end __END__ Warming up -------------------------------------- ob.a 38.100M i/s - 38.142M times in 1.001101s (26.25ns/i, 76clocks/i) hs[:a] 37.845M i/s - 38.037M times in 1.005051s (26.42ns/i, 76clocks/i) st.a 33.348M i/s - 33.612M times in 1.007904s (29.99ns/i, 87clocks/i) Calculating ------------------------------------- ob.a 87.917M i/s - 114.300M times in 1.300085s (11.37ns/i, 33clocks/i) hs[:a] 85.504M i/s - 113.536M times in 1.327850s (11.70ns/i, 33clocks/i) st.a 61.337M i/s - 100.045M times in 1.631064s (16.30ns/i, 47clocks/i) Comparison: ob.a: 87917391.4 i/s hs[:a]: 85503703.6 i/s - 1.03x slower st.a: 61337463.3 i/s - 1.43x slower ``` I believe we can speed up `Struct` similarly to ivar accesses, so we can improve the performance. BTW, OpenStruct (os.a) is slow. ``` Comparison: hs[:a]: 92835317.7 i/s ob.a: 85865849.5 i/s - 1.08x slower st.a: 53480417.5 i/s - 1.74x slower os.a: 12541267.7 i/s - 7.40x slower ``` For memory consumption, `Struct` is more lightweight because we don't need to keep the key names. ## Naming If we name an anonymous class, literals with the same members share the name. ```ruby s1 = ${a:1} s2 = ${a:2} p [s1, s2] #=> [#<struct a=1>, #<struct a=2>] A = s1.class p [s1, s2] #=> [#<struct A a=1>, #<struct A a=2>] ``` Maybe that is not a good behavior. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119531] [Ruby master Feature#16986] Anonymous Struct literal
by danh337 (Dan H) 15 Oct '24

15 Oct '24

Issue #16986 has been updated by danh337 (Dan H). Adding this here because a new method, something like `as_struct`, feels more Rubyish to me than a new syntax. I've been using this because it lets me define with standard Hash syntactic sugar, then access the object members with method names. ```ruby module AsStruct def as_struct if respond_to?(:keys) && respond_to?(:values) Struct.new(*keys.map(&:to_sym)).new(*values.map(&:as_struct)) elsif respond_to?(:map) map(&:as_struct) else self end end end ::Object.include AsStruct ``` Example usage: ```ruby MyCustomToolConfig = { boot_log: false, check_upd: false, pcc: false, rebooted: false, pacman: { pre_update: { uninstalls: %w[virtualbox-ext-oracle] } }, pikaur: { post_update: { installs: %w[virtualbox-ext-oracle] } }, pkg_cache_clean: { pkg_dirs: %W[#{ENV["HOME"]}/.cache/pikaur/pkg /var/cache/pacman/pkg], keep_installed: 2, keep_uninstalled: 0 } }.as_struct # <-- The new thing ``` ---------------------------------------- Feature #16986: Anonymous Struct literal https://bugs.ruby-lang.org/issues/16986#change-110145 * Author: ko1 (Koichi Sasada) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract How about introducing anonymous Struct literal such as `${a: 1, b: 2}`? It is almost the same as `Struct.new(:a, :b).new(1, 2)`. # Proposal ## Background In many cases, people use hash objects to represent a set of values such as `person = {name: "ko1", country: 'Japan'}` and access its values through `person[:name]` and so on. It is not easy to write (three characters `[:]`!), and it easily introduces misspelling (`person[:nama]` doesn't raise an error). If we make a `Struct` object by doing `Person = Struct.new(:name, :age)` and `person = Person.new('ko1', 'Japan')`, we can access its values through `person.name` naturally. However, it costs coding. And in some cases, we don't want to name the class (such as `Person`). Using `OpenStruct` (`person = OpenStruct.new(name: "ko1", country: "Japan")`), we can access it through `person.name`, but we can extend the fields unintentionally, and the performance is not good. Of course, we can define a class `Person` with attr_readers. But it takes several lines. To summarize the needs: * Easy to write * Doesn't require declaring the class * Accessible through `person.name` format * Limited fields * Better performance ## Idea Introduce new literal syntax for an anonymous Struct such as: `${ a: 1, b: 2 }`. Similar to Hash syntax (with labels), but with `$` prefix to distinguish. Anonymous structs which have the same member in the same order share their class. ```ruby s1 = ${a: 1, b: 2, c: 3} s2 = ${a: 1, b: 2, c: 3} assert s1 == s2 s3 = ${a: 1, c: 3, b: 2} s4 = ${d: 4} assert_equal false, s1 == s3 assert_equal false, s1 == s4 ``` ## Note Unlike Hash literal syntax, this proposal only allows `label: expr` notation. No `${**h}` syntax. This is because if we allow to splat a Hash, it can be a vulnerability by splatting outer-input Hash. Thanks to this spec, we can specify anonymous Struct classes at compile time. We don't need to find or create Struct classes at runtime. ## Implementatation https://github.com/ruby/ruby/pull/3259 # Discussion ## Notation Matz said he thought about `{|a: 1, b: 2 |}` syntax. ## Performance Surprisingly, Hash is fast and Struct is slow. ```ruby Benchmark.driver do |r| r.prelude <<~PRELUDE st = Struct.new(:a, :b).new(1, 2) hs = {a: 1, b: 2} class C attr_reader :a, :b def initialize() = (@a = 1; @b = 2) end ob = C.new PRELUDE r.report "ob.a" r.report "hs[:a]" r.report "st.a" end __END__ Warming up -------------------------------------- ob.a 38.100M i/s - 38.142M times in 1.001101s (26.25ns/i, 76clocks/i) hs[:a] 37.845M i/s - 38.037M times in 1.005051s (26.42ns/i, 76clocks/i) st.a 33.348M i/s - 33.612M times in 1.007904s (29.99ns/i, 87clocks/i) Calculating ------------------------------------- ob.a 87.917M i/s - 114.300M times in 1.300085s (11.37ns/i, 33clocks/i) hs[:a] 85.504M i/s - 113.536M times in 1.327850s (11.70ns/i, 33clocks/i) st.a 61.337M i/s - 100.045M times in 1.631064s (16.30ns/i, 47clocks/i) Comparison: ob.a: 87917391.4 i/s hs[:a]: 85503703.6 i/s - 1.03x slower st.a: 61337463.3 i/s - 1.43x slower ``` I believe we can speed up `Struct` similarly to ivar accesses, so we can improve the performance. BTW, OpenStruct (os.a) is slow. ``` Comparison: hs[:a]: 92835317.7 i/s ob.a: 85865849.5 i/s - 1.08x slower st.a: 53480417.5 i/s - 1.74x slower os.a: 12541267.7 i/s - 7.40x slower ``` For memory consumption, `Struct` is more lightweight because we don't need to keep the key names. ## Naming If we name an anonymous class, literals with the same members share the name. ```ruby s1 = ${a:1} s2 = ${a:2} p [s1, s2] #=> [#<struct a=1>, #<struct a=2>] A = s1.class p [s1, s2] #=> [#<struct A a=1>, #<struct A a=2>] ``` Maybe that is not a good behavior. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119530] [Ruby master Feature#18242] Parser makes multiple assignment sad in confusing way
by danh337 (Dan H) 15 Oct '24

15 Oct '24

Issue #18242 has been updated by danh337 (Dan H). These `and` & `or` operators are good things. They are much more readable for one-liners in some cases. @matz @nobu I know you are super busy, but is there any way to move this forward? ---------------------------------------- Feature #18242: Parser makes multiple assignment sad in confusing way https://bugs.ruby-lang.org/issues/18242#change-110144 * Author: danh337 (Dan H) * Status: Open ---------------------------------------- Example: ``` ruby a, b = 2, 1 if 1 < 2 # Works a, b = [2, 1] if 1 < 2 # Works (a, b) = 2, 1 if 1 < 2 # Works (a, b) = [2, 1] if 1 < 2 # Works (a, b = [2, 1]) if 1 < 2 # Works a, b = 2, 1 unless 2 < 1 # Works a, b = [2, 1] unless 2 < 1 # Works (a, b) = 2, 1 unless 2 < 1 # Works (a, b) = [2, 1] unless 2 < 1 # Works (a, b = [2, 1]) unless 2 < 1 # Works 1 < 2 and a, b = 2, 1 # SyntaxError 1 < 2 and a, b = [2, 1] # SyntaxError 1 < 2 and (a, b) = 2, 1 # SyntaxError 1 < 2 and (a, b) = [2, 1] # SyntaxError (1 < 2) and a, b = 2, 1 # SyntaxError (1 < 2) and a, b = [2, 1] # SyntaxError (1 < 2) and (a, b) = 2, 1 # SyntaxError (1 < 2) and (a, b) = [2, 1] # SyntaxError 1 < 2 and (a, b = 2, 1) # Works 1 < 2 and (a, b = [2, 1]) # Works 2 < 1 or a, b = 2, 1 # SyntaxError 2 < 1 or a, b = [2, 1] # SyntaxError 2 < 1 or (a, b) = 2, 1 # SyntaxError 2 < 1 or (a, b) = [2, 1] # SyntaxError (2 < 1) or a, b = 2, 1 # SyntaxError (2 < 1) or a, b = [2, 1] # SyntaxError (2 < 1) or (a, b) = 2, 1 # SyntaxError (2 < 1) or (a, b) = [2, 1] # SyntaxError 2 < 1 or (a, b = 2, 1) # Works 2 < 1 or (a, b = [2, 1]) # Works ``` Based on the precedence rules I've been able to find, all of these should work. Believe it or not, there are cases where using `and` or `or` in a stanza of lines is much more readable. Should the parser allow all of these? See attached driver script to reproduce this output. ---Files-------------------------------- driver.rb (1.17 KB) and-or-masgn-18242.diff (963 Bytes) driver.rb (2.1 KB) -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119527] [Ruby master Feature#15554] warn/error passing a block to a method which never use a block
by ko1 (Koichi Sasada) 15 Oct '24

15 Oct '24

Issue #15554 has been updated by ko1 (Koichi Sasada). In this ticket, `Warning[:strict_unused_block]` is accepted by Matz. We should discuss `:strict` category in different tickets. ---------------------------------------- Feature #15554: warn/error passing a block to a method which never use a block https://bugs.ruby-lang.org/issues/15554#change-110142 * Author: ko1 (Koichi Sasada) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- # Abstract Warn or raise an ArgumentError if block is passed to a method which does not use a block. In other words, detect "block user methods" implicitly and only "block user methods" can accept a block. # Background Sometimes, we pass a block to a method which ignores the passed block accidentally. ``` def my_open(name) open(name) end # user hopes it works as Kernel#open which invokes a block with opened file. my_open(name){|f| important_work_with f } # but simply ignored... ``` To solve this issue, this feature request propose showing warnings or raising an exception on such case. Last developer's meeting, matz proposed `&nil` which declares this method never receive a block. It is explicit, but it is tough to add this `&nil` parameter declaration to all of methods (do you want to add it to `def []=(i, e, &nil)`?). (I agree `&nil` is valuable on some situations) # Spec ## Define "use a block" methods We need to define which method accepts a block and which method does not. * (1) method has a block parameter (`&b`) * (2) method body has `yield' * (3) method body has `super` (ZSUPER in internal terminology) or `super(...)` * (4) method body has singleton method (optional) (1) and (2) is very clear. I need to explain about (3) and (4). (3). `super` (ZSUPER) passes all parameters as arguments. So there is no surprise that which can accept `block`. However `super(...)` also passes a block if no explicit block passing (like `super(){}` or `super(&b)`) are written. I'm not sure we need to continue this strange specification, but to keep compatibility depending this spec, I add this rule. (4). surprisingly, the following code invoke a block: ``` def foo class << Object.new yield end end foo{ p :ok } #=> :ok ``` I'm also not sure we need to keep this spec, but to allow this spec, I added (4) rule. Strictly speaking, it is not required, but we don't keep the link from singleton class ISeq to lexical parent iseq now, so I added it. ## Exceptional cases A method called by `super` doesn`t warn warning even if this method doesn't use a block. The rule (3) can pass blocks easily and there are many methods don`t use a block. So my patch ignores callings by `super`. ## corner cases There are several cases to use block without (1)-(4) rules. ### `Proc.new/proc/lambda` without a block Now it was deprecated in r66772 (commit:9f1fb0a17febc59356d58cef5e98db61a3c03550). Related discussion: [Bug #15539] ### `block_given?` `block_given?` expects block, but I believe we use it with `yield` or a block parameter. If you know the usecase without them, please tell us. ### `yield` in `eval` We can't know `yield` (or (3), (4) rule) in an `eval` evaluating string at calling time. ``` def foo eval('yield`) end foo{} # at calling time, # we can't know the method foo can accept a block or not. ``` So I added a warning to use `yield` in `eval` like that: `test.rb:4: warning: use yield in eval will not be supported in Ruby 3.` Workaround is use a block parameter explicitly. ``` def foo &b eval('b.call') end foo{ p :ok } ``` # Implementation Strategy is: * [compile time] introduce `iseq::has_yield` field and check it if the iseq (or child iseq) contains `yield` (or something) * [calling time] if block is given, check `iseq::has_yield` flag and show warning (or raise an exception) https://gist.github.com/ko1/c9148ad0224bf5befa3cc76ed2220c0b On this patch, now it raises an error to make it easy to detect. It is easy to switch to show the warning. # Evaluation and discussion I tried to avoid ruby's tests. https://gist.github.com/ko1/37483e7940cdc4390bf8eb0001883786 Here is a patch. There are several patterns to avoid warnings. ## tests for `block_given?`, `Proc.new` (and similar) without block Add a dummy block parameter. It is test-specific issue. ## empty `each` Some tests add `each` methods do not `yield`, like: `def each; end`. Maybe test-specific issue, and adding a dummy block parameter. ## Subtyping / duck typing https://github.com/ruby/ruby/blob/c01a5ee85e2d6a7128cccafb143bfa694284ca87/… This `parse` method doesn't use `yield`, but other sub-type's `parse` methods use. ## `super` with `new` method https://gist.github.com/ko1/37483e7940cdc4390bf8eb0001883786#file-tests-pat… This method override `Class#new` method and introduce a hook with block (yield a block in this hook code). https://github.com/ruby/ruby/blob/trunk/lib/rubygems/package/tar_writer.rb#… In this method, call `super` and it also passing a block. However, called `initialize` doesn't use a block. ## Change robustness This change reduce robustness for API change. `Delegator` requires to support `__getobj__` for client classes. Now `__getobj__` should accept block but most of `__getobj__` clients do not call given block. https://github.com/ruby/ruby/blob/trunk/lib/delegate.rb#L80 This is because of delegator.rb's API change. https://gist.github.com/ko1/37483e7940cdc4390bf8eb0001883786#file-tests-pat… Nobu says calling block is not required (ignoring a block is no problem) so it is not a bug for delegator client classes. ## Found issues. ``` [ 2945/20449] Rinda::TestRingServer#test_do_reply = 0.00 s 1) Error: Rinda::TestRingServer#test_do_reply: ArgumentError: passing block to the method "with_timeout" (defined at /home/ko1/src/ruby/trunk/test/rinda/test_rinda.rb:787) is never used. /home/ko1/src/ruby/trunk/test/rinda/test_rinda.rb:635:in `test_do_reply' [ 2946/20449] Rinda::TestRingServer#test_do_reply_local = 0.00 s 2) Error: Rinda::TestRingServer#test_do_reply_local: ArgumentError: passing block to the method "with_timeout" (defined at /home/ko1/src/ruby/trunk/test/rinda/test_rinda.rb:787) is never used. /home/ko1/src/ruby/trunk/test/rinda/test_rinda.rb:657:in `test_do_reply_local' [10024/20449] TestGemRequestSetGemDependencyAPI#test_platform_mswin = 0.01 s 3) Error: TestGemRequestSetGemDependencyAPI#test_platform_mswin: ArgumentError: passing block to the method "util_set_arch" (defined at /home/ko1/src/ruby/trunk/lib/rubygems/test_case.rb:1053) is never used. /home/ko1/src/ruby/trunk/test/rubygems/test_gem_request_set_gem_dependency_api.rb:655:in `test_platform_mswin' [10025/20449] TestGemRequestSetGemDependencyAPI#test_platforms = 0.01 s 4) Error: TestGemRequestSetGemDependencyAPI#test_platforms: ArgumentError: passing block to the method "util_set_arch" (defined at /home/ko1/src/ruby/trunk/lib/rubygems/test_case.rb:1053) is never used. /home/ko1/src/ruby/trunk/test/rubygems/test_gem_request_set_gem_dependency_api.rb:711:in `test_platforms' ``` These 4 detection show the problem. `with_timeout` method (used in Rinda test) and `util_set_arch` method (used in Rubygems test) simply ignore the given block. So these tests are simply ignored. I reported them. (https://github.com/rubygems/rubygems/issues/2601) ## raise an error or show a warning? At least, Ruby 2.7 should show warning for this kind of violation with `-w`. How about for Ruby3? -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119528] Swift Copy $76,034,00
by HSBC BANK 15 Oct '24

15 Oct '24

1 0

[ruby-core:119522] [Ruby master Bug#20798] Missing spaces/punctuation in SyntaxError message.
by sanjioh (Fabio Sangiovanni) 14 Oct '24

14 Oct '24

Issue #20798 has been reported by sanjioh (Fabio Sangiovanni). ---------------------------------------- Bug #20798: Missing spaces/punctuation in SyntaxError message. https://bugs.ruby-lang.org/issues/20798 * Author: sanjioh (Fabio Sangiovanni) * Status: Open * ruby -v: ruby 3.4.0dev (2024-10-14T07:01:30Z master 1001ea9606) +PRISM [x86_64-darwin23] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Hi all, with the following simple snippet of Ruby code: ``` ruby def x.y.z end ``` the interpreter raises a `SyntaxError`, whose message is made up of two sentences with no spaces or punctuation in between (see line no. 2 of the output): ``` shell scratch2.rb: --> scratch2.rb expected a delimiter to close the parametersunexpected '.', ignoring it > 1 def x.y.z > 2 end scratch2.rb:1: syntax errors found (SyntaxError) > 1 | def x.y.z | ^ unexpected '.', ignoring it | ^ expected a delimiter to close the parameters 2 | end 3 | ``` This happens on master with the sentences reported above, but also on 3.3.5 with the sentences: `expected a delimiter to close the parameterscannot parse the expression`. Unfortunately I can't tell if the same glitch occurs with other error messages. Thanks! -- https://bugs.ruby-lang.org/

2 2

[ruby-core:119511] [Ruby master Feature#18033] Time.new to parse a string
by Eregon (Benoit Daloze) 11 Oct '24

11 Oct '24

Issue #18033 has been updated by Eregon (Benoit Daloze). matz (Yukihiro Matsumoto) wrote in #note-27: > Currently, `Time.new` only takes numeric arguments, so adding extra argument pattern add only a small complexity. But older versions like 3.0 accept year as a String: https://bugs.ruby-lang.org/issues/18033#note-10 So we get very weird behavior between versions: ``` $ ruby -ve 'p Time.new "2234-10-12T01:02:03"' ruby 3.0.6p216 (2023-03-30 revision 23a532679b) [x86_64-linux] 2234-01-01 00:00:00 +0100 $ ruby -ve 'p Time.new "2234-10-12T01:02:03"' ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux] <internal:timev>:310:in `initialize': invalid value for Integer(): "2234-10-12T01:02:03" (ArgumentError) from -e:1:in `new' from -e:1:in `<main>' $ ruby -ve 'p Time.new "2234-10-12T01:02:03"' ruby 3.2.4 (2024-04-23 revision af471c0e01) [x86_64-linux] 2234-10-12 01:02:03 +0200 $ ruby -ve 'p Time.new "2234-10-12T01:02:03"' ruby 3.3.5 (2024-09-03 revision ef084cc8f4) [x86_64-linux] 2234-10-12 01:02:03 +0200 ``` ---------------------------------------- Feature #18033: Time.new to parse a string https://bugs.ruby-lang.org/issues/18033#change-110126 * Author: nobu (Nobuyoshi Nakada) * Status: Closed ---------------------------------------- Make `Time.new` parse `Time#inspect` and ISO-8601 like strings. * `Time.iso8601` and `Time.parse` need an extension library, `date`. * `Time.iso8601` can't parse `Time#inspect` string. * `Time.parse` often results in unintentional/surprising results. * `Time.new` also about 1.9 times faster than `Time.iso8601`. ``` $ ./ruby -rtime -rbenchmark -e ' n = 1000 s = Time.now.iso8601 Benchmark.bm(12) do |x| x.report("Time.iso8601") {n.times{Time.iso8601(s)}} x.report("Time.parse") {n.times{Time.parse(s)}} x.report("Time.new") {n.times{Time.new(s)}} end' user system total real Time.iso8601 0.006919 0.000185 0.007104 ( 0.007091) Time.parse 0.018338 0.000207 0.018545 ( 0.018590) Time.new 0.003671 0.000069 0.003740 ( 0.003741) ``` https://github.com/ruby/ruby/pull/4825 -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119487] [Ruby master Bug#20789] `->a=1...{}` is syntax error in 3.4.0dev parse.y
by tompng (tomoya ishida) 09 Oct '24

09 Oct '24

Issue #20789 has been reported by tompng (tomoya ishida). ---------------------------------------- Bug #20789: `->a=1...{}` is syntax error in 3.4.0dev parse.y https://bugs.ruby-lang.org/issues/20789 * Author: tompng (tomoya ishida) * Status: Open * ruby -v: ruby 3.4.0dev (2024-10-01T11:00:22Z v3_4_0_preview2~89 86ae409467) [x86_64-linux] * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- `->a=1...{}` is syntax error since https://github.com/ruby/ruby/pull/11751 -- https://bugs.ruby-lang.org/

2 1

[ruby-core:119491] [Ruby master Bug#20791] RbCONFIG::CONFIG does not have a LIBRUBY_RELATIVE key on mswin
by deivid 09 Oct '24

09 Oct '24

Issue #20791 has been reported by deivid (David Rodríguez). ---------------------------------------- Bug #20791: RbCONFIG::CONFIG does not have a LIBRUBY_RELATIVE key on mswin https://bugs.ruby-lang.org/issues/20791 * Author: deivid (David Rodríguez) * Status: Open * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- I noticed that mswin Ruby does not provide `RbCONFIG::CONFIG["LIBRUBY_RELATIVE"]`. My understanding is that all Windows should have this set to "yes", as per https://github.com/ruby/ruby/blob/67d6e89b0b6d7dd7d6454ace7734157ee51f3f79/…. Since `rbinstall` script uses this config to decide whether binstubs need a bash prolog or not as per https://github.com/ruby/ruby/blob/67d6e89b0b6d7dd7d6454ace7734157ee51f3f79/…, I think mswin is getting incorrect binstubs generated by default. I tried to look briefly into why this happens, but I could not figure it out. -- https://bugs.ruby-lang.org/

1 1

[ruby-core:119485] [Ruby master Bug#20788] Prism issues unused variable warnings for negative line numbers
by jeremyevans0 (Jeremy Evans) 09 Oct '24

09 Oct '24

Issue #20788 has been reported by jeremyevans0 (Jeremy Evans). ---------------------------------------- Bug #20788: Prism issues unused variable warnings for negative line numbers https://bugs.ruby-lang.org/issues/20788 * Author: jeremyevans0 (Jeremy Evans) * Status: Open * Assignee: kddnewton (Kevin Newton) * Backport: 3.1: DONTNEED, 3.2: DONTNEED, 3.3: DONTNEED ---------------------------------------- parse.y does not issue unused variable warnings for negative line numbers. However, prism does issue such warnings. Example code: ```ruby Object.class_eval(<<END, nil, -2) def a(locals) foo = locals[:foo] 2 end END ``` Output: ``` $ run_ruby -v --parser=prism --disable-gems t/t82.rb ruby 3.4.0dev (2024-10-08T22:14:44Z master 3fc1495c30) +PRISM [x86_64-openbsd7.6] (eval at t/t82.rb:1):-1: warning: assigned but unused variable - foo $ run_ruby -v --parser=parse.y --disable-gems t/t82.rb ruby 3.4.0dev (2024-10-08T22:14:44Z master 3fc1495c30) [x86_64-openbsd7.6] ``` This results in spurious verbose-mode warnings in applications using tilt, the template library used by most non-Rails web frameworks (Sinatra, Roda, Hanami, Cuba, Camping, etc.). -- https://bugs.ruby-lang.org/

1 0