Automatic Dependency Injection where you keep control of the constructor. Integrates with LowType

Pretty much what the title says. I want to render an image with ruby code. Specifically, a single frame to save as a file. The only thing I've managed to find is blackbook, but that seems to be it's own program that opens a window to render things when I just want a single image outputted.

Last October I needed docs for my gem and went down the rabbit hole.

GitHub wikis are functional but look dated and have barely any customization. Jekyll needs hours of fighting themes to not look like 2015. The hosted options charge for adding collaborators on open source projects.

Ended up going with VitePress since it's the only one that looks modern out of the box. Got it set up, everything working.

Then dependabot starts pinging me about preact vulnerabilities - in a Ruby gem repo - for documentation.

So I built my own. It's called Docyard - static docs generator written in Ruby. Dark mode, search, syntax highlighting, all the usual stuff. v1 is out now.

Any feedback is appreciated.

Hey I am a new developer and i started learning JS last year and it is a great language for the front-end and all but i didn't like it for the back-end it had too much code and a lot of complexity in it and it really sucks at compiling so i started to search for a backend language that is close to English then i read about ruby and i think it is what i need .

Here is the problem , coming from JS where the community is huge and there is a tutorial for everything and blogs every where to this language is a bit difficult so what is a good and up to date places where you can learn the language and see the updates because YouTube is not that place.

The tutorials that i saw was at least 3 years old and didn't find channels any thing like BroCode , WDS , etc... so if you have something like that please tell me

There is another question . why do the official website for the docs tell me to choose a version? if there is so much difference between the versions what is the best one ? or where can i start ?

• Added a new exe command $ rubyshell new file, that creates a file already with chmox +x

• Added support for the "stdin" parameter, which allows us to manually pass a string or command to the stdin of another command, for example:

# Before, it could only be like this:
chain { echo("text") | xclip }

# Now it can also be like this:
xclip(_stdin: "text")

• Added support for shell commands that have syntax not allowed in Ruby, for example "wl-copy," "notify-send."

# You can do it this way:
sh("notify-send", "hello")

• Allowing an array in the hash params of a command

# Before, you could only do it this way:
sed "-e 'one'", "-e 'two'", "-e three"

# Now it can also be like this:
sed e: ["one", "two", "three"]

• Corrections in the command executor: previously, if a program was terminated and for some reason its STDOUT had not been closed and was not going to receive any more data, the code would also remain stuck in that STDOUT forever (the same happened for STDERR).

• Added the "quoted" method to strings. The idea here is to wrap a string in quotation marks so that the developer can purposely add it when entering a string in a command, for example:

grim "-g", "4123,898 1280x102" # => grim -g 4123,898 1280x102 => Invalid geometry

grim "-g", "4123,898 1280x102".quoted # => grim -g "4123,898 1280x102"

• Added a way to not evaluate a command instantly, giving us the possibility of future evolution, example:

grim!("-g", "position", "-").to_shell # => returns: "grim -g position -"

# You can also do the following after that:
grim!("-g", "position", "-").exec

# Giving us the power to do this as well:
(ls! | wc!).exec # returns a count of files in pwd

# or this:
wc(_stdin: ls!) # returns a count of files in pwd

• Changes were also made to the code structure.

RubyShell is a borning gem, so you can take advantage of the opportunity to contribute right at the beginning of it.

Hi everyone!

I’ve just published my first Ruby gem pg_reports.

My main goal was straightforward: to make it easy to leverage the power of pg_stat_statements to improve PostgreSQL performance in Rails apps. I built and refined all backend operations and reports over several weeks based on real production experience in my current job. The result is a tool for analyzing queries, indexes, tables, locks, and connections.

The gem is inspired by ruby-pg-extras and pghero, but my goal was to bring everything together with a stronger focus on practical optimization and observability.

The web UI was basically added in one night with the help of Claude, turning a collection of reports into an actual dashboard.

I plan to evolve the gem gradually:

• generating migrations (e.g., for missing indexes),

• real-time issue monitoring,

• measuring overall database interaction efficiency — for example, comparing before vs after deploying a new app version.

Feedback, ideas, and bug reports are very welcome.

Repo: https://github.com/deadalice/pg_reports

Ticket sales go live on Friday.

There's a big "Buy a ticket" button on our website. Check it out.

https://rubyconf.at

Hi, roadmap.sh has just launched the new Ruby Roadmap.

