DEV Community: Eloy Pérez

Part 2 - Saving data. Creating a Ruby App to get notified about Epic Free Games.

Eloy Pérez — Tue, 27 Jun 2023 09:15:08 +0000

Part 1 | Part 2

Now that we know how to fetch the information we want, we can insert it into a database for later use. In this series we are going to use PostgreSQL so first of all we need to install the gem pg in our project:

bundle add pg

And in order to have a database to play with we can use docker-compose to set up our development (and test) postgres instance. So in a new docker-compose.yml file:

services:
  db:
    image: postgres
    volumes:
      - ./.data/db:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"

With that we can create our postgres container with docker compose up -d.

For connecting to the database in our Ruby applications we are going to use sequel so let's add it with bundle add sequel

Once we have our postgres instance up and running and sequel installed we need to create the database itself. Sequel gives us all the tools to manage our database but doesn't provide rake tasks, so we are going to create them for easier database management.

Add the gem rake with bundle add rake and, in a new Rakefile file, add the db:create task:

namespace :db do
  task :create do |t, args|
    require "sequel"

    development_database = "free_game_development"

    db = Sequel.connect(ENV["POSTGRES_URL"].to_s)
    db.run("DROP DATABASE IF EXISTS #{development_database}")
    db.run("CREATE DATABASE #{development_database}")
  end
end

This task expects an environment variable called POSTGRES_URL that points to the default postgres database. For managing environment variables in your local environment you can use many different tools, I use direnv

# In a .envrc file
export POSTGRES_URL="postgres://postgres:password@127.0.0.1:5432/postgres"

Then we can run the task with bundle exec rake "db:create"

For running Sequel migrations:

  namespace :db do
    task :create do |t, args|
      require "sequel"

      development_database = "free_game_development"

      db = Sequel.connect(ENV["POSTGRES_URL"].to_s)
      db.run("DROP DATABASE IF EXISTS #{development_database}")
      db.run("CREATE DATABASE #{development_database}")
    end
+
+   task :migrate do
+     require "sequel"
+     require "sequel/extensions/migration"
+
+     Sequel::Migrator.run(Sequel.connect(ENV["DATABASE_URL"].to_s), "db/migrations")
+   end
end

This task will connect to a database using the DATABASE_URL environment variable, for example:

  export POSTGRES_URL="postgres://postgres:password@127.0.0.1:5432/postgres"
+ export DATABASE_URL="postgres://postgres:password@127.0.0.1:5432/free_game_development"

The rake task expects migrations to be placed in a folder db/migrations, create it and lets move to creating models and their migrations.

We want to store games and their promotions, either active or expired. The migrations for games need to include data like the game's title and the url slug for crafting the Store URL we will send in the notification.

# In a new file 'db/migrations/001_create_games.rb'
Sequel.migration do
  up do
    create_table(:games) do
      primary_key(:id)

      String(:title, null: false)
      String(:url_slug, null: true)
    end
  end

  down do
    drop_table(:games)
  end
end

Each game may have many promotions so we are going to store promotion data in a different table. For each promotion we are going to store the reference to the game itself, start/end dates and the discount itself.

# In a new file 'db/migrations/002_create_promotions.rb'
Sequel.migration do
  up do
    create_table(:promotions) do
      primary_key(:id)

      foreign_key(:game_id, :games, null: false)
      DateTime(:start_date, null: false)
      DateTime(:end_date, null: false)
      String(:discount_type, null: false)
      Integer(:discount_percentage, null: false)
    end
  end

  down do
    drop_table(:promotions)
  end
end

Before running migrations lets modify the rake task to create a schema.rb file with our database structure after running migrations. Having this file is useful when we want to quickly check the structure of the database without reading all migrations.

  require "sequel"
  require "sequel/extensions/migration"

+ ENV["RACK_ENV"] ||= "development"

  Sequel::Migrator.run(Sequel.connect(ENV["DATABASE_URL"].to_s), "db/migrations")

