1. It can help with simplifying code by removing unnecessary transformations.

2. The support that Ruby has for doing things in multiple ways is very helpful when hitting a case where Sorbet has a rough edge

Let's take them step by step:

How to simplify methods by removing unnecessary transformations

Here is a piece of code that is a public interface of an object (this is not the actual code but an approximation of the actual code)

# typed: strictACCEPTED_KEYS = T.let(%i[name username email].freeze, T::Array[Symbol])sig { params(attributes: T::Hash[T.any(Symbol, String), Integer]).returns(T::Hash[Symbol, Integer]) }  def accepted_attributes(attributes)    attributes      .symbolize_keys      .slice(*ACCEPTED_KEYS)end

Let's first focus on the .symbolize_keys call and the definition of the attributes param that is T::Hash[T.any(Symbol, String), Integer] allowing the method to be called with a hash with keys, symbols, or strings.

Notice that because I defined the attributes in that way (to accept both types of keys), I called symbolize_keys to transform them into symbols so that I could slice by ACCEPTED_KEYS, which are symbols.

But there is another way to think about this:

Because the method has type definitions, there is no need to support both String and Symbol as keys for the hash. The developer who plans to use this method can see exactly what kind of objects the keys should be.

So, the method can be transformed into a simpler one where I remove the symbolize_keys :

- sig { params(attributes: T::Hash[T.any(Symbol, String), Integer]).returns(T::Hash[Symbol, Integer]) }  + sig { params(attributes: T::Hash[Symbol, Integer]).returns(T::Hash[Symbol, Integer])} def accepted_attributes(attributes)    attributes-      .symbolize_keys      .slice(*ACCEPTED_KEYS)end

An insight here is that Sorbet can help remove code that is there to handle the cases where the input is in various formats. Using types will provide hints to the user of the method about what kind of arguments are expected, so there is no need to handle multiple types.

Fixing the Sorbet splat arguments not well supported

Now, if you run the sorbet checker or play online on the sorbet playground, you will get an error that is something like this:

editor.rb:10: Splats are only supported where the size of the array                 is known statically https://srb.help/7019    10 |  attributes.slice(*ACCEPTED_KEYS)

And checking the Sorbet docs they say the following:

One solution would be to use T.unsafe but I don't want to do that unless there is no other way around.

After trying a couple of things, I finally decided to refactor it to:

sig { params(attributes: T::Hash[Symbol, Integer]).returns(T::Hash[Symbol, Integer]) }  def accepted_attributes(attributes)    attributes.select { |key, _| ACCEPTED_KEYS.include?(key) }end

And here comes the second insight:

The amazing thing about Ruby is that I can refactor that method from usingsliceto usingselectand still remain explicit and read like an English sentence.

Enjoyed this article?

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com- effortless learning anytime, anywhere

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

In the beginning, I had to choose the tech stack for it. Here is an exploration of what criteria I considered, what I chose, and why.

Criteria

When I think about the tech stack I want to use for this project, I have to consider the following:

Time

The most important part is time. This is a side project; thus, it receives a small part of my effort. This is a fixed allocation that I can put among spending time with family, having a full-time job, and taking time for myself.

I think about time in two ways:

• The time I have to build the project

• The time I will have to maintain the project

Speed of change

The second most important thing is being able to change. That includes releasing new features or reacting to users needs or wants.

Whats important here is the speed of change: How fast can I release something to production?

Costs

On the third place are costs: hosting, emailing, and additional services used to build the project.

I have not yet allocated a budget for this project but will do so over the next weeks. Having a budget will help to validate if the idea is feasible and sustainable over the long run.

Choices

Programming language: Ruby

I am using Ruby. It is the language the I know best and it is also a language that allows me enough flexibility to write code that is easy to change and quick to adapt.

Web framework: Ruby on Rails

I am using Ruby on Rails. I briefly considered Hanami 2 as it is fresh, and I wanted to pick it up, but considering the time and speed of change, there is not much room to learn a new framework. At the same time, Ruby on Rails comes with a lot of battery included, and that is what I need in this project where I plan to focus on the product and content.

Persistence: SQLite

I am using SQLite. Ruby on Rails now has good support for SQLite in production, and Stephen Margheim has a lot of easy-to-follow and to-the-point articles for configuring it. Choosing SQLite reduces the time allocated to maintenance, so it is an easy win.

I am not concerned with scalability as I dont see this project needing more than a server.

I also added the Activerecord-enhancedsqlite3-adapter that adds support for generated columns, deferred foreign keys, PRAGMA tunning, and extensions loading.

For backup, I am using litestream gem, which makes working with litestream.io easier.

Background running jobs

I use litestack gem that comes with everything, including Jobs, Caching, Search, and Metrics.

I am considering for jobs to move to SolidQueue at some point.

Admin: Avo

I am using Avo to build the Admin UI that I will use to manage the content. Avo looks excellent; it is modern and fast, and I dont want to spend time building a UI for myself to manage the content.

It is already built, it has a feel of Railsy while configuring it, and it is flexible enough so that if I need more custom things, I can do them.

The best benefit is that I get time back to invest in the content instead of the development of an admin.

CSS: Tailwind and TailwindUI

I am using Tailwind because I used it professionally, so I know it a bit, and also because I bought TailwindUI where I can find ready-made components that I can copy/paste into my project if needed.

Rails 7 also comes with an already integrated Tailwind, and it works with import maps.

Import maps

I like Rails import maps, and I am picking other UI-related gems only if it works with import maps. That is because I dont want to run nodejs or have any node_modules installed. It adds to maintenance, and I like to minimize maintenance tasks.

Views: ERBs and Phlex

First, I will create the general views as HTML ERB files. This is because it is close to HTML, will have low maintenance, and can be changed quickly. It also helps with copying/pasting elements from TailwindUI without making too many changes.

I will organize (or extract) standard components by using phlex. Phlex is closer to my backend background, so I can keep writing Ruby while building UI elements. phlex-rails has also a good integration with Lookbook and so I can easily preview my components.

How I use this mix is like this: the general structure of the page is done with HTML ERB, but the elements inside are mostly done with Phlex.

Testing

I use Minitest, the default testing framework for Rails.

I like Minitest in my side projects for two main reasons:

• It comes default with Rails and runs fast

• It is not a DSL, but it is just Ruby code. So it will be easy to return to it and not spend time remembering a DSL.

There is one gem that I usually install for tests and that is minitest-stub-const. Stubbing constanta can also be done without this gem, but I kept using this gem.

Static pages: Sitepress

For static pages, like homepage, or the blog section I am using sitepress. It has an easy integration with Rails and helps move from static files to dynamic options easily. I also like that it has Frontmatter support and comes with a way to work with each pages meta-data.

It is a maintenance and low configuration solution: Install it, write things in .html.md files, and all will work.

Debugging: Debug gem

Debug gem is now the default debugger gem for Rails, and I like it a lot.

A lot of development is happening, and new features are always added. I started moving away from puts debugging to real debugging, and I even use the debugger to inspect object states while I do code design.

As the debug gem is part of Ruby, I think it can be a safe bet for the future with little maintenance or overhead required. I am using it in all my projects.

Asset pipeline: Propshaft

On multiple occasions, propshaft mentioned that it would become the default in Rails, so I chose it because I think it will make upgrading Rails easier. I also like that propshaft is simple and does one thing well.

Beautiful web UX: Hotwire

Of course, Hotwire is my choice for building web UX. It comes with Rails by default, and it has a lot of good integrations. It allows me to build promising web UX without the mental overhead of learning more JS or a new JS library.

When I need to write some JS, I like to use Stimulus because it gives me a place and a way to organize JS code. This is important for a project you dont open daily to know exactly where to find each piece of code.

Environment variables: direnv

I started using direnv a while back, mostly because I needed to share some environment variables between projects. So I can put a .envrc file in the top folder for a group of projects and have those environment vars available in all subfolders.

It removes the need to use the dotenv gem and also decreases the chances of accidentally committing your .env file if you put the .envrc in the parent folder and not the code folder.

I mostly organize my projects like this:

projects/project/shortruby/project/shortruby/appsproject/shortruby/apps/shortruby.comproject/shortruby/apps/lean.shortruby.comproject/shortruby/apps/newsletter.shortruby.comproject/shortruby/imagesproject/shortruby/docsproject/shortruby/scripts

I can add the .envrc file under projects/shortruby/apps and have the common development environment variables shared between multiple projects.

Code Quality: Rubocop + Rubycritic

I use Rubocop to enforce a coding style that I like and made for myself. It is well-supported by any editor and allows me to configure it as I see fit. In my case, I lean toward using new Ruby syntax so the cops are configured to allow that.

I added to it the following gems:

• rubocop-rails - Automatic Rails code style checking tool

• rubocop-performance - A collection of RuboCop cops to check for performance optimizations in Ruby code

• rubocop-minitest - Automatic Minitest code style checking tool

• rubocop-capybara - Code style checking for Capybara test files (RSpec, Cucumber, Minitest)

• rubocop-rubycw - Integrate RuboCop and ruby -cw. You can get Ruby's warning as a RuboCop offense by rubocop-rubycw

I also use Rubycritic to keep complexity low. I dont refactor for every code smell, but it is good to have an excellent overview of what complexity each change might add to the existing codebase.

You can see how I configured all these tools in my article about First commits.

Code editor: RubyMine

I am using RubyMine as my primary code editor with IdeaVim plugin enabled. I worked with it quite a lot in the last few years and am fast when using it. Helps with debugging and go to definition.

Versioning: Github

I have some experience with both Github and Gitlab. But I think GitHub is a good choice here due to its UI simplicity. I dont want to spend time in configuration and the UI/UX choices are great. The PR flow is quick and easy to set up, and for my needs, I only use GitHub actions to run simple tasks. I think Gitlab has a more powerful CI but I dont think I need it right now.

Sending emails: Postmark

For sending emails, I choose Postmark. It is easy to set up and offers API-sending email and SMTP services.

I dont know if Postmark will be used to send the course content. But it will be used to send all transactional emails related to the project.

I am considering ConverKit to write and send the actual email content. This will depend on their API support for the features I plan to build for my users: restart an email course, choose periodicity, and more.

Hosting: Hetzner and Hatchbox

I am using VPS Hetzner as they have a good price and being in EU it helps me with registering the invoice to my accounting.

I am using deployment Hatchbox for ease of use. I enabled automatic deployments to make a deploy with git push - simple and effective.

Analytics: Plausible

I discovered Plausible while learning Elixir and Phoenix and started using it for all my side projects. I like the simplicity, and it is also a good price for what it is offering.

Image storage: Cloudflare R2

I started looking for an AWS S3 alternative primarily due to the time spent configuring IAM and other stuff that always needed to be done when setting up a new account.

