- ruby-talk - ml.ruby-lang.org

[ruby-talk:444660] [ANN] githubscore 1.0.1 Released
by Ryan Davis 26 May '25

26 May '25

githubscore version 1.0.1 has been released! * home: <https://github.com/seattlerb/githubscore> * rdoc: <http://docs.seattlerb.org/githubscore> githubscore provides a dashboard overview of the current state of your github issues and pull requests. Changes: ### 1.0.1 / 2025-05-26 * 1 bug fix: * Removed git_param and cleaned up client methods with simple call to %x(gh auth token)

1 0

[ruby-talk:444659] [ANN] github_contribs 2.0.1 Released
by Ryan Davis 26 May '25

26 May '25

github_contribs version 2.0.1 has been released! * home: <https://github.com/seattlerb/github_contribs> * rdoc: <http://docs.seattlerb.org/github_contribs> A simple commandline tool that downloads yearly contribution graphs from github and assembles them into a unified view. Changes: ### 2.0.1 / 2025-05-26 * 1 bug fix: * Unified and cleaned up code processing graphql query.

1 0

[ruby-talk:444658] [ANN] httpx 1.5.0 released
by Tiago Cardoso 16 May '25

16 May '25

httpx 1.5.0 has been released. ``` HTTPX.get("https://gitlab.com/honeyryderchuck/httpx <https://gitlab.com/honeyryderchuck/httpx>") ``` HTTPX is an HTTP client library for the Ruby programming language. Among its features, it supports: * HTTP/2 and HTTP/1.x protocol versions * Concurrent requests by default * Simple and chainable API * Proxy Support (HTTP(S), CONNECT tunnel, Socks4/4a/5) * Simple Timeout System * Lightweight by default (require what you need) And also: * Compression (gzip, deflate, brotli) * Streaming Requests * Authentication (Basic Auth, Digest Auth, AWS Sigv4) * Expect 100-continue * Multipart Requests * Cookies * HTTP/2 Server Push * H2C Upgrade * Automatic follow redirects * International Domain Names * GRPC * Circuit breaker * WebDAV * SSRF Filter * Response caching * HTTP/2 bidirectional streaming * QUERY HTTP verb * Datadog integration * Faraday integration * Webmock integration * Sentry integration Here are the updates since the last release: # 1.5.0 ## Features ### `:stream_bidi` plugin The `:stream_bidi` plugin enables bidirectional streaming support (an HTTP/2 only feature!). It builds on top of the `:stream` plugin, and uses its block-based syntax to process incoming frames, while allowing the user to pipe more data to the request (from the same, or another thread/fiber). ```ruby http = HTTPX.plugin(:stream_bidi) request = http.build_request( "POST", "https://your-origin.com/stream", headers: { "content-type" => "application/x-ndjson" }, body: ["{\"message\":\"started\"}\n"] ) chunks = [] response = http.request(request, stream: true) Thread.start do response.each do |chunk| handle_data(chunk) end end # now send data... request << "{\"message\":\"foo\"}\n" request << "{\"message\":\"bar\"}\n" # ... ``` You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Stream-Bidi ### `:query` plugin The `:query` plugin adds public methods supporting the `QUERY` HTTP verb: ```ruby http = HTTPX.plugin(:query) http.query("https://example.com/gquery", body: "foo=bar") # QUERY /gquery .... ``` You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Query this functionality was added as a plugin for explicit opt-in, as it's experimental (RFC for the new HTTP verb is still in draft). ### `:response_cache` plugin filesystem based store The `:response_cache` plugin supports setting the filesystem as the response cache store (instead of just storing them in memory, which is the default `:store`). ```ruby # cache store in the filesystem, writes to the temporary directory from the OS http = HTTPX.plugin(:response_cache, response_cache_store: :file_store) # if you want a separate location http = HTTPX.plugin(:response_cache).with(response_cache_store: HTTPX::Plugins::ResponseCache::FileStore.new("/path/to/dir")) ``` You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Response-Cache#:file_store ### `:close_on_fork` option A new option `:close_on_fork` can be used to ensure that a session object which may have open connections will not leak them in case the process is forked (this can be the case of `:persistent` plugin enabled sessions which have add usage before fork): ```ruby http = HTTPX.plugin(:persistent, close_on_fork: true) # http may have open connections here fork do # http has no connections here end ``` You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Pools#Fork-Safety . ### `:debug_redact` option The `:debug_redact` option will, when enabled, replace parts of the debug logs (enabled via `:debug` and `:debug_level` options) which may contain sensitive information, with the `"[REDACTED]"` placeholder. You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Debugging . ### `:max_connections` pool option A new `:max_connections` pool option (settable under `:pool_options`) can be used to defined the maximum number **overall** of connections for a pool ("in-transit" or "at-rest"); this complements, and supersedes when used, the already existing `:max_connections_per_origin`, which does the same per connection origin. ```ruby HTTPX.with(pool_options: { max_connections: 100 }) ``` You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Connection-Pools . ### Subplugins An enhancement to the plugins architecture, it allows plugins to define submodules ("subplugins") which are loaded if another plugin is in use, or is loaded afterwards. You can read more about it in https://honeyryderchuck.gitlab.io/httpx/wiki/Custom-Plugins#Subplugins . ## Improvements * `:persistent` plugin: several improvements around reconnections of failure: * reconnections will only happen for "connection broken" errors (and will discard reconnection on timeouts) * reconnections won't exhaust retries * `:response_cache` plugin: several improements: * return cached response if not stale, send conditional request otherwise (it was always doing the latter). * consider immutable (i.e. `"Cache-Control: immutable"`) responses as never stale. * `:datadog` adapter: decorate spans with more tags (header, kind, component, etc...) * timers operations have been improved to use more efficient algorithms and reduce object creation. ## Bugfixes * ensure that setting request timeouts happens before the request is buffered (the latter could trigger a state transition required by the former). * `:response_cache` plugin: fix `"Vary"` header handling by supporting a new plugin option, `:supported_vary_headers`, which defines which headers are taken into account for cache key calculation. * fixed query string encoded value when passed an empty hash to the `:query` param and the URL already contains query string. * `:callbacks` plugin: ensure the callbacks from a session are copied when a new session is derived from it (via a `.plugin` call, for example). * `:callbacks` plugin: errors raised from hostname resolution should bubble up to user code. * fixed connection coalescing selector monitoring in cases where the coalescable connecton is cloned, while other branches were simplified. * clear the connection write buffer in corner cases where the remaining bytes may be interpreted as GOAWAY handshake frame (and may cause unintended writes to connections already identified as broken). * remove idle connections from the selector when an error happens before the state changes (this may happen if the thread is interrupted during name resolution). ## Chore `httpx` makes extensive use of features introduced in ruby 3.4, such as `Module#set_temporary_name` for otherwise plugin-generated anonymous classes (improves debugging and issue reporting), or `String#append_as_bytes` for a small but non-negligible perf boost in buffer operations. It falls back to the previous behaviour when used with ruby 3.3 or lower. Also, and in preparation for the incoming ruby 3.5 release, dependency of the `cgi` gem (which will be removed from stdlib) was removed. # 1.4.4 ## Improvements * `:stream` plugin: response will now be partially buffered in order to i.e. inspect response status or headers on the response body without buffering the full response * this fixes an issue in the `down` gem integration when used with the `:max_size` option. * do not unnecessarily probe for connection liveness if no more requests are inflight, including failed ones. * when using persistent connections, do not probe for liveness right after reconnecting after a keep alive timeout. ## Bugfixes * `:persistent` plugin: do not exhaust retry attempts when probing for (and failing) connection liveness. * since the introduction of per-session connection pools, and consequentially due to the possibility of multiple inactive connections for the same origin being in the pool, which may have been terminated by the peer server, requests would fail before being able to establish a new connection. * prevent retrying to connect the TCP socket object when an SSLSocket object is already in place and connecting. # 1.4.3 ## Bugfixes * `webmock` adapter: reassign headers to signature after callbacks are called (these may change the headers before virtual send). * do not close request (and its body) right after sending, instead only on response close * prevents retries from failing under the `:retries` plugin * fixes issue when using `faraday-multipart` request bodies * retry request with HTTP/1 when receiving an HTTP/2 GOAWAY frame with `HTTP_1_1_REQUIRED` error code. * fix wrong method call on HTTP/2 PING frame with unrecognized code. * fix EOFError issues on connection termination for long running connections which may have already been terminated by peer and were wrongly trying to complete the HTTP/2 termination handshake. # 1.4.2 ## Bugfixes * faraday: use default reason when none is matched by Net::HTTP::STATUS_CODES * native resolver: keep sending DNS queries if the socket is available, to avoid busy loops on select * native resolver fixes for Happy Eyeballs v2 * do not apply resolution delay if the IPv4 IP was not resolved via DNS * ignore ALIAS if DNS response carries IP answers * do not try to query for names already awaiting answer from the resolver * make sure all types of errors are propagated to connections * make sure next candidate is picked up if receiving NX_DOMAIN_NOT_FOUND error from resolver * raise error happening before any request is flushed to respective connections (avoids loop on non-actionable selector termination). * fix "NoMethodError: undefined method `after' for nil:NilClass", happening for requests flushed into persistent connections which errored, and were retried in a different connection before triggering the timeout callbacks from the previously-closed connection. ## Chore * Refactor of timers to allow for explicit and more performant single timer interval cancellation. * default log message restructured to include info about process, thread and caller. # 1.4.1 ## Bugfixes * several `datadog` integration bugfixes * only load the `datadog` integration when the `datadog` sdk is loaded (and not other gems that may define the `Datadog` module, like `dogstatsd`) * do not trace if datadog integration is loaded but disabled * distributed headers are now sent along (when the configuration is enabled, which it is by default) * fix for handling multiple `GOAWAY` frames coming from the server (node.js servers seem to send multiple frames on connection timeout) * fix regression for when a url is used with `httpx` which is not `http://` or `https://` (should raise `HTTPX::UnsupportedSchemaError`) * worked around `IO.copy_stream` which was emitting incorrect bytes for HTTP/2 requests which bodies larger than the maximum supported frame size. * multipart requests: make sure that a body declared as `Pathname` is opened for reading in binary mode. * `webmock` integration: ensure that request events are emitted (such as plugins and integrations relying in it, such as `datadog` and the OTel integration) * native resolver: do not propagate successful name resolutions for connections which were already closed. * native resolver: fixed name resolution stalling, in a multi-request to multi-origin scenario, when a resolution timeout would happen. ## Chore * refactor of the happy eyeballs and connection coalescing logic to not rely on callbacks, and instead on instance variable management (makes code more straightforward to read).