+ if ENV["RACK_ENV"] == "development"
+   system("sequel -d #{ENV["DATABASE_URL"]} > db/schema.rb")
+ end

And finally run bundle exec rake db:migrate, this should have created a schema.rb with:

Sequel.migration do
  change do
    create_table(:games) do
      primary_key :id
      String :title, :text=>true, :null=>false
      String :url_slug, :text=>true
    end

    create_table(:schema_info) do
      Integer :version, :default=>0, :null=>false
    end

    create_table(:promotions) do
      primary_key :id
      foreign_key :game_id, :games, :null=>false, :key=>[:id]
      DateTime :start_date, :null=>false
      DateTime :end_date, :null=>false
      String :discount_type, :text=>true, :null=>false
      Integer :discount_percentage, :null=>false
    end
  end
end

To make use of these tables we need two Sequel models, Game and Promotion. In our app directory create a new models directory to store them.

# app/models/game.rb
class Game < Sequel::Model
  one_to_many :promotions
end

# app/models/promotion.rb
class Promotion < Sequel::Model
  many_to_one :game
end

Saving data into the database

In the previous post we created a class to fetch all games and return them as Data structures. We need to create a new class that make use of that and insert the data into the database.

Create a new file app/update_games.rb with our new class:

class UpdateGames
  def initialize(adapter)
    @adapter = adapter
  end

  def call
  end
end

As you can see this class receives the adapter to use and contains a method to do all the logic. The call method will fetch all free games and insert them (and their promotions) into the database:

  class UpdateGames
    def initialize(adapter)
      @adapter = adapter
    end

    def call
+       @adapter.get_free_games.each do |game_data|
+         game = Game.update_or_create(title: game_data.title) do |new_game|
+           new_game.url_slug = game_data.url_slug
+         end
+
+         game_data.promotions.each do |promotion_data|
+           Promotion.update_or_create(
+             game_id: game.id,
+             start_date: promotion_data.start_date,
+             end_date: promotion_data.end_date,
+             discount_type: promotion_data.discount_type,
+             discount_percentage: promotion_data.discount_percentage
+           )
+         end
+       end
+     end
  end

We use update_or_create because we are going to run this everyday and we will receive multiple times the same games.

Now lets create a simple test that checks that we have insert the correct number of games and promotions. In a new file spec/app/epic_store_adapter_spec.rb

require_relative "../../app/update_games"

RSpec.describe UpdateGames do
  subject { described_class.new(adapter) }
  let(:adapter) { EpicStoreAdapter.new("https://store-site-backend-static.ak.epicgames.com") }

  it "inserts game data into the database" do
    VCR.use_cassette("free_games") do
      expect { subject.call }.to change { Game.count }.from(0).to(6)
    end
  end

  it "inserts promotion data into the database" do
    VCR.use_cassette("free_games") do
      expect { subject.call }.to change { Promotion.count }.from(0).to(5)
    end
  end
end

Now before we run the test we have to update our testing configuration to connect to the database. First of all we need to create a different database for testing.

Update the .envrc file to add a new environment variable TEST_DATABASE_URL:

export POSTGRES_URL="postgres://postgres:password@127.0.0.1:5432/postgres"
export DATABASE_URL="postgres://postgres:password@127.0.0.1:5432/free_game_development"
export TEST_DATABASE_URL="postgres://postgres:password@127.0.0.1:5432/free_game_test"

And create a new rake tast to prepare the test environment:

  namespace :db do
  ...
+   namespace :test do
+     task :prepare do
+       require "sequel"
+       require "sequel/extensions/migration"
+
+       test_database = "free_game_test"
+
+       db = Sequel.connect(ENV["POSTGRES_URL"].to_s)
+       db.run("DROP DATABASE IF EXISTS #{test_database}")
+       db.run("CREATE DATABASE #{test_database}")
+
+       Sequel::Migrator.run(Sequel.connect(ENV["TEST_DATABASE_URL"].to_s), "db/migrations")
+     end
+   end
  end

