December 2022 - ruby-core - ml.ruby-lang.org

[ruby-core:111228] [Ruby master Bug#19190] `Regexp.compile('regexp', 'n')` raises `unknown regexp option: n (ArgumentError)`
by koic (Koichi ITO) 07 Dec '22

07 Dec '22

Issue #19190 has been reported by koic (Koichi ITO). ---------------------------------------- Bug #19190: `Regexp.compile('regexp', 'n')` raises `unknown regexp option: n (ArgumentError)` https://bugs.ruby-lang.org/issues/19190 * Author: koic (Koichi ITO) * Status: Open * Priority: Normal * ruby -v: ruby 3.2.0dev (2022-12-07T03:32:29Z master bcd8b2f00a) [x86_64-darwin19] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- I get the following unexpected error when using Ruby 3.2.0-dev. ## Expected (Ruby 3.1 and prior) No errors: ```console % ruby -ve "Regexp.compile('regexp', 'n')" ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-darwin19] ``` ## Actual (Ruby 3.2.0-dev) An unexpected error occurs. ```console % ruby -ve "Regexp.compile('regexp', 'n')" ruby 3.2.0dev (2022-12-07T03:32:29Z master bcd8b2f00a) [x86_64-darwin19] -e:1:in `initialize': unknown regexp option: n (ArgumentError) Regexp.compile('regexp', 'n') ^^^^^^^^^^^^^ from -e:1:in `compile' from -e:1:in `<main>' ``` ## Context I encountered the following error when developing the Parser gem with Ruby 3.2.0-dev. This is not encountered in Ruby 3.1. ```console % cd whitequark/parser % bundle exec rake racc --superclass=Parser::Base lib/parser/ruby32.y -o lib/parser/ruby32.rb --no-line-convert /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:219:in `initialize': unknown regexp option: n (ArgumentError) Regexp.compile(map, 'n') ^^^^^^^^ from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:219:in `compile' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:219:in `mkmapexp' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:179:in `addent' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:122:in `block in gen_action_tables' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/state.rb:56:in `each' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/state.rb:56:in `each_state' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:112:in `gen_action_tables' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:72:in `generate' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/statetransitiontable.rb:35:in `generate' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/state.rb:93:in `state_transition_table' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/grammar.rb:153:in `parser_class' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/grammarfileparser.rb:144:in `<module:Racc>' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/grammarfileparser.rb:20:in `<top (required)>' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/static.rb:3:in `require' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/lib/racc/static.rb:3:in `<top (required)>' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/bin/racc:11:in `require' from /Users/koic/.rbenv/versions/3.2.0-dev/lib/ruby/gems/3.2.0+3/gems/racc-1.6.0/bin/racc:11:in `<top (required)>' from /Users/koic/.rbenv/versions/3.2.0-dev/bin/racc:25:in `load' from /Users/koic/.rbenv/versions/3.2.0-dev/bin/racc:25:in `<main>' rake aborted! Command failed with status (1): [racc --superclass=Parser::Base lib/parser/...] /Users/koic/src/github.com/whitequark/parser/Rakefile:166:in `block in <top (required)>' /Users/koic/.rbenv/versions/3.2.0-dev/bin/bundle:25:in `load' /Users/koic/.rbenv/versions/3.2.0-dev/bin/bundle:25:in `<main>' Tasks: TOP => default => test => generate => lib/parser/ruby32.rb (See full trace by running task with --trace) ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:111227] [Ruby master Bug#19012] BasicSocket#recv* methods return an empty packet instead of nil on closed connections
by byroot (Jean Boussier) 07 Dec '22

07 Dec '22

Issue #19012 has been updated by byroot (Jean Boussier). I was able to implement the desired behavior in https://github.com/ruby/ruby/pull/6407 ---------------------------------------- Bug #19012: BasicSocket#recv* methods return an empty packet instead of nil on closed connections https://bugs.ruby-lang.org/issues/19012#change-100516 * Author: byroot (Jean Boussier) * Status: Open * Priority: Normal * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- `man recvmsg(2)` states: > Return Value > These calls return the number of bytes received, or -1 if an error occurred. The return value will be 0 when the peer has performed an orderly shutdown. But somehow the entire `receiv` family of methods in Ruby seem to interpret `0` as empty string instead of "EOF". ```ruby require 'socket' puts "=== pipes ===" r, w = IO.pipe r.read_nonblock(1, exception: false) # => :wait_readable w.close r.read_nonblock(1, exception: false) # => nil (EOF) puts "=== sockets ====" r, w = UNIXSocket.socketpair r.read_nonblock(1, exception: false) # => :wait_readable r.recvmsg_nonblock(1, exception: false) # => :wait_readable r.recv_nonblock(1, exception: false) # => :wait_readable w.close r.read_nonblock(1, exception: false) # => nil (EOF) r.recvmsg_nonblock(1, exception: false) # => ["", #<Addrinfo: empty-sockaddr SOCK_STREAM>, 128]] r.recvmsg # => ["", #<Addrinfo: empty-sockaddr SOCK_STREAM>, 0]] r.recv_nonblock(1, exception: false) # => "" ``` ### Expected behavior I would expect `recvmsg_nonblock`, `recvmsg`, `recv_nonblock` and `recv` to return `nil` when the connection is closed. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111221] [Ruby master Bug#19188] Ruby 2.7.7 CGI Cookie Processing
by apremdas＠yahoo.co.uk (Andrew Premdas) 07 Dec '22

07 Dec '22

Issue #19188 has been reported by apremdas(a)yahoo.co.uk (Andrew Premdas). ---------------------------------------- Bug #19188: Ruby 2.7.7 CGI Cookie Processing https://bugs.ruby-lang.org/issues/19188 * Author: apremdas(a)yahoo.co.uk (Andrew Premdas) * Status: Open * Priority: Normal * ruby -v: ruby 2.7.7p221 (2022-11-24 revision 168ec2b1e5) [arm64-darwin22] * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- This is my first bug report here, apologies if I mess things up. Ruby 2.7.7 introduced a code change in lib/ruby/2.7.0/cgi/cookie.rb. There is now a custom setter for the domain attribute. You can see me debugging this below ``` 126: def domain=(str) 127: byebug => 128: if str and ((str = str.b).bytesize > 255 or !DOMAIN_VALUE_RE.match?(str)) 129: raise ArgumentError, "invalid domain: #{str.dump}" 130: end ``` When you are running a test on rails using capybara and rspec the value of domain will be ".example.com". This value is the same on ruby 2.7.6. The new code in 2.7.7 rejects this code as an invalid domain because `DOMAIN_VALUE_RE.match?(str)` is false. I think `DOMAIN_VALUE_RE` needs to be changed so it matches ".example.com" otherwise lots of tests on Rails applications are going to fail -- https://bugs.ruby-lang.org/

3 2

[ruby-core:111219] [Ruby master Feature#18798] `UnboundMethod#==` with inherited classes
by ko1 (Koichi Sasada) 06 Dec '22

06 Dec '22

Issue #18798 has been updated by ko1 (Koichi Sasada). Status changed from Open to Closed https://github.com/ruby/ruby/pull/6855 was merged. `p String.instance_method(:object_id) == Array.instance_method(:object_id) #=> true` ---------------------------------------- Feature #18798: `UnboundMethod#==` with inherited classes https://bugs.ruby-lang.org/issues/18798#change-100509 * Author: ko1 (Koichi Sasada) * Status: Closed * Priority: Normal ---------------------------------------- Now `UnboundMethod` for a same method from a superclass and an inherited class are not `==`. ```ruby class C def foo = :C $mc = instance_method(:foo) end class D < C $md = instance_method(:foo) end p $mc == $md #=> false p $mc.owner #=> C p $mc.owner == $md.owner #=> true p $mc.source_location == $md.source_location #=> true p $mc.inspect #=> "#<UnboundMethod: C#foo() t.rb:3>" p $md.inspect #=> "#<UnboundMethod: D(C)#foo() t.rb:3>" ``` How about to make it `UnboundMethod#==` return true for this case? Rule: "return true if the UnboundMethod objects point to a same method definition" seems simple. FYI: On aliased unbound methods point to a same method are `==`. ```ruby class C def foo = :C alias bar foo $mfoo = instance_method(:foo) $mbar = instance_method(:bar) end p $mfoo, $mbar #=> #<UnboundMethod: C#foo() t.rb:2> #=> #<UnboundMethod: C#bar(foo)() t.rb:2> p $mfoo == $mbar #=> true ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111218] Ruby 3.2.0 RC 1 Released"
by NARUSE, Yui 06 Dec '22

06 Dec '22

We are pleased to announce the release of Ruby 3.2.0-rc1. Ruby 3.2 adds many features and performance improvements. ## WASI based WebAssembly support This is an initial port of WASI based WebAssembly support. This enables a CRuby binary to be available on a Web browser, a Serverless Edge environment, or other kinds of WebAssembly/WASI embedders. Currently this port passes basic and bootstrap test suites not using the Thread API. ![](https://i.imgur.com/opCgKy2.png) ### Background [WebAssembly (Wasm)](https://webassembly.org/) was originally introduced to run programs safely and fast in web browsers. But its objective - running programs efficiently with security on various environment - is long wanted not only for web but also by general applications. [WASI (The WebAssembly System Interface)](https://wasi.dev/) is designed for such use cases. Though such applications need to communicate with operating systems, WebAssembly runs on a virtual machine which didn't have a system interface. WASI standardizes it. WebAssembly/WASI support in Ruby intends to leverage those projects. It enables Ruby developers to write applications which run on such promised platforms. ### Use case This support encourages developers to utilize CRuby in a WebAssembly environment. An example use case is [TryRuby playground](https://try.ruby-lang.org/playground/)'s CRuby support. Now you can try original CRuby in your web browser. ### Technical points Today’s WASI and WebAssembly itself is missing some features to implement Fiber, exception, and GC because it’s still evolving, and also for security reasons. So CRuby fills the gap by using Asyncify, which is a binary transformation technique to control execution in userland. In addition, we built [a VFS on top of WASI](https://github.com/kateinoigakukun/wasi-vfs/wiki/Getting-Started-with… so that we can easily pack Ruby apps into a single .wasm file. This makes distribution of Ruby apps a bit easier. ### Related links * [Add WASI based WebAssembly support #5407](https://github.com/ruby/ruby/pull/5407) * [An Update on WebAssembly/WASI Support in Ruby](https://itnext.io/final-report-webassembly-wasi-support-in-ruby-4aface7d90c9) ## Regexp improvements against ReDoS It is known that Regexp matching may take unexpectedly long. If your code attempts to match a possibly inefficient Regexp against an untrusted input, an attacker may exploit it for efficient Denial of Service (so-called Regular expression DoS, or ReDoS). We have introduced two improvements that significantly mitigate ReDoS. ### Improved Regexp matching algorithm Since Ruby 3.2, Regexp's matching algorithm has been greatly improved by using a memoization technique. ``` # This match takes 10 sec. in Ruby 3.1, and 0.003 sec. in Ruby 3.2 /^a*b?a*$/ =~ "a" * 50000 + "x" ``` ![](https://cache.ruby-lang.org/pub/media/ruby320_regex_1.png) ![](https://cache.ruby-lang.org/pub/media/ruby320_regex_2.png) The improved matching algorithm allows most Regexp matching (about 90% in our experiments) to be completed in linear time. (For preview users: this optimization may consume memory proportional to the input length for each match. We expect no practical problems to arise because this memory allocation is usually delayed, and a normal Regexp match should consume at most 10 times as much memory as the input length. If you run out of memory when matching Regexps in a real-world application, please report it.) The original proposal is https://bugs.ruby-lang.org/issues/19104 ### Regexp timeout The optimization above cannot be applied to some kind of regular expressions, such as those including advanced features (e.g., back-references or look-around), or with a huge fixed number of repetitions. As a fallback measure, a timeout feature for Regexp matches is also introduced. ```ruby Regexp.timeout = 1.0 /^a*b?a*()\1$/ =~ "a" * 50000 + "x" #=> Regexp::TimeoutError is raised in one second ``` Note that `Regexp.timeout` is a global configuration. If you want to use different timeout settings for some special Regexps, you may want to use the `timeout` keyword for `Regexp.new`. ```ruby Regexp.timeout = 1.0 # This regexp has no timeout long_time_re = Regexp.new("^a*b?a*()\1$", timeout: Float::INFINITY) long_time_re =~ "a" * 50000 + "x" # never interrupted ``` The original proposal is https://bugs.ruby-lang.org/issues/17837 ## Other Notable New Features ### SyntaxSuggest * The feature of `syntax_suggest` (formerly `dead_end`) is integrated into Ruby. This helps you find the position of errors such as missing or superfluous `end`s, to get you back on your way faster, such as in the following example: ``` Unmatched `end', missing keyword (`do', `def`, `if`, etc.) ? 1 class Dog > 2 defbark > 4 end 5 end ``` [[Feature #18159]] ### ErrorHighlight * Now it points at the relevant argument(s) for TypeError and ArgumentError ``` test.rb:2:in `+': nil can't be coerced into Integer (TypeError) sum = ary[0] + ary[1] ^^^^^^ ``` ### Language * Anonymous rest and keyword rest arguments can now be passed as arguments, instead of just used in method parameters. [[Feature #18351]] ```ruby def foo(*) bar(*) end def baz(**) quux(**) end ``` * A proc that accepts a single positional argument and keywords will no longer autosplat. [[Bug #18633]] ```ruby proc{|a, **k| a}.call([1, 2]) # Ruby 3.1 and before # => 1 # Ruby 3.2 and after # => [1, 2] ``` * Constant assignment evaluation order for constants set on explicit objects has been made consistent with single attribute assignment evaluation order. With this code: ```ruby foo::BAR = baz ``` `foo` is now called before `baz`. Similarly, for multiple assignments to constants, left-to-right evaluation order is used. With this code: ```ruby foo1::BAR1, foo2::BAR2 = baz1, baz2 ``` The following evaluation order is now used: 1. `foo1` 2. `foo2` 3. `baz1` 4. `baz2` [[Bug #15928]] * The find pattern is no longer experimental. [[Feature #18585]] * Methods taking a rest parameter (like `*args`) and wishing to delegate keyword arguments through `foo(*args)` must now be marked with `ruby2_keywords` (if not already the case). In other words, all methods wishing to delegate keyword arguments through `*args` must now be marked with `ruby2_keywords`, with no exception. This will make it easier to transition to other ways of delegation once a library can require Ruby 3+. Previously, the `ruby2_keywords` flag was kept if the receiving method took `*args`, but this was a bug and an inconsistency. A good technique to find potentially missing `ruby2_keywords` is to run the test suite, find the last method which must receive keyword arguments for each place where the test suite fails, and use `puts nil, caller, nil` there. Then check that each method/block on the call chain which must delegate keywords is correctly marked with `ruby2_keywords`. [[Bug #18625]] [[Bug #16466]] ```ruby def target(**kw) end # Accidentally worked without ruby2_keywords in Ruby 2.7-3.1, ruby2_keywords # needed in 3.2+. Just like (*args, **kwargs) or (...) would be needed on # both #foo and #bar when migrating away from ruby2_keywords. ruby2_keywords def bar(*args) target(*args) end ruby2_keywords def foo(*args) bar(*args) end foo(k: 1) ``` ## Performance improvements ### YJIT * YJIT now supports both x86-64 and arm64/aarch64 CPUs on Linux, MacOS, BSD and other UNIX platforms. * This release brings support for Mac M1/M2, AWS Graviton and Raspberry Pi 4 ARM64 processors. * Building YJIT requires Rust 1.58.0+. [[Feature #18481]] * In order to ensure that CRuby is built with YJIT, please install rustc >= 1.58.0 and run `./configure` with `--enable-yjit`. * Please reach out to the YJIT team should you run into any issues. * Physical memory for JIT code is lazily allocated. Unlike Ruby 3.1, the RSS of a Ruby process is minimized because virtual memory pages allocated by `--yjit-exec-mem-size` will not be mapped to physical memory pages until actually utilized by JIT code. * Introduce Code GC that frees all code pages when the memory consumption by JIT code reaches `--yjit-exec-mem-size`. * RubyVM::YJIT.runtime_stats returns Code GC metrics in addition to existing `inline_code_size` and `outlined_code_size` keys: `code_gc_count`, `live_page_count`, `freed_page_count`, and `freed_code_size`. * Most of the statistics produced by RubyVM::YJIT.runtime_stats are now available in release builds. * Simply run ruby with `--yjit-stats` to compute stats (incurs some run-time overhead). * YJIT is now optimized to take advantage of object shapes. [[Feature #18776]] * Take advantage of finer-grained constant invalidation to invalidate less code when defining new constants. [[Feature #18589]] ### MJIT * The MJIT compiler is re-implemented in Ruby as a standard library `mjit`. * MJIT compiler is executed under a forked Ruby process instead of doing it in a native thread called MJIT worker. [[Feature #18968]] * As a result, Microsoft Visual Studio (MSWIN) is no longer supported. * MinGW is no longer supported. [[Feature #18824]] * Rename `--mjit-min-calls` to `--mjit-call-threshold`. * Change default `--mjit-max-cache` back from 10000 to 100. ### PubGrab * Bundler 2.4 now uses [PubGrab](https://github.com/jhawthorn/pub_grub) resolver instead of [Molinillo](https://github.com/CocoaPods/Molinillo). * PubGrab is the next generation solving algorithm used by `pub` package manager for the Dart programming language. * You may get different resolution result after this change. Please report such cases to [RubyGems/Bundler issues](https://github.com/rubygems/rubygems/issues) * RubyGems still uses Molinillo resolver in Ruby 3.2. We plan to replace it with PubGrab in the future. ## Other notable changes since 3.1 * Hash * Hash#shift now always returns nil if the hash is empty, instead of returning the default value or calling the default proc. [[Bug #16908]] * MatchData * MatchData#byteoffset has been added. [[Feature #13110]] * Module * Module.used_refinements has been added. [[Feature #14332]] * Module#refinements has been added. [[Feature #12737]] * Module#const_added has been added. [[Feature #17881]] * Proc * Proc#dup returns an instance of subclass. [[Bug #17545]] * Proc#parameters now accepts lambda keyword. [[Feature #15357]] * Refinement * Refinement#refined_class has been added. [[Feature #12737]] * RubyVM::AbstractSyntaxTree * Add `error_tolerant` option for `parse`, `parse_file` and `of`. [[Feature #19013]] * Set * Set is now available as a builtin class without the need for `require "set"`. [[Feature #16989]] It is currently autoloaded via the `Set` constant or a call to `Enumerable#to_set`. * String * String#byteindex and String#byterindex have been added. [[Feature #13110]] * Update Unicode to Version 15.0.0 and Emoji Version 15.0. [[Feature #18639]] (also applies to Regexp) * String#bytesplice has been added. [[Feature #18598]] * Struct * A Struct class can also be initialized with keyword arguments without `keyword_init: true` on `Struct.new` [[Feature #16806]] ## Compatibility issues Note: Excluding feature bug fixes. ### Removed constants The following deprecated constants are removed. * `Fixnum` and `Bignum` [[Feature #12005]] * `Random::DEFAULT` [[Feature #17351]] * `Struct::Group` * `Struct::Passwd` ### Removed methods The following deprecated methods are removed. * `Dir.exists?` [[Feature #17391]] * `File.exists?` [[Feature #17391]] * `Kernel#=~` [[Feature #15231]] * `Kernel#taint`, `Kernel#untaint`, `Kernel#tainted?` [[Feature #16131]] * `Kernel#trust`, `Kernel#untrust`, `Kernel#untrusted?` [[Feature #16131]] ## Stdlib compatibility issues ### No longer bundle 3rd party sources * We no longer bundle 3rd party sources like `libyaml`, `libffi`. * libyaml source has been removed from psych. You may need to install `libyaml-dev` with Ubuntu/Debian platfrom. The package name is different for each platform. * Bundled libffi source is also removed from `fiddle` * Psych and fiddle supported static builds with specific versions of libyaml and libffi sources. You can build psych with libyaml-0.2.5 like this: ```bash $ ./configure --with-libyaml-source-dir=/path/to/libyaml-0.2.5 ``` And you can build fiddle with libffi-3.4.4 like this: ```bash $ ./configure --with-libffi-source-dir=/path/to/libffi-3.4.4 ``` [[Feature #18571]] ## C API updates ### Updated C APIs The following APIs are updated. * PRNG update `rb_random_interface_t` updated and versioned. Extension libraries which use this interface and built for older versions. Also `init_int32` function needs to be defined. ### Removed C APIs The following deprecated APIs are removed. * `rb_cData` variable. * "taintedness" and "trustedness" functions. [[Feature #16131]] ### Standard library updates * The following default gems are updated. * RubyGems 3.4.0.dev * benchmark 0.2.1 * bigdecimal 3.1.3 * bundler 2.4.0.dev * cgi 0.3.6 * date 3.3.0 * delegate 0.3.0 * did_you_mean 1.6.2 * digest 3.1.1 * drb 2.1.1 * erb 4.0.2 * error_highlight 0.5.1 * etc 1.4.1 * fcntl 1.0.2 * fiddle 1.1.1 * fileutils 1.7.0 * forwardable 1.3.3 * getoptlong 0.2.0 * io-console 0.5.11 * io-nonblock 0.2.0 * io-wait 0.3.0.pre * ipaddr 1.2.5 * irb 1.5.1 * json 2.6.2 * logger 1.5.2 * mutex_m 0.1.2 * net-http 0.3.1 * net-protocol 0.2.0 * nkf 0.1.2 * open-uri 0.3.0 * openssl 3.1.0.pre * optparse 0.3.0 * ostruct 0.5.5 * pathname 0.2.1 * pp 0.4.0 * pstore 0.1.2 * psych 5.0.0 * racc 1.6.1 * rdoc 6.5.0 * reline 0.3.1 * resolv 0.2.2 * securerandom 0.2.1 * set 1.0.3 * stringio 3.0.3 * syntax_suggest 1.0.1 * timeout 0.3.1 * tmpdir 0.1.3 * tsort 0.1.1 * un 0.2.1 * uri 0.12.0 * win32ole 1.8.9 * zlib 3.0.0 * The following bundled gems are updated. * minitest 5.16.3 * power_assert 2.0.2 * test-unit 3.5.5 * net-ftp 0.2.0 * net-imap 0.3.1 * net-pop 0.1.2 * net-smtp 0.3.3 * rbs 2.8.1 * typeprof 0.21.3 * debug 1.7.0 See [NEWS](https://github.com/ruby/ruby/blob/v3_2_0_rc1/NEWS.md) or [commit logs](https://github.com/ruby/ruby/compare/v3_1_0...v3_2_0_rc1) for more details. With those changes, [2846 files changed, 203950 insertions(+), 127153 deletions(-)](https://github.com/ruby/ruby/compare/v3_1_0...v3_2_0_rc1#file… since Ruby 3.1.0! ## Download * <https://cache.ruby-lang.org/pub/ruby/3.2/ruby-3.2.0-rc1.tar.gz> SIZE: 20253652 SHA1: 9b45af61ef1ae3c21ab88d7c9e30b80060116ac3 SHA256: 3bb9760c1ac1b66416aaa4899809f6ccd010e57038eaaeca19a383fd56275dac SHA512: 798157d785ebae94cb128d3c134fa35e0e90c654972e531cb6562823042f3fb68a270226f7b1cf0c42572ef2b1488a1a3e44f88389ad2a6f9ca4b280a2a8e759 * <https://cache.ruby-lang.org/pub/ruby/3.2/ruby-3.2.0-rc1.tar.xz> SIZE: 14934012 SHA1: 5576e304786d466410f27a345dc1cb66f2c773f6 SHA256: 0d45b3af14e84337882a2021235a091ae5dcfc0baaf31dccc479b71d96dd07bc SHA512: d38fcb1e09eb9984f3b2347e65ae7406129c2578d068a25d33b5b4f021ec3b567a9abe56c2acbec6d07a3c2b4bc7b485dbd330cbfbb3a96350f60a2bb94d016e * <https://cache.ruby-lang.org/pub/ruby/3.2/ruby-3.2.0-rc1.zip> SIZE: 24473024 SHA1: 8fdc85363ce61e0b8f04da36e709d49028d04a75 SHA256: 7ff32473be108534548e401aaa9092c37a27f73323ea4091c33901c714c87ee5 SHA512: 07adf6a9c89fdcf420e7b131f40f2b1f4aca036aa6f28539ade26ca552f84a75e0698f77a8b774d2ea52b8c756c4982ef319bda5afa786c081a31dd9873c5ef7 ## What is Ruby Ruby was first developed by Matz (Yukihiro Matsumoto) in 1993, and is now developed as Open Source. It runs on multiple platforms and is used all over the world especially for web development. [Feature #12005]: https://bugs.ruby-lang.org/issues/12005 [Feature #12655]: https://bugs.ruby-lang.org/issues/12655 [Feature #12737]: https://bugs.ruby-lang.org/issues/12737 [Feature #13110]: https://bugs.ruby-lang.org/issues/13110 [Feature #14332]: https://bugs.ruby-lang.org/issues/14332 [Feature #15231]: https://bugs.ruby-lang.org/issues/15231 [Feature #15357]: https://bugs.ruby-lang.org/issues/15357 [Bug #15928]: https://bugs.ruby-lang.org/issues/15928 [Feature #16131]: https://bugs.ruby-lang.org/issues/16131 [Bug #16466]: https://bugs.ruby-lang.org/issues/16466 [Feature #16806]: https://bugs.ruby-lang.org/issues/16806 [Bug #16889]: https://bugs.ruby-lang.org/issues/16889 [Bug #16908]: https://bugs.ruby-lang.org/issues/16908 [Feature #16989]: https://bugs.ruby-lang.org/issues/16989 [Feature #17351]: https://bugs.ruby-lang.org/issues/17351 [Feature #17391]: https://bugs.ruby-lang.org/issues/17391 [Bug #17545]: https://bugs.ruby-lang.org/issues/17545 [Feature #17881]: https://bugs.ruby-lang.org/issues/17881 [Feature #18639]: https://bugs.ruby-lang.org/issues/18639 [Feature #18159]: https://bugs.ruby-lang.org/issues/18159 [Feature #18351]: https://bugs.ruby-lang.org/issues/18351 [Feature #18481]: https://bugs.ruby-lang.org/issues/18481 [Bug #18487]: https://bugs.ruby-lang.org/issues/18487 [Feature #18571]: https://bugs.ruby-lang.org/issues/18571 [Feature #18585]: https://bugs.ruby-lang.org/issues/18585 [Feature #18589]: https://bugs.ruby-lang.org/issues/18589 [Feature #18598]: https://bugs.ruby-lang.org/issues/18598 [Bug #18625]: https://bugs.ruby-lang.org/issues/18625 [Bug #18633]: https://bugs.ruby-lang.org/issues/18633 [Feature #18685]: https://bugs.ruby-lang.org/issues/18685 [Feature #18776]: https://bugs.ruby-lang.org/issues/18776 [Bug #18782]: https://bugs.ruby-lang.org/issues/18782 [Feature #18788]: https://bugs.ruby-lang.org/issues/18788 [Feature #18809]: https://bugs.ruby-lang.org/issues/18809 [Bug #19100]: https://bugs.ruby-lang.org/issues/19100 [Bug #19013]: https://bugs.ruby-lang.org/issues/19013

1 0

[ruby-core:111217] [Ruby master Feature#18639] Update Unicode data to Unicode Version 15.0.0
by duerst 06 Dec '22

06 Dec '22

Issue #18639 has been updated by duerst (Martin Dürst). Status changed from Open to Closed Completed with commits f82a38be2616 to 68bb6bfc35e8. ---------------------------------------- Feature #18639: Update Unicode data to Unicode Version 15.0.0 https://bugs.ruby-lang.org/issues/18639#change-100508 * Author: duerst (Martin Dürst) * Status: Closed * Priority: Normal * Assignee: duerst (Martin Dürst) * Target version: 3.2 ---------------------------------------- Unicode Version 15.0.0 is currently in alpha. See the announcement at http://blog.unicode.org/2022/02/unicode-150-alpha-review.html. At this time, we cannot test this, because not all necessary data files are available yet. The beta period is scheduled to start in late May, 2022. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111216] [Ruby master Feature#18980] Re-reconsider numbered parameters: `it` as a default block parameter
by maedi (Maedi Prichard) 06 Dec '22

06 Dec '22

Issue #18980 has been updated by maedi (Maedi Prichard). I see that `$.` is already a <a href="https://docs.ruby-lang.org/en/2.4.0/globals_rdoc.html">pre-defined variable</a> which would make `$.method_name` difficult to parse. Then `_$` looks a little bit too close to the pre-defined variable `$_`. Though I still like `_@`. Can anyone think of a solution? Anything is better than `_1`. I personally like `@` and `it` and `this` and `that` but there always seems to be some conflict with existing variables and methods. What about `$this` or `$it`? If someone somewhere ever named their global variable `$it` and used it in a block then I'm sure they would forgive us, if this unlikely situation ever happened at all. ```ruby [1, 2, 3].each { puts $it } ``` ---------------------------------------- Feature #18980: Re-reconsider numbered parameters: `it` as a default block parameter https://bugs.ruby-lang.org/issues/18980#change-100507 * Author: k0kubun (Takashi Kokubun) * Status: Open * Priority: Normal ---------------------------------------- ## Problem Numbered parameters (`_1`, `_2`, ...) look like unused local variables and I don't feel motivated to use them, even though I need this feature very often and always come up with `_1`. ```rb [1, 2, 3].each { puts _1 } ``` I have barely used it in the last 2~3 years because it looks like a compromised syntax. I even hesitate to use it on IRB. ### Why I don't use `_1` I'm not clever enough to remember the order of parameters. Therefore, when a block has multiple parameters, I'd always want to name those parameters because which is `_1` or `_2` is not immediately obvious. Thus I would use this feature only when a block takes a single argument, which is actually pretty common. If I use `_1`, it feels like there might be a second argument, and you might waste time to think about `_2`, even if `_2` doesn't exist, which is a cognitive overhead. If you use `it`, it kinda implies there's only a single argument, so you don't need to spend time remembering whether `_2` exists or not. It is important for me that there's no number in `it`. ## Proposal Hoping to introduce `it` as an alternative to `_1` later, experiment with warning `#it` method calls without any arguments or blocks. If nobody sees serious problems after some warning period, we'll implement `it` as follows: ### Specification ```rb [1, 2, 3].each { puts it } ``` `it`s behavior should be as close to `_1` as possible. `it` should treat array arguments in the same way as `_1`. `it` doesn't work in a block when an ordinary parameter is defined. `it` is implemented as a special case of `getlocal` insn, not a method. `it` without an argument is considered `_1` or a normal local variable if defined. `it` is considered a method call only when it has any positional/keyword/block arguments. ## Past discussions * [Feature #4475] default variable name for parameter: Proposed `it`, and merged as `@1`. * 2019/03/13: [DevelopersMeeting20190311Japan](https://docs.google.com/document/d/e/2PACX-… * 2019/04/17: [DevelopersMeeting20190417Japan](https://docs.google.com/document/d/1hw6Xca8… * 2019/04/20: [Ruby Committers vs the World](https://youtu.be/5eAXAUTtNYU?t=3118) * [Feature #15723] Reconsider numbered parameters: Renamed `@1` to `_1`. * 2019/08/29: [DevelopersMeeting20190829Japan](https://docs.google.com/document/d/1XypDO1c… * [Feature #15897] `it` as a default block parameter: Proposed `it`, and got closed because `_1` was merged. ### Compatibility `it` has not necessarily been rejected by Matz; he just said [it's difficult to keep compatibility](https://bugs.ruby-lang.org/issues/4475#note-6) and [`it` or `this` _could_ break existing code](https://bugs.ruby-lang.org/issues/15723#note-2). It feels like everybody thinks `it` is the most beautiful option but is not sure if `it` breaks compatibility. But, in reality, does `it`? The following cases have been discussed: * `it` method, most famously in RSpec: You almost always pass a positional and/or block argument to RSpec's `it`, so the conflict is avoided with my proposal. You virtually never use a completely naked `it` ([comment](https://bugs.ruby-lang.org/issues/15897#note-29)) * `it` local variable: With the specification in my proposal, the existing code can continue to work if we consider `it` as a local variable when defined. With the specification in my proposal, existing code seems to break if and only if you call a method `#it` without an argument. But it seems pretty rare (reminder: a block given to an RSpec test case is also an argument). It almost feels like people are too afraid of compatibility problems that barely exist or have not really thought about options to address them. Also, you could always experiment with just showing warnings, which doesn't break any compatibility. Even if it takes 2~3 years of a warning period, I'd be happy to use that in 3 years. ### Confusion We should separately discuss incompatible cases and "works but confusing" cases. Potential confusion points: * RSpec's `it "tests something" do ... end` vs `it` inside the `do ... end` * `it` could be a local variable or `_1`, depending on the situation My two cents: You'd rarely need to write `it` directly under RSpec's `it` block, and you would just name a block argument for that case. In a nested block under a test case, I don't think you'd feel `it` is RSpec's. When you use a local variable `it = 1`, you'd use the local variable in a very small scope or few lines because otherwise, it'd be very hard to figure out what the local variable has anyway. So you'd likely see the assignment `it = 1` near the use of the local variable and you could easily notice `it` is not `_1`. If not, such code would be confusing and fragile even without this feature. The same applies when `it` is a method/block argument. I believe it wouldn't be as confusing as some people think, and you can always choose to not use `it` in places where `it` is confusing. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111215] [Ruby master Bug#19007] Unicode tables differences from Unicode.org 14.0 data
by duerst 06 Dec '22

06 Dec '22

Issue #19007 has been updated by duerst (Martin Dürst). The wrong properties were fixed for version 14.0.0 with commit e31d645. This issue should stay open until we are sure what caused the wrong properties in the first place. ---------------------------------------- Bug #19007: Unicode tables differences from Unicode.org 14.0 data https://bugs.ruby-lang.org/issues/19007#change-100505 * Author: nobu (Nobuyoshi Nakada) * Status: Open * Priority: Normal * Assignee: duerst (Martin Dürst) * Target version: 3.2 * ruby -v: 3.2.0 6898984f1cd * Backport: 2.7: DONTNEED, 3.0: DONTNEED, 3.1: DONTNEED ---------------------------------------- I found the header in Unicode Emoji 14.0 data files had changed slightly (and again at 15.0), but `enc/unicode/case-folding.rb` didn't follow it. Then I fixed it and rebuilt the headers under `enc/unicode/14.0.0`, `name2ctype.h` had diffences from the master, as bellow. `CR_Lower`, `CR_Cased` and `CR_Other_Lowercase` just seem misses in the previous operation, and no problems. But U+11720..U+11721 in `CR_Grapheme_Cluster_Break_SpacingMark` is absent in the original data of the Unicode.org. According to @naruse's investigation, it was removed at the commit [Update to Unicode 14.0.0], while U+11720 is still SpacingMark in the latest https://www.unicode.org/reports/tr29/. [Update to Unicode 14.0.0]: https://github.com/latex3/unicode-data/commit/5570040ac8a30e2c2ca4912d415ec… ```diff diff --git a/enc/unicode/14.0.0/name2ctype.h b/enc/unicode/14.0.0/name2ctype.h index 99a3eeca190..f49e5cd7273 100644 --- a/enc/unicode/14.0.0/name2ctype.h +++ b/enc/unicode/14.0.0/name2ctype.h @@ -1565,7 +1565,7 @@ static const OnigCodePoint CR_Graph[] = { /* 'Lower': [[:Lower:]] */ static const OnigCodePoint CR_Lower[] = { - 664, + 668, 0x0061, 0x007a, 0x00aa, 0x00aa, 0x00b5, 0x00b5, @@ -2196,6 +2196,10 @@ static const OnigCodePoint CR_Lower[] = { 0x105a3, 0x105b1, 0x105b3, 0x105b9, 0x105bb, 0x105bc, + 0x10780, 0x10780, + 0x10783, 0x10785, + 0x10787, 0x107b0, + 0x107b2, 0x107ba, 0x10cc0, 0x10cf2, 0x118c0, 0x118df, 0x16e60, 0x16e7f, @@ -12651,7 +12655,7 @@ static const OnigCodePoint CR_Math[] = { /* 'Cased': Derived Property */ static const OnigCodePoint CR_Cased[] = { - 151, + 155, 0x0041, 0x005a, 0x0061, 0x007a, 0x00aa, 0x00aa, @@ -12763,6 +12767,10 @@ static const OnigCodePoint CR_Cased[] = { 0x105a3, 0x105b1, 0x105b3, 0x105b9, 0x105bb, 0x105bc, + 0x10780, 0x10780, + 0x10783, 0x10785, + 0x10787, 0x107b0, + 0x107b2, 0x107ba, 0x10c80, 0x10cb2, 0x10cc0, 0x10cf2, 0x118a0, 0x118df, @@ -22615,7 +22623,7 @@ static const OnigCodePoint CR_Extender[] = { /* 'Other_Lowercase': Binary Property */ static const OnigCodePoint CR_Other_Lowercase[] = { - 20, + 24, 0x00aa, 0x00aa, 0x00ba, 0x00ba, 0x02b0, 0x02b8, @@ -22636,6 +22644,10 @@ static const OnigCodePoint CR_Other_Lowercase[] = { 0xa770, 0xa770, 0xa7f8, 0xa7f9, 0xab5c, 0xab5f, + 0x10780, 0x10780, + 0x10783, 0x10785, + 0x10787, 0x107b0, + 0x107b2, 0x107ba, }; /* CR_Other_Lowercase */ /* 'Other_Uppercase': Binary Property */ @@ -37049,7 +37061,7 @@ static const OnigCodePoint CR_Grapheme_Cluster_Break_Extend[] = { /* 'Grapheme_Cluster_Break_SpacingMark': Grapheme_Cluster_Break=SpacingMark */ static const OnigCodePoint CR_Grapheme_Cluster_Break_SpacingMark[] = { - 161, + 160, 0x0903, 0x0903, 0x093b, 0x093b, 0x093e, 0x0940, @@ -37183,7 +37195,6 @@ static const OnigCodePoint CR_Grapheme_Cluster_Break_SpacingMark[] = { 0x116ac, 0x116ac, 0x116ae, 0x116af, 0x116b6, 0x116b6, - 0x11720, 0x11721, 0x11726, 0x11726, 0x1182c, 0x1182e, 0x11838, 0x11838, ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111214] [Ruby master Bug#19115] RubyGems fails to detect OpenSSL in --with-static-linked-ext builds
by alanwu (Alan Wu) 05 Dec '22

05 Dec '22

Issue #19115 has been updated by alanwu (Alan Wu). thomthom (Thomas Thomassen) wrote in #note-8: > Will this patch be pack-ported to the 3.1 branch? It's up to the branch maintainer, @nagachika, to decide. ---------------------------------------- Bug #19115: RubyGems fails to detect OpenSSL in --with-static-linked-ext builds https://bugs.ruby-lang.org/issues/19115#change-100504 * Author: thomthom (Thomas Thomassen) * Status: Closed * Priority: Normal * ruby -v: 3.1.2, 3.2.0dev * Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN ---------------------------------------- Related discussion: https://bugs.ruby-lang.org/issues/18876 We are seeing OpenSSL failing to autoload with the Ruby build we've been using. (We first observed this when using `Gem.install` that relies on autoload of OpenSSL). Our last working build was Ruby 2.7.2 with similar config. This causes RubyGems' `HAVE_OPENSSL` constant to be incorrectly initialized, and subsequent calls to `Gem.install` fails. There might be other scenarios that fail as a result of that, but we've not managed to identified that. ``` module Gem HAVE_OPENSSL = defined? OpenSSL::SSL # :nodoc: ``` Our Ruby 3.1.2 config: ``` '--prefix=/Users/user/.conan/data/ruby/3.1.2/sketchup/stable/build/bd95825b99dcb274d0e577fbdc953653a9ea0fb9' '--with-openssl-dir=/Users/user/.conan/data/openssl/1.1.1q/sketchup/stable/package/93ae0b0e7eebe0611c04d3e0d9bbf49fbce92332' '--with-libyaml-dir=/Users/user/.conan/data/libyaml/0.2.5/sketchup/stable/package/a56a950abed2e10dbdc26845400f0a034d97c454' '--disable-install-doc' '--disable-install-rdoc' '--enable-shared' '--enable-load-relative' '--with-static-linked-ext' '--without-debug' '--without-gdbm' '--without-gettext' '--without-irb' '--without-mkmf' '--without-rdoc' '--without-readline' '--without-tk' '--bindir=${prefix}/bin' '--sbindir=${prefix}/bin' '--libexecdir=${prefix}/bin' '--libdir=${prefix}/lib' '--includedir=${prefix}/include' '--oldincludedir=${prefix}/include' '--datarootdir=${prefix}/share' 'cflags=-mmacosx-version-min=10.14 -fdeclspec' 'cxxflags=-mmacosx-version-min=10.14 -fdeclspec' 'LDFLAGS=-mmacosx-version-min=10.14 -fdeclspec' ``` We also tested with latest build from master (November 8th 2022): ``` ./ruby -ve 'p RbConfig::CONFIG["configure_args"]' ruby 3.2.0dev (2022-11-07T19:35:21Z master b14f133054) [x86_64-darwin20] " '--prefix=/Users/vmehta/ruby/ruby-master/' '--with-openssl-dir=/Users/vmehta/.conan/data/openssl/1.1.1q/sketchup/stable/package/f2d937af1fa19d5fc4095849a65d1927e9e75ae7/' '--with-libyaml-dir=/Users/vmehta/.conan/data/libyaml/0.2.5/sketchup/stable/package/3fc084e254210603a5c5aece184b2d45e2509b30' '--disable-install-doc' '--disable-install-rdoc' '--enable-shared' '--enable-load-relative' '--with-static-linked-ext' '--without-debug' '--without-gdbm' '--without-gettext' '--without-irb' '--without-mkmf' '--without-rdoc' '--without-readline' '--without-tk'" ``` Using an RVM of Ruby 3.1.2 this appear to work as expected. But using out configuration, that we've used for the Ruby 2.x versions are now failing. We haven't been able to figure out the reason for this. -- https://bugs.ruby-lang.org/

1 0

[ruby-core:111213] [Ruby master Feature#16122] Data: simple immutable value object
by zverok (Victor Shepelev) 05 Dec '22

05 Dec '22

Issue #16122 has been updated by zverok (Victor Shepelev). @ston1x I understand where you are coming from (make the declaration more homogenous for the sake of IDE's convenience), and I don't think that the goal is meaningless, but in this case, it will lead to severe complication of semantics/implementation: what's the state of the object between `Ticket < Data` and `attr`? What if `attr` never declared? What if it used several times? What if it used again in the descendant of `Ticket`? This kind of complication doesn't seem worth the gain, for me. It is up to IDE to handle `Data`, it seems (as far as I know, say, YARD documentation system has a handling for `Struct` descendants, and it isn't impossible for other tools, too). Especially considering that a lot of `Data` usage would probably be just short one-line declarations and ideally, IDE that wants to autocomplete available attributes should understand them anyway, so... ---------------------------------------- Feature #16122: Data: simple immutable value object https://bugs.ruby-lang.org/issues/16122#change-100503 * Author: zverok (Victor Shepelev) * Status: Closed * Priority: Normal * Assignee: zverok (Victor Shepelev) ---------------------------------------- ## Intro (original theoretical part of the proposal) **Value Object** is a useful concept, introduced by Martin Fowler ([his post](https://martinfowler.com/bliki/ValueObject.html), [Wikipedia Entry](https://en.wikipedia.org/wiki/Value_object)) with the following properties (simplifying the idea): * representing some relatively simple data; * immutable; * compared by type & value; * nicely represented. Value objects are super-useful especially for defining APIs, their input/return values. Recently, there were some movement towards using more immutability-friendly approach in Ruby programming, leading to creating several discussions/libraries with value objects. For example, [Tom Dalling's gem](https://github.com/tomdalling/value_semantics), [Good Ruby Value object convention](https://github.com/zverok/good-value-object) (disclaimer: the latter is maintained by yours truly). I propose to introduce **native value objects** to Ruby as a core class. **Why not a gem?** * I believe that concept is that simple, that nobody *will even try* to use a gem for representing it with, unless the framework/library used already provides one. * Potentially, a lot of standard library (and probably even core) APIs could benefit from the concept. **Why `Struct` is not enough** Core `Struct` class is "somewhat alike" value-object, and frequently used instead of one: it is compared by value and consists of simple attributes. On the other hand, `Struct` is: * mutable; * collection-alike (defines `to_a` and is `Enumerable`); * dictionary-alike (has `[]` and `.values` methods). The above traits somehow erodes the semantics, making code less clear, especially when duck-typing is used. For example, this code snippet shows why `to_a` is problematic: ```ruby Result = Struct.new(:success, :content) # Now, imagine that other code assumes `data` could be either Result, or [Result, Result, Result] # So, ... data = Result.new(true, 'it is awesome') Array(data) # => expected [Result(true, 'it is awesome')], got [true, 'it is awesome'] # or... def foo(arg1, arg2 = nil) p arg1, arg2 end foo(*data) # => expected [Result(true, 'it is awesome'), nil], got [true, 'it is awesome'] ``` Having `[]` and `each` defined on something that is thought as "just value" can also lead to subtle bugs, when some method checks "if the received argument is collection-alike", and value object's author doesn't thought of it as a collection. ## `Data` class: consensus proposal/implementation, Sep 2022 * Name: `Data` * PR: https://github.com/ruby/ruby/pull/6353 * Example docs rendering: https://zverok.space/ruby-rdoc/Data.html * Full API: * `Data::define` creates a new Data class; accepts only symbols (no `keyword_init:`, no "first argument is the class name" like the `Struct` had) * `<data_class>::members`: list of member names * `<data_class>::new`: accepts either keyword or positional arguments (but not mix); converts all of the to keyword args; raises `ArgumentError` if there are **too many positional arguments** * `#initialize`: accepts only keyword arguments; the default implementation raises `ArgumentError` on missing or extra arguments; it is easy to redefine `initialize` to provide defaults or handle extra args. * `#==` * `#eql?` * `#inspect`/`#to_s` (same representation) * `#deconstruct` * `#deconstruct_keys` * `#hash` * `#members` * `#to_h` ## Historical original proposal * Class name: `Struct::Value`: lot of Rubyists are used to have `Struct` as a quick "something-like-value" drop-in, so alternative, more strict implementation, being part of `Struct` API, will be quite discoverable; *alternative: just `Value`* * Class API is copying `Struct`s one (most of the time -- even reuses the implementation), with the following exceptions *(note: the immutability is **not** the only difference)*: * Not `Enumerable`; * Immutable; * Doesn't think of itself as "almost hash" (doesn't have `to_a`, `values` and `[]` methods); * Can have empty members list (fun fact: `Struct.new('Foo')` creating member-less `Struct::Foo`, is allowed, but `Struct.new()` is not) to allow usage patterns like: ```ruby class MyService Success = Struct::Value.new(:results) NotFound = Struct::Value.new end ``` `NotFound` here, unlike, say, `Object.new.freeze` (another pattern for creating "empty typed value object"), has nice inspect `#<value NotFound>`, and created consistently with the `Success`, making the code more readable. And if it will evolve to have some attributes, the code change would be easy. **Patch is provided** [Sample rendered RDoc documentation](https://zverok.github.io/ruby-rdoc/Struct-Value.html) ---Files-------------------------------- struct_value.patch (18.6 KB) -- https://bugs.ruby-lang.org/

1 0