1 0

[ruby-talk:444657] [ANN] wxRuby3 1.5.4 released
by martin＠corino.nl 15 May '25

15 May '25

This upgrade release provides some fixes for potential problems and some useful enhancements. ** What's Changed ** * fix potential problems with optional keyword argument handling * add optional keyword arguments to Sizer classes * add array compatibility for GridBagSizer position and span values * update wxWidgets master branch compatibility to at least commit 1652d9882a7e8650d1c14c98c558dbbf7624b10b For more details see the original release announcement here: https://github.com/mcorino/wxRuby3/discussions/378

1 0

[ruby-talk:444656] [ANN] JRuby 10.0.0.1 Released
by Thomas E Enebo 07 May '25

07 May '25

The JRuby community is pleased to announce the release of JRuby 10.0.0.1. - Homepage: https://www.jruby.org/ - Download: https://www.jruby.org/download We’ve jumped to Ruby 3.4 compatibility and Java 21 minimum to bring you the best Ruby on JVM experience possible. We are confident this is the most compatible and stable major release we’ve ever had. Security jruby-openssl has been updated to 0.15.4, which re-enables hostname verification by default. This addresses CVE-2025-46551 and GHSA-72qj-48g4-5xgx. https://github.com/jruby/jruby-openssl/security/advisories/GHSA-72qj-48g4-5… -- blog: http://blog.enebo.com twitter: tom_enebo mail: tom.enebo(a)gmail.com