Now in our spec_helper we have to connect to the new database using Sequel.


- require "vcr"
+ Bundler.require(:default, :test)

+ Sequel.connect(ENV["DATABASE_URL"].to_s)
+ Sequel::Model.plugin(:update_or_create)

We have removed the vcr require and updated it to use the bundler require method that will require every gem we have defined in our Gemfile, either outside any groups or in the testing one.

Is mandatory to enable the plugin update_or_create because we use in our UpdateGames class.

To allow our test to access our models we need to require them too in spec_helper:

  Bundler.require(:default, :test)

  Sequel.connect(ENV["DATABASE_URL"].to_s)
  Sequel::Model.plugin(:update_or_create)

+ require_relative "../app/models/game"
+ require_relative "../app/models/promotion"

  VCR.configure do |config|
    config.cassette_library_dir = "spec/fixtures/vcr_cassettes"
    config.hook_into(:faraday)
  end

And that's it, let's run the test

 bundle exec rspec
..F

Failures:

  1) UpdateGames inserts promotion data into the database
     Failure/Error: expect { subject.call }.to change { Promotion.count }.from(0).to(5)
       expected `Promotion.count` to have initially been 0, but was 5
     # ./spec/app/update_games_spec.rb:17:in `block (3 levels) in <top (required)>'
     # ./spec/app/update_games_spec.rb:16:in `block (2 levels) in <top (required)>'

Finished in 0.07583 seconds (files took 0.30525 seconds to load)
3 examples, 1 failure

Failed examples:

rspec ./spec/app/update_games_spec.rb:15 # UpdateGames inserts promotion data into the database

Woops. The first one succeeded but the second one failed. It says that initially it should have had 0 promotions in the database which is correct but it found 5 already. The issue is that we already inserted promotions in the previous spec so we have to clean up the database between test cases.

For that we can add the gem database_cleaner-sequel which will truncate all data created in each test. Add it as usual with bundle add database_cleaner-sequel and configure it in our spec_helper.rb file:

  RSpec.configure do |config|
+   config.before(:suite) do
+     DatabaseCleaner.strategy = :transaction
+     DatabaseCleaner.clean_with(:truncation)
+   end
+
+   config.around(:each) do |example|
+     DatabaseCleaner.cleaning do
+       example.run
+     end
+   end
  ...
  end

And if we run our tests again:

bundle exec rspec
...

Finished in 0.06822 seconds (files took 0.30429 seconds to load)
3 examples, 0 failures

Nice!

We've reached the end of the second part. We have created the logic needed to save games and promotions into our database. The next step is to notify about new promotions to a telegram channel that users can join.

Part 1 - Fetching Data. Creating a Ruby App to get notified about Epic Free Games.

Eloy Pérez — Fri, 23 Jun 2023 10:12:34 +0000

Part 1 | Part 2

In the Epic Store there is a selection of free games that changes each week. If you want to get them you have to manually access the web page of the store each week, could we build something to get notified?

Turns out there is an endpoint to get the current free games so we can build a Ruby app to fetch it and notify us if there is anything new. Let's build it!

Creating the project

mkdir free-game-watcher
cd free-game-watcher
bundle init

This will create a simple Gemfile pointing to RubyGems and nothing more. I like to always have installed a static analysis library, so I encourage you to add standard to your development dependencies.

bundle add standard --groups development

And configure your editor to run it on save and/or tell you about issues.

Making HTTP Requests

The main selling point of the application is to get notified of free games, for that we need to query the Epic Games Store to fetch the current selection.

The endpoint that the Store uses is public so we will use it as well. It is a GET request without query params and doesn't require any authentication. Let's have a look.

$ curl https://store-site-backend-static.ak.epicgames.com/freeGamesPromotions | jq '.data.Catalog.searchStore.elements[1] | {title: .title, promotions: .promotio
ns.promotionalOffers, upcoming: .promotions.upcomingPromotionalOffers, images: .keyImages[3]}'

