TIL about the RAILS_DEVELOPMENT_HOSTS env variable. This adds the hosts specified to your environment, so that you don't have to manually update config.hosts.
Just start your server like so
$ RAILS_DEVELOPMENT_HOSTS="my-url.ngrok-free.app" bin/rails sh/t Matt Polito
By default, if you make a change to a belongs_to associated model and save the parent model, the associated model won't be saved. This is probably a good default, but it is overridable with the :autosave option.
class Book < ApplicationRecord
belongs_to :author
end
book = Book.first
book.author.name # => "J.R.R. Tolkein"
book.author.name = "John Tolkein"
book.save
book.reload
book.author.name # => "J.R.R. Tolkein"
But we can change this behaviour by setting :autosave to true.
class Book < ApplicationRecord
belongs_to :author, autosave: :true
end
book = Book.first
book.author.name # => "J.R.R. Tolkein"
book.author.name = "John Tolkein"
book.save
book.reload
book.author.name # => "John Tolkein"
While this is off by default for belongs_to associations, has_one and has_many associations have :autosave true because the foreign keys are on the associated records to ensure those FKs are kept up to date.
Today I learned a way to view all the enums defined on an ActiveRecord Model.
Suppose I have a class Post with enums status and category:
class Post < ApplicationRecord
enum status: [:draft, :published]
enum category: [:ruby, :rails, :lord_of_the_rings]
end
I can view the enum values for statuses with Post.statuses and category with Post.categories, but what if I want to see all the enums on Post? defined_enums will do that:
Post.defined_enums
# => {"status"=>{"draft"=>0, "published"=>1}, "category"=>{"ruby"=>0, "rails"=>1, "lord_of_the_rings"=>2}}
You can of course key in to each enum here too:
Post.defined_enums["status"]
# => {"draft"=>0, "published"=>1}
Kamal, the default deployment tool for Rails, has some really great features. One that I just discovered today is kamal secrets.
You can use this utility to expand sensitive credentials from external sources during deployment. Out of the box, it supports 1Password, Bitwarden (and Secrets Manager), LastPass, AWS Secrets Manager, Doppler, and GCP.
You can run the command for SECRETS from the .kamal/secrets file manually to test everything out.
A pre-req for using 1Password is that you will need to install the OP CLI and login to your vault:
brew install 1password-cli
op signinNext you'll need your account id. You can get that with -
op whoami
Then verify you can read your secrets. The output of the command inside the $(...) is a stringified JSON -
SECRETS=$(kamal secrets fetch --adapter 1password --account op_account_id --from "op://Example/ApiKeys" KAMAL_REGISTRY_PASSWORD)The output will look something like this -
\{\"Example/ApiKeys/KAMAL_REGISTRY_PASSWORD\":\"xxxxxxxxxxxxx\"\}
The last part is expanding this. You can pass this JSON string to kamal secrets extract to extract the value from the key in the JSON.
kamal secrets extract KAMAL_REGISTRY_PASSWORD ${SECRETS}
You can change the context of your console session by using the cd just like you would change the context of your directory.
Here is an example.
# Grab an object, in our example a customer.
c = Customer.all.sample
# Now, 'cd' in to that object.
cd c
# From here you will notice that we are now within
# the context of our object and can call methods on it directly.
pry(<Customer>):1> first_name
=> "Peter"
pry(<Customer>):1> last_name
=> "Parker"I found this cool tip, as well as some others in this awesome blog post.
I was curious if I could trigger a rake task from within my Rails application.
After some digging, I found Rails::Command.invoke() which lets you run rake tasks from inside your Rails app.
Here's an example using db:migrate:
Rails::Command.invoke('db:migrate')Just pass it the name of your task (db:migrate, your_custom_task, etc) and it will begin processing it.
This is great for automating or triggering rake tasks during bootstrapping or background operations without needing to leave the Rails environment.
ActiveSupport has a lot of useful inflections to transform strings, and I often forget which one does what exactly.
#humanize will capitalize the first word, whereas #titleize will capitalize every word:
"hi_how_are_you?".humanize
# => "Hi how are you?"
"hi_how_are_you?".titleize
# => "Hi How Are You?"
Actually, it turns out #titleize is just a special case of #humanize!
Ever been debugging in ActiveRecord and wanted to inverse a query? You can do that without changing the whole query!
User.where(active: true)
# => "select * from users where active = 'true'"
User.where(active: true).invert_where
# => "select * from users where active != 'true'"It also works with multiple conditions:
User.where(active: true, subscribed: false)
# => "select * from users where active = 'true' and subscribed = 'false'"
User.where(active: true, subscribed: false).invert_where
# => "select * from users where active != 'true' and subscribed != 'false'"It works on scopes, too:
class User < ActiveRecord::Base
scope :active, -> { where(active: true) }
end
User.active.invert_where
# => "select * from users where active != 'true'"
I recently ran into a situation where I wanted to know the return state of a transaction in ActiveRecord. Basically, I wanted to know if it succeeded or failed, then return true/false.
There's 3 scenarios to keep in mind to when trying to use this approach:
class TestModel
def save
result =
ActiveRecord::Base.transaction do
SomeModel.last.touch
end
result
end
end
> TestModel.new.save
=> trueActiveRecord::Rollback by default, so the transaction block returns nil class TestModel
def save
result =
ActiveRecord::Base.transaction do
raise ActiveRecord::Rollback
end
result
end
end
> TestModel.new.save
=> nilclass TestModel
def save
result =
ActiveRecord::Base.transaction do
raise ActiveRecord::Rollback
end
result
end
end
> TestModel.new.save
StandardError: StandardError from .....Putting it all together now, we can return a true/false for all scenarios -
class TestModel
def save
result =
ActiveRecord::Base.transaction do
SomeModel.new(attrs).save!
OtherModel.new(other_attrs).save!
end
result
did_save = !!result
did_save
rescue => e
false
end
endAndrew's TIL from the other day got me thinking about rails generators, and I never knew there was a generator for rake tasks!
There's not a ton of boilerplate in rake tasks, but that's never stopped me from making a typo.
bin/rails g task hello will generate just the namespace hello
# lib/tasks/hello.rake
namespace :hello do
end
If you have one or more tasks within the namespace, you can include them and the generator will add a task for each one:
bin/rails g task say hi bye good_day will generate
# lib/tasks/say.rake
namespace :say do
desc "TODO"
task hi: :environment do
end
desc "TODO"
task bye: :environment do
end
desc "TODO"
task good_day: :environment do
end
endRails 8 added a new generator command for creating 1 script files. The docs encourage the use of this folder for one off tasks, data migrations, etc. Previously, you could have used rake tasks to accomplish a similar thing.
Running this generator command will create the script dir if one does not already exist.
❯ rails g script migration_script
create script/migration_script.rb
When you generate a new Rails app, it comes with the web-console gem, a handy helper for embedding a rails console in the browser.
This can be useful in development for debugging things in the same process as your webserver. In my case, I used it to test out some action cable related things.
In your controller, just add console to the action -
class AppointmentsController < ApplicationController
def index
console
end
end
In Rails, if you want to ensure that you are using the same database connection from the connection pool to execute a number of commands, you can use the ActiveRecord::Base.with_connection method.
This method yields a single connection from the pool for you to execute your commands against:
ActiveRecord::Base.with_connection do |conn|
conn.execute("select * from sessions")
endIt is important to note that the connection yielded is taken out of the pool until the processing in the block is complete.
In a Rails task if you need to load in your rails application (to get access to your models, etc.), you have to call :environment in the task:
task task_name: :environment do
...
end
I kind of always took this for granted, and never thought much about it. Then, in Xavier Noria's 2024 Rails World talk he mentioned that :environment itself is a task - and that syntax is actually saying your task depends upon :environment and run that task before your task runs. 🤯
So I decided to look up what the environment task actually does:
task :environment do
ActiveSupport.on_load(:before_initialize) { config.eager_load = config.rake_eager_load }
require_environment!
end
require_environment! ... requires your environment, specifically it requires your config/environment.rb which runs Rails.application.initialize! - which is what actually starts your rails app.
Cool!
You can use the rails model generator to generate namespaced models. I always have a hard time remembering the syntax for namespaces, but it's pretty straightforward.
Say I want to create a model Blog::Post. The generator for this is:
rails generate model blog/post title:string ...This will generate the following files (assuming you're using rspec and FactoryBot)
invoke active_record
create db/migrate/20241028193321_create_blog_posts.rb
create app/models/blog/post.rb
create app/models/blog.rb
invoke rspec
create spec/models/blog/post_spec.rb
invoke factory_bot
create spec/factories/blog/posts.rb
If the namespace already exists, you'll be prompted to either overwrite or keep the existing app/models/blog.rb file (you'll probably want to keep the existing one).
Happy generating!
Using the Ruby on Rails migration generator is great to get up and running but always seems to require just a little bit more effort once the migration file is created.
There is a shorthand syntax for the cli interface of the generator but I can never remember it past a column name and type... so I'm putting this here to remember it for all of us!
To create an index just continue adding a bit more information to your column declaration. Let's start with this as a base so we're on the same page:
rails generate add_name_to_widgets nameThis will create this migration:
class AddNameToWidgets < ActiveRecord::Migration[7.0]
def change
add_column :widgets, :name, :string
end
endNow by making a minor adjustment to the original cli call we can generate the index too:
rails generate add_name_to_widgets name:string:indexclass AddNameToWidgets < ActiveRecord::Migration[7.0]
def change
add_column :widgets, :name, :string
add_index :widgets, :name
end
endAnd you know what? We can do unique indexes as well:
rails generate add_name_to_widgets name:string:uniqclass AddNameToWidgets < ActiveRecord::Migration[7.0]
def change
add_column :widgets, :name, :string
add_index :widgets, :name, unique: true
end
endI'm sure many of us are familiar with the Ruby on Rails migration generator...
rails generate migration add_name_to_widgets namewhich generates a migration that looks like so:
class AddNameToWidgets < ActiveRecord::Migration[7.0]
def change
add_column :widgets, :name, :string
end
end
Then to make the name column have a non-null constraint an addition of null: false would be needed:
class AddNameToWidgets < ActiveRecord::Migration[7.0]
def change
add_column :widgets, :name, :string, null: false
end
endHowever, now in Rails 8 an adjustment was made to allow this to be done from the generator shorthand
rails generate migration add_name_to_widgets name:string!By adding the exclamation point after the column type a migration will now be generated as we wanted before but without the additional manual edit:
class AddNameToWidgets < ActiveRecord::Migration[8.0]
def change
add_column :widgets, :name, :string, null: false
end
endh/t Akshay Khot
A lot of times I find I have to alias a method on a model when I'm exposing it on a GraphQL type. Most often I have to do this with ? methods:
class Post < ApplicationRecord
def draft?
...
end
end
class PostType < GraphQL::Schema::Object
field :draft, Boolean, null: false
def draft
@object.draft?
end
end
I want the field to be draft (without the ?), but on it's own the GraphQL Ruby gem can't resolve it to draft?, so I have to add an additional def in the Type class. This works, but it feels clunky.
Turns out you can use the method: option on the field to alias it inline, which I think streamlines things:
class PostType < GraphQL::Schema::Object
field :draft, Boolean, null: false, method: :draft?
end
The form helper select tag (ex - f.select) accepts a boolean option for include_blank, which informs the select tag to have an extra blank option. Setting include_blank: true will look like the below -
But you can also pass a string to include_blank and this will change the text content of the blank option -
<%= f.select :state, options_for_select(state_options), {include_blank: 'Select a State'} %>
https://devdocs.io/rails~7.1/actionview/helpers/formtaghelper#method-i-select_tag
Today I Learned the GraphQL ruby gem includes generators for types, mutations and other fun things.
rails g graphql:object
rails g graphql:input
rails g graphql:interface
rails g graphql:union
rails g graphql:enum
rails g graphql:scalar
rails g graphql:mutationWhat's even neater is if the name of thing things you're generating matches an existing ActiveRecord model, it will scaffold all the database columns as fields!
If you have a model Book like:
class Book < ApplicationRecord
attribute :id
attribute :author_id
attribute :title
attribute :published_at
end
Running the object generator rails g graphql:object Book will produce:
module Types
class BookType < Types::BaseObject
field :id, ID
field :author_id, ID
field :title, String
field :published_at, GraphQL::Types::ISO8601DateTime
end
end
Today I learned about some nice helper methods for ActiveRecord Enums. You might already know the ? methods to check the value of the enum. There are also ! methods to succinctly set the value of the enum too!
class Post < ActiveRecord::Base
enum status: {
draft: 0,
published: 1
}
end
post = Post.new
post.published? # => false
post.published! # updates the status to `published`
post.published? # => trueIn Rails, there is an nice and easy interface that can be used to check a string for equality.
To do this, you can use the ActiveSupport::StringInquirer object. Simply initialize it with a string value, like so:
string = ActiveSupport::StringInquirer.new("vanilla")
and now we can just call string#vanilla? to check for equality
string.vanilla?
=> true
string.chocolate?
=> falseFun fact:
This is how you are able to do Rails.env.production?
H/T: Matt Polito
If you want to conditionally add class names in Rails, here is a clean way to do it.
<%= link_to("Some Page", some_path,
class: class_names("bg-black text-black", {"text-white": text_visible?})
%>
This takes advantage of the class_names method, which is just an alias for the token_list method.
h/t to Matt Polito.
I always find myself looking up his TIL and figured if I make it myself it will help me retain it. 😅
ActiveSupport has a handy tool for handling exceptions globally in your Rails app. You can use it to catch specific exceptions and provide a centralized way to manage errors across your application, making your code cleaner and more maintainable.
Here is the example from the docs, showcasing how to catch specific exceptions and what method to run when they are caught.
Note: You can also pass it a block as the handler instead.
class ApplicationController < ActionController::Base
rescue_from User::NotAuthorized, with: :deny_access
rescue_from ActiveRecord::RecordInvalid, with: :show_record_errors
rescue_from "MyApp::BaseError" do |exception|
redirect_to root_url, alert: exception.message
end
private
def deny_access
head :forbidden
end
def show_record_errors(exception)
redirect_back_or_to root_url, alert: exception.record.errors.full_messages.to_sentence
end
end
Today I learned about some focused reload methods for ActiveRecord Associations.
Let's say I have an Author class that can have one magnum opus.
class Author < ApplicationRecord
has_one :magnum_opus
end
Now suppose I've instantiated an Author, and his magnum opus gets updated elsewhere. If I try to access that instance's magnum opus again (existing instance, no reloading), I'll get the old cached version:
author = Author.first
author.magnum_opus.title # => "The Dark Tower"
#elsewhere
mo = MagnumOpus.find_by(title: "The Dark Tower")
mo.update title: "The Shining"
author.magnum_opus.title # => "The Dark Tower"Now to remedy this, we can reload the author:
author.reload.magnum_opus.title # => "The Shining"
But why reload the whole author when you can reload just the association? ActiveRecord has reload_* methods for each has_one and belongs_to association that does just that - it reloads only the associated record.
author.reload_magnum_opus.title # => "The Shining"Docs for has_one and belongs_to.
h/t Matt Polito
It can be kind of clunky to query ActiveRecord for records where the has_manyassociation is empty.
Say I have an Author class that has many Books. One way to query for Authors without books is the following:
class Author < ApplicationRecord
has_many :books
end
Author.left_joins(:books).where(books: {id: nil})
This totally works, but at least for me is difficult to reason what we're querying. However, Rails 6.1 added a .missing method that really helps clarify what the query is doing:
Author.where.missing(:books)Much clearer - this will grab all authors that do not have any books.
Docs for further reading. Happy querying!
You can set attributes to be used when creating new records with .create_with:
Author.create_with(name: "Hashrocketeer")
Author.new.name # => "Hashrocketeer"
This can be particularly useful if you're doing a .find_or_create_by and want to set some values only when creating:
Author
.create_with(post_count: 0)
.find_or_create_by(name: "Hashrocketeer")
This will find an author with name "Hashrocketeer". If we find an existing Author, we won't change their post_count. If we don't find an existing Author, we'll create one with a post_count of 0.
Read more in the docs
Ever since I used ecto in Elixir Phoenix, I've always thought about their alter table function while working on Rails projects. Turns out, I have been living under a rock and I could have been using change_table this whole time 🤦🏻♂️
For those new to the change_table function, it allows you to make bulk alterations to a single table with one block statement. You can adjust columns(and their types), references, indexes, indexes, etc. For a full list of transformations, see the official api documentation.
If you're using Postgres or MySQL, you can also add an optional argument bulk: true and it will tell the block to generate a bulk SQL alter statement.
class AddUserIdToPosts < ActiveRecord::Migration[7.1]
def change
change_table(:posts, bulk: true) do |t|
t.remove_reference :user_post, :text, null: false
t.references :user, null: false
end
end
endAPI Ruby on Rails - change_table
Hooray Rails! 🥳
In Rails you can easily convert objects into URL query strings.
Here are a few examples:
string = "vanilla"
big_string = "extra chocolate"
integer = 5
array = ["vanilla", "chocolate"]
hash = {flavor: "vanilla", scoops: 2}
string.to_query("flavor")
=> "flavor=vanilla"
big_string.to_query("flavor")
=> "flavor=extra+chocolate"
integer.to_query("scoops")
=> "scoops=5"
array.to_query("flavors")
=> "flavors%5B%5D=vanilla&flavors%5B%5D=chocolate"
hash.to_query
=> "flavor=vanilla&scoops=2"
Note: Hashes don't require a key to be passed in, because they are inferred from the hash keys.
ActionCable provides a handy escape hatch for changing the url path of the cable in your frontend. In my case, I wanted to specify a token on the cable url so that I could preserve some in place functionality while also being able to use the Turbo::StreamsChannel.
I did some source diving in turbo-rails and found that turbo calls out to createConsumer which comes from @rails/actioncable.
And that's where I found this (part of which is pasted below with a subtle change for readers) -
export function createConsumer(url = getConfig("url") || "/cable") {
return new Consumer(url)
}
export function getConfig(name) {
const element = document.head.querySelector(`meta[name='action-cable-${name}']`)
if (element) {
return element.getAttribute("content")
}
}You can place a meta tag for the cable url in your views; this will be picked up by Action Cable and Turbo -
<meta name="action-cable-url" content="/cable?foo=bar">In a rails project, you can run the seeds programmatically from within Ruby. In my case, I used this to seed some configuration data before the test suite ran.
Rails.application.load_seedhttps://api.rubyonrails.org/classes/ActiveRecord/Tasks/DatabaseTasks.html#method-i-load_seed
Say you have an Activerecord object that you are making changes to.
user = User.last
user.update(first_name: "Joe", last_name: "Hashrocket")
With ActiveModel's Dirty module, you can view the changes made to the model even after it has been saved using the saved_changes method
user.saved_changes
# {"first_name"=>[nil, "Joe"], "last_name"=>[nil, "Hashrocket"]]}I was recently reading about the ActiveRecord::Store API and just today, I got the chance to use it. It's a really great API for working with serialized data in Rails.
Let's consider the following model Geolocation, with a jsonb column data. The contents of the data column look something like this -
{
"coordinates": {
"latitude": "5.887692972524717",
"longitude": "-162.08234016158394"
}
}
The store_accessor creates getters and settings for coordinates.
class Geolocation < ApplicationRecord
store_accessor :data, :coordinates
end
Geolocation.last.coordinates
# => {"latitude" => "5.887692972524717", "longitude" => "-162.08234016158394"}
In my case, I have nested data that I'd like to create accessors for - latitude and longitude. From what I could find, this API doesn't support nested data yet, so we have to bring in a helper from ActiveModel::Attributes. We declare the coordinates portion as a jsonb attribute.
class Geolocation < ApplicationRecord
store_accessor :data, :coordinates
store_accessor :coordinates, :latitude, :longitude
attribute :coordinates, :jsonb
end
geo = Geolocation.new
geo.coordinates
# => nil
geo.latitude
# => nil
geo.longitude
# => nil
geo.latitude = 5.887692972524717
# => 5.887692972524717
geo.coordinates
# => {"latitude"=>5.887692972524717}
geo.longitude = -162.08234016158394
# => -162.08234016158394
geo.coordinates
# => {"latitude"=>5.887692972524717, "longitude"=>-162.08234016158394}I_Ran_Out_Of_Words_Hopefully_You_Get_My_Point :)
Let's say you have a blog, with Authors and BlogPosts. A BlogPost has an
Author and a title. If we have a requirement that the post titles need to be
unique, our model would look something like this:
class Blog < ApplicationRecord
has_one :author
validates :title, uniqueness: true
endLet's say the requirement changes, and the post title needs to be unique to the author (yeah it's convoluted, but let's roll with it). So Ann can author a post titled 'Cool Post', and Bob can also author 'Cool Post', but Ann can't publish another post titled 'Cool Post'.
Conveniently, uniqueness validations can be scoped to a particular attributes. So to satisfy the above, we can update the validation to:
class Blog < ApplicationRecord
has_one :author
validates :title, uniqueness: {scope: :author_id}
end
Let's say you have a blog with an Author model, and you want to create a
blog_posts table. Each post has an author, and you want a foreign key on
blog_posts to the Author's id.
class CreateAuthors < ActiveRecord::Migration[7.0]
def change
create_table :authors do |t|
t.string :name
end
end
end
class CreateBlogPosts < ActiveRecord::Migration[7.0]
def change
create_table :blog_posts do |t|
t.string :title
t.text :content
t.references :author, null: false, foreign_key: true
end
end
end
Pretty straightforward, right? But if Author#id is a UUID, you'll probably
run into some issues with this migration. Rails by default assumes your table's
IDs will be BigInt and if your IDs aren't then you need to specify the type
in t.references:
class CreateAuthors < ActiveRecord::Migration[7.0]
def change
create_table :authors, id: :uuid do |t|
t.string :name
end
end
end
class CreateBlogPosts < ActiveRecord::Migration[7.0]
def change
create_table :blog_posts, id: :uuid do |t|
t.string :title
t.text :content
t.references :author, null: false, foreign_key: true, type: :uuid
end
end
end
If you wish to not have Rails manage migrations, seeds, schema changes, etc, you can add the database_tasks: false to your database.yml. This may be useful if you are "inheriting", sharing a database managed with some other system, or if you are connecting to a readonly database.
production:
database: hashrocket
adapter: postgresql
encoding: unicode
pool: 5
database_tasks: false
Many, many moons ago 🌕🌗🌑🌓🌕 before Rails 3, ERB would add additional spaces before and after rendering HTML content, using <% %>.
To avoid those additional spaces you can use <%- %> or <% -%>
I share this in case you were like me, checking out some older code and didn't know what was going on here.
If you've worked with the rails encrypted credentials system before, you're probably familiar with the command to edit them
bin/rails credentials:edit
This will create(if it doesn't exist config/credentials.yml.enc by way of the RAILS_MASTER_KEY). If you only have this credentials file, the items in this file will be available to all environments of your application.
But you can also create/edit environment specific credentials by specifying an environment. This will similarly create 2 files - config/development.key and config/development.yml.enc.
bin/rails credentials:edit --environment developmentCredentials specified in this file will only be available in the development environment
https://edgeguides.rubyonrails.org/security.html#custom-credentials
An odd issue occurs when trying to use attributes similar to methods you'd expect with Rails ActiveRecord relationships in FactoryBot.
Take a relationship named provider. You would expect the ActiveRecord object to have methods for provider and provider_id.
However, some interesting behavior happens when you legitimately have a reason to have methods with those names, not during an ActiveRecord relationship.
FactoryBot.define do
factory :widget do
url { "URL" }
provider { "PROVIDER_NAME" }
provider_id { "PROVIDER_ID" }
end
end
One will get cleared out when providing the attributes for provider and provider_id.
There is a long-running issue regarding this, but for now, this is how I could remedy the situation. Set the methods as transient attributes and merge the attributes during initialization.
FactoryBot.define do
factory :widget do
url { "URL" }
transient do
provider { "PROVIDER" }
provider_id { "PROVIDER_ID" }
end
initialize_with do
new(
attributes.merge(
provider: provider,
provider_id: provider_id
)
)
end
end
endWhen using ActiveRecord, lazy loading is the default behavior, where associated records are loaded when accessed. While convenient, this can lead to N+1 query problems, where an unanticipated number of database queries are triggered, potentially degrading performance.
Strict loading is a countermeasure to this issue. When enabled, it enforces the eager loading of associations, meaning all necessary data is loaded upfront in a single query. This approach mitigates the risk of N+1 queries and makes data fetching more efficient and predictable.
Strict loading can be set at various levels:
Globally: Set strict loading for all models by configuring it in the application:
config.active_record.strict_loading_by_default = trueModel Level: Enable strict loading for a specific model:
class Book < ApplicationRecord
has_many :chapters, strict_loading: true
endAssociation Level: Apply it to specific associations:
has_many :comments, strict_loading: true Query Level: Use it on a per-query basis:
User.strict_loading.find(params[:id])You can use this command to view all of the middleware currently used by your application -
bundle exec rails middlewarehttps://guides.rubyonrails.org/rails_on_rack.html#inspecting-middleware-stack
Optional routing segments in Ruby on Rails are a versatile feature in the framework's routing system, allowing for more flexible and dynamic URL structures. These segments are denoted by parentheses and can significantly streamline routing patterns.
For example, a route like:
get 'books(/:genre)', to: 'books#index'
Here, :genre is an optional segment. This route will match /books and /books/fiction, routing them to the books#index action. The presence or absence of the genre parameter can be used within the controller to tailor the response.
Optional segments are handy for simplifying routes that cater to multiple URL patterns, reducing the need for numerous specific routes. They enhance the flexibility and readability of the code, making the application's URL structure more intuitive and user-friendly.
ActiveRecord::Associations#belongs_to has an option of touch.
If passed true, the associated object will have its updated_at/updated_on attributes set to current time.
You can also pass a symbol, in that case that attribute will be updated with the current time in addition to the updated_at/updated_on
class Comment < ApplicationRecord
# When a comment is saved/destroyed, its post will
# update the updated_at/updated_on to the current time
belongs_to :post, touch: true
# OR
# When a comment is saved/destroyed, its post will update both
# the updated_at/updated_on as well as comment_last_updated_at
belongs_to :post, touch: :comment_last_updated_at
endNote: No validations are performed when touching.
In Ruby on Rails, saved_changes and previous_changes are methods used to track changes in Active Record models. saved_changes is used after an object is saved to the database. It provides a hash of all the attributes changed when persisting an object, including their original and final values. This method helps understand what changes have just persisted. On the other hand, previous_changes is used after an object is saved but before reloading. It holds the same information as saved_changes but becomes available only after the save operation and before the object is reloaded. It is helpful for actions triggered immediately after a save, like callbacks or logging changes.
Both methods are instrumental in tracking attribute changes and responding to them effectively in a Rails application.
Now with Rails 7.1, has_secure_password can now automatically verify the current password when updating the password. This is useful to check if the user who is trying to update the password, knows the current password:
class User < ActiveRecord::Base
has_secure_password
end
user = User.new(password: "sekret", password_confirmation: "sekret")
user.save
#=> true
user.update(password: "HAHAHA", password_challenge: "")
#=> false, challenge doesn't authenticate
user.update(password: "updated*sekret", password_challenge: "sekret")
#=> trueAs of Rails 7.1, you can now generate your application using the Bun JavaScript runtime.
To do so, you can pass the --javascript=bun option to rails new.
rails new --javascript=bunWanted to share a method that I learned about today.
ActiveRecord has a handy utility for checking the value of an attribute in the database. These methods are actually on the Dirty module, and as such, are intended to be used when checking during validations or callbacks before saving.
These particular methods will read from the database (as their name implies), instead of using the value currently in memory.
There's 2 different methods to be aware of that you can use like below -
class Invoice < ActiveRecord::Base
validates :amount, presence: true
end
invoice = Invoice.last
invoice.amount
=> 10.0
invoice.amount = 80.0
invoice.attribute_in_database("amount")
=> 10.0
invoice.amount_in_database
=> 10.0
In the past, we've written about how to disable IRB autocomplete on Heroku. However, as of Rails 7.1, the Rails console turns off IRB's autocompletion feature in production by default.
As usual, there is a way to customize the functionality, so setting IRB_USE_AUTOCOMPLETE=true can override this default.
A newly generated Rails 7.1 app will now add an endpoint to your routes file to act as a heartbeat. You can point to many services or monitoring tools to check for downtime.
get "up" => "rails/health#show", as: :rails_health_checkHowever, this is just an indicator of the application running. If you want to do anything more advanced, like checking if the database is up... feel free to write your own. Ultimately, this is a great addition and will work in most situations.
Many years ago, the lib folder was removed from being auto-loaded in Rails. However, in Rails 7.1 it's back.
You can add autoload_lib to your config, and the lib folder will be added to your application's autoload paths. It does accept an ignore argument, which allows you to, of course, ignore folders in lib. When your new project is generated, it will add the assets & tasks folder to be ignored.
config.autoload_lib(ignore: %w(assets tasks))
There is a caveat that autoloading of lib is unavailable for Rails engines.