Rails on Jake Worth

Inferred Controller Parameters

Fri, 01 Mar 2024 16:54:46 -0500

Be careful when making a network request like this to a Rails controller with strong parameters:

// const employee = { name: "Jake" };

const updateEmployee = (id: number, employee: Employee) =>
 axios.put<Employee>(`/employees/${id}`, employee)

def employee_params
 params.require(:employee).permit(:name)
end

Note that our payload is expected under key employee– but we aren’t sending it that way. When this happens, Rails infers what goes where:

PUT https://server.dev/employees/1 { "employee" => { "name" => "Jake" } }

Notice that name is in the employee object, even though I didn’t send such a payload. This works fine until you send a parameter that’s not on the Employee model, such as a nested attribute. Then you get this:

Assert About Response Body in RSpec Controller Tests

Fri, 23 Feb 2024 15:22:30 -0500

When testing a serialized Rails API with RSpec, a common mistake is to assert about the response body, only to find that it’s an empty string. The controller is controlling, the view is presenting. What’s missing?

What’s missing is the view: RSpec views are stubbed by default. This is ideal for most controller tests. Just not those asserting about serialized data.

Render those views with render_views:

require "rails_helper"

RSpec.describe WidgetsController, type: :controller do
 render_views

 describe "GET index" do
 it "has a widgets related heading" do
 get :index
 expect(response.body).to match /<h1>.*widgets/im
 end
 end
end

Highlighted Routes Searching

Tue, 24 Aug 2021 14:14:40 -0400

On a non-trivial Rails app, the output from rake routes will be huge. Many people develop a reflex for searching through this output via something like:

$ rake routes | grep "<string>"

Which filters the output to matches on the string. I’d like to suggest a better option: use a command-line search tool that highlights the output! Here’s that same command with RipGrep:

$ rake routes | rg "<string>"

The results are the same (although much faster 😈), but even better is that that each match will be colorized. It’s bright red in my terminal. The colorizing makes the matches much easier to interpret.

fields_for exclude ID

Thu, 12 Aug 2021 09:47:32 -0400

Rails’ fields_for helper inserts a hidden ID field into your form. This is generally helpful, because you’ll want that information when you’re updating the record. But what if you don’t?

This is the scenario I encountered today: a ‘read-only’ form nested inside a fields_for helper, with no inputs. It almost worked: unfortunately, due to the default ID-inserting behavior of fields_for, there was a hidden ID input. It was getting submitted with the rest of the form and breaking things.

Generate a Rails Secret Key

Tue, 12 Jan 2016 13:55:55 -0600

Have you ever wondered about those secret keys found in config/secrets.yml of your Rails app? The comments generated in that file describe the keys as ‘used for verifying the integrity of signed cookies.’

Great… but what if they become compromised? Or we need to change them? We can generate new ones.

Rails provides rake secret for just this purpose.

The source code is here. It’s pretty simple; the code simply requires SecureRandom and spits out a string. If you want to be really clever, you can pipe the string directly into your Vim buffer for the config file, with :.! rake secret.

Show Model and Grep with Pry-rails

Fri, 08 Jan 2016 13:11:52 -0600

This week Josh Branchaud wrote about show-models in Pry-rails:

http://til.hashrocket.com/posts/62f61ee06f-show-rails-models-with-pry

This method has two nice variants. show-model User shows you that model, useful in a large database.

show-models also accepts --grep for searching:

[1] pry(main)> show-models --grep published
Post
 id: integer
 title: string
 published_at: datetime # 'published' is highlighted

Set a Default Scope

Fri, 08 Jan 2016 10:23:35 -0600

ActiveRecord provides default_scope, which you can use to control how records are returned. An example:

# app/model/chapter.rb
class Chapter < ActiveRecord::Base
 default_scope { order(:title) }
end

Now, instead of this (ordered by ID):

Chapter.all.pluck(:title).take(5)
=> ["BALINESE CAUSE",
"BUILDING RAT",
"TAIL",
"LILAC MERCURY",
"PUMP SQUARE"]

We get this:

Chapter.all.pluck(:title).take(5)
=> ["AFGHANISTAN COAT",
"ALCOHOL GONG",
"ANTARCTICA BULL",
"ASPARAGUS",
"BALINESE CAUSE"]

Beware, this decision can lead to inexplicable behavior down the road. Use with caution.

One use case I’ve heard is soft deletes. We might not want soft-deleted records appearing in .all:

Rails restore_attributes

Tue, 13 Oct 2015 11:56:12 -0500

Today I found a useful method in ActiveRecord, restore_attributes.

This method restores attributes on a dirty model. Use it when you are hacking in the Rails console and want to quickly return to a clean slate.

Dirty the record:

[1] pry(main)> p = Post.first
Post Load (0.4ms) SELECT "posts".* FROM "posts" ORDER BY "posts"."id" ASC LIMIT 1
=> #<Post:0x007f8462b09eb8
id: 106,
title: "Hello World!",
created_at: Sun, 09 Feb 2014 17:15:01 CST -06:00,
url_slug: "hello-world">
[2] pry(main)> p.url_slug = 'foobar'
=> "foobar"
[3] pry(main)> p.created_at = Time.now
=> 2015-10-13 11:41:37 -0500
[4] pry(main)> p
=> #<Post:0x007f8462b09eb8
id: 106,
title: "Hello World!",
created_at: Tue, 13 Oct 2015 11:41:37 CDT -05:00,
url_slug: "foobar">

And restore:

Rails destroy

Tue, 06 Oct 2015 11:32:01 -0500