{
  "title": "Breathedge",
  "promotions": [
    {
      "promotionalOffers": [
        {
          "startDate": "2023-04-27T15:00:00.000Z",
          "endDate": "2023-05-04T15:00:00.000Z",
          "discountSetting": {
            "discountType": "PERCENTAGE",
            "discountPercentage": 0
          }
        }
      ]
    }
  ],
  "upcoming": [],
  "images": {
    "type": "Thumbnail",
    "url": "https://cdn1.epicgames.com/08ae29e4f70a4b62aa055e383381aa82/offer/EGS_Breathedge_RedRuinsSoftworks_S2-1200x1600-c0559585221ea11c9d48273c3a79b1ba.jpg"
  }
}

I've used jq to show you the information that we will care about (only for one game), feel free to inspect the full JSON response.

We have to implement this query in Ruby, for that we will use Faraday. There are many different http libraries but I've chosen Faraday because, besides being a great tool, the gem that we will use later to connect to telegram has Faraday as a dependency so installing the same library saves us from having different libraries for the same purpose.

bundle add faraday

Now we are going to create an EpicStoreAdapter class that will contain the method to query the endpoint. Where should we place it?

The application logic should go into its own app folder. If later we want to add a simple web page we can create a standalone web directory.

So, create the new app folder and place a new file called epic_store_adapter.rb inside it with our new class that needs to receive the base URL of the endpoint to configure the Faraday client.

# app/epic_store_adapter.rb

+ class EpicStoreAdapter
+  def initialize(base_url)
+    @connection = Faraday.new(
+      url: base_url,
+      headers: {"Content-Type": "application/json"},
+      request: {timeout: 15}
+    )
+  end
+ end

And a method to query free games:

# app/epic_store_adapter.rb

class EpicStoreAdapter
  def initialize(base_url)
    @connection = Faraday.new(
      url: base_url,
      headers: {"Content-Type": "application/json"},
      request: {timeout: 15}
    )
  end
+
+  def get_free_games
+    response = @connection.get("/freeGamesPromotions")
+    JSON.parse(response.body)
+  end
end

Let's check that this class does what we want. To create basic for it we'll use rspec.

# Install RSpec
$ bundle add rspec --group test
Fetching gem metadata from https://rubygems.org/...
...

# Init RSpec configuration files
$ bundle exec rspec --init
  create   .rspec
  create   spec/spec_helper.rb

# Check that it works
$ bundle exec rspec
No examples found.


Finished in 0.00051 seconds (files took 0.06503 seconds to load)
0 examples, 0 failures

Before creating our spec we are going to add VCR to store API responses so everytime we run tests we avoid making new real requests.

# Install VCR
$ bundle add vcr --group test

VCR needs to be configured first so in our spec_helper.rb file (which was created previously with rspec --init) set the cassette library directory and the HTTP library:

# spec/spec_helper.rb

+ require "vcr"
+
+ VCR.configure do |config|
+   config.cassette_library_dir = "spec/fixtures/vcr_cassettes"
+   config.hook_into(:faraday)
+ end

RSpec.configure do |config|
  # ...
end

And finally we can write a simple test to check that we have correctly fetched games.

# spec/app/epic_store_adapter_spec.rb

require_relative "../../app/epic_store_adapter"

RSpec.describe EpicStoreAdapter do
  let(:adapter) { EpicStoreAdapter.new("https://store-site-backend-static.ak.epicgames.com") }

  it "fetches current selection of free games" do
    VCR.use_cassette("free_games") do
      response = adapter.get_free_games
      games = response["data"]["Catalog"]["searchStore"]["elements"]
      expect(games.first["title"]).to eq("Borderlands 3 Season Pass")
    end
  end
end

We will clean up that require_relative later

You should find the saved response from the API in the folder we specified before.

Now, instead of returning the parsed JSON from the response we could create a couple of data structures to store the information we care about. For that we can use the new Data core class.