I discovered Cloudflare R2 last year (https://www.cloudflare.com/developer-platform/r2/), and I started using it. Again, I like the simplicity (it can be configured in minutes) and can be used for ActiveStorage. What I plan to build, where I will mostly upload and display images, worked perfectly and for an excellent price.

AWS S3 could be better for more complex tasks, but if the only need is to upload images and display them publicly while being a solo developer, the R2 is a good choice.

Conclusion

These are the tools I use and why I chose them to build the email courses project

I dont think there exists a thing called the best tech stack, but depending on my knowledge and purpose, I can create an excellent tech stack to help me deliver fast and with good code quality.

Enjoyed this article?

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com- effortless learning anytime, anywhere

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

I was unsure what form the product would have, so I focused first on setting up coding styles, static analysis checks, and some other defaults that I consider essential when starting a project.

In this article, I will explore what I added and why I chose that specific tool, talking specifically from the perspective of a single-person side project.

What I wanted to achieve with my first commits

There is a kind of inertia to the code design: new code tends to be similar to existing code.

Here is a better quote from Edmond Lau book called The Effective Engineer that shows the positive side of this inertia:

The code quality also self-propagates; new engineers model their own code based on the excellent code that they see, creating a positive feedback loop.

When working alone on your project, you can replace new engineer with you in the future, the quote will still be relevant.

My initial commits aimed to set up automated checks for code quality and security. I want to help my future self be fast and write quality code.

Side projects developed while having a full-time job have a unique characteristic worth noting. The time dedicated to working on the side project is not continuous. For instance, you may work on it for 1-2 hours on Saturday, and the next opportunity to work on it may only arise a week later.

It is then essential to make the code quality built-in and use as much automation as possible.

First commits

My first commits were about:

• adding Rubocop to correct and enforce coding styles automatically

• check code quality with Rubycritic

• security audits with brakeman, bundler-audit and importmap audit

• enable Rails strict loading

• make Rails console run on sandbox mode in production

Add Rubocop

I have a Rubocop configuration that I like to use in my side projects.

The first commit sets up Rubocop and adds my configuration to the .rubocop.yml file.

Why add Rubocop

I have a lot of thoughts about what cop I want enabled and what cop disabled, and sometimes I change my mind about some of them, but for this project, consistency is more important than a specific cop.

It is essential to have a consistent style while coding. I also like to have the editor auto-format my code, so I chose Rubocop because I want to use the new Ruby syntax, and thus, I can switch on/off rules that will impede this.

What I added to the commit

1. Rubocop gems

I am using the following Rubocop gems:

• rubocop-rails - Automatic Rails code style checking tool

• rubocop-performance - A collection of RuboCop cops to check for performance optimizations in Ruby code

• rubocop-minitest - Automatic Minitest code style checking tool

• rubocop-capybara - Code style checking for Capybara test files (RSpec, Cucumber, Minitest)

• rubocop-rubycw - Integrate RuboCop and ruby -cw. You can get Ruby's warning as a RuboCop offense by rubocop-rubycw

2. Apply Rubocop autocorrection to files generated by Rails generate

I want to automatically run Rubocop with autocorrect on any .rb file generated by the Rails generate command. This will ensure that any gem that generates Ruby files or any I generate will have the style automatically corrected.

I added the following code to the config/application.rb to do this:

config.generators.after_generate do |files|  parsable_files = files.filter { |file| file.end_with?(".rb") }  unless parsable_files.empty?    system("bundle exec rubocop -A --fail-level=E #{parsable_files.shelljoin}", exception: true)  endend

I took this code from Rubocop Rails Configuration tip and you can see it added to the current Rails master

And I made Rubocop run on Github CI with by adding the following content to the file under .github/workflows/rubocop.yml:

name: Rubocop Linteron:  push:    branches:      - main  pull_request:    branches:      - mainjobs:  build:    runs-on: ubuntu-latest    steps:      - name: Checkout code        uses: actions/checkout@v2      - name: Set up Ruby        uses: ruby/setup-ruby@v1        with:          ruby-version: 3.3          bundler-cache: true      - name: Install dependencies        run: bundle install      - name: Checking Rubocop Styles        run: bundle exec rubocop

This will run Rubocop on the following two cases:

• When code is pushed to the main branch.

• When a pull request is made to the main branch.

Code Quality with Rubycritic

The third commit adds Rubycritic as a code quality static analysis.

Why add Rubycritic

I added this because I want to ensure I create simple code. And while Rubycritic does not guarantee the code will be simple, it can help maintainability. I see maintainability as an essential metric in the context of a side project.

The commit

I dont want to run Rubycritic in CI mostly because I think about having little time and trying to be fast with feature releases, and sometimes refactoring to remove a code smell can take quite some time.

But I do want to run this locally, so I just created a file under bin/quality_check with the following content:

#!/bin/bash -ebundle exec rubycritic

Why a file and not run directly rubycritic? Id like to add more tools like this here or configure Rubycritic in a specific way and having a bash script allows me this flexibility.

Rubycritic uses reek under the hood so I added a reek config files at .reek.yml with the following content:

---detectors:  IrresponsibleModule:    enabled: false  LongParameterList:    enabled: true    exclude: []    max_params: 4    overrides:      initialize:        max_params: 5  DataClump:    max_copies: 3    min_clump_size: 3### Excluding directoriesexclude_paths:  - test/  - config/

I mostly disabled IrresponsibleModule because I dont want to add a description to all classes/modules I create.

I also allowed a maximum of 4 parameters for methods and 5 for the initializers. I also allowed a maximum of 3 methods in an object to have the same parameters, and the check happens only from 3 parameters up. I can rationalize this decision, but it is mainly based on my experience with extracting objects from a long list of parameters and finding a balance when to make this effort.

Security checks on CI

The fourth commit is concerned with adding security checks to the CI.

Why add security checks

I want to run on CI a couple of security audits that I grouped under the name of Static Analysis:

• Brakeman - Brakeman detects security vulnerabilities in Ruby on Rails applications via static analysis

• Bundle audit - Patch-level verification for Bundler

• Importmap audit - checks the NPM registry for known security issues

The commit

Here is the CI config for Github to run all these tools in .github/workflows/static_analysis.yml:

name: Static Analysison:  push:    branches:      - main  pull_request:    branches:      - mainjobs:  static_analysis:    runs-on: ubuntu-latest    steps:      - name: Checkout code        uses: actions/checkout@v2      - name: Setup Ruby        uses: ruby/setup-ruby@v1        with:          ruby-version: 3.3          bundler-cache: true      - name: Install Bundler        run: gem install bundler      - name: Install dependencies        run: |          bundle config path vendor/bundle          bundle install --jobs 4 --retry 3      - name: Run bundler-integrity check        run: bundle exec bundler-integrity      - name: Run Brakeman        run: bundle exec brakeman      - name: Run Bundle Audit        run: bundle exec bundle-audit check --update      - name: Run Importmap audit        run: bundle exec bin/importmap audit

Enable Rails strict loading

Here is what strict_loading does (source):

Add #strict to any record to prevent lazy loading of associations. strict will cascade down from the parent record to all the associations to help you catch any places where you may want to use preload instead of lazy loading.

Why enable strict loading

This is an excellent way to prevent N+1 and ensure that any needed association is included or preloaded.

The commit

I enabled strict_loading in all environments:

# config/environments/development.rbconfig.active_record.strict_loading_by_default = true

# config/environments/test.rbconfig.active_record.strict_loading_by_default = true

# config/environments/production.rbconfig.active_record.strict_loading_by_default = true

Make Rails console run on sandbox mode in production

Why make console run in sandbox mode

It is a good practice to run the rails console in production in the sandbox box to ensure any change is intentional.

I use rails console quite often in production, but I want to make sure that if I want to make any changes, that should be intentional and not accidental.

The commit

This is a simple switch that I can toggle in the Rails config for production:

# config/environments/production.rbconfig.sandbox_by_default = true

If this is enabled, then to make changes, you have to run rails console --no-sandbox

Conclusion

I made the first commits in this repository intentional about code quality and automatic checks.

It helps with moving fast while keeping a good code quality. A lot can be done in this area, but I tried to add the minimum that would help me.

A note about eager loading code

A previous version of this article included a section about configuring CI to run bin/rails zeitwerk:check to check if the code loads correctly.

Xavier Noria correctly pointed out that running this in CI is unnecessary.

First, there is a config setting called config.eager_load, and if you put that on true in your test environment and run any test that will eagerly load your entire application. This setting exists already in Rails 6.0 (and even before 6.0).

Since Rails 7.0 the generated config/environment/test.rb includes the following line:

config.eager_load = ENV["CI"].present?

That means if you run your tests in Github CI (or similar CIs) that sets the CI environment variable, it will eagerly load your application.

So there is no need to execute rails zeitwerk:check separately. Either set the config.eager_load to true on CI, or you already have that if you generated your app with Rails >= 7.0 and run your tests on CI.

Enjoyed this article?

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com- effortless learning anytime, anywhere

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

In this article, I will show how to find the source where a method is defined.

There are three ways to find out where a method is defined in Ruby using IRB:

• using the source_location defined on the Method object

• using the IRB show_source command

• displaying information about an object using ls (for displaying the object but not the source file)

Before we start, here is my IRB configuration:

# .irbrc content# I use the Dracula theme for IRB from https://github.com/katsyoshi/irb-theme-dracularequire "irb/theme/dracula/light"

All code executed below is run inside irb.

A simple Ruby script

Let's assume the following object:

# frozen_string_literal: truemodule Universe  module Galaxy    class Star      attr_reader :name      attr_writer :name      def initialize(name)        @name = name      end    end  endend

Now let's start IRB and instantiate an object out of it:

require_relative "universe/galaxy/star"star = Universe::Galaxy::Star.new("Some Other Sun")

Finding available methods and instance variables

When in IRB you can use ls to display the available methods and instance variables:

ls star# => # Universe::Galaxy::Star#methods: name  name=# instance variables: @name

While this does not provide a source file and a line number you will see in examples below that it can correctly identify in case of inheritance for example where a method is defined.

Finding the source using Method#source_location

Executing star.method(:name).source_location will return the proper source location with the specific line number:

star.method(:name) # This will return a Method objectstar.method(:name).source_location # => # ["universe/galaxy/star.rb", 6]

What about the setter? It will work in this case too:

star.method(:name=).source_location # => # ["universe/galaxy/star.rb", 7]

Finding the source using show_source from IRB

When in IRB you can use show_source to display the source for a method:

show_source star.name

The response will be:

From: universe/galaxy/star.rb:6      attr_reader :name      attr_writer :name

This will work for the setter too so executing the following command:

show_source star.name=

Will return the following response:

From: universe/galaxy/star.rb:7      attr_writer :name

A more complex Ruby script

What if we add inheritance? How will discovering the source work in this case?
Let's now create a new class:

module Universe  module Galaxy    class SimpleSun < Star      def initialize        super('Sun')      end      def our_planet        Planet.new('Earth')      end      def name        puts "SimpleSun#{@name}"      end    end  endend

Let's load this in an IRB session:

require_relative "universe/galaxy/simple_sun"simple_sun = Universe::Galaxy::SimpleSun.new

Finding available methods and instance variables

Let's explore with ls:

ls simple_sun# => # Universe::Galaxy::SimpleSun#methods: name  our_planet# Universe::Galaxy::Star#methods: name=# instance variables: @name

Notice that it correctly showed that name is from Star and was not overwritten in the SimpleSun while name= is correctly identified as being from Universe::Galaxy::Star

Finding source location with Method#source_location

Using source_location on name will show the source being in simple_sun.rb while using source_location on name= will show the source being star.rb:

simple_sun.method(:name).source_location# => # ["universe/galaxy/simple_sun.rb", 14]simple_sun.method(:name=).source_location# =># ["universe/galaxy/star.rb", 7]

Finding source location with show_source IRB command

Using show_source will correctly display the source code for both name and for name= (inherited from Star).

Executing:

show_source simple_sun.name

Will return the following response:

From: universe/galaxy/simple_sun.rb:14      def name        puts "SimpleSun#{@name}"      end

While executing:

show_source simple_sun.name=

Will return the following response:

From: universe/galaxy/star.rb:7      attr_writer :name

An extra option for show_source

Let's execute again the show_source but this time on the initializer where in SimpleSun I wrote super('Sun') so I am calling super with an argument:

show_source Universe::Galaxy::SimpleSun#initialize

This will return:

From: universe/galaxy/simple_sun.rb:6      def initialize        super('Sun')      end

What if you want to see the super method? show_source supports a flag -s that will help displaying the super class method. You can stack as many -s as you like eg. -sssss

In our case there is one single super added there so I will execute:

show_source Universe::Galaxy::SimpleSun#initialize -s

And this will return:

From: universe/galaxy/star.rb:9      def initialize(name)        @name = name      end

A Ruby script using define_method

Now let's complicate a bit the things and define methods dynamically with define_method:

require_relative "star"module Universe  module Galaxy    class TwinSun < Star      NAME_ALTERNATIVES = %i(twin_helios twin_sun twin_sol twin_solis)      def initialize        super('TwinSun')      end      def our_planet        'Twin Earth'      end      NAME_ALTERNATIVES.each do |name|        define_method "#{name}?" do          true        end        define_method name do          name        end      end    end  endend

With our new class defined, let's start the IRB and instantiate twin_sun:

require_relative "universe/galaxy/twin_sun"twin_sun = Universe::Galaxy::TwinSun.new

Finding available methods and instance variables

And we can explore with ls:

ls twin_sun# => # Universe::Galaxy::TwinSun#methods:#   our_planet  twin_helios  twin_helios?  twin_sol  twin_sol?  twin_solis  twin_solis?  twin_sun  twin_sun?# Universe::Galaxy::Star#methods: name  name=# instance variables: @name

You can notice that it shows all the defined method too when doing ls twin_sun.

ls also correctly identifies that name and name= are from the parent Star object.

Finding source location with Method#source_location

What about source_location?

Let's first try a method defined directly on the TwinSun and notice it shows the file and the line number:

twin_sun.method(:our_planet).source_location# => # ["universe/galaxy/twin_sun.rb", 12]

Now let's try to identify one of the methods created with define_method:

twin_sun.method(:twin_sun?).source_location# => # ["universe/galaxy/twin_sun.rb", 17]

And opening that directly from IRB with edit "universe/galaxy/twin_sun.rb" will show the exact line where define_method #{name}? is written:

Finding source location with show_source IRB command

If you want to directly get a glimpse in IRB of the source code, you can use show_source

show_source twin_sun.twin_sun?

The result will be:

From: universe/galaxy/twin_sun.rb:17        define_method "#{name}?" do          true        end

This is super cool => it is showing the place where define_method is used to create the twin_sun? method:

Rails

I am using for this a newly generated Rails app (using Ruby 3.2.2 and Rails 7.1) where I just added two models. They are very simple:

# db/schema.dbcreate_table "galaxies", force: :cascade do |t|  t.string "name"  t.datetime "created_at", null: false  t.datetime "updated_at", null: falseendcreate_table "stars", force: :cascade do |t|  t.string "name"  t.integer "galaxy_id", null: false  t.datetime "created_at", null: false  t.datetime "updated_at", null: false  t.index ["galaxy_id"], name: "index_stars_on_galaxy_id"endadd_foreign_key "stars", "galaxies"# app/models/galaxy.rbclass Galaxy < ApplicationRecord  has_many :starsend# app/models/star.rb class Star < ApplicationRecord  belongs_to :galaxyend

Let's start the Rails console with rails c and try to find the source code or location for some methods.

Assume there is already a record for Galaxy with name Andromeda and a couple of stars in that galaxy: Alpheratz and Mirach.

Finding using source_location

We might want to load the galaxy with name Andromeda by using Galaxy.find_by but where is that method defined?

Galaxy.method(:find_by).source_location# => # [".gem/ruby/3.2.2/gems/activerecord-7.1.2/lib/active_record/core.rb", 256]

And if we open that file, we will get:

What about exists? from Active Record? That works too indicating where exists? is defined:

Galaxy.method(:exists?).source_location# => # [".gem/ruby/3.2.2/gems/activerecord-7.1.2/lib/active_record/querying.rb", 23]

Finding the source using show_source

show_source Galaxy.find_by

The result of executing that line will be:

From: .gem/ruby/3.2.2/gems/activerecord-7.1.2/lib/active_record/core.rb:256      def find_by(*args) # :nodoc:        return super if scope_attributes?        hash = args.first        return super unless Hash === hash        hash = hash.each_with_object({}) do |(key, value), h|# ...

I only included here the first few lines from the find_by method but you can notice that it correctly displayed the source code.

Finding source code for params in the Rails controller

I generated a simple scaffolding for Galaxies and I will use the debug gem (included by default in Rails 7.1) to start an IRB session in the context of the index action:

# app/controllers/galaxies_controller.rbclass GalaxiesController < ApplicationController  before_action :set_galaxy, only: %i[ show edit update destroy ]  # GET /galaxies or /galaxies.json  def index    binding.irb    @galaxies = Galaxy.all  end# ... more code

Using source_location

Knowing that params is a method (can be easily checked with self.methods.include?(:params) inside the action) I can do the following:

self.method(:params).source_location # works also without self# => [".gem/ruby/3.2.2/gems/actionpack-7.1.2/lib/action_controller/metal/strong_parameters.rb", 1281]

Using show_source

show_source params# => From: .gem/ruby/3.2.2/gems/actionpack-7.1.2/lib/action_controller/metal/strong_parameters.rb:1281    def params      @_params ||= begin        context = {          controller: self.class.name,          action: action_name,          request: request,          params: request.filtered_parameters        }        Parameters.new(request.parameters, context)      end    end

Exploring params with ls

You can find out more information about params if you use ls command:

irb(#<GalaxiesController:0x000000...):004> ls paramsActionController::Parameters#methods:  ==                    []               []=               always_permitted_parameters  always_permitted_parameters=  as_json      compact  compact!              compact_blank    compact_blank!    converted_arrays             deep_dup                      deep_merge?  deep_transform_keys  deep_transform_keys!  delete           delete_if         dig                          each                          each_key     each_pair  each_value            empty?           encode_with       eql?                         except                        exclude?     extract!  extract_value         fetch            has_key?          has_value?                   hash                          include?     init_with  inspect               keep_if          key?              keys                         member?                       merge        merge!  permit                permit!          permitted?        reject                       reject!                       require      required  reverse_merge         reverse_merge!   select            select!                      slice                         slice!       stringify_keys  to_h                  to_hash          to_param          to_query                     to_s                          to_unsafe_h  to_unsafe_hash  transform_keys        transform_keys!  transform_values  transform_values!            value?                        values       values_at  with_defaults         with_defaults!   withoutActiveSupport::DeepMergeable#methods: deep_merge  deep_merge!instance variables: @logging_context  @parameters  @permittedclass variables:  @@action_on_unpermitted_parameters  @@allow_deprecated_parameters_hash_equality  @@always_permitted_parameters  @@permit_all_parameters

When show_source and source_location does not work

When methods are defined with method_missing

In case you have your behavior defined with method_missing then source_location and show_source will not work:

# frozen_string_literal: truemodule Universe  module Galaxy    class Sun < Star      DYNAMIC_METHODS = %i(life?).freeze      def initialize        super('Sun')      end      def our_planet        'Earth'      end      private      def respond_to_missing?(name, include_private = false)        DYNAMIC_METHODS.include?(name) || super      end      def method_missing(name, *args)        return super unless DYNAMIC_METHODS.include?(name)        if name == :life?          return true        end      end    end  endend

In this case if you load this into IRB:

require_relative "universe/galaxy/sun"sun = Universe::Galaxy::Sun.new

You can notice that you can execute sun.life? and even check sun.respond_to?(:life?) :

sun.life? # => truesun.respond_to?(:life?) # => true

You will then notice that life? is not a method when investigating with:

sun.methods.include?(:life?) # => falsesun.private_methods.include?(:life?) # => falseUniverse::Galaxy::Sun.public_methods.include?(:life?) #  falseUniverse::Galaxy::Sun.protected_methods.include?(:life?) # falseUniverse::Galaxy::Sun.private_methods.include?(:life?) # false Universe::Galaxy::Sun.singleton_methods.include?(:life?) # falseUniverse::Galaxy::Sun.instance_methods.include?(:life?) # false

You can still get the Method object for it:

sun.method(:life?)# => #<Method: Universe::Galaxy::Sun#life?(*)>

But source_location or show_source will not work:

sun.method(:life?).source_location# => nilshow_source sun.life?# => Error: Couldn't locate a definition for sun.life?

It is also not displayed when using ls on the sun object:

ls sun# => # Universe::Galaxy::Sun#methods: our_planet# Universe::Galaxy::Star#methods: name  name=# instance variables: @name

On the Kernel, BasicObject and Object methods

In general source_location and show_source will show you the Ruby code that defined a method, but will not show you any C code behind any method that you are using in Ruby.

So for example the following will not work:

# respond_to? is inherited from Objectsun.method(:respond_to?)# => #<Method: Universe::Galaxy::Sun(Kernel)#respond_to?(*)>show_source sun.respond_to?# => Error: Couldn't locate a definition for sun.respond_to?sun.method(:respond_to?).source_location# => nil# == is inherited from BasicObject sun.method(:==) # => #<Method: Universe::Galaxy::Sun(BasicObject)#==(_)>sun.method(:==).source_location# => nilshow_source sun.==# Error: Couldn't locate a definition for sun.==

If you want to make this work you have to use Ruby TracePoint but that is out of the scope of this article.

Conclusion

I think Ruby has now very good tools to navigate to the source of a method either from the class or from the instantiated object. Using IRB and debug gem makes this navigation easy, and I would recommend anyone learning Ruby to keep an irb or rails console session open. That way, whenever you have a question about how some particular method works, you can navigate to the source of that method and read the code.

I would like to thank Stephen Margheim and Stan Lo for reviewing an early version of this article and providing valuable feedback.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

This is a partial list of some of the things happening in Ruby. Still, I think it is an excellent start to glimpse how Ruby's programming language is evolving and how much effort the community puts into keeping Ruby a joy to use.

Context

First, I recommend you watch this video where Matz is talking about how he chooses to include in Ruby and about Ruby future:

New language syntax

Then I recommend you read the following series of articles (hint: They are not useless 😀 )

• That useless Ruby syntax sugar that emerged in new versions

• Useless syntax sugar: Numeric block parameters

• Useless Ruby sugar: Pattern matching (Pt. 1)

• "Useless Ruby sugar: Pattern matching (Pt. 2)

• Useless Ruby sugar: Pattern matching (Pt. 3/3)

• Useless Ruby sugar: Keyword argument and hash values omission

• Useless Ruby sugar: Argument forwarding

• Useless Ruby sugar: Endless (one-line) methods

Performance

First, I would recommend you read about Object Shapes:

• Object shapes - how this under-the-hood change in Ruby 3.2.0 will improve your code performance

• Performance impact of the memoization idiom on modern Ruby

• Writing Object Shape friendly code in Ruby

Then I would recommend you read about YJIT:

• YJIT Is the Most Memory-Efficient Ruby JIT

• Ruby 3.3's YJIT: Faster While Using Less Memory

• Ruby 3.2s YJIT is Production-Ready

I think you could also read a good article about Ractors by Julie Kent or watch a presentation about them by Abiodun Olowode.

A more high-level overview

(A shameless plug) I would also recommend my presentation at Friendly.rb this year about The State of the Rubyverse where I try to show various projects happening in Ruby world:

Going deep into details

I would recommend you browse https://rubyreferences.github.io/rubychanges/

It contains a more detailed (with examples) list of changes per each Ruby version.

Then I would recommend the series called Advent of Prism from Kevin Netwon and also watch this video from Takashi Kokubun about RJIT

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

In preparation for this, Ruby 3.3 will show a warning when it is used without a receiver, argument, or block.

I made a quick video about this if you want to watch it or if you prefer the written version continue reading on:

Deprecation warning

For this, let's define some simple code where I will name a method it and then call it from a block:

puts RUBY_VERSIONdef it = "works"def run(&block) = yieldputs run { it }

If you run this with Ruby 3.2.2 then you will get the following result:

3.2.2works

But if you run this with Ruby 3.3.0.rc1 you will get the following result:

example_deprecation_warning.rb:7: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4; use it() or self.it3.3.0works

How to fix the warning

In case you have a method named it and still want to call it inside a block without a receiver, arguments or params you should either add paranthesis:

- puts run { it }+ puts run { it() }

or add the receiver:

- puts run { it }+ puts run { self.it }

When using it as local variable name

There will be no problem when you defined it as local variable name.

Here is an example where I created:

puts RUBY_VERSIONdef log(&block) = puts yielddef run  it = 2  log { it }endrun

If you run this it on Ruby 3.3.0.rc1 will not display an error. The output will be:

3.3.02

Now if you will extract the local variable to a method with the same name:

puts RUBY_VERSIONdef log(&block) = puts yield++ def it = 2+def run-  it = 2  log { it }endrun

It will show a warning:

it_as_local_variable.rb:8: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4; use it() or self.it3.3.02

RSpec

RSpec uses a lot it. But in most cases (I would argue majority of them) this will not be a problem. Because usually it is called with a string argument:

require "rspec"describe Galaxy do  context "when created with a name and number of stars" do    it "should hold the correct name and star count" do      galaxy = Galaxy.new("Milky Way", 100_000_000_000)      expect(galaxy.name).to eq("Milky Way")      expect(galaxy.number_of_stars).to eq(100_000_000_000)    end  endend

The code above will NOT display a warning.

But if you will try to write something like this:

require "rspec"describe Galaxy do  subject { Galaxy.new("Milky Way", 100_000_000_000).stars }  context "When there are no known stars" do    it  endend

If you run this with Ruby 3.3.0.rc.1 you will get the warning:

explore-it/rspec_example/spec/more_galaxy_spec.rb:8: warning: `it` calls without arguments will refer to the first block param in Ruby 3.4; use it() or self.it*Pending: (Failures listed here are expected and do not affect your suite's status)  1) Galaxy When there are no known stars      # Not yet implemented     # ./spec/more_galaxy_spec.rb:8Finished in 0.0074 seconds (files took 0.06474 seconds to load)1 example, 0 failures, 1 pending

You can fix this by using one of the other alias for it from RSpec:

• specify

• example

Here is the complete list of methods defined in RSpec core:

# Defines an example within a group.define_example_method :example# Defines an example within a group.# This is the primary API to define a code example.define_example_method :it# Defines an example within a group.# Useful for when your docstring does not read well off of `it`.# @example#  RSpec.describe MyClass do#    specify "#do_something is deprecated" do#      # ...#    end#  enddefine_example_method :specify# Shortcut to define an example with `:focus => true`.# @see exampledefine_example_method :focus,    :focus => true# Shortcut to define an example with `:focus => true`.# @see exampledefine_example_method :fexample, :focus => true# Shortcut to define an example with `:focus => true`.# @see exampledefine_example_method :fit,      :focus => true# Shortcut to define an example with `:focus => true`.# @see exampledefine_example_method :fspecify, :focus => true# Shortcut to define an example with `:skip => 'Temporarily skipped with xexample'`.# @see exampledefine_example_method :xexample, :skip => 'Temporarily skipped with xexample'# Shortcut to define an example with `:skip => 'Temporarily skipped with xit'`.# @see exampledefine_example_method :xit,      :skip => 'Temporarily skipped with xit'# Shortcut to define an example with `:skip => 'Temporarily skipped with xspecify'`.# @see exampledefine_example_method :xspecify, :skip => 'Temporarily skipped with xspecify'# Shortcut to define an example with `:skip => true`# @see exampledefine_example_method :skip,     :skip => true# Shortcut to define an example with `:pending => true`# @see exampledefine_example_method :pending,  :pending => true

Conclusion

I really like that it was accepted as a default block parameter. Looking forward to Ruby 3.4 (next year) to write code using it.

The warning feature in Ruby 3.3 serves as a useful heads-up for potential conflicts with its usage, although these are expected to occur infrequently.

The transition should be smooth for most developers. RSpec tests should not require any changes, as it largely uses it with a string argument and is not likely to trigger the warning. In the instances where it does, alternatives like specify and example can be used to fix the warning.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

https://joinmastodon.org

Mastodon is a free, open-source social network server based on ActivityPub where users can follow friends and discover new ones. On Mastodon, users can publish anything they want: links, pictures, text, and video. All Mastodon servers are interoperable as a federated network.

Open source

The project is open source at https://github.com/mastodon/mastodon

License

The license is GNU Affero General Public License v3.0

Technical review

Architecture

Ruby on Rails - used for API and some of the web pages

React and Redux - used for dynamic parts of the interface

Node.js - used for streaming API

I will focus on this review on the Ruby on Rails part.

Ruby and Rails version

It uses Ruby 3.2.2 and (at the moment of writing this review) Rails 7.1.1

Stats

Running bin/rails stats will give the following:

Running the VScodeCounter will give the following stats:

There are very few actual XML files. So what is marked there as XML is probably a flavour of HTML either from the Ruby on Rails side or from the React/Nodejs side.

Style Guide

They are using Rubocop to enforce coding guidelines. They are using along with standard Rubocop:

• rubocop-rails - "Automatic Rails code style checking tool. A RuboCop extension focused on enforcing Rails best practices and coding conventions."

• rubocop-performance - "A collection of RuboCop cops to check for performance optimizations in Ruby code."

• rubocop-capybara - " Code style checking for Capybara test files (RSpec, Cucumber, Minitest). A plugin for the RuboCop code style enforcing & linting tool"

• rubocop-rspec - " Code style checking for RSpec files. A plugin for the RuboCop code style enforcing & linting tool"

And a custom cop called MiddleDot that does the following:

Bans the usage of (bullet) in HTML/HAML in favour of (middle dot) in string literals

Here are some extra configurations for Rubocop:

• DisplayStyleGuide: true so that it will display the URL for the Style guide when there is an offense.

• UseCache: true - to store and reuse results for making the Rubocop run faster

What I noticed and liked is that for each Rubocop rule where they overwrite, they provide as a comment the URL for that rule. This makes it easier to navigate to it and read about it.

Storage Persistence and in-memory storage

The database used is PostgreSQL and they configure by default a primary and replica DB:

The Database pool is set by using the following:

# https://github.com/mastodon/mastodon/blob/main/config/database.yml#L3pool: <%= ENV["DB_POOL"] || (if Sidekiq.server? then Sidekiq[:concurrency] else ENV['MAX_THREADS'] end) || 5 %>

So if there is not DB_POOL environment it will try to use Sidekiq[:concurrency] else it will default to `MAX_THREADS`

As in-memory storage it uses Redis and there is a RedisConfiguration object that helps with configuring the connection pool:

# https://github.com/mastodon/mastodon/blob/main/app/lib/redis_configuration.rb#L3class RedisConfiguration  class << self    def establish_pool(new_pool_size)      @pool&.shutdown(&:close)      @pool = ConnectionPool.new(size: new_pool_size) { new.connection }    end    delegate :with, to: :pool    def pool      @pool ||= establish_pool(pool_size)    end    def pool_size      if Sidekiq.server?        Sidekiq[:concurrency]      else        ENV['MAX_THREADS'] || 5      end    end  end  def connection    if namespace?      Redis::Namespace.new(namespace, redis: raw_connection)    else      raw_connection    end  end# ... other methodend

It uses a class instance variables @pool to share the connection pool across multiple instances of this class and the size is by default Sidekiq[:concurrency] size if Sidekiq used or MAX_THREADS value.

If there is an environment variable REDIS_NAMESPACE it will use Redis under that specific namespace.

Further down this RedisConfiguration is added to other objects (controllers for example) by using a module called Redisable

# https://github.com/mastodon/mastodon/blob/main/app/models/concerns/redisable.rb#L3module Redisable  def redis    Thread.current[:redis] ||= RedisConfiguration.pool.checkout  end  def with_redis(&block)    RedisConfiguration.with(&block)  endend

There is then a module called Lockable that defines with_redis_lock:

# https://github.com/mastodon/mastodon/blob/main/app/models/concerns/lockable.rb#L3module Lockable  # @param [String] lock_name  # @param [ActiveSupport::Duration] autorelease Automatically release the lock after this time  # @param [Boolean] raise_on_failure Raise an error if a lock cannot be acquired, or fail silently  # @raise [Mastodon::RaceConditionError]  def with_redis_lock(lock_name, autorelease: 15.minutes, raise_on_failure: true)    with_redis do |redis|      RedisLock.acquire(redis: redis, key: "lock:#{lock_name}", autorelease: autorelease.seconds) do |lock|        if lock.acquired?          yield        elsif raise_on_failure          raise Mastodon::RaceConditionError, "Could not acquire lock for #{lock_name}, try again later"        end      end    end  endend

They are used for example in a controller:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/api/v1/statuses/reblogs_controller.rb#L3class Api::V1::Statuses::ReblogsController < Api::V1::Statuses::BaseController  include Redisable  include Lockable  # ... callbacks  def create    with_redis_lock("reblog:#{current_account.id}:#{@reblog.id}") do      @status = ReblogService.new.call(current_account, @reblog, reblog_params)    end    render json: @status, serializer: REST::StatusSerializer  end  # ... other methodsend

Gems used

I picked some gems from the Gemfile that I found interesting to mention:

• addressable - "Addressable is an alternative implementation to the URI implementation that is part of Ruby's standard library. It is flexible, offers heuristic parsing, and additionally provides extensive support for IRIs and URI templates"

• blurhash - "Encode an image as a small string that can saved in the database and used to show a blurred preview before the real image loads"

• charlock_holmes - "charlock_holmes provides binary and text detection as well as text transcoding using libicu"

• chewy - "Chewy provides functionality for Elasticsearch index handling, documents import mappings and chainable query DSL"

• climate_control - "Modify your ENV"

• cocoon - "Unobtrusive nested forms handling, using jQuery. Use this and discover cocoon-heaven."

• color_diff - "Calculate RGB color distances using CIEDE2000 formula"

• discard - "Allows marking ActiveRecord objects as discarded, and provides scopes for filtering."

• doorkeeper - "Doorkeeper is an OAuth 2 provider for Rails and Grape."

• ed25519 - "A Ruby binding to the Ed25519 elliptic curve public-key signature system described in RFC 8032."

• email_spec - "Easily test email in RSpec, Cucumber, and MiniTest"

• fabrication - "Fabrication is an object generation framework for ActiveRecord, Mongoid, DataMapper, Sequel, or any other Ruby object."

• fast_blank - "Provides a C-optimized method for determining if a string is blank"

• fastimage - "FastImage finds the size or type of an image given its uri by fetching as little as needed."

• fuubar - "the instafailing RSpec progress bar formatter"

• haml_lint - "Configurable tool for writing clean and consistent HAML"

• hcaptcha - "Ruby helpers for hCaptcha"

• htmlentities - "A module for encoding and decoding (X)HTML entities."

• http_accept_language - "Find out which locale the user preferes by reading the languages they specified in their browser"

• httplog - "Log outgoing HTTP requests made from your application. Helpful for tracking API calls of third party gems that don't provide their own log output."

• i18n-tasks - "i18n-tasks helps you find and manage missing and unused translations. It analyses code statically for key usages, such as I18n.t('some.key'), in order to report keys that are missing or unused, pre-fill missing keys (optionally from Google Translate), and remove unused keys. "

• idn-ruby - " Ruby Bindings for the GNU LibIDN library, an implementation of the Stringprep, Punycode and IDNA specifications defined by the IETF Internationalized Domain Names (IDN) working group. Included are the most important parts of the Stringprep, Punycode and IDNA APIs like performing Stringprep processings, encoding to and decoding from Punycode strings and converting entire domain names to and from the ACE encoded form. "

• json-ld - "JSON::LD parses and serializes JSON-LD into RDF and implements expansion, compaction and framing API interfaces for the Ruby RDF.rb library suite."

• json-ld-preloaded - "A meta-release of the json-ld gem including preloaded vocabularies for the Ruby RDF.rb library suite."

• json-schema - "Ruby JSON Schema Validator"

• kt-paperclip - "Easy upload management for ActiveRecord"

• link_header - "Converts conforming link headers to and from text, LinkHeader objects and corresponding (JSON-friendly) Array representations, also HTML link elements."

• mario-redis-lock - "Yet another Ruby distributed lock using Redis, with emphasis in transparency. Requires Redis >= 2.6.12, because it uses the new syntax for SET to easily implement the robust algorithm described in the SET command documentation (http://redis.io/commands/set)."

• memory_profiler - "Memory profiling routines for Ruby 2.5+"

• nsa - "Listen to your Rails ActiveSupport::Notifications and deliver to a Statsd compatible backend"

• oj - "The fastest JSON parser and object serializer."

• ox - "A fast XML parser and object serializer that uses only standard C lib. Optimized XML (Ox), as the name implies was written to provide speed optimized XML handling. It was designed to be an alternative to Nokogiri and other Ruby XML parsers for generic XML parsing and as an alternative to Marshal for Object serialization. "

• parslet - "Parser construction library with great error reporting in Ruby."

• pghero - "A performance dashboard for Postgres"

• private_address_check - "Checks if a IP or hostname would cause a request to a private network (RFC 1918)"

• public_suffix - "PublicSuffix can parse and decompose a domain name into top level domain, domain and subdomains."

• redis-namespace - "Adds a Redis::Namespace class which can be used to namespace calls to Redis. This is useful when using a single instance of Redis with multiple, different applications. "

• ruby-progressbar - "Ruby/ProgressBar is an extremely flexible text progress bar library for Ruby. The output can be customized with a flexible formatting system including: percentage, bars of various formats, elapsed time and estimated time remaining."

• scenic - " Adds methods to ActiveRecord::Migration to create and manage database views in Rails "

• sidekiq-bulk - "Augments Sidekiq job classes with a push_bulk method for easier bulk pushing."

• sidekiq-unique-jobs - "Prevents simultaneous Sidekiq jobs with the same unique arguments to run. Highly configurable to suite your specific needs. "

• simple-navigation - "With the simple-navigation gem installed you can easily create multilevel navigations for your Rails, Sinatra or Padrino applications. The navigation is defined in a single configuration file. It supports automatic as well as explicit highlighting of the currently active navigation through regular expressions."

• stoplight - "An implementation of the circuit breaker pattern."

• tty-prompt - "A beautiful and powerful interactive command line prompt with a robust API for getting and validating complex inputs."

• twitter-text - "A gem that provides text handling for Twitter"

• xorcist - "Blazing-fast-cross-platform-monkey-patch-free string XOR. Yes, that means JRuby too."

Code & Design Patterns

Folders

Here are some non-standard Rails folders:

• app/chewy - containing Chewy objects

• app/policies - containing objects that implement policies used by Pundit gem

• app/presenters - contain objects that implement ActiveModelSerializers::Model interface or that exposes methods that return hashes

• app/services - contain objects that implement Service Object pattern

• app/validators - contain objects that mostly implement ActiveModel::Validator interface

• app/workers - contain objects that implement Sidekiq::Worker interface

• app/lib - contains probably POROs that do not belong anywhere else

• dist - contains systemd files used to manage all web app services on Linux-based systems with systemd installed

• lib - contains code that either extends or changes other libraries objects or that extends external libraries used

Controllers

There are 2 main categories of controllers when thinking about how the information will be displayed:

• General controllers (like the ones that are directly under app/controllers or app/controllers/admin) that render an SSR view that will write some HTML tags and then load the React app. They respond to html and json

• The controllers under app/api that only responds to json

Caching

It implements the Vary header:

The Vary HTTP response header describes the parts of the request message aside from the method and URL that influenced the content of the response it occurs in. Most often, this is used to create a cache key when content negotiation is in use.

# https://github.com/mastodon/mastodon/blob/main/app/controllers/concerns/cache_concern.rb#L150def vary_by(value, **kwargs)  before_action(**kwargs) do |controller|    response.headers['Vary'] = value.respond_to?(:call) ? controller.instance_exec(&value) : value  endend# Used like this# https://github.com/mastodon/mastodon/blob/main/app/controllers/follower_accounts_controller.rb#L3vary_by -> { public_fetch_mode? ? 'Accept, Accept-Language, Cookie' : 'Accept, Accept-Language, Cookie, Signature' }

A note about using instance_exec is a method from BasicObject#instance_eval that can be used to execute a block within the context of the receiver.

Another method used is render_with_cache used by API controllers to cache JSON responses:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/concerns/cache_concern.rb#L172 def render_with_cache(**options)  raise ArgumentError, 'Only JSON render calls are supported' unless options.key?(:json) || block_given?  key        = options.delete(:key) || [[params[:controller], params[:action]].join('/'), options[:json].respond_to?(:cache_key) ? options[:json].cache_key : nil, options[:fields].nil? ? nil : options[:fields].join(',')].compact.join(':')  expires_in = options.delete(:expires_in) || 3.minutes  body       = Rails.cache.read(key, raw: true)  if body    render(options.except(:json, :serializer, :each_serializer, :adapter, :fields).merge(json: body))  else    if block_given?      options[:json] = yield    elsif options[:json].is_a?(Symbol)      options[:json] = send(options[:json])    end    render(options)    Rails.cache.write(key, response.body, expires_in: expires_in, raw: true)  endend# Used like this:# https://github.com/mastodon/mastodon/blob/main/app/controllers/accounts_controller.rb#L35format.json do  expires_in 3.minutes, public: !(authorized_fetch_mode? && signed_request_account.present?)  render_with_cache json: @account, content_type: 'application/activity+json', serializer: ActivityPub::ActorSerializer, adapter: ActivityPub::Adapterend

And a third method that is used is cache_collection used with models that include the Cacheable concern:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/concerns/cache_concern.rb#L193-L194def cache_collection(raw, klass)  return raw unless klass.respond_to?(:with_includes)  raw = raw.cache_ids.to_a if raw.is_a?(ActiveRecord::Relation)  return [] if raw.empty?  cached_keys_with_value = begin    Rails.cache.read_multi(*raw).transform_keys(&:id).transform_values { |r| ActiveRecordCoder.load(r) }  rescue ActiveRecordCoder::Error    {} # The serialization format may have changed, let's pretend it's a cache miss.  end  uncached_ids = raw.map(&:id) - cached_keys_with_value.keys  klass.reload_stale_associations!(cached_keys_with_value.values) if klass.respond_to?(:reload_stale_associations!)  unless uncached_ids.empty?    uncached = klass.where(id: uncached_ids).with_includes.index_by(&:id)    uncached.each_value do |item|      Rails.cache.write(item, ActiveRecordCoder.dump(item))    end  end  raw.filter_map { |item| cached_keys_with_value[item.id] || uncached[item.id] }end# Used like this:format.rss do  expires_in 1.minute, public: true  limit     = params[:limit].present? ? [params[:limit].to_i, PAGE_SIZE_MAX].min : PAGE_SIZE  @statuses = filtered_statuses.without_reblogs.limit(limit)  @statuses = cache_collection(@statuses, Status)end

Controller with multiple respond_to

Here is an example of a controller action with multiple respond_to formats:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/accounts_controller.rb#L17def show  respond_to do |format|    format.html do      expires_in(15.seconds, public: true, stale_while_revalidate: 30.seconds, stale_if_error: 1.hour) unless user_signed_in?      @rss_url = rss_url    end    format.rss do      expires_in 1.minute, public: true      limit     = params[:limit].present? ? [params[:limit].to_i, PAGE_SIZE_MAX].min : PAGE_SIZE      @statuses = filtered_statuses.without_reblogs.limit(limit)      @statuses = cache_collection(@statuses, Status)    end    format.json do      expires_in 3.minutes, public: !(authorized_fetch_mode? && signed_request_account.present?)      render_with_cache json: @account, content_type: 'application/activity+json', serializer: ActivityPub::ActorSerializer, adapter: ActivityPub::Adapter    end  endend

ApplicationController

It includes a list of concerns, defines some helper methods and define a couple of rescue_from responses.

What I discovered here and I find useful to have a common language when writing custom controllers:

truthy_param? the method that I think is useful to use to check if a param is a truthy value:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/application_controller.rb#L91def truthy_param?(key)  ActiveModel::Type::Boolean.new.cast(params[key])end# Used like this# https://github.com/mastodon/mastodon/blob/main/app/controllers/api/v1/timelines/public_controller.rb#L37-L44def public_feed  PublicFeed.new(    current_account,    local: truthy_param?(:local),    remote: truthy_param?(:remote),    only_media: truthy_param?(:only_media)  )end

A series of methods that can be used to respond with errors:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/application_controller.rb#L169-L174# First there is a respond_with_error defined: def respond_with_error(code)  respond_to do |format|    format.any  { render "errors/#{code}", layout: 'error', status: code, formats: [:html] }    format.json { render json: { error: Rack::Utils::HTTP_STATUS_CODES[code] }, status: code }  endend# Then there a series of methods defined like this:# https://github.com/mastodon/mastodon/blob/main/app/controllers/application_controller.rb#L96def forbidden  respond_with_error(403)enddef not_found  respond_with_error(404)enddef gone  respond_with_error(410)end

Models

Some stats:

• 189 files in app/models and 29 of them are in app/models/concerns

• 71 files are not directly inherited from ApplicationRecord

• 89 are ActiveRecord models

The ApplicationRecord model is connected to writing and reading databases and defines one common instance method boolean_with_default that will be used to define some getters that return a default value when nil. It is a simple method but very useful.

# https://github.com/mastodon/mastodon/blob/main/app/models/application_record.rb#L16def boolean_with_default(key, default_value)  value = attributes[key]  if value.nil?    default_value  else    value  endend# Used like this# https://github.com/mastodon/mastodon/blob/main/app/models/tag.rb#L71def usable  boolean_with_default('usable', true)endalias usable? usable

Also, notice the choice to use alias to define the predicate method usable? instead of defining it as a normal method (e.g. def usable? = usable)

Here are some things that I found in the models:

Counting cache

The Account model has a couple of associated stats models implemented by using a has_one :account_stat that includes some colums like: statuses_count, following_count, followers_count . The count is incremented by executing the following SQL:

# https://github.com/mastodon/mastodon/blob/main/app/models/concerns/account_counters.rb#L34def update_count!(key, value)# omitted code ...  sql = if value.positive? && key == :statuses_count          <<-SQL.squish            INSERT INTO account_stats(account_id, #{key}, created_at, updated_at, last_status_at)              VALUES (:account_id, :default_value, now(), now(), now())            ON CONFLICT (account_id) DO UPDATE            SET #{key} = account_stats.#{key} + :value,                last_status_at = now(),                updated_at = now()            RETURNING id;          SQL        else          <<-SQL.squish            INSERT INTO account_stats(account_id, #{key}, created_at, updated_at)              VALUES (:account_id, :default_value, now(), now())            ON CONFLICT (account_id) DO UPDATE            SET #{key} = account_stats.#{key} + :value,                updated_at = now()            RETURNING id;          SQL        end  sql = AccountStat.sanitize_sql([sql, account_id: id, default_value: default_value, value: value])  account_stat_id = AccountStat.connection.exec_query(sql)[0]['id']  # Omitted code ..end# Used like thisdef increment_count!(key) = update_count!(key, 1)def decrement_count!(key) = update_count!(key, -1)

The reason for using the custom SQL is explained in the same method:

We do an upsert using manually written SQL, as Rails' upsert method does not seem to support writing expressions in the UPDATE clause, but only re-insert the provided values instead. Even ARel seem to be missing proper handling of upserts.

This will be used in the following way:

class Favourite < ApplicationRecord  after_create :increment_cache_counters  belongs_to :status,  inverse_of: :favourites  # Code omitted ...   private  def increment_cache_counters    status&.increment_count!(:favourites_count)  end  # code omitted ...end

User Roles

User Roles are defined in the UserRole AR model using the bitwise shift left operator:

class UserRole < ApplicationRecord  FLAGS = {    administrator: (1 << 0),    view_devops: (1 << 1),    view_audit_log: (1 << 2),    view_dashboard: (1 << 3),    manage_reports: (1 << 4),    manage_federation: (1 << 5),    manage_settings: (1 << 6),    manage_blocks: (1 << 7),    manage_taxonomies: (1 << 8),    manage_appeals: (1 << 9),    manage_users: (1 << 10),    manage_invites: (1 << 11),    manage_rules: (1 << 12),    manage_announcements: (1 << 13),    manage_custom_emojis: (1 << 14),    manage_webhooks: (1 << 15),    invite_users: (1 << 16),    manage_roles: (1 << 17),    manage_user_access: (1 << 18),    delete_user_data: (1 << 19),  }.freeze  module Flags    NONE = 0    ALL  = FLAGS.values.reduce(&:|)    DEFAULT = FLAGS[:invite_users]    # code omitted ...   end  # code omitted ... end

In case you want to understand how they are used, here are some expressions:

• If you execute (1 << 2).to_s(2) => 100

• If you execute (1 << 3).to_s(2) => 1000

• If you execute ((1<<2) | (1<<3)).to_s(2) => 1100

• If you execute ALL.to_s(2) will get 11111111111111111111

Then in the UserRole model there are the following methods defined:

# https://github.com/mastodon/mastodon/blob/main/app/models/user_role.rb#L164def can?(*any_of_privileges)  any_of_privileges.any? { |privilege| in_permissions?(privilege) }enddef in_permissions?(privilege)  raise ArgumentError, "Unknown privilege: #{privilege}" unless FLAGS.key?(privilege)  computed_permissions & FLAGS[privilege] == FLAGS[privilege]end

They are used in AccountPolicy like this:

# https://github.com/mastodon/mastodon/blob/main/app/policies/account_policy.rb#L3class AccountPolicy < ApplicationPolicy  def index?    role.can?(:manage_users)  end  def show?    role.can?(:manage_users)  end# code omitted ...end

Services

BaseService

There is a simple BaseService that looks like this:

# https://github.com/mastodon/mastodon/blob/main/app/services/base_service.rb#L3class BaseService  include ActionView::Helpers::TextHelper  include ActionView::Helpers::SanitizeHelper  include RoutingHelper  def call(*)    raise NotImplementedError  endend

and then almost all services are inherited from this BaseService

The services defined here can be called from controllers or from models.

Here is an example of the Follow service (will just add here the #call method):

• It documents the call using the YARD format

• It uses comments to explain why the home feed is marked as partial! (that will set a key in Redis to regenerate the home feed)

# https://github.com/mastodon/mastodon/blob/main/app/services/follow_service.rb#L3# Follow a remote user, notify remote user about the follow# @param [Account] source_account From which to follow# @param [Account] target_account Account to follow# @param [Hash] options# @option [Boolean] :reblogs Whether or not to show reblogs, defaults to true# @option [Boolean] :notify Whether to create notifications about new posts, defaults to false# @option [Array<String>] :languages Which languages to allow on the home feed from this account, defaults to all# @option [Boolean] :bypass_locked# @option [Boolean] :bypass_limit Allow following past the total follow number# @option [Boolean] :with_rate_limitdef call(source_account, target_account, options = {})  @source_account = source_account  @target_account = target_account  @options        = { bypass_locked: false, bypass_limit: false, with_rate_limit: false }.merge(options)  raise ActiveRecord::RecordNotFound if following_not_possible?  raise Mastodon::NotPermittedError  if following_not_allowed?  if @source_account.following?(@target_account)    return change_follow_options!  elsif @source_account.requested?(@target_account)    return change_follow_request_options!  end  ActivityTracker.increment('activity:interactions')  # When an account follows someone for the first time, avoid showing  # an empty home feed while the follow request is being processed  # and the feeds are being merged  mark_home_feed_as_partial! if @source_account.not_following_anyone?  if (@target_account.locked? && !@options[:bypass_locked]) || @source_account.silenced? || @target_account.activitypub?    request_follow!  elsif @target_account.local?    direct_follow!  endend

FetchLinkCardService

Here is a piece of code from FetchLinkCardService that parses a status and extracts shared URLs.

First, it defines a Regexp for searching for URL patterns:

# https://github.com/mastodon/mastodon/blob/main/app/services/fetch_link_card_service.rb#L7  URL_PATTERN = %r{    (#{Twitter::TwitterText::Regex[:valid_url_preceding_chars]})                                                                #   $1 preceding chars    (                                                                                                                           #   $2 URL      (https?://)                                                                                                               #   $3 Protocol (required)      (#{Twitter::TwitterText::Regex[:valid_domain]})                                                                           #   $4 Domain(s)      (?::(#{Twitter::TwitterText::Regex[:valid_port_number]}))?                                                                #   $5 Port number (optional)      (/#{Twitter::TwitterText::Regex[:valid_url_path]}*)?                                                                      #   $6 URL Path and anchor      (\?#{Twitter::TwitterText::Regex[:valid_url_query_chars]}*#{Twitter::TwitterText::Regex[:valid_url_query_ending_chars]})? #   $7 Query String    )  }iox

Then it extracts URLs with:

# https://github.com/mastodon/mastodon/blob/main/app/services/fetch_link_card_service.rb#L73def parse_urls  urls = if @status.local?            @status.text.scan(URL_PATTERN).map { |array| Addressable::URI.parse(array[1]).normalize }          else            document = Nokogiri::HTML(@status.text)            links = document.css('a')            links.filter_map { |a| Addressable::URI.parse(a['href']) unless skip_link?(a) }.filter_map(&:normalize)          end  urls.reject { |uri| bad_url?(uri) }.firstend

TagSearchService

Here is a nice and easy-to-read method in TagSearchService

# https://github.com/mastodon/mastodon/blob/main/app/services/tag_search_service.rb#L4def call(query, options = {})  @query   = query.strip.delete_prefix('#')  @offset  = options.delete(:offset).to_i  @limit   = options.delete(:limit).to_i  @options = options  results   = from_elasticsearch if Chewy.enabled?  results ||= from_database  resultsend

Views

The views have the following structure:

• They are written using HAML

• The contains in the HAML file some content_for header or open graph

• And they call at the end shared/web_app

Example from the Home#index:

- # https://github.com/mastodon/mastodon/blob/main/app/views/home/index.html.haml#L1- content_for :header_tags do  - unless request.path == '/'    %meta{ name: 'robots', content: 'noindex' }/  = render partial: 'shared/og'= render 'shared/web_app'

Where the web_app will do something like this:

• Preload some assets based on user sign-in

• Render by using InitialStatePresenter as JSON in a Script tag

• Include javascript_pack_tag for application

I will not go into this review into the Javascript part as this is focused on Ruby and Rails.

Testing

It uses RSPec for testing.

In general, the tests are pretty straightforward, with very few custom matches defined.

The tests are easy to find as the folder inside spec matches the folder in app.

The coverage is a bit hard to guess from the test folder structure:

• not all controllers have a corresponding test in controller specs

• not all models have a corresponding test in model specs

Just looking at some numbers (as I don't have time to understand the entire codebase) here is a comparison of the number of files in the app folder vs the number of files in the corresponding specs folder.

Generating data

It uses Fabricator gem to generate test data. Here is an example of generating a User:

Fabricator(:user) do  account      { Fabricate.build(:account, user: nil) }  email        { sequence(:email) { |i| "#{i}#{Faker::Internet.email}" } }  password     '123456789'  confirmed_at { Time.zone.now }  current_sign_in_at { Time.zone.now }  agreement trueend

and then it can be called as Fabricator(:user)

Testing views

Probably the React part is tested in some other specific way. I will not dig into that. But here is a test for open graph tags included in the status view:

# https://github.com/mastodon/mastodon/blob/main/spec/views/statuses/show.html.haml_spec.rb#L5describe 'statuses/show.html.haml', :without_verify_partial_doubles do  before do    allow(view).to receive_messages(api_oembed_url: '', show_landing_strip?: true, site_title: 'example site', site_hostname: 'example.com', full_asset_url: '//asset.host/image.svg', current_account: nil, single_user_mode?: false)    allow(view).to receive(:local_time)    allow(view).to receive(:local_time_ago)    assign(:instance_presenter, InstancePresenter.new)  end  it 'has valid opengraph tags' do    alice  = Fabricate(:account, username: 'alice', display_name: 'Alice')    status = Fabricate(:status, account: alice, text: 'Hello World')    Fabricate(:media_attachment, account: alice, status: status, type: :video)    assign(:status, status)    assign(:account, alice)    assign(:descendant_threads, [])    render    header_tags = view.content_for(:header_tags)    expect(header_tags).to match(/<meta content=".+" property="og:title">/)    expect(header_tags).to match(/<meta content="article" property="og:type">/)    expect(header_tags).to match(/<meta content=".+" property="og:image">/)    expect(header_tags).to match(%r{<meta content="http://.+" property="og:url">})  end# code omitted ...end

Testing Rack::Attack

This is done via shared_examples:

# https://github.com/mastodon/mastodon/blob/main/spec/config/initializers/rack/attack_spec.rb#L5describe Rack::Attack, type: :request do  def app    Rails.application  end  shared_examples 'throttled endpoint' do    before do      # Rack::Attack periods are not rolling, so avoid flaky tests by setting the time in a way      # to avoid crossing period boundaries.      # The code Rack::Attack uses to set periods is the following:      # https://github.com/rack/rack-attack/blob/v6.6.1/lib/rack/attack/cache.rb#L64-L66      # So we want to minimize `Time.now.to_i % period`      travel_to Time.zone.at(counter_prefix * period.seconds)    end    context 'when the number of requests is lower than the limit' do      before do        below_limit.times { increment_counter }      end      it 'does not change the request status' do        expect { request.call }.to change { throttle_count }.by(1)        expect(response).to_not have_http_status(429)      end    end    def throttle_count      described_class.cache.read("#{counter_prefix}:#{throttle}:#{remote_ip}") || 0    end # code omitted ..end

and the shared example will be used like this:

context 'when accessed through the website' do  let(:throttle) { 'throttle_sign_up_attempts/ip' }  let(:limit)  { 25 }  let(:period) { 5.minutes }  let(:request) { -> { post path, headers: { 'REMOTE_ADDR' => remote_ip } } }  context 'with exact path' do    let(:path) { '/auth' }    it_behaves_like 'throttled endpoint'  end# code omitted ..end

Conclusion

Mastodon open-source web app is a well-structured code base, easy to navigate (when focusing on the Ruby on Rails part). There is a good structure for testing and it probably covers most of the important functions, but there are still some models and controllers left out of testing that could be covered.

The code design is simple and easy to understand. The app tried to have slim controllers and pretty well-contained models while delegating more complex business logic to Service objects and simple Ruby objects. This makes the existing tests simple to follow and understand.

I think it could be a good pick for someone who wants to contribute. There are useful pieces of code that can be used as inspiration for other parts.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Here is a video version of this article:

or continue reading for the text version 👇

The original code

The original code is based on Mastodon ApplicationController:

# https://github.com/mastodon/mastodon/blob/main/app/controllers/application_controller.rb#L3class ApplicationController < ActionController::Base  # other code ...  def forbidden    respond_with_error(403)  end  def not_found    respond_with_error(404)  end  def gone    respond_with_error(410)  end  def unprocessable_entity    respond_with_error(422)  end  def not_acceptable    respond_with_error(406)  end  def bad_request    respond_with_error(400)  end  def internal_server_error    respond_with_error(500)  end  def service_unavailable    respond_with_error(503)  end  def too_many_requests    respond_with_error(429)  end  # other code ...end

Refactoring

Use the endless method

# https://github.com/mastodon/mastodon/blob/main/app/controllers/application_controller.rb#L3class ApplicationController < ActionController::Base  # other code ...  def forbidden = respond_with_error(403)  def not_found = respond_with_error(404)  def gone = respond_with_error(410)  def unprocessable_entity = respond_with_error(422)  def not_acceptable = respond_with_error(406)  def bad_request = respond_with_error(400)  def internal_server_error = respond_with_error(500)  def service_unavailable = respond_with_error(503)  def too_many_requests = respond_with_error(429)  # other code ...end

In this specific case, the endless method is the best to be used here.

It is almost like aliasing the same method but giving it different names based on the parameters passed.

Let's take a look at a side-by-side comparison:

Extract to a concern

I think we can take this one step further and extract it all to a concern or simple module if you want to:

module RespondWithError  extend ActiveSupport::Concern  private  def forbidden = respond_with_error(403)  def not_found = respond_with_error(404)  def gone = respond_with_error(410)  def unprocessable_entity = respond_with_error(422)  def not_acceptable = respond_with_error(406)  def bad_request = respond_with_error(400)  def internal_server_error = respond_with_error(500)  def service_unavailable = respond_with_error(503)  def too_many_requests = respond_with_error(429)  def respond_with_error(code)    respond_to do |format|      format.any  { render "errors/#{code}", layout: 'error', status: code, formats: [:html] }      format.json { render json: { error: Rack::Utils::HTTP_STATUS_CODES[code] }, status: code }    end  endend

This way all behavior about responding with error status code is contained in a single file. Adding or changing this behaviour could be made in this one single place.

Group together by status code

Based on the reply from Russell Garner and Bradley Schaefer we can refactor this more by removing new lines between endless methods and grouping them by status:

module RespondWithError  extend ActiveSupport::Concern  private  # Client error responses 4xx  def bad_request           = respond_with_error(400)  def forbidden             = respond_with_error(403)  def not_found             = respond_with_error(404)  def not_acceptable        = respond_with_error(406)  def gone                  = respond_with_error(410)  def unprocessable_entity  = respond_with_error(422)  def too_many_requests     = respond_with_error(429)  # Server error responses 5xx  def internal_server_error = respond_with_error(500)  def service_unavailable   = respond_with_error(503)  def respond_with_error(code)    respond_to do |format|      format.any  { render "errors/#{code}", layout: 'error', status: code, formats: [:html] }      format.json { render json: { error: Rack::Utils::HTTP_STATUS_CODES[code] }, status: code }    end  endend

Read more about the endless method

I strongly recommend this article from Victor Shepelev about the endless method:

https://zverok.substack.com/p/useless-ruby-sugar-endless-one-line

You will find there more cases and examples about when to use and when not to use this construct.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Updates

• 2023-12-06: Added a new refactoring variant based on replies to my share on Ruby.social - see Group together by status code

• a list of gem names, one per line

• Gemfile format

Initial code

This is for my Rails app that I use to curate the content for the Short Ruby Newsletter and so in general I have little time to write code for it.

So I wrote a very quick draft of a working code along with some simple tests.

Here is the initial code:

class Parser  def initialize(list, rubygems_client: RubyGems::Client.new)    @list = list    @rubygems_client = rubygems_client  end  def parse    return parse_gemfile_format if gemfile_format?    parse_single_line_format  end  private    attr_reader :list, :rubygems_client    def gemfile_format? = lines.any? { gem_method_call?(_1) }    def parse_gemfile_format      ast = Prism.parse(list)      root_node = ast.value      parsed_gems = []      root_node.statements.body.each do |call_node|        case call_node.name        when :gem          name = gem_name_from_call_node(call_node)          parsed_gems << name        when :group          names = gem_names_from_group(call_node)          parsed_gems.concat(names) if names.present?        end      end      parsed_gems.compact_blank.map { rubygems_client.info(_1) }    end    def parse_single_line_format      lines.filter_map do |line|        gem_name = line.strip        gem_info = rubygems_client.info(gem_name) unless gem_name.empty?        gem_info      end.compact_blank    end    def gem_names_from_group(call_node)      statements_node = call_node&.block&.body      statements_node.body.map { gem_name_from_call_node(_1) }    end    def gem_name_from_call_node(call_node) = call_node&.arguments&.arguments&.first&.unescaped    def gem_method_call?(line) = line.strip.include?("gem ")    def lines = list.linesend

You can notice that the code is not very OOP and it also has some issues with naming. Add to that the fact that parse_gemfile_format is quite a long method and it can get a bit complex. It does not handle exceptions at all and it abuses a bit the Ruby safe operator (&.) when calling methods. Also, there are some cases that this parser will fail to handle like a more complex syntax of Gemfile.

So it seemed to me like a good fit to use it to assess the usefulness of using ChatGPT and RubyMine AI to review this code and propose improvements.

The prompt

I wrote a simple prompt that explains what I wanted to achieve with this code and describes some areas of concern:

I have a Ruby on Rails object designed for parsing a list of gems in various formats, including the Gemfile format, and for each gem, I will call a RubyGems client to get information about it.  The current implementation differentiates between the format of specifying one gem name per line and the Gemfile format and, based on this, will branch out into separate logic for each case. It uses Prism to parse the Gemfile format and identify the name of the gems. I'm concerned about the efficiency and readability of object and code design. I aim to refine the code to be more idiomatic and maintainable, ensuring it aligns with Ruby and Rails best practices. I also want to make use of the latest language features and syntax. One concern I have is how I use `prism` gem (repository is at https://github.com/ruby/prism and documentation at https://ruby.github.io/prism/rb/index.html).The application runs on Ruby 3.2 and Rails 7. Any suggestions should be compatible with these versions.Extra guidelines:I want the private methods ordered in the order the public methods require.When guidelines are conflicting, choose readability over anything else.

I know that the prompt can be made better but I wanted to make it as close as possible (while still making it a prompt) to maybe a discussion that anyone could have with a friend or colleague when asking for feedback.

ChatGPT

Here is the response from ChatGPT after I provided the prompt and the code:

Your Ruby on Rails code for parsing a list of gems is well-structured, but there are some improvements and refinements that can be made to enhance its efficiency, readability, and maintainability. Here are my suggestions:

1. Refactor Conditional Logic:

   • The parse method uses a conditional to differentiate between formats. This is clear, but you might want to encapsulate the format-checking logic in more descriptive methods to improve readability.

2. Use Memoization:

   • For methods that are called multiple times and return the same result, like lines, consider memoizing their results to improve efficiency.

3. Refactor parse_gemfile_format:

   • This method can be refactored to reduce its complexity and increase readability. Extract parts of its logic into smaller, more focused methods.

4. Refine gem_names_from_group and gem_name_from_call_node Methods:

   • These methods can be made more robust. Ensure that they handle potential nil cases gracefully.

5. Update Method Names for Clarity:

   • Renaming methods like gem_method_call? to something more descriptive can improve readability.

6. Error Handling:

   • Consider adding error handling for cases where the gem list might be in an unexpected format or when external calls fail.

7. Documentation and Comments:

   • Adding comments to explain complex parts of the code or the reasoning behind certain decisions can be very helpful for maintainability.

8. Leverage Ruby 3.2 Features:

   • Review the new features in Ruby 3.2 to see if any can be applied to improve the code. For example, pattern matching might be useful in parsing different formats.

9. Private Method Ordering:

   • Reorder the private methods to match the sequence in which they are called by the public methods.

It provided the following code:

class Parser  def initialize(list, rubygems_client: RubyGems::Client.new)    @list = list    @rubygems_client = rubygems_client  end  def parse    return parse_gemfile_format if gemfile_format?    parse_single_line_format  end  private    attr_reader :list, :rubygems_client    def gemfile_format?      lines.any? { |line| line.include?('gem ') }    end    def parse_gemfile_format      ast = Prism.parse(list).value      parse_ast_nodes(ast.statements.body)    end    def parse_single_line_format      lines.filter_map do |line|        next if line.strip.empty?        rubygems_client.info(line.strip)      end.compact    end    def parse_ast_nodes(nodes)      nodes.each_with_object([]) do |node, gems|        case node.name        when :gem          gems << gem_name_from_call_node(node)        when :group          gems.concat(gem_names_from_group(node))        end      end.compact.map { |name| rubygems_client.info(name) }    end    def gem_names_from_group(group_node)      block_node = group_node&.block&.body      block_node&.body&.map { |node| gem_name_from_call_node(node) } || []    end    def gem_name_from_call_node(node)      node&.arguments&.first&.unescaped    end    def lines      @lines ||= list.lines    endend

Review of the provided code

It is a bit more readable, the methods are smaller and I like the split into smaller methods.

It added memoization for lines. I am not sure how long the execution of String#lines take but could be an improvement to have them memoized. But it does not consider Object Shapes when introducing this change even if it was asked to use Ruby 3.2 features

It adds a bug that makes tests fail in the method gem_name_from_call_node(node) where it did the following change:

- node&.arguments&.arguments&.first&.unescaped+ node&.arguments&.first&.unescaped

This bug is a bit subtle and to catch it before running the tests one has to know that Prism returns the arguments from a CallNode (Prism:CallNode) as Prism::ArgumentsNode that has an attribute called arguments that will return the arguments as Arary.

Looking at this method:

def parse_ast_nodes(nodes)  nodes.each_with_object([]) do |node, gems|    case node.name    when :gem      gems << gem_name_from_call_node(node)    when :group      gems.concat(gem_names_from_group(node))    end  end.compact.map { |name| rubygems_client.info(name) }end

It is more idiomatic to use each_with_object to collect the gem names over the previous implementation where I manually created an accumulator variable but I find the end.compact.map syntax as inclining more to idiomatic than readability. At the same time, this is very subjective so I cannot say it is wrong.

I would have preferred:

def parse_ast_nodes(nodes)  gemlist = nodes.each_with_object([]) do |node, gems|    case node.name    when :gem      gems << gem_name_from_call_node(node)    when :group      gems.concat(gem_names_from_group(node))    end  end  gemlist.compact.map { |name| rubygems_client.info(name) }end

It also removed all numbered block params and all endless methods, even if they are valid syntax for Ruby 3.2 and I dare say they are more modern.

RubyMine AI

Here is the response from RubyMine AI:

From looking at your current implementation, you've done a great job at keeping your code well-structured and easy to reason about. The usage of syntax and language features from Ruby 3.2 shows a good understanding of modern Ruby idioms.

Here are some suggestions for refinements:

1. include? is not the most accurate method to use in gem_method_call?. Prefixing a gem name with 'gem' might not be on purpose and can lead to false positives. Using a regex that checks specifically for a 'gem' followed by a space at the start of a line would work better here; This avoids matching lines where 'gem' is somewhere in the gem's name rather than at the start.

2. Prism's parsing will fail for Gemfiles that include logic or DSL methods beyond simple gem or group calls, For robustness, consider adding error handling, or even falling back to parse_single_line_format method, This way you can always handle gem lists which are not neatly formatted.

3. You could consolidate the private methods gem_name_from_call_node and gem_names_from_group together into a single method that extracts gem names from a node, as they are both doing something quite similar.

4. To make the code a bit cleaner and more maintainable, you could refactor the parse_gemfile_format method further by extracting a few more smaller private methods out. This should make the code easier to read and understand.

Here is the code that is suggested:

class Parser  def initialize(list, rubygems_client: RubyGems::Client.new)    @list = list    @rubygems_client = rubygems_client  end  def parse    return parse_gemfile_format if gemfile_format?    parse_single_line_format  rescue StandardError => e    Rails.logger.error("Parsing gemfile format failed with exception: #{e.message}. Falling back to single line format.")    parse_single_line_format  end  private  attr_reader :list, :rubygems_client  def gemfile_format? = lines.any? { gem_method_call?(_1) }  def parse_gemfile_format    ast = Prism.parse(list)    root_node = ast.value    parsed_gems = nodes_to_gem_names(root_node.statements.body)    parsed_gems.compact_blank.map { rubygems_client.info(_1) }  end  def nodes_to_gem_names(nodes)    nodes.map do |node|      case node.name      when :gem then gem_name_from_node(node)      when :group then gem_names_from_node(node.block.body)      end    end.flatten.compact  end  def parse_single_line_format    lines.filter_map do |line|      gem_name = line.strip      gem_info = rubygems_client.info(gem_name) unless gem_name.empty?      gem_info    end.compact_blank  end  def gem_name_from_node(node) = node&.arguments&.arguments&.first&.unescaped  def gem_names_from_node(node) = nodes_to_gem_names(node.body)  def gem_method_call?(line) = line.lstrip.start_with?("gem ")  def lines = list.linesend

Review of the response

First, I think it identified two issues: (1) That a more complex Gemfile syntax will fail to be parsed and (2) Having a logic based on include?("gem") will fail if the name of a gem has the word gem inside.

Regarding the second case, I think it failed to see that the actual check is using gem<space> so it could fail for gem names that end with gem . But will work even in those cases because there is a strip call just before that (the actual code is strip.include?("gem ") ) so it will work well even for gems that finish in <name>gem because of the strip.

I appreciate that it did not refactor my endless methods and left them alone. But it did a subtle change and aligned all private methods to the private keyword, while the original code had the private method aligned and then nested under private keyword. This is not a bug but more of a style choice.

I like that it added a Rails logger when the parse fails in any way and in that case, will try to parse them as simple gem names.

I think extraction of the logic to nodes_to_gem_names makes it a bit better in readability.

And it passes all tests.

Conclusion

Both failed to identify some things that I think could make the code better:

• There are quite a few methods named like this gem_ and that is not a good name. I provided this example on purpose but, indeed, the prompt did not instruct specifically to give good names. Still, as the prompt says "readability" I think having good names is a pre-requisite of readability.

ChatGPT provided code that failed tests while RubyMine AI provided code that passed the tests.

ChatGPT removed endless methods and refactored them to normal methods. RubyMine AI respected my choice to use endless methods.

I would use an AI tool to kick start a code review and see their answers as a conversaation starter, but will not refactor based on their own review.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

https://feedbin.com

"Feedbin is the best way to enjoy content on the Web. By combining RSS, and newsletters, you can get all the good parts of the Web in one convenient location"

Open source

The open-source repository can be found at https://github.com/feedbin/feedbin

License

The license they use is MIT:

Technical review

Ruby and Rails version

They are currently using:

• Ruby version 3.2.2

• They used a fork of Rails at https://github.com/feedbin/rails forked from https://github.com/Shopify/rails. They are using a branch called 7-1-stable-invalid-cache-entries - It seems to be Rails 7.1 and about 1 month behind the Shopify/rails which is usually pretty up to date with main Rails

Architecture

Code Architecture:

• They are using the standard Rails organisation of MVC.

Database:

• The DB is PostgreSQL

Jobs queue:

• Sidekiq

On the front-end side:

• They use .html.erb

• They are using Phlex for components

• They are using Jquery for the JS library

• They have some custom JS code written in CoffeeScript

• They are using Hotwire via importmaps

• They are using Tailwind

Stats

Running /bin/rails stats will output the following:

Running VSCodeCounter will give the following stats:

Style Guide

For Ruby:

• They are using standardrb as the Style Guide with no customisations.

Storage, Persistence and in-memory storage

The DB is PostgreSQL.

They are not using the schema.rb but the structure.sql format for DB schema dump is configured via application.rb:

module Feedbin    class Application < Rails::Application        # other configs        config.active_record.schema_format = :sql        # other configs    endend

Enabled PSQL extensions:

• hstore - "data type for storing sets of (key, value) pairs"

• pg_stat_statements - "track planning and execution statistics of all SQL statements executed"

• uuid-ossp - "generate universally unique identifiers (UUIDs)"

CREATE EXTENSION IF NOT EXISTS hstore WITH SCHEMA public;COMMENT ON EXTENSION hstore IS 'data type for storing sets of (key, value) pairs';CREATE EXTENSION IF NOT EXISTS pg_stat_statements WITH SCHEMA public;COMMENT ON EXTENSION pg_stat_statements IS 'track planning and execution statistics of all SQL statements executed';CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA public;COMMENT ON EXTENSION "uuid-ossp" IS 'generate universally unique identifiers (UUIDs)';

Redis is configured to be used with Sidekiq.

This is what the redis initializer looks like:

# https://github.com/feedbin/feedbin/blob/main/config/initializers/redis.rb#L1defaults = {connect_timeout: 5, timeout: 5}defaults[:url] = ENV["REDIS_URL"] if ENV["REDIS_URL"]$redis = {}.tap do |hash|  options2 = defaults.dup  if ENV["REDIS_URL_PUBLIC_IDS"] || ENV["REDIS_URL_CACHE"]    options2[:url] = ENV["REDIS_URL_PUBLIC_IDS"] || ENV["REDIS_URL_CACHE"]  end  hash[:refresher] = ConnectionPool.new(size: 10) { Redis.new(options2) }end

Further, there is a RedisLock configured like this:

# https://github.com/feedbin/feedbin/blob/main/app/models/redis_lock.rb#L1class RedisLock  def self.acquire(lock_name, expiration_in_seconds = 55)    Sidekiq.redis { _1.set(lock_name, "locked", ex: expiration_in_seconds, nx: true) }  endend

Further down this is used in a clock.rb (that defines scheduled tasks to run):

# https://github.com/feedbin/feedbin/blob/main/lib/clock.rb#L8every(10.seconds, "clockwork.very_frequent") do  if RedisLock.acquire("clockwork:send_stats:v3", 8)    SendStats.perform_async  end  if RedisLock.acquire("clockwork:cache_entry_views", 8)    CacheEntryViews.perform_async(nil, true)  end  if RedisLock.acquire("clockwork:downloader_migration", 8)    FeedCrawler::PersistCrawlData.perform_async  endendevery(1.minutes, "clockwork.frequent") do  if RedisLock.acquire("clockwork:feed:refresher:scheduler:v2")    FeedCrawler::ScheduleAll.perform_async  end  if RedisLock.acquire("clockwork:harvest:embed:data")    HarvestEmbeds.perform_async(nil, true)  endendevery(1.day, "clockwork.daily", at: "7:00", tz: "UTC") do  if RedisLock.acquire("clockwork:delete_entries:v2")    EntryDeleterScheduler.perform_async  end  if RedisLock.acquire("clockwork:trial_expiration:v2")    TrialExpiration.perform_async  end  if RedisLock.acquire("clockwork:web_sub_maintenance")    WebSub::Maintenance.perform_async  endend

Gems used

Here are some of the gems used:

• sax-machine - "A declarative sax parsing library backed by Nokogiri"

• feedjira - "Feedjira is a Ruby library designed to parse feeds"

• html-pipeline - "HTML processing filters and utilities. This module is a small framework for defining CSS-based content filters and applying them to user provided content"

• apnotic - "A Ruby APNs HTTP/2 gem able to provide instant feedback"

• autoprefixer-rails - "Autoprefixer is a tool to parse CSS and add vendor prefixes to CSS rules using values from the Can I Use database. This gem provides Ruby and Ruby on Rails integration with this JavaScript tool"

• clockwork - "Clockwork is a cron replacement. It runs as a lightweight, long-running Ruby process which sits alongside your web processes (Mongrel/Thin) and your worker processes (DJ/Resque/Minion/Stalker) to schedule recurring work at particular times or dates"

• down - "Streaming downloads using net/http, http.rb, HTTPX or wget"

• phlex-rails - "Phlex is a framework that lets you compose web views in pure Ruby"

• premailer-rails - "This gem is a drop in solution for styling HTML emails with CSS without having to do the hard work yourself"

• raindrops - "raindrops is a real-time stats toolkit to show statistics for Rack HTTP servers. It is designed for preforking servers such as unicorn, but should support any Rack HTTP server on platforms supporting POSIX shared memory"

• strong_migrations - "Catch unsafe migrations in development"

• web-push - "This gem makes it possible to send push messages to web browsers from Ruby backends using the Web Push Protocol"

• stripe-ruby-mock - "A drop-in library to test stripe without hitting their servers"

• rails-controller-testing - "Brings back assigns and assert_template to your Rails tests"

There are many other gems used, I only selected few here. Browse the Gemfile to discover more.

What could be mentioned is that they use their fork for some of the gems included in the file:

# https://github.com/feedbin/feedbin/blob/main/Gemfile# other gemsgem "rails", github: "feedbin/rails", branch: "7-1-stable-invalid-cache-entries"# some other gemsgem "http",                github: "feedbin/http",                branch: "feedbin"gem "carrierwave",         github: "feedbin/carrierwave",         branch: "feedbin"gem "sax-machine",         github: "feedbin/sax-machine",         branch: "feedbin"gem "feedjira",            github: "feedbin/feedjira",            branch: "f2"gem "feedkit",             github: "feedbin/feedkit",             branch: "master"gem "html-pipeline",       github: "feedbin/html-pipeline",       branch: "feedbin"gem "html_diff",           github: "feedbin/html_diff",           ref: "013e1bb"gem "twitter",             github: "feedbin/twitter",             branch: "feedbin"# other gems group :development, :test do  gem "stripe-ruby-mock", github: "feedbin/stripe-ruby-mock", branch: "feedbin", require: "stripe_mock"# other gemsend# other gem groups

Code & Design Patterns

Code Organisation

Under /app there are 3 folders different from the ones that Rails comes with:

• presenters

• uploaders

• validators

The lib folder includes very few extra objects. Most of them seems to be related to communicating with external services.

Maybe worth mentioning from lib folder is the ConditionalSassCompressor

# https://github.com/feedbin/feedbin/blob/main/lib/conditional_sass_compressor.rb#L1class ConditionalSassCompressor  def compress(string)    return string if string =~ /tailwindcss/    options = { syntax: :scss, cache: false, read_cache: false, style: :compressed}    begin      Sprockets::Autoload::SassC::Engine.new(string, options).render    rescue => e      puts "Could not compress '#{string[0..65]}'...: #{e.message}, skipping compression"      string    end  endend

This is used to configure:

# https://github.com/feedbin/feedbin/blob/main/config/application.rb#L47config.assets.css_compressor = ConditionalSassCompressor.new

Routes

There is a combination of RESTful routes and non-restful routes.

Here is an example from entries in the routes.rb :

# https://github.com/feedbin/feedbin/blob/main/config/routes.rb#L133  resources :entries, only: [:show, :index, :destroy] do    member do      post :content      post :unread_entries, to: "unread_entries#update"      post :starred_entries, to: "starred_entries#update"      post :mark_as_read, to: "entries#mark_as_read"      post :recently_read, to: "recently_read_entries#create"      post :recently_played, to: "recently_played_entries#create"      get :push_view      get :newsletter    end    collection do      get :starred      get :unread      get :preload      get :search      get :recently_read, to: "recently_read_entries#index"      get :recently_played, to: "recently_played_entries#index"      get :updated, to: "updated_entries#index"      post :mark_all_as_read      post :mark_direction_as_read    end  end

Controllers

The controllers are mostly what I would call vanilla Rails controllers.

Three notes about them:

• Some of them are responding with JS usually using USJ or JQuery to change elements from the page.

• They contain non-Rails standard actions (actions that are not show, index, new, create ...)

• There is a namespaced api folder that contains APIs used by mobile apps

Here is one simple example for DELETE /entries/:id , the controller looks like this:

# https://github.com/feedbin/feedbin/blob/main/app/controllers/entries_controller.rb#L238  def destroy    @user = current_user    @entry = @user.entries.find(params[:id])    if @entry.feed.pages?      EntryDeleter.new.delete_entries(@entry.feed_id, @entry.id)    end  end

And here is the view destroy.js.erb :

$('[data-behavior~=entries_target] [data-entry-id=<%= @entry.id %>]').remove();feedbin.Counts.get().removeEntry(<%= @entry.id %>, <%= @entry.feed_id %>, 'unread')feedbin.Counts.get().removeEntry(<%= @entry.id %>, <%= @entry.feed_id %>, 'starred')feedbin.applyCounts(true)feedbin.clearEntry();feedbin.fullScreen(false)

The main pattern adopted to controllers is to have some logic in them and delegate to jobs some part of the processing.

The repo contains mostly straight-forward controllers like this one:

# https://github.com/feedbin/feedbin/blob/main/app/controllers/pages_internal_controller.rb#L1class PagesInternalController < ApplicationController  def create    @entry = SavePage.new.perform(current_user.id, params[:url], nil)    get_feeds_list  endend

But also few controllers that include some logic:

# https://github.com/feedbin/feedbin/blob/main/app/controllers/api/podcasts/v1/feeds_controller.rb#L8 def show  url = hex_decode(params[:id])  @feed = Feed.find_by_feed_url(url)  if @feed.present?    if @feed.standalone_request_at.blank?      FeedStatus.new.perform(@feed.id)      FeedUpdate.new.perform(@feed.id)    end  else    feeds = FeedFinder.feeds(url)    @feed = feeds.first  end  if @feed.present?    @feed.touch(:standalone_request_at)  else    status_not_found  endrescue => exception  if Rails.env.production?    ErrorService.notify(exception)    status_not_found  else    raise exception  endend

Even with this structure, I find all controllers easy to read and I think they can be easier to change.

Models

The app/models folders contain both ActiveRecord and normal Ruby objects. With few exceptions, they are not namespaced.

Jobs

The jobs folder contains Sidekiq jobs which are used to do processing on various objects. They are usually called from controllers and most of them are async.

Here is one job that is caching views:

# https://github.com/feedbin/feedbin/blob/main/app/jobs/cache_entry_views.rb#L1class CacheEntryViews  include Sidekiq::Worker  include SidekiqHelper  SET_NAME = "#{name}-ids"  def perform(entry_id, process = false)    if process      cache_views    else      add_to_queue(SET_NAME, entry_id)    end  end  def cache_views    entry_ids = dequeue_ids(SET_NAME)    entries = Entry.where(id: entry_ids).includes(feed: [:favicon])    ApplicationController.render({      partial: "entries/entry",      collection: entries,      format: :html,      cached: true    })    ApplicationController.render({      layout: nil,      template: "api/v2/entries/index",      assigns: {entries: entries},      format: :html,      locals: {        params: {mode: "extended"}      }    })  endend

Presenters

There is a BasePresenter and all other presenters are extending it via inheritance:

This controller defines a private method called presents:

# https://github.com/feedbin/feedbin/blob/main/app/presenters/base_presenter.rb#L1class BasePresenter  def initialize(object, locals, template)    @object = object    @locals = locals    @template = template  end  # ...  private  def self.presents(name)    define_method(name) do      @object    end  endend

and it is used like this for example:

# https://github.com/feedbin/feedbin/blob/main/app/presenters/user_presenter.rb#L2class UserPresenter < BasePresenter  presents :user  delegate_missing_to :user  # ... more code  def theme    result = settings["theme"].present? ? settings["theme"] : nil    result || user.theme || "auto"  end  # ... other codeend

To use the presenters, there is a helper defined in ApplicationHelper will instantiate the proper helper based on the object class:

module ApplicationHelper  def present(object, locals = nil, klass = nil)    klass ||= "#{object.class}Presenter".constantize    presenter = klass.new(object, locals, self)    yield presenter if block_given?    presenter  end  # more code ...end

and it is used like this in views:

<% present @user do |user_presenter| %>    <% @class = "settings-body settings-#{params[:action]} theme-#{user_presenter.theme}"%><% end %>

ApplicationComponents

Components are based on Phlex and they inherit from ApplicationComponent

It defines a method to add Stimulus controller in components like this:

# https://github.com/feedbin/feedbin/blob/main/app/views/components/application_component.rb#L25  def stimulus(controller:, actions: {}, values: {}, outlets: {}, classes: {}, data: {})    stimulus_controller = controller.to_s.dasherize    action = actions.map do |event, function|      "#{event}->#{stimulus_controller}##{function.camelize(:lower)}"    end.join(" ").presence    values.transform_keys! do |key|      [controller, key, "value"].join("_").to_sym    end    outlets.transform_keys! do |key|      [controller, key, "outlet"].join("_").to_sym    end    classes.transform_keys! do |key|      [controller, key, "class"].join("_").to_sym    end    { controller: stimulus_controller, action: }.merge!({ **values, **outlets, **classes, **data})  end

Where we can also see a bit of hash literal omission at {controller: stimulus_controller, action: }

But more interesting that this method that helps defining a Stimulus controller, is the method used to define a Stimulus item that uses binding to get variables from the object where it is used:

# https://github.com/feedbin/feedbin/blob/main/app/views/components/application_component.rb#L47  def stimulus_item(target: nil, actions: {}, params: {}, data: {}, for:)    stimulus_controller = binding.local_variable_get(:for).to_s.dasherize    action = actions.map do |event, function|      "#{event}->#{stimulus_controller}##{function.to_s.camelize(:lower)}"    end.join(" ").presence    params.transform_keys! do |key|      :"#{binding.local_variable_get(:for)}_#{key}_param"    end    defaults = { **params, **data }    if action      defaults[:action] = action    end    if target      defaults[:"#{binding.local_variable_get(:for)}_target"] = target.to_s.camelize(:lower)    end    defaults  end

The part with binding does the following:

• stimulus_controller = binding.local_variable_get(:for).to_s.dasherize This line retrieves the value of the local variable for, converts it to a string, and then applies the dasherize method (presumably to format it for use in a specific context, like a CSS class or an identifier in HTML).

• Apparently binding.local_variable_get should not be needed as the variable is passed a keyword parameter to the method. But the name of the variable is for which is a reserved word and thus if the code would have been stimulus_controller = for.to_s_dasherize that would have raised syntax error, unexpected '.' (SyntaxError)

This is a way to have keyword arguments named as reserved words and still be able to use them.

ComponentsPreview

All components can be previewed via Lookbook and they can be found in test/components

Testing

For testing it uses Minitest, the default testing framework from Rails. It uses fixtures to set up the test db.

Tests are simple and direct, containing all preconditions and postconditions in each test. This is great for following what each test is doing.

There are controller tests, model tests, job tests and some system tests. There are more controller tests than system tests making the test suite run quite fast. Also the jobs are covered pretty good with testing as there is a log of logic in the jobs.

Custom assertions

There are some custom assertions created specifically to work with collections: assert_has_keys will check if all keys are included in the hash and assert_equal_ids will check if the two collections provided have the same ids (one being a collection of objects and the other one being a hash).

# https://github.com/feedbin/feedbin/blob/main/test/support/assertions.rb#L3    def assert_has_keys(keys, hash)      assert(keys.all? { |key| hash.key?(key) })    end    def assert_equal_ids(collection, results)      expected = Set.new(collection.map(&:id))      actual = Set.new(results.map { |result| result["id"] })      assert_equal(expected, actual)    end

Conclusion

In conclusion, Feedbin is an open-source project that combines RSS feeds and newsletters into a convenient platform.

It utilizes Ruby on Rails, PostgreSQL, Sidekiq, and various other technologies to provide a robust and efficient service.

The code is well-organized and simple to follow the logic and what is happening. I think it will make it easy for anyone to contribute to this repo. If you want to run this yourself locally you should take a look at the feedbin-docker.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

So the question they asked there was the following:

Anyone here use Rails to start their own business?

Here are some answers that I picked from there.

airnoise.io

"The fast, easy way to file airport noise complaints"

His creator describes it as:

I want to add here that by looking at what people share online, the upgrades are easier and easier. Also now Shopify and Github along with Basecamp are I think running on Rail's main branch so the upgrade should be way easier

saashub.com

"Software Alternatives And Reviews"

libhunt.com

"Discover trending open-source projects and their alternatives"

Both projects SaasHub and LibHunt are created by the same developer. Here is they say about these projects:

I would add here that with the help of litestack you can start a Rails 7 project and host it all in one single Hetzner VPS. No extra servers are needed for DB, Cronjobs, or processing queues. Everything is in one single server.

radius.to

"Radius is a platform for finding and organising events, both online and in person"

Here is what the creator says about this project:

ordonest.com

"Tracking bills made simple"

Here is what the creator says about this project:

creatornest.work

"It's the job platform where creators and innovators unite to redefine the landscape of content, technology, and design"

Here is what the creator says about this project:

LogCheck.com

"LogCheck is the easiest way to stay on top of routine maintenance tasks, inspections, and meter readings"

Here is what the creator says about the project:

smartynames.com

"Instant Business Name Generator For Entrepreneurs"

Here is what the creator says about this project:

transcribesimple.com

lectronz.com

"The marketplace for makers. Support open-source hardware creators"

Here is what the creator says about the project:

statusgator.com

"StatusGator gives your team a unified status page showing the status of all of your cloud vendors, hosted applications, services, websites, and more"

trackssl.com

"Monitor SSL Certificate Expiration"

gemfilecheck.com

"Gemfilecheck is the easiest way to keep an eye on your Ruby and Rails projects for security issues and vulnerabilities. Go to bed every night knowing your project is safe from hackers"

callstacking.com

"Decode even the most convoluted Ruby on Rails production incidents with our debugger's powerful visualization, guiding you through the labyrinth of call chains and data flow"

www.invoicework.com/invoices/new

"Free invoice generator"

www.motivware.com

"We're Motivware, and we've got a prototype in the oven for running coaches. We're cooking up a tool that's helping manage clients, payments, and all the important stuff. It's like your coaching sidekick in the making"

www.gaia.law

"Discover our legal management solution tailored for SMBs, startups, and growing companies. Our innovative platform offers a template library, simplifies contract creation and contract lifecycle management and streamlines legal workflows"

Here is what the creator says about the project:

www.comprehension.club

"Simple language exchanges to improve your listening and reading in another language"

www.vocabspot.com

"Vocab Spot helps language teachers create a library of teaching materials and share them with students in a way that's easy and fun"

Here is what the creator of comprehension.club and vocabspot.com says about these projects:

dime.run

"Faster CI with Custom Machines"

Here is what the creator says about the project:

receipt-ai.com

"Receipt management with AI and Text messages"

Here is what the creator says about the project:

www.kindmind.com

"KindMind is a delighfully simple online journal with a goal: helping you become a more accepting, mindful, better you"

Here is what the creator says about the project:

looknforgroup.com

"Whether you're looking for someone to go running with, play basketball, pickleball, tennis, go rollerblading, or a sweaty gym session, or to the movies or the museum, browse posts created by other people and join the ones that interest you"

Here is what the creator says about the project:

www.localedata.com

"LocaleData is a simple translation management platform that helps you work on your YAML translation files even with your non-technical teammates"

Here is what the creator says about the project:

n28.fr

"A micro saas to collect monthly rents that I use for my properties"

Conclusion

I think you should read the original thread on /r/rails there are more comments there than what I included there.

I just wanted to show the diversity of projects built with Ruby on Rails. I find it inspiring to look at these projects and ideas.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

As a reminder, this is a 30-minute review so this is a high-level overview and there might be things that I missed or that I misunderstood.

The product

chatwoot is an "Open-source customer engagement suite, an alternative to Intercom, Zendesk, Salesforce Service Cloud etc"

The interface looks like this (source their website)

They were part of YCombinator batch in 2021.

Open Source

Repository and License

The repository is on Github at https://github.com/chatwoot/chatwoot and it is open sourced with a license that seems a variant of MIT license:

Ruby and Rails version

At the moment of writing this article (November 2023), it runs on Ruby 3.2.2 and Rails 7.0.8

Architecture

Backend

• It uses Rails to create a REST API with jbuilder as the serializer

Frontend

• It uses Vue for the front end with Tailwind CSS. You can explore the package.json here

• It also uses Administrate gem as an admin dashboard

Background processing queue

• Sidekiq with Redis

Database:

• PostgreSQL

Stats

Running rails stats returned the following:

As this project uses Vue on the front, here is the output of running an extension in VScode called Code Counter:

Not sure how it does all these calculations but it seems the application has quite some lines of code in JS (JavaScript and Vue files together).

Style Guide

They use Rubocop with some custom settings added in their .rubocop.yml file:

require:  - rubocop-performance  - rubocop-rails  - rubocop-rspec

Among the cops that have their default settings changed:

• RSpec/ExampleLength with max=25

• Style/FrozenStringLiteralComment with enabled=false

• Style/OpenStructUse with enabled=false

• Style/GlobalVars are allowed in redis and rack_attack initializers and in lib/global_config.rb

• Style/ClassVars are allowed in one file app/services/email_templates/db_resolver_service.rb

• Style/HashSyntax has the shorthand syntax disabled

• Naming/VariableNumber is disabled

and there are more there.

Storage, Persistence and in-memory storage

As a database it uses PostgreSQL.

It defines two global variables for Redis:

# Alfred# Add here as you use it for more features# Used for Round Robin, Conversation Emails & Online Presence$alfred = ConnectionPool.new(size: 5, timeout: 1) do  redis = Rails.env.test? ? MockRedis.new : Redis.new(Redis::Config.app)  Redis::Namespace.new('alfred', redis: redis, warning: true)end# Velma : Determined protector# used in rack attack$velma = ConnectionPool.new(size: 5, timeout: 1) do  config = Rails.env.test? ? MockRedis.new : Redis.new(Redis::Config.app)  Redis::Namespace.new('velma', redis: config, warning: true)end

Then these global variables are used in other places in the code:

Gems used

Here is a selection from all the gems they use:

• act_as_taggable_on - "A tagging plugin for Rails applications that allows for custom tagging along dynamic contexts"

• attr_extras - "Takes some boilerplate out of Ruby with methods like attr_initialize"

• hashie - "Hashie is a growing collection of tools that extend Hashes and make them more useful"

• responders - "A set of Rails responders to dry up your application"

• telephone_number - "TelephoneNumber is global phone number validation gem based on Google's libphonenumber library"

• valid_email2 - "Validate emails with the help of the mail gem instead of some clunky regexp. Aditionally validate that the domain has a MX record. Optionally validate against a static list of disposable email services. Optionally validate that the email is not subaddressed (RFC5233)"

• flag_shih_tzu - "This gem lets you use a single integer column in an ActiveRecord model to store a collection of boolean attributes (flags). Each flag can be used almost in the same way you would use any boolean attribute on an ActiveRecord object"

• haikunator - "Generate Heroku-like memorable random names to use in your apps or anywhere else."

• commonmarker - "Ruby wrapper for Rust's comrak crate. It passes all of the CommonMark test suite, and is therefore spec-complete. It also includes extensions to the CommonMark spec as documented in the GitHub Flavored Markdown spec, such as support for tables, strikethroughs, and autolinking"

• down -"Down is a utility tool for streaming, flexible and safe downloading of remote files. It can use open-uri + Net::HTTP, http.rb, HTTPX, or wget as the backend HTTP library"

• gmail_xoauth - "Get access to Gmail IMAP and SMTP via OAuth2 and OAuth 1.0a, using the standard Ruby Net libraries. The gem supports 3-legged OAuth, and 2-legged OAuth for Google Apps Business or Education account owners"

• csv-safe - "This gem decorates the built in CSV library to prevent CSV injection attacks. Wherever you would use CSV in your code, use CSVSafe. The gem will encode your fields in UTF-8"

• hairtrigger - "lets you create and manage database triggers in a concise, db-agnostic, Rails-y way. You declare triggers right in your models in Ruby, and a simple rake task does all the dirty work for you"

• wisper - "A micro library providing Ruby objects with Publish-Subscribe capabilities"

• groupdate - "The simplest way to group by: day, week, hour of the day, and more"

• html2text - "a very simple gem that uses DOM methods to convert HTML into a format similar to what would be rendered by a browser - perfect for places where you need a quick text representation"

• informers - "State-of-the-art natural language processing for Ruby: Sentiment analysis, Question answering, Named-entity recognition, Text generation"

• climate_control - "Climate Control modifies environment variables only within the context of the block, ensuring values are managed properly and consistently"

Design Patterns

The "app" directory has the following sub-folders that are not the ones included by default in Rails:

• actions

• builders

• dashboards

• dispatchers

• drops

• fields

• finders

• listeners

• mailboxes

• policies

• presenters

• services

• workers

Here are some examples of some patterns from the codebase:

Actions

Inside actions, some objects define the perform method where they execute a series of steps:

class SomeAction  pattr_initialize [:user, :base]  def perform    ActiveRecord::Base.transaction do      action1      action2      # ...    end  endend

Where pattr_initialize comes from attr_extras gem and it will create an initializer with those variables and declare them as private.

Builders

These have the same interface where they define perform and it seems to be a flavor of Builder Pattern maybe with a service object where the builder will create or find one or more records.

Here is an example of the AccountBuilder that will create an account and then create a user and link these two together.

class AccountBuilder  include CustomExceptions::Account  pattr_initialize [:account_name!, :email!, :confirmed, :user, :user_full_name, :user_password, :super_admin, :locale]  def perform    if @user.nil?      validate_email      validate_user    end    ActiveRecord::Base.transaction do      @account = create_account      @user = create_and_link_user    end    [@user, @account]  rescue StandardError => e    puts e.inspect    raise e  end  # ... more methodsend

Controllers

Take a look at the app/controllers/api there is a versioning of the API using namespaces (app/controllers/api/v1 , app/controllers/api/v2 )

The controllers appears to be slim calling other objects and usually returning a JSON represented in views via .json.builder files.

Dashboards

Here they define the Administrate custom dashboards

Dispatchers

They implement the Wisper::Publisher module to dispatch events. Here is an example of an async dispatcher using a job:

# https://github.com/chatwoot/chatwoot/blob/develop/app/dispatchers/async_dispatcher.rbclass AsyncDispatcher < BaseDispatcher  def dispatch(event_name, timestamp, data)    EventDispatcherJob.perform_later(event_name, timestamp, data)  end  def publish_event(event_name, timestamp, data)    event_object = Events::Base.new(event_name, timestamp, data)    publish(event_object.method_name, event_object)  end  def listeners    [      CampaignListener.instance,      CsatSurveyListener.instance,      HookListener.instance,      InstallationWebhookListener.instance,      NotificationListener.instance,      ReportingEventListener.instance,      WebhookListener.instance,      AutomationRuleListener.instance    ]  endend

Finders

Finders are another patterns used here which takes care of querying the DB while taking care of filters or other conditions coming from params in controllers. They usually define a perform method and the initializer accepts a params to get the params from the controller.

Here is an example:

# https://github.com/chatwoot/chatwoot/blob/develop/app/finders/conversation_finder.rb#L1class ConversationFinder  attr_reader :current_user, :current_account, :params  # params  # assignee_type, inbox_id, :status  def initialize(current_user, params)    @current_user = current_user    @current_account = current_user.account    @params = params  end  def perform   # calls to compose the response from other methods   end  private  # other methods ...  def find_all_conversations    @conversations = current_account.conversations.where(inbox_id: @inbox_ids)    filter_by_conversation_type if params[:conversation_type]    @conversations  end  def filter_by_assignee_type    case @assignee_type    when 'me'      @conversations = @conversations.assigned_to(current_user)    when 'unassigned'      @conversations = @conversations.unassigned    when 'assigned'      @conversations = @conversations.assigned    end    @conversations  end  def filter_by_conversation_type    case @params[:conversation_type]    when 'mention'      conversation_ids = current_account.mentions.where(user: current_user).pluck(:conversation_id)      @conversations = @conversations.where(id: conversation_ids)    when 'participating'      @conversations = current_user.participating_conversations.where(account_id: current_account.id)    when 'unattended'      @conversations = @conversations.unattended    end    @conversations  end  def filter_by_query    return unless params[:q]    allowed_message_types = [Message.message_types[:incoming], Message.message_types[:outgoing]]    @conversations = conversations.joins(:messages).where('messages.content ILIKE :search', search: "%#{params[:q]}%")                                  .where(messages: { message_type: allowed_message_types }).includes(:messages)                                  .where('messages.content ILIKE :search', search: "%#{params[:q]}%")                                  .where(messages: { message_type: allowed_message_types })  end  # some other methods ... end

Listeners

The listeners are implemented using the Singleton interface and all inherit from the BaseListener and usually will do an action like calling a Job or Builder or some other object when the event is received.

Mailboxes

This could be a good repo if you want to see how to read and process inbound emails. Take a look at ApplicationMailbox which it matches either a reply to a conversation or a new conversation received via a channel:

class ApplicationMailbox < ActionMailbox::Base  include MailboxHelper  # Last part is the regex for the UUID  # Eg: email should be something like : reply+6bdc3f4d-0bec-4515-a284-5d916fdde489@domain.com  REPLY_EMAIL_UUID_PATTERN = /^reply\+([0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12})$/i  CONVERSATION_MESSAGE_ID_PATTERN = %r{conversation/([a-zA-Z0-9-]*?)/messages/(\d+?)@(\w+\.\w+)}  # routes as a reply to existing conversations  routing(    ->(inbound_mail) { reply_uuid_mail?(inbound_mail) || in_reply_to_mail?(inbound_mail) } => :reply  )  # routes as a new conversation in email channel  routing(    ->(inbound_mail) { EmailChannelFinder.new(inbound_mail.mail).perform.present? } => :support  )# ... more methodsend

Mailers

The Mailers are implemented using liquid gem. The logic to decide how to deliver a reply based on the inbox_type can be found in the ConversationReplymailerHelper in a method that looks like this:

# https://github.com/chatwoot/chatwoot/blob/develop/app/mailers/conversation_reply_mailer_helper.rb#L2  def prepare_mail(cc_bcc_enabled)    @options = {      to: to_emails,      from: email_from,      reply_to: email_reply_to,      subject: mail_subject,      message_id: custom_message_id,      in_reply_to: in_reply_to_email    }    if cc_bcc_enabled      @options[:cc] = cc_bcc_emails[0]      @options[:bcc] = cc_bcc_emails[1]    end    ms_smtp_settings    set_delivery_method    mail(@options)  end

Models

Models are Active Record models with just the right amount of logic. They are not very big but they are also not slim.

Policies

They use pundit gem and thus this folder contains policies. Each method is simple and easy to understand.

Services

There are 63 files inside the services having a similar interface, defining a perform or perform_reply method.

Lib

There are over 60 fiels in the /lib folder. They don't use the same pattern and are doing various things. From defining some types or constants like Events::Types to for example a client connecting to MicrosoftGraphAuth

Testing

They use RSpec for testing with FactoryBot and some fixtures.

Looking a bit at the structure of some tests:

• They use nested describe or describe with nested context

• let and let!

• subject

• A limited number of shared_examples inside models

The tests appear to be simple with little setup in a before block and some let! and the test is self-contained.

Conclusion

In conclusion, chatwoot is an open-source customer engagement suite with a well-structured codebase and a variety of design patterns. Most of them are trying to define a common interface (like perform method). The controllers and models are pretty close to vanilla Rails: slim controllers, with some logic in models, making use of callbacks.

It employs several gems and libraries to enhance its functionality but without changing too much the flavour of Rails.

The project uses Ruby 3.2.2, Rails 7.0.8, and Vue for its front end and also has a bit of ERB for the Administrate gem.

From the Ruby on Rails perspective it could be a project easy to grasp with a bit of mental load on the testing side where there is a mix of let, subject and shared_examples.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Downloads trends of all gems

source

Data points

Here is how I read this, first there are two data sets: the total downloads and the daily downloads

Total downloads

It is a sum of downloads of all gems -> so of course this will always be increasing.

But what I think is interesting is how fast the total downloads are increasing. I think it can be seen with the naked eye that starting with say 2019/2020 the total downloads are increasing a lot:

• ~2B downloads increase from 2013 to 2019

• ~133 B downloads increase from 2019 to 2023

How do I get to this differences:

• 1.47B downloads in 2013-07-01 and 3.71B downloads in 2019-07-01 => a difference of about 2.24B

• 3.71B downloads in 2019-07-01 and 137.53B downloads in 2023-07-01 => a difference of about 133.82B

Conclusion: There are two orders of magnitude increase in the total downloads in the last 4 years versus the previous 5 years.

Daily downloads

If the total downloads are increased of course also daily downloads are increased.

• 5.75M daily downloads in 2013 (data point taken on 2013-07-03)

• 50M daily downloads in 2019 (data point taken on 2019-07-03)

• 127M daily downloads in 2023 (data point taken on 2023-07-11)

Conclusion: the number of downloads per day is more than double, with some periods from 2019 until 2023 with a higher number of downloads per day (like 160M or 154M).

What does this mean?

For sure it means the number of downloaded gems accelerated since 2019.

One explanation could be running tests using CI pipelines and containers so that for every run there is a download of gems.

Some data points:

• GitHub launched its Github Actions in 2018 (source)

• Gitlab launched its first version of CI in 2012 (source)

• Jenkins launched in 2011 (source)

• Circle CI launched in 2011 (source)

• Travis CI launched in 2011 (source)

• Almost 30% of businesses were already using CI/CD in 2013-2014 (source)

I will assume these features took off the next year so it would be 2019 for Github and 2013 for Gitlab and the other major CIs 2012.

It is hard to know if this explanation is the only one. I don't feel it is accounting for all the fast growth since 2019. The only data point that matches that is Github launching their Actions in 2019 but that alone cannot explain the increase of two orders of magnitude since then.

Another explanation could be that Ruby is growing and the pace is increasing. There could be two root causes for this:

• More often version updates for gems result in multiple organisations' teams updating

• The pace of new projects started is increasing

Again it is hard to know exactly which one is the reality. But I add this explanation that Ruby is growing because I see signs of it also in other places (more conferences, more talk on social media, an increased number of articles, more releases, more jobs, more contacts on Linkedin about jobs ...)

There can be other causes for the increase we have seen since 2019 - maybe the way data is gathered changed, it is more granular or better captured.

I think it is a combination of both explanations - CI being adopted on a large scale while also the Ruby number of projects growing more rapidly in the last 3-4 years.

Data validation

bestgems.org is not rubygems.org and I could not yet find how they are taking their data.

Still, when looking at the total number of downloads (see the comparison image below), it seems to have the same data so I wrote this article starting with the assumption that bestgems.org data is valid.

(left) https://rubygems.org/stats vs (right) https://bestgems.org/stat/downloads

On another side, ruby-toolbox.com is using bestgems.org as a data source:

Maybe a conclusion

The rapid increase in Ruby gem downloads since 2019 can be attributed to the widespread adoption of CI/CD pipelines (with a small note that a lot of CI/CD tools were launched years before) and also to the growing popularity of Ruby in new projects.

This trend reflects the growing importance of Ruby in the software development ecosystem.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Zammad is an open-source ticketing system, that also offers an on-cloud product.

They have their product open-sourced on Github and it is built using (at the moment of writing this article) Ruby 3.1.3 and Rails 7

Licensing

The license is GNU AGPL

They mention on their website why they chose to make the product open source:

Each file in the repository has a license line like:

Some ideas from the open-source repo

I don't have enough time to analyse in depth the repo. So just looking around for 30 minutes, here are some things that I extracted

Stats

Running rails stats returned the following:

Styling Guide

They use Rubocop with extra cops added. They require some cops provided by gems and custom cops written by them:

require:  - rubocop-capybara  - rubocop-factory_bot  - rubocop-faker  - rubocop-graphql  - rubocop-inflector  - rubocop-performance  - rubocop-rails  - rubocop-rspec  - ../config/initializers/inflections.rb  - ./rubocop_zammad.rb

In rubocop_zammad.rb they are loading custom cops from .rubocop/cop/zammad

Here are some custom cops written by them:

• Checking if the migration file starts with a valid timestamp

• Checking usages of find_by to check if an Active Record exists and replace it with exists?

• Checking that the only allowed default_scope is about simple ordering

• Checking for using rand

• Checking usages of .to_sym on strings and change to : prefix

• Checking usages of unless and suggest using !

• Checking copyright notice and adding it when missing

More about their style guide can be found at doc/developer_manual/standards

Persistence

They appear to use 3 DBs, each one having their group. One (the activerecord-nulldb-adapter) is actually a NullObject pattern implemented for Active Record.

Based on the loaded connection they do a preflight check in an initializer. This is what it looks like:

Rails.application.config.after_initialize do  Zammad::Application::Initializer::DbPreflightCheck.performend

and you can go check lib/zammad/application/initializer to see what kind of checks are executed for each adapter.

This is a way to make sure that the actual DB server respects a contract they have defined in these initializers (e.g. what extensions are activated or config defaults or minimum version).

See this example of a check for MySQL from the same file:

Some gems used

• argon2 - "A Ruby gem offering bindings for Argon2 password hashing"

• rszr - "Rszr is an image resizer for Ruby based on the Imlib2 library. It is faster and consumes less memory than MiniMagick, GD2 and VIPS, and comes with an optional drop-in interface for Rails ActiveStorage image processing"

• biz - "Time calculations using business hours"

• diffy - "It provides a convenient way to generate a diff from two strings or files. Instead of reimplementing the LCS diff algorithm Diffy uses battle tested Unix diff to generate diffs, and focuses on providing a convenient interface, and getting out of your way"

• chunky_png - "ChunkyPNG is a pure Ruby library to read and write PNG images and access textual metadata. It has no dependency on RMagick, or any other library for that matter"

• localhost - "This gem provides a convenient API for generating per-user self-signed root certificates"

• activerecord-nulldb - "NullDB is the Null Object pattern as applied to ActiveRecord database adapters. It is a database backend that translates database interactions into no-ops. Using NullDB enables you to test your model business logic - including after_save hooks - without ever touching a real database"

Design Patterns

They use service objects. There is a Service::Base class that is empty and then there is also Service::BaseWithCurrentUser that looks something like this:

The main method that a Service object should define is execute but there is no enforcement of this. It is just that everything under app/services/service has this method defined.

GraphQL objects

All the logic about GraphQL is inside app/graphql, namescoped to Gql.

Jobs

They can be found at app/jobs. Job priority is defined in a concern called ApplicationJob::HasQueuingPriority that looks like this:

And all jobs have a default priority of 200 while low_priority is defined as being 300

Models

They are under app/models and there is an ApplicationModel defined that includes some defaults like this:

There are probably a lot more interesting things to discover about the codebase but this is what I got in a short review.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

You want to have a way to skip all callbacks for all models in Rails.

Before we begin

Two things:

1. Skip callbacks if this is a debugging session

2. Don't try to skip all callbacks in your business logic or production code. This is a strong hint for refactoring.

Context

Let's assume you have the following model:

class User < ApplicationRecord  before_save :downcase_name  after_save :add_title  before_validation :ensure_username  private  def downcase_name    self.name = name.downcase  end  def add_title    self.title = "The #{name}"  end  def ensure_username    self.username = self.email.split("@").first if username.blank?  endend

I used one single type of callback on save. But the solutions we will explore will try to skip all callbacks.

If you plan to use this I think you should first make sure that all callbacks work:

require "test_helper"class UserTest < ActiveSupport::TestCase  def test_callback_changes_name_and_title    user = User.new(name: "TEST", email: "username@domain.com")    user.save    assert_equal "test", user.name    assert_equal "The test", user.title    assert_equal "username", user.username  endend

Solution 1: Using an Suppressor

I think this is the idiomatic way to achieve this in Rails if you need to suppress create and destroy callbacks -> use ActiveRecord::Suppressor (thank you Rob for sharing this)

ActiveRecord::Suppressor prevents the receiver from being saved during a given block

Here is how to use it:

require "test_helper"class UserTest < ActiveSupport::TestCase  def test_suppressor_skip_callbacks    user = User.new(name: "TEST", email: "username@domain.com")    # 👇 An example of using User.supress    User.suppress do      user.save    end    assert_equal "TEST", user.name    refute user.title    refute user.username  endend

Looking at the tests for it from Rails codebase it seems that Suppressor only works for save and create callbacks.

Here is a test that shows that it does not work on create do

# app/models/user.rbclass User < ApplicationRecord  before_destroy :before_destroy_action  private  def before_destroy_action    raise "Can't destroy this record"  endend# test/models/user_test.rbrequire "test_helper"class UserTest < ActiveSupport::TestCase  def test_suppressor_does_not_work_on_destroy    user = User.create(name: "TEST", email: "username@domain.com")    User.suppress do      # It confirms that it will raise RuntimeError       assert_raise RuntimeError do        user.destroy      end    end  endend

So I will explore below two more methods to stop all callbacks. But again if you are only trying to stop the creation of other records from callbacks try to use this.

Solution 2: Use conditional callbacks

You can use the following feature from Rails:

Here the solution will be to have an attribute that is by default nil or false and then define all callbacks with unless :attribute so that when we set that attribute to true, it will skip that callback:

class User < ApplicationRecord  attr_accessor :skip_callbacks  before_save :downcase_name, unless: :skip_callbacks?  after_save :add_title, unless: :skip_callbacks?  before_validation :ensure_username, unless: :skip_callbacks?  private  def skip_callbacks?    skip_callbacks  end  def downcase_name    self.name = name.downcase  end  def add_title    self.title = "The #{name}"  end  def ensure_username    self.username = self.email.split("@").first if username.blank?  endend

Here is how you can use it for one model:

require "test_helper"class UserTest < ActiveSupport::TestCase  def test_with_setting_skip_callbacks    user = User.new(name: "TEST")    user.skip_callbacks = true    user.save    assert_equal "TEST", user.name    refute user.title    refute user.username  endend

This solution is simple to add it to one model or to start using it if you start a greenfield project. But if you already have 1000 models, it will be painful to change callbacks on all models to change them to conditional callbacks. Extra pain points if they already have a condition defined.

Advantage of this solution: It uses only public APIs/methods from Active Record so it should be safe to use and Rails upgrades will not break it.

Solution 3: Patching ApplicationRecord to allow removing all callbacks

For this solution, we will use reset_callback and set_callback and patch ApplicationRecord to allow execution of something like without_callbacks with a block.

Let's first define this to work with one or multiple callbacks:

# app/models/application_record.rbclass ApplicationRecord < ActiveRecord::Base  primary_abstract_class  def self.without_callbacks(*callbacks)    saved_callbacks = save_current_callbacks(callbacks)    remove_callbacks(callbacks)    yield    restore_callbacks(saved_callbacks)  end  private  def self.save_current_callbacks(callbacks)    callbacks.map { |callback| [callback, self.__callbacks[callback]] }.to_h  end  def self.remove_callbacks(callbacks)    callbacks.each { |callback| reset_callbacks(callback) }  end  def self.restore_callbacks(saved_callbacks)    saved_callbacks.each { |callback, chain| set_callbacks(callback, chain) }  endend

and you can use it like this for one callback or many:

require "test_helper"class UserTest < ActiveSupport::TestCase  def test_without_callbacks_does_not_change_name_or_title    user = User.new(name: "TEST")    User.without_callbacks(:save) do      user.save    end    assert_equal "TEST", user.name    refute user.title  end  def test_without_callbacks_does_not_change_name_title_or_username    user = User.new(name: "TEST", email: "username@domain.com")    User.without_callbacks(:save, :validation) do      user.save    end    refute user.title    refute user.username    assert_equal "TEST", user.name  endend

And then if you want you can add one more thing to the ApplicationRecord:

# app/models/application_record.rb  def self.without_all_callbacks    callbacks = self.__callbacks.keys    without_callbacks(*callbacks) { yield }  end

and then you can use this like this:

require "test_helper"class UserTest < ActiveSupport::TestCase  def test_without_callbacks_does_not_change_name_title_or_username    user = User.new(name: "TEST", email: "username@domain.com")    User.without_all_callbacks do      user.save    end    refute user.title    refute user.username    assert_equal "TEST", user.name  endend

Warning

I would advise against using this solution because it uses private methods from ActiveRecord. These methods are open to be changed/removed and should be treated that way.

From all the methods I used in the code, only reset_callbacks is a public Ruby on Rails API. See it on api.rubyonrails.org. The others are methods not listed publicly on the api.rubyonrails.org. So they might change without any deprecation or warning.

Improving on solution 3: Put the custom code in .irbrc

An intermediate solution would be not to pollute your application code with patching Active Record and put the patching into .irbrc file that you can put in the root of your Ruby on Rails app:

# .irbrcclass ApplicationRecord < ActiveRecord::Base  def self.without_all_callbacks    callbacks = self.__callbacks.keys    without_callbacks(*callbacks) { yield }  end  def self.without_callbacks(*callbacks)    saved_callbacks = save_current_callbacks(callbacks)    remove_callbacks(callbacks)    yield    restore_callbacks(saved_callbacks)  end  private  def self.save_current_callbacks(callbacks)    callbacks.map { |callback| [callback, self.__callbacks[callback]] }.to_h  end  def self.remove_callbacks(callbacks)    callbacks.each { |callback| reset_callbacks(callback) }  end  def self.restore_callbacks(saved_callbacks)    saved_callbacks.each { |callback, chain| set_callbacks(callback, chain) }  endend

So now when you start the Rails server the ApplicationRecord is not affected. So if you wrote those tests they will fail.

But if you open rails c then the without_all_callbacks and without_callbacks methods will be available on all your models.

Checking before upgrade

If you decide to go for adding this kind of code, then I suggest you add the following test:

require 'test_helper'class ActiveRecordCallbacksTest < ActiveSupport::TestCase  def setup    @model = User.new  end  test "should have access to reset_callbacks" do    assert(      User.respond_to?(:reset_callbacks, true),      "User models should have access to `reset_callbacks` to implement without_callbacks method"    )  end  test "should have access to __callbacks hash" do    assert_respond_to(      @model,      :__callbacks,      "User model should have access to `__callbacks` hash to implement without_callbacks method"    )  end  test "__callbacks should be a hash with keys as symbols to implement without_callbacks method" do    callbacks = @model.__callbacks.keys    assert_kind_of(      Symbol,      callbacks.first,      "Expected `ApplicationRecords#__callbacks` should be a hash with keys as symbols"    )  endend

And run this check when you upgrade your Rails version.

Special case: Rails 7.1 normalizes method

None of the techniques I presented above will skip normalizes transformations.

If you have something like this in your models:

class User < ApplicationRecord  normalizes :email, with: -> email { email.strip.downcase }  normalizes :name, with: -> name { name.strip.downcase }end

Then skipping callbacks will not stop normalization from happening. Thus if you save the User record it will update the email and name as specified in the transformation

Conclusion

In conclusion, skipping all callbacks for all models in Rails can be achieved using various methods such as ActiveRecord::Suppressor, conditional callbacks, or patching ApplicationRecord.

However, it is important to consider the potential drawbacks of each method and use them cautiously, especially in production code. Always test your solutions and be mindful of Rails version upgrades that may affect your implementation

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

These language models can serve as helpful conversation partners, providing different solutions to the same problem.

Here, we'll compare their responses to a specific request involving the golden ratio and discuss their effectiveness.

Problem

As this was a personal project, I did not have a complete design, just some inspirational ideas that I wanted to try.

I wanted to add some custom width-sized in a Tailwind config for a web app up until about 800px for the desktop resolution.

I asked both Chat GPT 4 and Github Copilot Chat the same question and got different answers.

Chat GPT 4

Here is what I asked Chat GPT 4:

Here is what it suggested:

As you can notice it used the constraint that I added (to use the golden ratio) to calculate the actual size from the last one provided by me (384px) to reach the 800px that I asked for and then tried to create a series of width utilities matching a bit how Tailwind does it - by spacing them out.

Did not check all of the utilities proposed, but the first one and the last one are calculated ok from the rem to px ratio.

Github Copilot

I then tried to use Github Copilot via VSCode to generate this list.

Here is the prompt and the response:

It has some fine-grained steps, it reaches the 800 px and it correctly started from 400 (as Tailwind already defined 384px) but I don't see how it used the golden ratio (which is around 1.61).

It ignored the request to use the golden ratio: did not use it for spacing the utilities, nor used it for calculating the distance in rem or pixels between two utility classes.

Github Copilot Chat

I then tried Github Copilot Chat:

And it replied with the following:

It seems that it was not aware that Tailwind already has width classes up until 384px. But it did apply with an approximation of the golden ratio when spacing the width classes.

Phind

I asked Phind the same question and here is the answer:

I find the Phind answer better. It explains how it did the calculation, it used the golden ratio for each step and it also provides the Tailwind config and shows how to use it.

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

If you are learning Ruby, I hope this article demonstrates that Ruby enables excellent self-exploration, and most questions about its functionality can be answered through hands-on experimentation and just a little documentation.

Context

Someone asked me the following question:

When I write in IRB or in a file the following

def my_methodend

Where is the my_method created? What object will contain this method? And what is the access modifier for this method?

Detective Tools

I will use some simple but powerful tools:

1. Ruby interpreter installed on the local machine

2. Ruby documentation at https://docs.ruby-lang.org/en/3.2

Solution

Instead of giving a direct answer, let's put on the hat of an investigator and try to find some clues about this while having fun with Ruby.

First question: When I run a script who is there already?

First, let's create a file called exploration.rb and ask it about self:

# exploring.rbputs "Who is here? #{self}"# => `Who is here? main`

We notice this return main. But what is this main?

Maybe we can ask Ruby about it. I will add a couple of methods to find out more about main while trying to dig around:

puts "Who is here: #{self}"puts "What is your class: #{self.class}"puts "What are your ancestors: #{self.class.ancestors}"puts "What is the current exection stack: #{caller.inspect}"# =>Who is here: mainWhat is your class: ObjectWhat are your ancestors: [Object, Kernel, BasicObject]What is the current caller stack: []

We found out that main exists inside Object. Good, let's poke around then:

puts "Is `main` a public method? #{self.public_methods.include?(:main)}"puts "Is `main` a public method? #{self.protected_methods.include?(:main)}"puts "Is `main` a private method? #{self.private_methods.include?(:main)}"puts "Is `main` a singleton method? #{self.singleton_methods.include?(:main)}"# => Is `main` a public method? falseIs `main` a public method? falseIs `main` a private method? falseIs `main` a singleton method? false

It appears that main is not a method. That seems strange, right? If main is not a method then what could it be?

I think we should now explore how we are asking the question: we are using puts to ask the question. Here is what the documentation says

Then maybe something is deturning the puts self and that something could be a method to_s on Object. Here let's check a bit the documentation for Object#to_s

CLUE A - FOUND -> main is just a string printed by Ruby in the initial execution context. Nothing special here.

Second: Where is a method created when I don't define an object?

For this, we will create a second file called exploration_method.rb and again ask it about itself:

def my_method  puts "Who is here: #{self}"  puts "What is your class: #{self.class}"  puts "What are your ancestors: #{self.class.ancestors}"  puts "What is the current exection stack: #{caller.inspect}"  puts "What is your current file: #{__FILE__}"endmy_method# => Who is here: mainWhat is your class: ObjectWhat are your ancestors: [Object, Kernel, BasicObject]What is the current exection stack: ["exploration_method.rb:10:in `<main>'"]What is your current file: exploration_method.rb

CLUE B - FOUND -> my_method is created inside Object

Third: What kind of method is my_method?

Let's ask Object about this method:

def my_methodendputs "Is `my_method` a public method? #{Object.public_methods.include?(:my_method)}"puts "Is `my_method` a private method? #{Object.private_methods.include?(:my_method)}"puts "Is `my_method` a private method? #{Object.protected_methods.include?(:my_method)}"puts "Is `my_method` a singleton method? #{Object.singleton_methods.include?(:my_method)}"# => Is `my_method` a public method? falseIs `my_method` a private method? trueIs `my_method` a private method? falseIs `my_method` a singleton method? false

CLUE C - FOUND -> Seems like my_method is a private method defined on Object

I will try to test this. I know that public_send can only call public methods on an object. And I know that send will call any method.

I will create a simple method that will print self and object_id and try out various things:

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endmy_method# => Who is here: main with object_id 60

What happens if I try the following things:

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endObject.new.my_method# => testing.rb:5:in `<main>': private method `my_method' called for #<Object:0x00000001054229c0> (NoMethodError)

What about using public_send -> the same result

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endObject.new.public_send(:my_method)# => testing.rb:5:in `public_send': private method `my_method' called for #<Object:0x0000000105952968> (NoMethodError)

Then send should work:

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endObject.new.send(:my_method)# => Who is here: #<Object:0x0000000107412960> with object_id 60

So if my_method will be defined on the Object then I must be able to use it in my custom objects right?

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endclass SimpleObject  def test    my_method  endendSimpleObject.new.test

Indeed it works! I now confirmed in two ways that my_method is indeed created at runtime in Object

Four: Is my_method defined in Object or added to Object?

Just to push things more, let's try to find out what kind of mechanism is used to add this method to the Object (well from how I formulated this you probably can guess):

def my_method  puts "Who is here: #{self} with object_id #{self.object_id}"endclass SimpleObject  def test    my_method  endendputs "Are you defining `my_method`? #{SimpleObject.private_method_defined?(:my_method)}"uts "Do you have this method? #{Object.private_methods.include?(:my_method)}"# => Are you defining `my_method`? trueDo you have this method? true

This is a method that was added to the Object and Object is defining this method as a private method.

We can test this by using Object#method_added

class Object  def self.method_added(method_name)    puts "I just added #{method_name.inspect} on #{self}"  endenddef my_method  puts "Who is here: #{self} with object_id #{self.object_id}"end# => I just added :my_method on Object

CLUE D - FOUND The method is defined on Object but as a private method. That's why it is accessible everywhere, but that is also why if you add this kind of method, you would be polluting every object with extra private methods if you define top-level methods like that or you might redefine already existing methods.

Five: Is my_method part of BasicObject

In the beginning, I asked this question inside the exploration.rb file:

puts "What are your ancestors: #{self.class.ancestors}"# => What are your ancestors: [Object, Kernel, BasicObject]

I think it is worth investigating a bit what happens with BasicObject and Kernel.

Question 1: Does BasicObject include my_method?

def my_method    puts "Who is here: #{self} with object_id #{self.object_id}"endclass AVeryBasicObject < BasicObject  def look_for_my_method    my_method  endendbegin  AVeryBasicObject.new.look_for_my_methodrescue NameError => _  puts "`my_method` is not here"end# => `my_method` is not here

BasicObject does not include my_method

Question 2: Does Kernel module include my_method?

First I will include Kernel and test to make sure it is included properly by testing that the newly created object has puts

class AnObjectWithKernel < BasicObject  include ::Kernel  def a_method    puts "Inside AnObjectWithKernel - it now includes puts"  end  def look_for_my_method    my_method  endendobj = AnObjectWithKernel.newobj.a_method# => Inside AnObjectWithKernel - it now includes putsbegin  obj.look_for_my_methodrescue NameError => _  puts "`my_method` is not here"end# => `my_method` is not here

Kernel does not include my_method

Conclusion

In conclusion, when defining a method without specifying an object in Ruby, the method is created as a private method inside the Object class.

This method can be called on any custom object, as it is added during the execution of the file.

Make sure you are not defining in the main context a method that is already defined by Object, Kernel or any other classes by Ruby cause that will create some not-wanted side effects.

Check out the result of executing the following code that I added inside a file called side_effects.rb:

class SimpleObject  def my_method    puts "Who is here inside? #{self}"    puts "Where is `to_s` defined? #{method(:to_s).source_location.inspect}"  endendputs "Who is here in the initial execution context? #{self}"SimpleObject.new.my_methoddef to_s  "THIS IS NOT MAIN"endclass SecondSimpleObject  def my_method    puts "Who is here inside? #{self}"    puts "Where is `to_s` defined? #{method(:to_s).source_location.inspect}"  endendputs "Who is here in the initial execution context? #{self}"SecondSimpleObject.new.my_method

The output will be:

Who is here in the initial execution context? mainWho is here inside? #<SimpleObject:0x00000001057b21f8>Where is `to_s` defined? nilWho is here in the initial execution context? mainWho is here inside? THIS IS NOT MAINWhere is `to_s` defined? ["side_effects.rb", 12]

Notice that to_s from SecondSimpleObject has now the value THIS IS NOT MAIN and it is reported to be defined in side_effects.rb file?

Updates

• Ufuk Kayserilioglu gave me valuable feedback on an earlier version of this article that I incorrectly used method_defined? instead of private_method_defined? in the section about if method was added or defined. Thus I refactored that section and now it states clearly that my_method is defined as a private method on the Object

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Data

• 311 million visits last month (September 2023) - according to similarweb.com

• 6.3 million users (as publicly shared by archiveofourown.org on their main website)

You can find data that is a bit bigger if you look at for example semrush.com:

Whatever data you pick, this is a big web app with 6 million users and between 300 million and 1 billion visits.

Tech Stack

They use at the date of writing this article:

• Ruby version 3.0.5

• Rails version 6

Source: their open-source Github repo

Conclusion

Ruby on Rails does scale!

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Here is how to create a new Rails app that runs on Rails 7.1 beta1

gem install -v 7.1.0.beta1 railsrails _7.1.0.beta1_ new myrails71app

Replace myrails71app with your own app name and you are good to go.

This will generate a Gemfile that has something like this inside and then install required gems for Rails 7.1.0.beta1

# Gemfilegem "rails", "~> 7.1.0.beta1"

New app with Rails main branch

Here is how to create a new Rails app that runs on Rails main branch from GitHub:

rails new myrailsapp --main

This will generate a Gemfile that has something like this inside:

gem "rails", github: "rails/rails", branch: "main"

May you have a lot of ideas to try!

Enjoyed this article?

👉 Join my Short Ruby News newsletter for weekly Ruby updates from the community and visit rubyandrails.info, a directory with learning content about Ruby.

👐 Subscribe to my Ruby and Ruby on rails courses over email at learn.shortruby.com - effortless learning anytime, anywhere

🤝 Let's connect on Ruby.social or Linkedin or Twitter where I post mainly about Ruby and Rails.

🎥 Follow me on my YouTube channel for short videos about Ruby

Note: When I am writing in this text GPT-4 I want to say that I am using Cursor IDE with GPT-4 option.

First, this is the result. I am pretty happy with it as I spent little time making it and it was a small iteration. This will probably evolve over the next weeks thus it is better to capture here how it looks like at the end of this coding session:

Adding the logo to the top left

After I created a very simple hero section that contained the title and a description I wanted to add a logo to the left side.

The prompt here is simple, it includes a reference to the hero partial (I am using Cursor IDE) and I asked it as clearly as I could what to do.

I received a good enough response along with an explanation of the solution. I was pleased to notice that the logo was indeed on the left side.

The only thing is that I asked for a "square with rounded corners" but I received a full-circle image. I kept it because I liked how it looked. Yet I appreciated that it told me how to make the corners "less rounded"

Decreasing the top and bottom space

You cannot see it in the final form of the website but you can see in the above image that the vertical padding on the second div is quite big py-32 or py-40 depending on the screen size.

Thus as you can notice I asked it to decrease the spacing while choosing the appropriate Tailwind dimension. Notice that here I tried to be explicit but did not use any Tailwind (like asking for a specific utility class) or CSS-specific terms (like padding or margin ...)

The response was again good enough:

I like the explanation about how it arrived to transform py-32 to py-20 (reducing in this case to about 62.5%) and py-40 to py-28 (reducing in this case to about 70%). I found them pretty close to the 1/3 that I asked for and they looked good enough to keep this change.

Making the columns the same height

I then had a page with 3 columns (or cells) each one having a different height because the description had a different length. Thus I asked GPT-4 to change it:

Here I tried again to be as descriptive as possible without giving into what solution I am looking for.

I received a response that uses flex-grow to achieve this result. It worked, but in the end, I needed to edit more. After seeing the result I also added height to the title of the column.

Replacing a div with a

After playing a bit with the design I figured out that I wanted to make the entire column clickable and not only the small button to visit.

This time I used the in-editor chat and selected one column that I asked to be transformed. What you can notice in the above prompt is that I ask specifically to keep the format/layout of the column. I asked this based on previous experiences when I asked for changing tags and I noticed that it needs guidance on what to choose when merging styles.

Here is the diff that Cursor GPT-4 proposed:

It is a good result, it does do the job that I asked for. I noticed that it added a bg-white class that was not necessary, but I think it makes sense to add it so that it is clear what happens on hover - what background colour it transitions from.

Making an element show when the column is hovered

I wanted to add a bit of colour on the entire page because it is a bit grey. Thus I added a small animated bullet in blue.

Thus my objective was to display that element only when the column is hovered:

In this case, because this is about show and hide, from my previous experiments I noticed it needs to know what to do when what is added will conflict (using flex and block or hidden and block). I added, "when there is a conflict between added CSS classes please choose the ones that will achieve this functionality".

The result works and it uses group and group-hover to achieve the result:

It did the work and now I can have this:

Conclusions

Here are some learning points from this experiment:

• GPT-4 is not aware of CSS classes that are doing similar things through different CSS rules. Thus it cannot act like a linter nor it can choose one or the other => it needs to be instructed on what to do in case such conflict occurs. I instructed it generally in the examples above asking to pick only classes that will achieve the functionality but you can also instruct it specifically like preferring flex or grid or something similar

• Among the most important learning for me - not only from this small experiment but for many others - is that the effort to write prompt forces you to put your thoughts in writing and this simple act will help to make some choices or be aware of some choices and thus will contribute to having a better code design.

• Even with better prompts and the results containing an explanation, the programmer still needs to be able to understand the solution and assess if it works and if they want to keep it.

• I still like more the side chat for Cursor IDE and prefer it over the inline chat. Probably it is a preference that comes from because I used it before for 1-2 months Github Copilot Chat and thus it probably was the start of a habit

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates from the community. For more Ruby learning resources, visit rubyandrails.info. You can also find me on Ruby.social or Linkedin

Here let me show you how I made two changes to the rubyandrails.info website.

Replacing a form with a Phlex component

The first task that I asked was about replacing an HTML with a component. To achieve this in Cursor (MacOS edition) you have to select the text and then press CMD+K. Then a pop-up will appear where you can ask your question (or write your prompt) like this:

After submitting Cursor (that uses GPT4 in this case under the hood) will make a diff for the selected code and ask you to accept it or not:

I like this idea that it proposed a diff because I can review it and check if it is correct or not.

This was a small change and I was happy with the result. I did a lot more replaces like this but I did not use Cursor LLM for this.

My conclusion is that for this very small case, writing the prompt and reviewing the change is much more effort than directly writing the code myself and the return on investment is small. It does not even contain any new insights or something to learn for me.

What I would like (and maybe Cursor knows this but I am just starting to use it) is to ask to replace all forms like that with the component. I will still need to review the code because the risk would be to replace a code that looks like that but it is not the same search functionality.

A small security PR

Next, I moved from the Edit with LLM functionality to the Chat with LLM functionality that Cursor IDE offers.

Looking at the source code I noticed the following code, which I think it is a security risk.

<strong>Search Term: </strong><%= params[:search_term] %>

Thus I asked the following to the Cursor chat:

One advantage I found while using Cursor chat is that it makes it easy to reference open files in a prompt.

Notice that I opened _index_nav.html.erb and reference it in my prompt with @_index_nav.html.erb and Cursor read the content to provide it to GPT4. The same can be achieved by selecting the text and pressing CMD+L will add the code itself as the context in the chat. By the way with CMD+L you can add multiple pieces of code from multiple files (but we will explore that in another article).

Here is the response:

What I notice in the response is that indeed h is an alias for html_escape but the response is a bit outdated, thus incorrect. Since Rails 3.0 there is no need to escape with h because:

• You no longer need to call h(string) to escape HTML output, it is on by default in all view templates. If you want the unescaped string, call raw(string).

The response, although it won't break anything, is also unnecessary and should not be followed. It is incorrect because until a vulnerability - if any - is found in the escape Rails does, the code should be considered safe. If we don't do this then we cannot work with abstractions or trust a framework.

Furthermore, since this information is from Rails 3.0, GPT-4 should already be aware of it.

I followed up with this question:

In this context is `html_escape` or `h` enough to mitigate the security risk of displaying an URL parameter provided by the user inside an ERB file?

Here is the response:

Also, the response here is a bit out of place. We are in the context of an ERB file where the code is just printing a variable. There is no SQL query executed. Again while the response sounds logical apparently it is unhelpful. It also shows that once the GPT gets into a direction it hardly self-corrects itself unless instructed to do so.

I still decided to extract into a component the display of the search and thus have it ready for further UI improvements across all pages.

You can see the PRs that I implemented with the Cursor IDE at:

• Add search component to all other pages

• Refactor Search Term Display into a Reusable Component

Some temporary conclusions

I used very simple prompts. Almost no context was given except for the ruby files or code itself. Nor did I ask for some proper follow-ups to nudge it in the desired direction. There was also no instruction about what a good code looks like for me.

I already had a good idea of what to look for. Thus, it was easy to know when a result was what I expected and when it was not.

The changes I made were small. Thus, it was easy to assess the code.

One challenging task is to determine if a response is up-to-date, as demonstrated by the interaction about escaping the parameter.

Another challenging task is to be able to detect a response that sounds logical, but is out of context and thus would be wrong to be applied in that specific situation.

Update

1. In a previous version of this article, I was evaluating the response from GPT-4 which recommends using h to escape the HTML output when using in ERB as good enough. Xavier Noria pointed out that it is not needed to use h as Rails ERB <%= is escaping HTML output by default. I confirmed this by testing and also found the changelog that mentions this since Rails 3.0.

2. After a second review from Xavier and following a discussion we had I am reconsidering my evaluation of the response about XSS vulnerability from unnecessary to incorrect. Until proven otherwise (by someone else finding a bug in the html_escape) the escape provided by Rails should be considered safe and this should be the correct response from LLM.

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates. For more Ruby learning resources, visit rubyandrails.info. You can also find me on Ruby.social or Linkedin

In this article, we delve into Albert Endres' findings and explore how understanding the problem, effective communication, and domain knowledge play crucial roles in reducing errors.

These principles remain highly relevant in current software development practices, where collaboration, clear communication, and comprehensive knowledge of the project's domain could be crucial for the success of the product.

About the paper

In 1975, Albert Endres published a paper called "An Analysis of Errors and their Causes in System Programs".

In this paper, they analyze the errors detected in an operating system DOS/VS developed by IBM Laboratories in Germany.

The system was released in 1973. The paper analyses:

- 500 modules, with an average of 360 lines per module and 480 lines of comments, resulting in 190K instructions and 60K comments.

- A total of 740 problems were found, of which 432 were classified as program errors.

Areas where errors where found

And here are some of the conclusions from this paper:

If we want to reduce the number of errors then we should focus not only on better programming techniques but also on the problem definition, and understanding domain knowledge:

And based on the paper here are the categories of causes for errors or bugs:

1. Technological = "definability of the problem, feasibility of solving it, available procedures and tools"

2. Organisational = "division of work load, available in- formation, communication, resources"

3. Historic = "history of the project, of the program, special situations, and external influences"

4. Group dynamic = "willingness to cooperate, distribution of roles inside the project group"

5. Individual = "experience, talent, and constitution of the individual programmer"

6. Other

Some conclusions:

1. When considering quality in a software product, we should consider all aspects, not only the tools and programming techniques we use.

2. When joining a product or team, it is important to understand the history of the product & team.

3. To become a better developer one has to learn more than coding/engineering techniques.

4. When we think about a possible future of using AI to augment programming, we should consider that if this study remains true it is not enough to reduce the number of errors. As half of them are not caused by code.

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates. For more Ruby learning resources, visit rubyandrails.info

Numbers (source):

• All respondents: in 2023 Ruby has 6.23% while in 2022 had 6.05%. It also moved up a spot in 2023

• Professional Developers: 2023 is at 6.94% while in 2022 was at 6.72%

• Learn to code: in 2023 is at 2.55% while in 2022 was at 2.52%

What does this mean:

• Ruby is growing in adoption, with a higher adoption rate for professionals than for beginners.

• Our efforts to bring new people toward Ruby are working but at a slow pace. Here we need more power, more people and more money and energy to spread the idea to learn Ruby for people that are learning to code.

• I started to see more new content created addressed to beginners in the last 3 months that might contribute toward the end of this year to more beginners discovering Ruby

Top paying technologies

Numbers (source):

Ruby is this year (2023) in 4th position from the top, with an average of $98.552, moving up from last year (2022) when it was in the fifth position with $93.000

What does this say:

• Even if they were quite a few layoffs in the Ruby community, the remaining Ruby developers had (as a group) an increase in their compensation

• Ruby is still among the top 10 top-paying technologies

To consider

• This is a survey filled in by people that are using Stack Overflow.

• This year's survey had more responses than last year's survey, 90.000 this year compared with 70.000 last year and so in some cases (like the growth of Ruby in the Most popular technology category) it means not only a percentage growth but also in absolute terms.

• (subjective) Stack Overflow is not too friendly to Ruby beginners because there are a lot of old questions with answers not being updated to match the current knowledge, version, and capabilities of both Ruby and Rails in 2023.

What can we do?

First, when considering the Ruby community as a whole, I believe that there are likely more senior members than junior ones, with a ratio of at least 2:1 or greater. Although I don't have data to support this claim, my impression is based on the online presence of community members in social media, forums, and comments.

I think there are already projects in the community (both new and old) that are great and successful in addressing the needs of senior programmers. With more to be launched and I discover more and more every week while I curate content for Short Ruby Newsletter.

As others have pointed out in various discussions this year, we need to invest more effort in welcoming new people to the ecosystem. This means creating more content for beginners, more jobs and at-work learning experiences for beginners, and providing learning materials and books for those just starting. A broader range of perspectives and voices will help attract a larger audience.

In today's rapidly evolving online content, we should also try to find ways to encourage beginners to share their experiences and write tutorials to teach others. We should want to put Ruby on the beginner's radar and talk about why they should pick Ruby as a programming language and then provide learning support.

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates. For more Ruby learning resources, visit rubyandrails.info

When I talk with someone that is learning Ruby or Ruby on Rails I usually receive this question: what project should I build when I learn Ruby on Rails?

The same goes for me: when I am learning something new, I feel the need to build something with it. And it works best if what I am trying to build is as real as possible and not only a "theoretical" abstract learning project.

In this article, I will try to make the case that it is best to:

1. Try to solve a problem you have while learning a new programming language or framework

2. If that does not work or if it feels too hard to tackle in the beginning I will present a list of projects that I think are good to be picked up as a learning project

Solve a problem/need you have

I think from the learning process point of view the best project to work on is to solve a need you have. This works best because it will keep your motivation up and you will also get enthusiastic about seeing that using Ruby will help you directly.

Create a script to solve your problem

I recommend starting with this more if you are learning Ruby now and did not yet start to learn a web framework.

A script that will take some inputs, execute some logic and then output something on the terminal is a small time investment and will let you focus on Ruby and writing idiomatic code instead of dealing with UI.

I have a lot of scripts written in Ruby. Here are some examples:

• parse CSVs and extract information from there: you can do counts, averages, sum ... on some specific fields. I use this for example to parse Stripe exports and some other financial exports and then get quick information like total amount per month, unpaid invoices ...

• a script that takes a screenshot of a web page and will save it in a specific folder

• a script that will read the <title> and <meta name="description" content="..."> and will print them out

I can go on with more examples, but I hope you got the idea. Write a small script that is executing some code that will solve one single need.

How to approach this:

1. Write a script that will solve your problem and make it as specific as possible. Eg if you are writing a parse CSV script to read an export you have and print a total sum, just write this script based on the CSV file that you currently have. Don't try to make it work with any CSV or try to make it work with columns being moved around or renamed.

2. Then try to redesign the code and improve the code quality

3. Then try to make your script more generic or customizable: like accepting a different CSV file with other columns and other column names.

I know this probably sounds very simple, but trust me. I got so many times into rabbit holes trying to write a script that can handle so many edge cases and be so flexible and I almost every time invented a kind of framework.

Create a simple web app to solve your problem

Again my recommendation is to look at a problem or need that you have and try to build a simple web app for it.

The same advice applies:

• Just focus on directly solving the problem. Please don't add authentication to it from the beginning or automated deployment or any extra flexibility. Pick one single thing and focus on solving that.

• Make it work on your computer. Don't bother to create a big architecture that will handle millions of edge cases. That is good learning maybe, but not the first time you learn a web framework.

• Try to focus on following the guides for that specific web framework. Even if you disagree with some of the things there, it is good to understand first what are the cases that the framework solves and how it tries to solve them before going into making it work for you.

• Then after you have something working you can now expand your web app to handle more cases.

If you want to pickup some good habits when building a web app, after you did the initial version consider working to improve the following 3 areas:

1. Accessibility

2. Security

3. Performance

Examples of web apps that you can build

The following is a list of possible web apps that you can build as a learning process. I choose them because I think they are easy to be approached and their domain knowledge is not hard to understand.

Weekly Meal Planner

A web app where users will submit their recipes, food items and then do a meal plan for a week (breakfast, lunch, dinner). Bonus if you can support multiple family members and allow them to vote on which day they liked the most.

Here is a possible list of features and the order to build them:

1. Create a new recipe with a title, description, steps, and time to cook

2. Create a Week with an attribute called Title

3. Add multiple recipes to a Week

From here you can add accounts, owners, voting ...

Lists Share

An app that allows a user to create a list of things gives a short tile of that list and a description about it, and then after saving it allows the user to share it with anyone. A visitor should be able to see the list without being authenticated.

Here is a possible list of features and the order to build them:

1. Create a list with a title, description

2. Add items to a list

3. Create users

From here you can add more complex features:

• Display a view counter

• Add a feature to allow authenticated users to do a thumbs up kind of vote for other users' lists

• display on your app's home page the top 10 most-seen lists and the last 10 recently created lists

Habits Tracker

Create a web app that will allow the user to set up a list of habits the user wants to track daily and then ask every day user to mark with a check if they made that habit or now that day. Display completion progress for 30 days.

Here is a possible list of features and the order to build them:

1. Create a habit

2. Mark a habit as done for today

3. Display a calendar view showing if the habit was completed each day

From here you can add more complex features:

• Tracking multiple habits per day

• Add users

• Display a graphic about how the completion of each habit worked (see D3 or Charkick JS libraries for inspiration - both have rails gems)

• Send a monthly email with a summary of progress for each habit.

Symptoms Tracker

An app to track symptoms daily. The user should add one or more symptoms by clicking on a specific day and choosing the time and adding a text describing the symptoms. Display a monthly calendar and mark the days with symptoms.

Here is a possible list of features and the order to build them:

1. Add a symptom for today from a predefined list

2. Add a custom symptom for the current day

3. Add symptoms in the past: choose any day and add one or many symptoms

From here you can add more complex features like:

1. Add a tag for the symptoms and categorize them

2. Display the evolution of a tag/symptom during a week/month. Like adding a scale for each symptom

3. Add users support

4. Allow for a user to track symptoms for multiple people (like a partner, child )

SWOT Analysis

Create a web app to allow users to create a SWOT analysis on any topic. This should allow the user to fill in all 4 quadrants and then share the Swot Analysis with other people.

Here is a possible list of features and the order to build them:

1. Create a new SWOT analysis and fill in the 4 quadrants

2. Create a unique shareable link for each SWOT analysis

3. Edit SWOT analysis

From here you can add more complex features like:

1. It should also allow adding comments to each section of the analysis.

2. Add users

3. Allow other users to suggest new lines to be added to each section and let the owner accept it or reject it

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates. Also, check out my co-authored book, LintingRuby, for insights on automated code checks. For more Ruby learning resources, visit rubyandrails.info

Here is where I think you should submit/publish your article to reach a wider audience.

Links aggregators & Newsletters

Here are some places where I would submit an article:

• rubyflow.com - there is a submit button there and it is easy to submit it

• rubyland.news - here you will need to go to About and write an email to the owner of the website asking them to add your RSS feed. Then every time you write your article will automatically appear on Rubyland

• ruby.libhunt.com - also here you can submit your article by clicking on the Submit button from the menu

• news.ycombinator.com - here you can submit your article by going to Submit

• lobste.rs - here you can submit your article but you will need an invite to create your account

• RubyWeekly - while there is no official way to submit an article for RubyWeekly it is worth trying to suggest your article there as it has the largest audience. One way would be to subscribe to the newsletter and then reply to an issue with your proposal.

• RubyRadar - you can submit your article to be included in the Ruby Radar newsletter by creating a discussion on their Github repo

• Short Ruby Newsletter - you can submit your article as an issue to this Github Repo

• Hotwire Dev Newsletter - if you write anything related to Hotwire you should send it to Joe Masilotti

In almost all cases for these websites, you will have to create an account or authenticate via Github.

Cross-posting

There are two places where I recommend you should republish your article:

• Dev.to community. They are a great and supportive community for developers and there is even a weekly Rubyist Hangout Thread

• Hashnode - another quite active community of fellow developers

How this works:

• You should just copy/paste your blog content. Both Dev.to and Hashnode support markdown so if you wrote your blog post as markdown publishing it there should be as fast as a copy/pasting and re-uploading some images

• Then after you copied your content, DO NOT YET publish until you made sure you specified the canonical URL where you write the original URL of your article (the one from your blog)

Here is where you find the canonical URL at Dev.to:

Here is where you find the place to write the canonical URL at Hashnode:

If you want you can do the same for Medium. They also support the option to republish and can specify the canonical URL. There is still an audience there that reads technical content so from an authorship perspective if you want to spread your message as wide as possible you can consider publishing there too.

Online Communities

daily.dev

You can publish on daily.dev and you can ask for your RSS feed to be included automatically on their website. I think they started as an aggregator but they are adding a lot of features that could support a community like Squads.

Ruby on Rails group on Linkedin

This is I think the biggest group on Linkedin for Ruby and Rails developers. They accept posting your article and usually, people will engage with your content.

Web Developers United on Linkedin

This is a group that is not specific to Ruby but there is a Ruby audience there and the group accepts submissions for technical articles.

Reddit /r/ruby

An active community of Ruby developers on Reddit. They are engaging with your articles and will usually reply with direct feedback.

Reddit /r/rails

Also an active community of Ruby on Rails developers where you can submit an article and get direct feedback about it.

Other places

Of course, you should publish this on your social media channels. If you keep publishing Ruby content more people will probably follow you knowing that this is the type of content that you publish.

What other places to promote an article about Ruby do you know?

If you know other places where an author of an article about Ruby can promote their content please let me know in the comments here.

Enjoyed this article?

Join my Short Ruby News newsletter for weekly Ruby updates. Also, check out my co-authored book, LintingRuby, for insights on automated code checks. For more Ruby learning resources, visit rubyandrails.info

def init_options(options)  options = { widget: true }enddef add_default_config(options)  options[:add_on] ||= trueend

Do not focus on the code design. There might be better ways to express this, but I want here to focus on what happens when executing the following statements:

options = { plugin: true }add_default_config(options)puts options # => {:plugin=>true, :add_on=>true}init_options(options)puts options # => {:plugin=>true, :add_on=>true}

Notice that after executing init_options the content is still the same even if inside there is a statement that would instantiate a new hash.

Or take a look at the following code:

options = { widget: true }options.tap do |opt|  opt[:widget] = falseendputs options # => { :widget => false }new_options = { plugin: true }new_options.tap do |opt|  opt = {}  opt = { plugin: false }endputs new_options # => { :plugin => true }

Why in this case the new_options is not changed after the tap was executed?

To answer this we will need to understand how objects are passed in Ruby: pass by value or pass by reference?

Let's dig in to find out how Ruby works when talking about passing objects.

A variable is a reference to an object

To understand this I will execute a series of statements and explain step by step how they work:

options = {}puts options.object_id # => 60

This will do two things:

• Creates a new Hash object that in this specific case on my machine has the id 60

• Create a new label called options and associate that with the newly created object.

Then calling options.object_id on it will return an integer that identifies uniquely that object during the execution of the program.

Imagine that Ruby is just creating a link between the label options) and the object that is associated with that label.

This association might look (visually) like this:

+-------------+-----------+| label       | object id |+-------------+-----------+| options     | 60        |+-------------+-----------+

In this case, we can affirm: "options points to object with id 60" or "options references object with id 60".

Now I will add a second variable called new_options:

new_options = optionsputs new_options.object_id === options.object_id # => true

This second variable will reference now to the same object as options:

+-------------+-----------+| label        | object id |+-------------+-----------+| options     | 60        || new_options | 60        |+-------------+-----------+

What do you think will happen if I start adding more hash keys to either options or new_options?

options[:plugin] = trueputs options # => { :plugin =>true }puts new_options # => { :plugin =>true }new_options[:widget] = trueputs options # => { :plugin =>true, :widget =>true }puts new_options # => { :plugin =>true, :widget =>true }# Are they still the same object?# Yes, they are.puts new_options.object_id == options.object_id # => true

Because they are both references to the same object, calling a method on any of those variables like for example []= will be called on the referenced object (in the specific example the object with object_id 60).

What happens when I try to instantiate a new object and assign that to one of the existing variables?

# What if I try to assign the `options` variable to a new object?options = Hash.newputs options.object_id # => 80puts new_options.object_id # => 60puts new_options # => { :plugin =>true, :widget =>true }puts options # => {}# They are not the same objectputs new_options.object_id == options.object_id # => false

In this case the options will point to a new object while new_options is still pointing to the existing one:

+-------------+-----------+| label       | object id |+-------------+-----------+| options     | 80        || new_options | 60        |+-------------+-----------+

Here we can draw a couple of lessons:

1. Variables are references to objects, but not the objects

2. Assigning a new object to a variable will change it to reference the new object

Passing arguments to methods

When passing an argument to a method we are in a way creating a local variable inside that method that references the object that is passed.

Let's start with a simple example:

options = { widget: true }def add_default_config(options)  puts "Object has id: #{options.object_id}"endadd_default_config(options) # => Object has id: 60

What happens here is that inside the add_default_config method a new variable called options is created and it is assigned to the same object that is passed to the method as a reference. This means that the options variable inside the method is pointing to the same object as the options variable outside the method.

To represent the references we will need to add a new column that is defining the scope of the variable:

+--------------------+------------+-----------+| lexical scope      | label      | object id ||--------------------|------------|-----------|| main               | my_options | 60        || add_default_config | options    | 60        |+--------------------+------------+-----------+

This simply says:

• There exists a label called my_options that is referencing an object with id 60 in the main scope

• There exists a label called options that is referencing an object with id 60 in the add_default_config scope or the local scope of the method add_default_config

Now let's try to change the object inside the method:

my_options = { widget: true }puts my_options.object_id # => 60def add_default_config(options)  puts "Object has id: #{options.object_id}"  options[:add_on] ||= trueendadd_default_config(my_options) # => Object has id: 60puts my_options # => { :widget => true, :add_on => true }

It just works because both the local variable my_options in the main scope and the local variable options in the method scope are referencing the same object. Calling a method by referencing it via any of those two variables will change the same object.

What happens if I try to assign a new object to the local variable options ?

my_options = { widget: true }puts my_options.object_id # => 60def add_default_config(options)  puts "Object has id: #{options.object_id}"  options = {}  puts "Object now has id: #{options.object_id}"  options[:add_on] = trueendadd_default_config(my_options)# will print# => Object has id: 60# => Object now has id: 80puts my_options # => { :widget => true }