1 0

[ruby-talk:444655] [ANN] JRuby 9.4.12.1 Released
by Thomas E Enebo 07 May '25

07 May '25

The JRuby community is pleased to announce the release of JRuby 9.4.12.1. - Homepage: https://www.jruby.org/ - Download: https://www.jruby.org/download JRuby 9.4.12.x targets Ruby 3.1 compatibility. Security jruby-openssl has been updated to 0.15.4, which re-enables hostname verification by default. This addresses CVE-2025-46551 and GHSA-72qj-48g4-5xgx. https://github.com/jruby/jruby-openssl/security/advisories/GHSA-72qj-48g4-5… -- blog: http://blog.enebo.com twitter: tom_enebo mail: tom.enebo(a)gmail.com

1 0

[ruby-talk:444654] Made an MCP server that makes it easy to expose Ruby commands to an MCP client
by Miles Georgi 28 Apr '25

28 Apr '25

Hey hey! It uses a framework I wrote that I've mentioned here before. Here's a video code demo of it: https://youtu.be/_w3ZHdiJEGU And there's code examples in the repo here: https://github.com/foobara/mcp-connector I like how easy it is to just switch from exposing commands on the command line to an MCP server in the demo. Which is kind of the point of the framework. Anyways, figured I ought to mention it on this list in case somebody finds it to be of interest! Cheers! Miles