class EpicStoreAdapter
+ GameData = Data.define(
+   :title,
+   :product_slug,
+   :url_slug,
+   :image_url,
+   :promotions
+ )
+ PromotionData = Data.define(
+   :start_date,
+   :end_date,
+   :discount_type,
+   :discount_percentage
+ )

def initialize(base_url)
end
...

The Data class is similar to Struct and it shares most of their implementation. We'll store only a selection of attributes from games and their promotions.

We are going to create a new private method to map the JSON response to an array of Games.

+ private
+
+ def build_games(games_data)
+   games_data.map do |game|
+     thumbnail_image = game["keyImages"].find { |image| image["type"] == "Thumbnail" }
+
+     GameData.new(
+       title: game["title"],
+       product_slug: game["productSlug"],
+       url_slug: game["urlSlug"],
+       image_url: thumbnail_image&.fetch("url", nil)
+     )
+   end
+ end

As you can see is pretty straight-forward, the only attribute a bit more complex to fetch is the thumbnail image that we have to find in the array of images.

There is still one attribute missing, promotions. Promotions have their own structure so we are going to create another to map them into Data structures.

+ def build_promotions(promotional_offers)
+   promotions = []
+   promotional_offers.each do |offer|
+     offer["promotionalOffers"].each do |promotional_offer|
+       promotions << PromotionData.new(
+         start_date: Time.parse(promotional_offer["startDate"]),
+         end_date: Time.parse(promotional_offer["endDate"]),
+         discount_type: promotional_offer["discountSetting"]["discountType"],
+         discount_percentage: promotional_offer["discountSetting"]["discountPercentage"]
+       )
+     end
+   end

+   promotions
+ end

Here we traverse the JSON to get the data we want (check the full JSON you have saved for details)

Now we can update our build_games method to add promotions. The JSON contains both current promotions and future ones, we can save both.

   def build_games(games_data)
    games_data.map do |game|
+     active_promotions = build_promotions(game.dig("promotions", "promotionalOffers") || [])
+     upcoming_promotions = build_promotions(game.dig("promotions", "upcomingPromotionalOffers") || [])
      thumbnail_image = game["keyImages"].find { |image| image["type"] == "Thumbnail" }

      GameData.new(
        title: game["title"],
        product_slug: game["productSlug"],
        url_slug: game["urlSlug"],
        image_url: thumbnail_image&.fetch("url", nil),
+       promotions: active_promotions + upcoming_promotions
      )
    end
  end

Finally we have to update our get_free_games method to, instead of returning the parsed JSON, create the needed structures.

  def get_free_games
    response = @connection.get("/freeGamesPromotions")
-     JSON.parse(response.body)
+     parsed_response = JSON.parse(response.body)
+     games_data = parsed_response["data"]["Catalog"]["searchStore"]["elements"]
+     build_games(games_data)
  end

But now our spec is failing, we have to update it accordingly:

  # spec/app/epic_store_adapter_spec.rb

  require_relative "../../app/epic_store_adapter"

  RSpec.describe EpicStoreAdapter do
    let(:adapter) { EpicStoreAdapter.new("https://store-site-backend-static.ak.epicgames.com") }

    it "fetches current selection of free games" do
      VCR.use_cassette("free_games") do
-       response = adapter.get_free_games
-       games = response["data"]["Catalog"]["searchStore"]["elements"]
-       expect(games.first["title"]).to eq("Borderlands 3 Season Pass")
+       games = adapter.get_free_games
+       expect(games.first.title).to eq("Borderlands 3 Season Pass")
      end
    end
  end

And that's it for now, we have implemented the request to the Epic Store and mapped the data into our own data structures.

In the following part we will save the data into a database.

Using Nemo in Fedora

Eloy Pérez — Thu, 08 Dec 2022 19:35:00 +0000

File managers are used a lot. GNOME comes with its own file manager called Files (formerly known as Nautilus) which is good enough for most operations. However, every time I do heavy work with it, there is one major feature that is missing: split view.

