DEV Community: Juan Ferrari

Form object patterns in Rails: Stop creating services for everything with YAAF

Juan Ferrari — Mon, 11 Jan 2021 16:04:40 +0000

Working with large controllers

How many times have you encountered large controller methods? If you are lucky like me, probably many times.

One of the most common practices to start refactoring a long controller is to move the code to a service.

Services are great, and if we code them in an atomic way, they will be easy to test and understand. But the problem is when we use the services it's like using a Swiss Army knife.

-"Hey, I don't know how to properly refactor this piece of code" -"Dude, just do a new service"

But no!, making a new service is not always the best option. In some cases, we are reinventing the wheel and maybe there is a pattern that already fits with our needs.

So here comes YAAF, yet another active form to save our day. YAAF is a gem that lets you create form objects using Rails in an easy and friendly way. It makes use of ActiveRecord and ActiveModel features, to provide you with a form object that behaves like a Rails model while remaining completely configurable.

When to use YAAF?

Let's imagine that we have an API endpoint that saves a new post on our database. A post has a title, body, publisher, and could also have tags and a category.

Tags and categories can be created as soon as the publisher sends the post. (If our inputs don't find the correct tag or category, they will let the user write the name of a new one).

So, in the worst-case scenario, our controller could have something like this:

class Api::V1::PostsController < Api::V1::ApiController
  def index
    @posts = Post.all
  end

  def create
    ActiveRecord::Base.transaction do
      @post = Post.new(post_params)
      @post.tags = params[:tags].map do |tag|
        tag[:id].present? ? Tag.find(tag[:id]) : Tag.find_or_create_by(name: tag[:name])
      end
      if params[:category_name].present?
        category = Category.create!(name: params[:category_name])
        @post.category = category
      end
      @post.save!
    end
  end


  def post_params
    params.require(:post).permit(:title, :body, :publisher_id, :category_id)
  end
end

It looks terrible, right? Maybe our first thought about that piece of code is to make a refactoring that moves the creation of the post to a service named PostCreationService. This could be useful and might be used in the future in another part of the system. But, what have we said about reinventing the wheel?

When using YAAF, we should create a new PostForm class that is going to encapsulate all the logic of post creation and related models inside it. And it is very simple to implement it! Just look at this code:

# app/forms/post_form.rb

class PostForm < ApplicationForm
  attr_accessor :post, :category_name, :tags
  validate :amount_of_tags

  def initialize(args = {})
    super(args)
    @models = [new_post, category, post_tags].flatten.compact
  end

  def new_post
    @new_post ||= Post.new(post).tap do |post|
      post.category = category
      post.tags = post_tags
    end
  end

  def category
    return [] if category_name.blank?

    @category ||= Category.find_or_initialize_by(name: category_name)
  end

  def post_tags
    return [] if tags.blank?

    @post_tags ||= tags.map do |tag|
      tag[:id].present? ? Tag.find(tag[:id]) : Tag.find_or_initialize_by(name: tag[:name])
    end
  end

  private

  def amount_of_tags
    return if tags.size.between?(1, 3)

    errors.add(:base, "You can't assign more than three tags to a post")
  end
end

Note: We have also added a custom validation named amount_of_tags, as YAAF helps us to encapsulate business rules in our Form Object.

And then, in our controller, we have the following:

class Api::V1::PostsController < Api::V1::ApiController
  def index
    @posts = Post.all
  end

  def create
    form = PostForm.new(post_form_params)
    form.save!
    @post = form.post
  end

  private

  def post_form_params
    params.permit(:category_name, tags: %i[id name], post: %i[title body publisher_id category_id])
  end
end

Tip: Having an ApplicationForm which inherits from YAAF::Form is a good practice.

That's it, now we have a PostForm which encapsulates all the persistency logic of post/tags/categories, leaving our controller and models clean, with an easy to follow code.

Another good thing is that YAAF provides a similar API to ActiveModel models, so you can treat them interchangeably.

Why not a Service or PORO's?

Making customized Services or PORO's could be disorganized if you're working in a team.
YAAF helps you to apply the Form Pattern in an easy way.
YAAF is only 64 lines long.
It's well tested and maintained.
It helps you keep your models, views, and controllers thin by providing a better place to put business logic. In the end, this will improve the quality of your codebase and make it easier to maintain and extend.
And a lot more.

Summary

Well, if you've got this far, I hope this article helps you to integrate YAAF in your project, while also helping you use the FormObject Pattern to make your code even better. You can see more examples here. YAAF is open-source and is open to receive new contributions.

So check it out and see what you think!

The 8 Best Visual Studio Code Extensions for Programming Ruby

Juan Ferrari — Thu, 01 Oct 2020 23:33:58 +0000

This post was originally created for the Rootstrap blog

Choosing a Text Editor

It may be a tough decision, as a programmer, to choose a text editor, since it will be your main tool to do your work, and you will use it every day in your work-life.

Everybody has their favorite text editor, I have known people who use Vim, Notepad++, Sublime Text, Atom, and many others.

I have tried different text editors in my career and was always looking for the perfect one. At first, I started with Sublime Text, later the pretty UI of Atom hooked me, and for the last year I have been coding with Visual Studio Code.

I was enjoying Atom, but in some cases, my computer at the time couldn't handle it very well and it was getting a bit laggy to open the text editor or work with it. So a friend of mine told me that maybe Visual Studio Code could fit my needs, and he was right.

Visual Studio Code Extensions

GitLens

This extension includes a lot of cool functionalities of Git in Visual Studio Code: "GitLens simply helps you better understand code" says Eric Amodio, the creator of the extension.

I love Gitlens because it allows me to detect who wrote the code that I am reading, and this is really useful because when I have doubts about the code, I know who to talk to.

Features:

An unobtrusive current line blame annotation at the end of the line with detailed blame information accessible via hovers
Authorship code lens showing the most recent commit and # of authors to the top of files and/or on code blocks
A status bar blame annotation showing author and date for the current line
On-demand gutter blame annotations, including a heatmap, for the whole file
On-demand gutter heatmap annotations to show how recently lines were changed, relative to all the other changes in the file (hot vs. cold)
On-demand recent changes annotations to highlight lines changed by the most recent commit
And much more.

Ruby

This extension provides enhanced Ruby language and debugging support. One of the coolest things about this extension is the syntax support to our ruby files, so this is a must-have if you are a Ruby developer.

Features:

Automatic Ruby environment detection with support for rvm, rbenv, chruby, and asdf
Lint support via RuboCop, Standard, and Reek
Format support via RuboCop, Standard, Rufo, and RubyFMT
Semantic code folding support
Semantic highlighting support
Basic Intellisense support

Ruby Solargraph

Another vital extension if you are a Ruby developer, which gives Visual Studio Code some features that can be found in IDE's like "Go to definition" for classes, modules, and methods. Also provides documentation and code completion. If you are learning Ruby, this extension will help you a lot.

Features:

Context-aware suggestions and documentation for the Ruby core
Detection of some variable types and method return values (e.g., String.new. returns String instance methods)
Identification of local, class, and instance variables within the current scope
Find references and rename symbols (experimental as of solargraph gem v0.22.0)
Support for gems
Near-complete support for the Ruby core and stdlib
Partial support for Ruby on Rails

ruby-rubocop

Having RuboCop configured in your ruby project will help you maintain the quality of the code, especially if your project is being developed by a team. This extension will let you autoformat and correct your code basing it the directives written in the .rubucop.yml file. With only a key shortcut your code will be formatted in a second, it's fast, it's good, it's an essential extension.

Features:

Lint by executing the command "Ruby: lint by rubocop" (cmd+shift+p and type command)
Auto invoke when saving file
Auto correct command "Ruby: autocorrect by rubocop"

Prettier

This extension will help you to format the code of Javascript, HTML, CSS, JSON, and many more files. Is simple and quick, is not as configurable as other code-formatter extensions.

Features:

Supports many languages
You press save and code is formatted
No need to discuss style in code review
Saves you time and energy

VSCode Great Icons

A very simple one, adds icons to your files and it personally helps me a lot to know instantly which kind of file I'm viewing.

Switching from Atom to Visual Studio Code

I missed the Atom shortcut keymap so much when I made the switch, but here is your salvation.

Atom Keymap

This extension ports popular Atom keyboard shortcuts to Visual Studio Code and helps to make the switch between code editors a lot easier.

Atom One Dark Theme

And the last extension that I will share with you is an aesthetic one, when I started using Visual Studio Code I missed the theme that Atom provides, so this extension fixed that problem for me.

Conclusion

These are currently my favorite extensions for Visual Studio Code. I hope this famous code editor will help you improve your experience. Please feel free to comment below if you have any other extension recommendations!

How to customize the display name of dynamic ActiveAdmin search filters

Juan Ferrari — Tue, 14 Jul 2020 17:00:56 +0000

This post was originally created for the Rootstrap blog

Working with ActiveAdmin

At Rootstrap, my first assignment was to develop a Ruby on Rails application which uses ActiveAdmin (with ActiveAdmin Addons) as a framework to implement the user interface.

I had never used ActiveAdmin before and I found myself reading a lot of documentation of the gem, in some cases, the documentation was not enough. For example, when I tried to display a custom name on an AJAX's search select filter at first it was a little tricky. So today I will show you how to do it, in the end, it's really simple!

Showing our custom display_name

In this tutorial, you will learn how to customize the display_name of a search_select the filter provided by ActiveAdmin Addons.

Before starting we have to include in our Gemfile the activeadmin gem and activeadmin-addons gem.

In this example we are going to use a search select to filter people and search a person, our person model has two fields named first_name and last_name, and we want to display the full name of the person when we are searching it. The full_name is the concatenation of first_name and last_name.

Steps to show our custom display_name

Create a Search Select

First of all, you should create a search select input in ActiveAdmin. This can be used in many places but in this example, we are going to use it in a filter. To do that, go to an ActiveAdmin view and put this code on it:

      filter :person_id,
             as: :search_select_filter,
             fields: %i[first_name last_name],
             display_name: :full_name

(If you are going to use this on a form you have to change search_select_filter to search_select).

The fields array indicates the fields that are used to filter, our input will be matched with the first_name of a person or their last_name.

The display_name is the field that our filter is showing to us meanwhile we search.

Setting up the returned JSON

The search select input is requesting a JSON meanwhile the user is searching for a person, for example in this case the filter will be doing requests to this endpoint /admin/people and retrieving a JSON showing all model attributes from a person. This is auto-generated by ActiveAdmin, but we can overwrite the response.

In this application we are using JBuilder to render JSON response so we have to create a file in:

views/admin/(model_name_pluralized)/index.json.jbuilder

In our example, the view created is in

views/admin/people/index.json.jbuilder

In this file we can write the custom JSON that we want to retrieve for example:

json.array!(@people) do |person|
  json.extract! person, :id, :full_name
end

Attention: full_name is a method on person model, we have to write that method in the model and not in a decorator because if we are using this search_select in edit/new view an error will raise when validation fails, ActiveAdmin will call a method from person model named full_name and not from the decorator.

Writing the full_name method

Just write the method that we want in app/models/person.rb:

def full_name
    [first_name, last_name].compact.join(' ')
end

And now our search select input is ready to display the person full name!

What we learned about Search Select Inputs?

In this article, we learned how to display a custom field in our search select inputs. This will help us to give better search feedback to the user and it can be used in many different scenarios. It also helps us take control of the JSON returned by ActiveAdmin to the input (by default, all attributes are returned and maybe that's not good for us).

References

Select2_Search ActiveAdmin

It's has been a year since my first gem was published. What I have learned so far?

Juan Ferrari — Sun, 03 May 2020 17:48:17 +0000

Things happen fast! One year ago I was a Junior Developer building a really small gem for Ruby on Rails sort_n_params, my first contribution as a developer to the open source's scene.

What have I learned since then?

1.- It's always good to build things, no matter how small.

If you have an idea, build it up. Ask for help from your colleagues if you're stuck -- it doesn't matter if your idea sounds silly or small, building and finishing things helps us improve our skills.

2.- Publish and share your work!

The solution you have found may be useful to others, so share it. Maybe someone else will help you improve your solution. Don't be shy!

3.- An example of what you can do

Maybe you're looking for your first job in the industry, but a lot of interviewers ask you about previous experience. Having your own project published in Github or deployed in Heroku will help you prove that you already have some experience with coding.

4.- The importance of testing and continuous integration

Technology is advancing rapidly and it is very possible that our code will change in the near future. Testing our code prevents problems and saves time and setting up a continuous integration service like TravisCI to our repository ensures the proper functioning of our project.

5.- It's good to contribute to the Open Source scene

It doesn't matter if you only make a small contribution, it will help you improve and meet a world that is growing every day

6.- Publishing a gem is really easy

Don't be scared! If you want to publish a new gem, there are plenty of tutorials on the web and it doesn't take long to do so.

I hope my experience encourages you to make your own gems and projects. Let's code!