1 0

[ruby-talk:444653] [ANN] wxRuby3 1.5.3 released
by martin＠corino.nl 27 Apr '25

27 Apr '25

This upgrade release updates the targeted wxWidgets release to the new 3.2.8 release and some updates and fixes. ** What's Changed ** * update targeted wxWidgets release to 3.2.8 * fix Wx::Dialog sizer creation methods (thanks to @Randalphwa for reporting this) * update wxWidgets master branch compatibility to at least commit 9495129c5eda0b0a1147cf90f122408787dd4fde For more details see the original release announcement here: https://github.com/mcorino/wxRuby3/discussions/376

1 0

[ruby-talk:444652] [ANN ro-v4.4.0]
by ara.t.howard 23 Apr '25

23 Apr '25

TL;DR: ------ `ro` stands for `read only`, and it is the tiniest, best, headless cms. it lets you keep all your content in github, as god intended. it is one part cms, one part database, one part api, and one part magic. if you used a headless cms, it's like that, before they existed, except way better, and free. with `ro`, you can seperate your content from presentation, like a sane and decent human being. > silent code whispers > github's gentle, peaceful hush > simplicity reigns README ------ `ro` is has been in professional, production use for over a decade, powering many, many websites built by http://dojo4.com, and others. from static sites, to rails monoliths, to simple ruby sites, to javascript sites built on next.js, `ro` is the portable, simple, future-proof content system you always dreamed about then started to write but found out the web is a mess. with `ro`, your shit will be *clean*. --- to grok `ro` it is best to start with an example of some real content, for a real site. ```sh drawohara@drawohara.dev:ro[main] #=> tree public/ro/posts/almost-died-in-an-ice-cave/ public/ro/posts/almost-died-in-an-ice-cave/ ├── assets │ ├── image1.png │ ├── image2.png │ ├── image3.png │ ├── og.jpg │ └── purple-heart.jpg ├── attributes.yml └── body.md ``` in this example you can see a few things, regarding the layout of a `ro` directory: - `ro` content often, but is not required, to live in `public`. more on this below. - the essential layout is ```ruby @root = "ro" @collection = "posts" @id = "almost-died-in-an-ice-cave" "#{ @root }/#{ @collection }/#{ @id }" ``` if you learn best by example, you can examine the `ro` directory of my own website here -> https://github.com/ahoward/drawohara.io/tree/main/public/ro - several environment variables control how `ro` works, most notably ```ruby # this is the fs root of all ro content # Ro.root = ENV['RO_ROOT'] || './public/ro' # this is the url where ro content, especially images, will be expected to # live at when live Ro.url = ENV['RO_URL'] || '/ro' ``` more about this can be rtfm'd here -> https://github.com/ahoward/ro/blob/main/lib/ro.rb#L29-L55 because not having a repl sucks, so `ro` has one. you should too. ```sh # fire up the KONSOULLLLL! ~> ro console ./public/ro/ ``` ```ruby ro.posts.almost_died_in_an_ice_cave.attributes.keys #=> ["og", "body", "assets", "_meta"] ro.posts.almost_died_in_an_ice_cave.attributes.og #=> {"image"=>{"url"=>"/ro/posts/almost-died-in-an-ice-cave/assets/og.jpg"}, "title"=>"Almost Died In An Ice Cave", "description"=>"On April of 2024, I, along with 6 of my friends, dug for our lives to come out on the other side."} ro.posts.almost_died_in_an_ice_cave.attributes.body.slice(0,420) #=> "<div class=\"ro markdown\">\n <a href=\"#tl;dr;\">tl;dr;</a>\n\n<blockquote>\n in april, 2024, myself, and 6 brave men attempted to cross the harding\nicefield.\n\n in celebration of <a href=\" https://en.wikipedia.org/wiki/Harding_Icefield#History\">yule kilcher’s 1968 crossing</a>\n\n midway through our trip, at the point of no return, we were beseiged by a storm of storms.\n\n we dug shoulder to " ro.posts.almost_died_in_an_ice_cave.assets.first #=> "public/ro/posts/almost-died-in-an-ice-cave/assets/image1.png" ro.posts.almost_died_in_an_ice_cave.assets.first.url #=> "/ro/posts/almost-died-in-an-ice-cave/assets/image1.png" ``` __boom__ // **now we're cooking with gas!** serveral things will be obvious to the non-ai enabled observer: - every node has a hash of attributes - 'file' attributes are *rendered* based on file type - assets in rendered content are __url aware__ you can see the list of file types `ro` supports here -> https://github.com/ahoward/ro/blob/main/lib/ro/template.rb#L43-L63 if you can't build a website with just these... 🙊 [you've come to the wrong place!]( https://media0.giphy.com/media/v1.Y2lkPTc5MGI3NjExd2NpbmsxMHRxNnRsNjFzNWczN… ) --- now, about that rendering process... for any 'html-ish' type, links to relative assets, will be expanded such that images will be resolved to thier final deployment destination. eg. given __ro/posts/foo-bar/body.md__ containing the markdown ```markdown [linky](./assets/report.pdf) ![alty](./assets/pretty.png) ``` you will end up with html that looks like so: ```html <a href='/ro/posts/foo-bar/assets/report.pdf'>linky</a> <img src='/ro/posts/foo-bar/assets/pretty.png'>alty</a> ``` --- __OH MAN THAT SUX I DO NOT WANT MY IMAGES STORED IN GH!!!!__ *sit down... breathe...* and enable [git-lfs](https://git-lfs.com/) it used to be fragile but, since everyone the in the world is now checking in massive jupyter notebooks it 'just works' --- now, recall what we said about `public` and `RO_URL`? by default, this is is `/ro`... therefore, if we have: `./public/ro/posts/foobar/...' paths found under `public` are going to start with `/ro`... > are you tracking yet? also, if you do not host your `ro` directory under public (but why not? it *is* public content after all..), then you will need to set `RO_URL` to be the ultimate destination of your image deployment. this can be cloudinary, s3, whatever. it just needs to be the url prefix to whack in front of relative image urls. note - not only html has this 'expansion' applied, relative assets in your attributes will be expanded too, at any depth. eg. -> https://github.com/ahoward/ro/blob/main/lib/ro/methods.rb#L233-L260 this means code like this: ```yaml # file: public/ro/posts/foo-bar/attributes.yml og: image: ./assets/og.jpg ``` will 'just work'. of course, this assumes that 'public/ro/foo-bar/assets/og.jpg' exists! the code is rather robust here, and is not a simple string bashing approach. it's tight, and you can trust it. --- a bit about markdown... markdown is. the web. also AI, but i digress... if you aren't writing in markdown, you are probably writing `perl`... (nothing wrong with that btw!) but markdown has a lot of edge cases, not least of which syntax highlighting and bs css to deal with. `ro`, again, 'just works' here. - it uses github flavored markdown (gfm), extracts front-matter and folds it into `attributes`, auto-links stuff (gfm does not), and inlines the css styles for speed and so you don't have to eff with the css to render src code all pretty. see https://github.com/ahoward/ro/blob/main/lib/ro/template.rb#L117-L143 - you can set the gfm theme via the `RO_MD_THEME` ENV var. this supports anything [rouge](https://github.com/rouge-ruby/rouge) does. --- > __I HATE RUBY!!!! RAWR__ whatever. use javascript. `ro` is also a 'static cms api builder`. *WUT*? it can compile your entire content db into a static api of js, designed to be ultra, ultra, ultra easy to consume. no stupid graphql thing, no bullsxxx api_key, no vendor lock-in to prismic, dato, contentful, or some other extorsionist regime., just a lil `fetch` and you are __GTG BRO!__ you don't even have to render the stuff, it's pre-rendered html in the api ready to `dangerouslySetInnerHTM`! __(alsoCamelCaseMakeAPIHARDToReadWithEMPHASIS)__ you can see an example here -> https://github.com/ahoward/ro/tree/main/public/api/ro i won't explain more now except to say that all you need to do to make a js bundle is ```sh ~> ro build ``` and then look carefully, it makes it easy to 'grab everything stupid style' or to paginate client side. each collection has a `index.js` with everything, a `index-$pageno.js` with details about the next page, iff any, and of course, it produces an `index.json` file, complete with those gnarly *width* and *height* numbers you need to *fight FUOC* and layout shift. if you don't know what that means, probably use [wordpress]( https://drawohara.io/dojo4/archive/irish-dance-and-wordpress-the-soul-destr… ) lil detail about that link^, it is from *10 years ago*, when dojo4 was still running, and running on `ro`. --- one super comman pattern, is to add a build step to a github workflow, and then publish the js api via gh-pages. see an example here: https://github.com/ahoward/ro/blob/main/.github/workflows/gh-pages.yml __WUT!?!?!___ - your content is in github - you want to consume it in js - add a build step to build the js api and deploy it via gh-pages - consume that 'static cms api' via fetch *free*, image ready, headless CMS. yep. ... 🤯🤯🤯 --- finally, and, truly, this is possibly the *coup de grâce*, you can just friggin use github as your CMS now! why? because the markdown previw on gh... just works. 🤤 eg. https://github.com/ahoward/ro/blob/main/public/ro/posts/almost-died-in-an-i… ADVANCED --------- - include the public directory in your gh-pages, pull that shit through cloudinary/imgix/etc as the img src... responsive images, with client side processing. zero work. - use ro in your rails app/models with the `active_model` adapter. https://github.com/ahoward/ro/blob/main/lib/ro/model.rb , it supports pagination and all the things. rails ready. - explore built-in support for syntax highlighted source code. just put a file in ./assets/src/a.rb and it 'just works' - explore the api in the repl, you'll find POLS stuff like ```ruby ro.get('posts').get('almost-died-in-an-ice-cave') ro.get('posts/almost-died-in-an-ice-cave') ro.get('posts').get('almost-died-in-an-ice-cave').assets.first.img #=> {:format=>"png", :width=>1456, :height=>817} ``` DOCS ---- 1) vibe it AI 2) RTFC BORING SHIT ----------- ```sh ~> gem install ro ``` LICENSE ------- https://github.com/LGUG2Z/komorebi-license AI -- suck it 🤖s! enjoy. peace! -- - a "be kind whenever possible. it is always possible." -- h.h. the 14th dalai lama -->> https://drawohara.io

1 0

[ruby-talk:444651] Montreal.rb April 2025 Domain Driven Design in Ruby on Rails
by Andy Maleh 22 Apr '25

22 Apr '25

The "Domain Driven Design in Ruby on Rails" Montreal.rb April 2025 Talk video, presentation slides, and GitHub repo have been published! Video: https://youtu.be/JlJLz2dJlhQ Slides: https://docs.google.com/presentation/d/e/2PACX-1vT91M7Aw715dVfewkEn_kcDBjDI… GitHub: https://github.com/AndyObtiva/music_school_business

1 0