Split view was part of Nautilus up until version 3.6 where it was removed to reduce the complexity of the software. However, there are at least dozens of us that just work better with a split view file manager so, what's the alternative?

For me is Nemo. Nemo is the file manager that Linux Mint maintains and uses by default in its desktop environment. It is a fork of Nautilus so is similar and migrating to it is painless.

As of today my Linux distribution of choice is Fedora, so Nemo is not installed by default, as expected. Fortunately, installing it is as simple as:

$ sudo dnf install nemo-5.4.3-1.fc37.x86_64

You can install extensions to Nemo too, for example to be able to use File Roller you just do:

$ sudo dnf install nemo-fileroller-5.4.1-2.fc37.x86_64

There is one minor thing we have to fix though, there isn't any launcher to access the software we just installed. You can launch it from the terminal just typing nemo but that's not ideal for a GUI application.

To add a new icon to the GNOME launcher for Nemo, you just have to create its Desktop entry file and place it in ~/.local/share/applications.

[Desktop Entry]
Encoding = UTF-8
Name = Nemo File Manager
Exec = /usr/bin/nemo
Icon = nemo
Type = Application
Categories = Development

To find the location of the Nemo executable, you can use which:

$ which nemo
/usr/bin/nemo

And that's it! Now once you are inside Nemo you can press F3 and the side panel will show up.

Format CSV in your terminal using awk

Eloy Pérez — Mon, 28 Nov 2022 12:02:00 +0000

It's pretty common to have a CSV file that you want to have a look at and you are forced to either open it in a software that support reading such files like Libreoffice Calc or you open it as a plain text file in which case you are not able to read the content easily because it's not pretty printed.

However, if you already have a terminal open, you can easily format the file right in your terminal without the need for extra software. Say we have the following CSV file:

Type, Primary Text, Name, Description, Owner
"A type", "Lorem ipsum dolor sit amet consectetur adipiscing elit", "A name", "This requirement defines something", "John Snow"
"Something else", "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua", "Another name", "This is THE requirement", "Eloy Perez"
"Important stuff", "consectetur adipiscing elit", "And another one", "It cannot be", "Luke"

And you want to pretty print it right in your terminal, you can use awk for that.

awk -F',' '{ printf "%-030s %-70s %-30s %-40s %-30s\n", $1, $2, $3, $4, $5 }' file.csv
Type                            Primary Text                                                           Name                           Description                              Owner
"A type"                        "Lorem ipsum dolor sit amet consectetur adipiscing elit"               "A name"                       "This requirement defines something"     "John Snow"
"Something else"                "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua"    "Another name"                 "This is THE requirement"                "Eloy Perez"
"Important stuff"               "consectetur adipiscing elit"                                          "And another one"              "It cannot be"                           "Luke"

By default, awk works with text that uses whitespace as separator -F',' specifies what separator to use. In this case we are working with Comma-Separated Values, so we will use a ,

After that, we configure the output for each line of the file. We configure each column with the width of the content it will contain, for example %-30s means that it will have a string (%s) aligned to the left (%-s character) and it will be 30 characters wide (%-30s)

Then we specify what values are going to be printed $1, $2, $3, $4, $5 which are the return values of splitting the original string with the separator ,.

If we wanted to only print certain columns, we just have to not add them to the awk program. Let's say we only want to show Type and Name:

awk -F',' '{ printf "%-30s %-30s\n", $1, $3 }' file.csv
Type                            Name
"A type"                        "A name"
"Something else"                "Another name"
"Important stuff"               "And another one"

Linux application stuck in fullscreen

Eloy Pérez — Thu, 24 Nov 2022 12:45:21 +0000

From time to time a running application gets stuck in fullscreen mode. This has happened to me even in software that does not support fullscreen mode, like Spotify. Usually when that happens I used to kill the process and restart it, but there is a way of fixing it without being forced to restart the application.

We can use wmctrl for that.