The rails generate (g) command is useful for quickly creating the building blocks of a Rails app. Until you misspell or otherwise mess up a command:

% rails g model blurg_post
invoke active_record
create db/migrate/20151006162244_create_blurg_posts.rb
create app/models/blurg_post.rb
invoke rspec
create spec/models/blurg_post_spec.rb

‘Blurg post’? I meant ‘blog post’. Luckily, we can remove those auto-generated files as fast as we created them, with destroy (d).

% rails d model blurg_post
invoke active_record
remove db/migrate/20151006162244_create_blurg_posts.rb
remove app/models/blurg_post.rb
invoke rspec
remove spec/models/blurg_post_spec.rb

http://edgeguides.rubyonrails.org/command_line.html#rails-destroy

Change Column Null

Sun, 28 Jun 2015 12:34:19 -0500

The not null constraint is a great way to ensure data integrity. If a Rails model validates_presence_of an attribute, that column should be not null in the database.

Rails has a special migration method for setting this constraint.

change_column_null :users, :mandatory_attribute, false

You could also use the change_column method. The reason change_column_null is a better choice is that change_column requires you to state the type of the column; change_column_null does not.

change_column(table_name, column_name, type, options)
change_column_null(table_name, column_name, null, default = nil)

Classify and Constantize

Wed, 03 Jun 2015 22:28:22 -0500

Metaprogramming! Today I created a variable event that calls a serializer unique to the value of event. Along the way I learned about the Rails methods classify and constantize.

classify takes a plural table name and returns a class name.

> 'some_things'.classify
=> "SomeThing"

constantize tries to find a constant with the name specified in the argument string.

> "Module".constantize
=> Module

> "Nothing".constantize
NameError: uninitialized constant Nothing

Here’s a sample of how I used these methods today (on the ‘Today I Learned’ app itself):

Find Or Create By With Block

Sat, 30 May 2015 16:50:30 -0500

The Rails find_or_create_by method is great for bringing something into existence only once. I like to use it for database seeds, so you get the basic objects you need to make your development site useable, but don’t keep creating them over and over again.

One feature I recently learned is that this method takes a block.

User.find_or_create_by(first_name: 'Jake') do |user|
 user.last_name = 'Worth'
end

This lets you find the object, and if it doesn’t exist, create it with whatever attributes you need.

Multipurpose Environmental Variables

Tue, 26 May 2015 21:25:36 -0500

I use HTTP Basic auth in non-production environments because it ships with Rails and is easy to implement. The first time I used it, I set it up like this:

# app/controllers/application_controller.rb
if ENV['http_basic_auth']
 http_basic_authenticate_with name: ENV['username'], password: ENV['password']
end

I used environmental variables so that no credentials were hard-coded, and so I could toggle it without deploying.

Today I learned you can also implement it like this:

# app/controllers/application_controller.rb
if creds = ENV['basic_auth_credentials']
 username, password = creds.split(':', 2)
 http_basic_authenticate_with name: username, password: password
end

This requires an environmental variable called basic_auth_credentials, set to <username>:<password>. I prefer this because it allows one variable to serve two purposes: it toggles the feature and also contains the information the feature needs to work.

Redirect a Path

Mon, 11 May 2015 17:17:51 -0500

To redirect a path in Rails:

# config/routes.rb

get "/authors" => redirect("/designers")

This lets you take a difficult-to-type path name and expose it to your users as a simpler path name:

# config/routes.rb

get "/login" => redirect("/auth/google_oauth2")

Bypass Basic Auth

Fri, 08 May 2015 13:23:33 -0400

Rails comes with HTTP Basic authentication built in. Adding this to a controller is how it’s done:

# app/controllers/application_controller.rb

http_basic_authenticate_with name: 'name', password: 'password'

When you visit a URL requiring authentication, you can bypass the authentication screen by adding your username and password to the beginning of the URL. For localhost, this would look like:

name:password@localhost:3000

Parameters Filtering

Sat, 02 May 2015 15:16:47 -0500

Rails logs your server’s activity, which is useful for development and debugging. However, often the server handles sensitive information that should not be logged.

A few examples are authentication credentials, personal data, and financial information.

To prevent Rails from logging such data, add this to your application configuration:

config.filter_parameters << :sensitive_param

When the named parameter is handled by the server, it will be logged as [FILTERED] instead of its actual value. Add this configuration by environment if you want to keep the parameters unfiltered in development.

Modify Attribute on Set

Sat, 02 May 2015 15:12:39 -0500

In this example, we want to allow users to enter a twitter handle with or without an at-sign (’@’), just like Twitter, but save it without the at-sign. twitter_handle is already an attribute on the class.

class User < ActiveRecord::Base
 def twitter_handle=(handle)
 write_attribute(:twitter_handle, handle.to_s.gsub(/^@/, ''))
 end
end

How Rails Action Name Works

Mon, 10 Nov 2014 11:04:17 -0500

Today I was trying to control what rendered on a page based on which controller action called it, and discovered the action_name method. It’s located in actionview:

pry> method(:action_name).source_location
=> ["/Users/jake/.rvm/gems/ruby-2.2.3/gems/actionview-4.2.4/lib/action_view/helpers/controller_helper.rb", 10]

Add this to your view code, and it you’ll get the relevant action:

pry> action_name
=> "index"

Same partial, different context:

pry> action_name
=> "drafts"

This method would allow conditionals like this (written in HAML):

- if action_name == 'index'
 Welcome to the index.
- else
 Welcome to the drafts.

https://github.com/rails/rails/blob/master/actionview/lib/action_view/helpers/controller_helper.rb#L10