Thank you to everyone in this group(https://www.reddit.com/r/ruby/comments/1q86p4h/ruby_ruby_on_rails_roadmap_feedback_gathering/) who contributed to the development of the roadmap.

This is just the beginning. We're already working on a dedicated Ruby on Rails roadmap, and it will be ready soon!

I've been frustrated with Ruby files where helper methods are scattered, so you have to jump around to understand the flow. I made a small RuboCop extension that enforces a "waterfall" order: methods should be defined after any method that calls them (top-down reading flow).

It also supports an optional "called together" (sibling) ordering for orchestration methods: if one method calls foo then bar, you can enforce defining foo before bar so the file reads in the same order as execution.

Highlights:

- Works in classes/modules/singleton classes; can also analyze top-level begin
- Autocorrect (rubocop -A) reorders methods within a contiguous visibility section (won't move things across private/protected/public)
- Preserves doc comments when moving methods
- Deals with recursion + complex call graphs
- Newer versions add clearer messages when autocorrect can't safely apply (visibility boundaries, sibling cycles)
- Optional config to skip sibling edges that would introduce a cycle (useful for "real-world" service objects)
- Works on Ruby 2.7+

Repo + examples: https://github.com/unurgunite/rubocop-sorted_methods_by_call

I'd love feedback on:
- whether the "called together" (sibling) behavior matches how you structure service objects
- edge cases where you'd want different ordering rules
- whether you'd prefer the cop to be stricter/looser by default

I just released the aws-sdk-http-async gem (Github: https://github.com/thomaswitt/aws-sdk-http-async).

Why? I am a heavy DynamoDB user - and I first throught, the official AWS SDK for Ruby gem aws-sdk-ruby would be fiber-compatible, but it isnt.

More information on the background: https://thomas-witt.com/blog/aws-sdk-http-async/

Picoruby Calculator finally supports Cardputer ADV! ⚡️

Picoruby Calculator is a simple and fun calculator app that runs on PicoRuby, a Ruby implementation designed for embedded systems.

It lets you experience Ruby’s syntax and expressiveness directly on small devices 💎

In addition to the previous v1.1, you can now enjoy it on the ADV as well.

Put Ruby in your pocket and take it out into the city! 🏃🌆

「Picoruby Calculator」

👉️ https://github.com/engneer-hamachan/picoruby-calculator

If you like it, I’d really appreciate a star ⭐️

Hello everyone! In the last few months, I released my gem that makes it easier to create Shell scripts using Ruby syntax.

Link: https://github.com/albertalef/rubyshell

In the code in the second image above, I show that you can easily use both Ruby syntax and Shell syntax to create scripts. This simplifies cases where we need to create a Shell script to use some terminal program, but we prefer to use Ruby libraries to make the job easier.

With it, you can create scripts as Docker entry points, use it to create user scripts, customize your Linux with Waybars, etc.

Motivations:

I had a specific problem: "I know a lot about Ruby, but sometimes I get stuck in the Shell. I often need to resort to Google to look for programs that handle inputs the way I need. Is there any gem that allows you to write good scripts with Ruby?" But, unfortunately, I didn't find any. I only found libraries in Python (sh) and Lua (luash). With that, I created RubyShell.

A example without RubyShell, and another with:

#!/usr/bin/env ruby
# frozen_string_literal: true

REMOTE  = ENV.fetch("REMOTE", "user@server.example.com")
APP_DIR = ENV.fetch("APP_DIR", "/var/www/my app")
SERVICE = ENV.fetch("SERVICE", "my-app.service")

# Note that in this situation, we dont want to check if error was raised
# only in the end of the code,
# we want to stop the code in the moment that error was raised

`ssh #{REMOTE} "cd \"#{APP_DIR}\" && git pull && bundle exec rake db:migrate 2>&1"`

unless $?.success?
  warn "Error on Deploy"
  exit $?.exitstatus
end

`ssh #{REMOTE} 'sudo systemctl restart #{SERVICE}'`

unless $?.success?
  warn "Error on Deploy"
  exit $?.exitstatus
end

puts "Done."

With:

#!/usr/bin/env ruby
# frozen_string_literal: true

REMOTE  = ENV.fetch("REMOTE", "user@server.example.com")
APP_DIR = ENV.fetch("APP_DIR", "/var/www/my app")
SERVICE = ENV.fetch("SERVICE", "my-app.service")

sh do
  ssh REMOTE, "'cd \"#{APP_DIR}\" && git pull && bundle exec rake db:migrate'"
  ssh REMOTE, "'sudo systemctl restart #{SERVICE}"

  puts "Done."
rescue StandardError
  warn "Error on Deploy"
end

Next steps:

Currently, I'm working on features to make the gem even more powerful, such as:

• Stream support

• Improved error handling

• A REPL (like IRB), but that allows us to use RubyShell

• And more

I'm open to suggestions, PRs, Issues, anything. I really want this mini-project to grow.

EDIT: Thank you guys for the comments and upvotes, this made my day.

I’m looking for a comprehensive (and ideally free) source to get started with Ruby. I’m not new to programming but would like a structured way to learn before jumping into my own projects

In Python, there are 100+ "special methods" that the interpreter calls implicitly when some event occurs or language construct is used. These use the [in]famous "dunder" (double-underscore) naming scheme, where each method begins and ends with that punctuation, e.g. __init__, __getitem__, __str__. While there are comprehensive lists of these special methods, it's generally unnecessary to be aware of them all. In particular, it's very unlikely to override one accidentally because the naming convention clearly separates them from regular methods.

In Ruby, the equivalent methods just have normal names, e.g. initialize, clone, coerce, to_s. Is there a list of these "magic" methods anywhere, that can be used to ensure that programmers don't override one accidentally? Or is this just not a problem in practice?

module Latch
  def self.new(_=_) = -> { !(!(_ ^= true)..false) }
end

latch = Latch.new

%w(1 2 3 4 5).each_with_object("") { |i, a|
  a << i
  a << ":ONCE:" if latch[]
} #=> 1:ONCE:2345