wmctrl is a command that can be used to interact with an X Window manager that is compatible with the EWMH/NetWM specification. wmctrl can query the window manager for information, and it can request that certain window management actions be taken.

Important: wmctrl wont't work with Wayland applications.

First we need to list all applications with wmctrl -l to get the name of the one stuck.

$> wmctrl -l
0x00c00003  1 fedora Spotify

Now we have to modify the fullscreen property of the application, for that we'll use wmctrl -b

$> wmctrl -r Spotify -b toggle,fullscreen

We've used -r to specify the application we are going to modify and -b to tell wmctrl the action (toggle) and the property (fullscreen) to be modified.

With that the application should be back to windowed mode.

Get static analysis of your Pull Requests with Pronto

Eloy Pérez — Mon, 14 Aug 2017 17:47:18 +0000

Almost in every programming language there are static analysis tools which evaluates code quality and check if it follows a series of basics rules of styling.

This is very important because in a project where many developers work, it will be easier to read, understand and collaborate with if everyone generates their code following a set of common rules.

In Ruby, for example, we have Rubocop as reference to styling (and more) rules. These rules have been created and maintained by the ruby community.

Rubocop can be installed in our development environment and used in our day to day basis to check if the code we generate follows the Rubocop's style guide, however this procedure is not as effective as it should, because it depends on the developer to check and fix its code.

To improve this procedure we could use any of the multiple SAAS that already exists to do checks on our project's Pull Requests, like HoundCI, but if we already have a continuous integration system configured we won't need to delegate these checks to any new SAAS.

We can reuse our CircleCI or TravisCI (or the CI system of your choice) to launch our custom command of static analysis.

Pronto

Pronto is a tool created specifically to check the changes made in a Pull Request, whether it is in Github, Gitlab or Bitbucket. It has many plugins which you can add depending of which aspects of your codebase you want pronto to check.

We are going to use a Rails application as test subject, in this case we will check style of our code with Rubocop.

Configuration of the Rails application

First we have to install the required dependencies, because we are going to check only styling we need to install pronto and pronto-rubocop in development and test environments.

group :development, :test do
  gem 'pronto',          require: false
  gem 'pronto-rubocop',  require: false
end

From now on we can use pronto cli tool to launch the style check. For example if we add the following Article class to our project and run pronto:

class Article < ApplicationRecord
    def is_available?
      Time.now >= publish_on
    end
end

This way we can check the code that we just wrote before committing it, but we want this to be executed automatically, right?

Analysis in our Pull Requests

The next step is to configure our test build to execute pronto when the build is successful, we can use the hooks that our CI provider gives us.

In this example we are using TravisCI so we'll modify its configuration file, .travis.yml, with the following configuration:

language: ruby
cache: bundler
rvm:
  - 2.4.1
after_success:
  - export PRONTO_PULL_REQUEST_ID=${TRAVIS_PULL_REQUEST} && bundle exec pronto run -f github_pr

With the environment variable TRAVIS_PULL_REQUEST we will obtain the ID of the Pull Request being analyzed, then pronto will launch and only will check code differences against origin/master, not the full codebase.

This time we have configured the build to check style issues only when test build is successful but you can use many different hooks.

Before running to Github to check our Pull Request we have to do one more thing. Pronto needs a specific token to be able to access our Github repository, to create it access your github settings and generate a new token with only read access, it doesn't need anything else.

Once you have created it, go to your Travis configuration and add the token as an environment variable name PRONTO_GITHUB_ACCESS_TOKEN

If everything went right you can create a new Pull Request with your changes and check that pronto makes his work.

This would be the result with the previous example code:

Conclusion

The landscape of tools at our service to check and improve our code is huge, from styling issues to security and complexity checks.

Here we have seen a little example of what it can be accomplished, but it can do a lot more, it depends on the necessities of every project and group of developers.

The important thing is that we checked our code against a set of rules of quality that allows us to spend time on what is important, our business logic.