DEV Community: Alexey Poimtsev

CLI in ruby using OptionParser or GetoptLong

Alexey Poimtsev — Sat, 27 Apr 2024 09:21:21 +0000

Few days ago I've created a script for the project I'm working on. It was an ugly script with hardcoded values, but it did ther job - create tokens on request. But I've decided to improve it a bit, because sometimes I needed to change params and I've added ability to submit params from the command line. Of course, there are a lot of awesome libraries such as dry-cli, TTY Toolkit or cli-kit from Shopify, but in most cases you can use standard ruby libraries like OptionParser or GetoptLong. Lets see how you can create a CLI utils with those libraries just in few minutes.

We will create simple app, which will ask for your name for the time of the day. If there's no input - script will show you a help screen with list of required and optional arguments.

GetoptLong

We will start with GetoptLong library.

#!/usr/bin/env ruby

require "getoptlong"

opts = GetoptLong.new(
  [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
  [ '--name', '-n', GetoptLong::REQUIRED_ARGUMENT ],
  [ '--time', GetoptLong::OPTIONAL_ARGUMENT ]
)

options = {}

help_message = <<-EOF
Usage: greeting.rb [options]

-h, --help:
   show help

--name yourname, -n yourname:
   your name

--time time_of_the_day:
   time of the day
      EOF

opts.each do |opt, arg|
  case opt

  when "--help"
    puts help_message

  when "--name"
    options[:name] = arg

  when "--time"
    options[:time] = arg
end
end

if options.empty?
  puts help_message
else
  puts "Good #{options[:time]}, #{options[:name]}"
end

Our code is simple - we create an instance of GetoptLong class with list of available params, then in case of match with param name we do execute some code.

OptionParser

Next stop - OptionParser. Similar with GetoptLong we create an instance of OptionParser class with list of available params. There are an opts.banner option which allow us to add some text before list of available params.

#!/usr/bin/env ruby

require 'optparse'


option_parser = OptionParser.new do |opts|
  opts.banner = 'Usage: greeting.rb [options]'

  opts.on '-n', '--name=NAME', 'Set name'
  opts.on '-t', '--time=TIME', 'Set time'
end

options = {}

option_parser.parse!(into: options)

if options.empty?
  puts option_parser
else
  puts "Good #{options[:time]}, #{options[:name]}"
end

Every solution is simple and easy to implement without any additional library, but OptionParser code looks more compact and readable, isn't it?

Rails GraphQL authentication from scratch #2

Alexey Poimtsev — Mon, 25 Sep 2023 10:46:58 +0000

Welcome back to my series how to develop GraphQL API for rails applications from scratch.

Authentication - signIn method

To authenticate our users, we need to add jwt gem to our Gemfile

$ bundle add jwt

and create app/models/auth_token.rb

class AuthToken
  def self.key
    Rails.application.credentials.jwt_secret
  end

  def self.token(user)
    payload = {user_id: user.id}
    JWT.encode(payload, key)
  end

  def self.verify(token)
    result = JWT.decode(token, key)[0]
    User.find_by(id: result["user_id"])
  rescue JWT::VerificationError, JWT::DecodeError
    nil
  end
end

How does it work. We use jwt_secret which is stored in rails credentials to create a token which stores user_id and to find User record by token.

Let's create our jwt_secret for development and test environments

$ rails credentials:edit --environment=development
$ rails credentials:edit --environment=test

and add the following line

jwt_secret: "secret"

Btw, don't forget to generate secure keys using

$ rails secret

Let's test it out.

AuthToken.key # "secret"

user = User.create(email: FFaker::Internet.email, password: SecureRandom.hex, first_name: FFaker::Name.first_name, last_name: FFaker::Name.last_name )

AuthToken.token(user) # "token-secret-value"

AuthToken.verify("token-secret-value") # returns User instance

Next, let's implement current_user method. We need to update app/controllers/graphql_controller.rb

class GraphQLController < ApplicationController

 protect_from_forgery with: :null_session # <-- uncomment this line

  def execute
    variables = prepare_variables(params[:variables])
    query = params[:query]
    operation_name = params[:operationName]
    context = {
      current_user: current_user # <-- add this line
    }
    result = GraphqlFromScratchSchema.execute(query, variables: variables, context: context, operation_name: operation_name)
    render json: result
  rescue => e
    raise e unless Rails.env.development?
    handle_error_in_development(e)
  end

############### Add this method

  def current_user
    return nil if request.headers["Authorization"].blank?
    token = request.headers["Authorization"].split(" ").last
    return nil if token.blank?
    AuthToken.verify(token)
  end

###############

end

We need to create our mutation in app/graphql/mutations/users/sign_in.rb

module Mutations::Users
  class SignIn < Mutations::BaseMutation
    graphql_name "signIn"

    argument :email, String, required: true
    argument :password, String, required: true

    field :user, Types::UserType, null: true
    field :token, String, null: true

    def resolve(email:, password:)
      user = User.find_by(email:)
      errors = {}

      if user&.authenticate(password)
        context[:current_user] = user
        token = AuthToken.token(user)

        {token: AuthToken.token(user), user:, success: true}
      else
        user = nil
        context[:current_user] = nil

        raise GraphQL::ExecutionError, "Incorrect Email/Password"
      end
    end
  end
end

and add it to app/graphql/types/mutation_type.rb

module Types
  class MutationType < Types::BaseObject
    field :sign_up, mutation: Mutations::Users::SignUp
    field :sign_in, mutation: Mutations::Users::SignIn # <-- add this line
  end
end

Let's try it in our GraphQL console

mutation {
  signIn(input: { email: "test@example.com", password: "1234567890" }) {
    user {
      id
      email
      name
    }
    success
    token
  }
}

And you'll see a result

{
  "data": {
    "signIn": {
      "user": {
        "id": "9a7fb463-2493-48f6-8641-509f58c9b47f",
        "email": "test@example.com",
        "name": "Alexey Poimtsev"
      },
      "success": true,
      "token": "correct-token"
    }
  }
}

In case of wrong email/password

mutation {
  signIn(input: { email: "test@example.com", password: "111" }) {
    user {
      id
      email
      name
    }
    success
    token
  }
}

You'll see an error message

{
  "data": {
    "signIn": null
  },
  "errors": [
    {
      "message": "Incorrect Email/Password",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "path": ["signIn"]
    }
  ]
}

Don't forget to write specs spec/graphql/mutations/users/sign_in_spec.rb

require "rails_helper"

RSpec.describe "#signIn mutation" do
  before do
    @password = SecureRandom.hex
    @user = FactoryBot.create(:user, email: "user@example.com", password: @password)
  end

  let(:mutation) do
    <<~GQL
      mutation signIn($email: String!, $password: String!) {
        signIn(input: {
          email: $email
          password: $password
        }) {
          user {
            id
            email
            name
          }
          token
        }
      }
    GQL
  end

  it "is successful with correct email and password" do
    result = GraphqlFromScratchSchema.execute(mutation, variables: {
      email: "user@example.com",
      password: @password
    })

    expect(result.dig("data", "signIn", "errors")).to be_nil
    expect(result.dig("data", "signIn", "user", "email")).to eq("user@example.com")
    expect(result.dig("data", "signIn", "user", "id")).to be_present
    expect(result.dig("data", "signIn", "token")).to be_present
  end


  it "fails with wrong password" do
    result = GraphqlFromScratchSchema.execute(mutation, variables: {
      email: "user@example.com",
      password: "wrong-password"
    })

    expect(result.dig("data", "signIn", "user", "id")).to be_nil
    expect(result.dig("data", "signIn", "token")).to be_nil
    expect(result.dig("errors", 0, "message")).to eq("Incorrect Email/Password")
  end
end

Let's break for a while to improve our code a bit.

Improvements - whoAmI method, inflections and GraphQL schema dump

Let's add a helper method to easily test our authentication. Add following lines to app/graphql/types/query_type.rb (you can replace test_field method)

field :who_am_i, String, null: false,
  description: "Who am I"
def who_am_i
  "You've authenticated as #{context[:current_user].presence || "guest"}."
end

If you're not authenticated

{
  whoAmI
}

you'll see

{
  "data": {
    "whoAmI": "You've authenticated as guest."
  }
}

But if you use correct token

{
  "Authorization": "correct-token"
}

You'll see

{
  "data": {
    "whoAmI": "You've authenticated as Alexey Poimtsev."
  }
}

Let's play with inflections. Open file config/initializers/inflections.rb and make in looks like

ActiveSupport::Inflector.inflections(:en) do |inflect|
  inflect.acronym "RESTful"
  inflect.acronym "GraphQL" # <-- add this line
end

Now, we can rename in app/controllers/graphql_controller.rb class name GraphqlController to GraphQLController. Looks better, isn't it? But don't forget to rename every Graphql string in class names to GraphQL.

Let's add rake task for schema dump. I've created lib/tasks/graphql.rake with following code

namespace :graphql do
  desc "Dump GraphQL schema"
  task dump_schema: :environment do
    # Get a string containing the definition in GraphQL IDL:
    schema_defn = GraphQLFromScratchSchema.to_definition
    # Choose a place to write the schema dump:
    schema_path = "app/graphql/schema.graphql"
    # Write the schema dump to that file:
    File.write(Rails.root.join(schema_path), schema_defn)
    puts "Updated #{schema_path}"
  end
end

and added spec in spec/graphql/schema_spec.rb

require "rails_helper"

RSpec.describe "GraphQL schema" do
  it "must be reflected in the .graphql file" do
    current_defn = GraphQLFromScratchSchema.to_definition
    printout_defn = File.read(Rails.root.join("app/graphql/schema.graphql"))
    assert_equal(current_defn, printout_defn, "Update the printed schema with `bundle exec rake dump_schema`")
  end
end

Now, with

$ rake graphql:dump_schema

I'll have updated schema in app/graphql/schema.graphql and specs will remind me to update it.

Rails GraphQL authentication from scratch #1

Alexey Poimtsev — Fri, 22 Sep 2023 21:02:46 +0000

Devise is an awesome gem to add authentication for your rails application, but it may me a bit overkill solution if you are going to develop REST or GraphQL API for your SPA or mobile application. Today I'll show you how to create GraphQL API without devise. I'll use some methods that become available in rails 7.1.0.beta1, so please install this or higher version.

Project preparation

Firstly, let's create our rails application. Of course - you can use an --api key to skip adding asset pipeline to your project, but I'll use basic template because I need graphiql-rails gem.

$ rails new graphql_from_scratch --database=postgresql --skip-test --skip-system-test -j bun
$ cd graphql_from_scratch/
$ rails db:create && rails db:migrate

I prefer to use UUID, so I'll create the following migration with rails g migration EnableUuidPsqlExtension

class EnableUuidPsqlExtension < ActiveRecord::Migration[7.0]
  def change
    enable_extension "pgcrypto"
    enable_extension "uuid-ossp"
  end
end

Also, I'll add some test-relates gems:

$ bundle add rspec-rails shoulda-matchers factory_bot_rails ffaker database_cleaner database_cleaner-active_record email_spec --group "development, test"
$ rails g rspec:install

Then I'll create config/initializers/generators.rb file

Rails.application.config.generators do |g|
  g.orm :active_record, primary_key_type: :uuid
  g.helper false
  g.test_framework :rspec,
    fixtures: false,
    view_specs: false,
    helper_specs: false,
    routing_specs: false
end

update spec/rails_helper.rb

require "spec_helper"
ENV["RAILS_ENV"] ||= "test"
require_relative "../config/environment"
# Prevent database truncation if the environment is production
abort("The Rails environment is running in production mode!") if Rails.env.production?
require "rspec/rails"

begin
  ActiveRecord::Migration.maintain_test_schema!
rescue ActiveRecord::PendingMigrationError => e
  abort e.to_s.strip
end

RSpec.configure do |config|
  config.use_transactional_fixtures = true
  config.infer_spec_type_from_file_location!
  config.filter_rails_from_backtrace!

  config.include FactoryBot::Syntax::Methods

  ### Database Cleaner
  config.before(:suite) { DatabaseCleaner.clean_with(:truncation) }
  config.before(:each) { DatabaseCleaner.strategy = :transaction }
  config.before(:each, js: true) { DatabaseCleaner.strategy = :truncation }
  config.before(:each) { DatabaseCleaner.start }
  config.after(:each) { DatabaseCleaner.clean }
end

Shoulda::Matchers.configure do |config|
  config.integrate do |with|
    with.test_framework :rspec
    with.library :rails
  end
end

and spec/spec_helper.rb

require "action_mailer"
require "email_spec"
require "email_spec/rspec"

RSpec.configure do |config|
  config.expect_with :rspec do |expectations|
    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
  end

  config.mock_with :rspec do |mocks|
    mocks.verify_partial_doubles = true
  end

  config.shared_context_metadata_behavior = :apply_to_host_groups
end

Next, we need to add graphql to our Gemfile

$ bundle add graphql
$ bundle add graphiql-rails --group "development"
$ rails g graphql:install

You can start our rails server with ./bin/dev and open http://localhost:3000/graphiql to test our API with following query

{
  testField
}

you will see

{
  "data": {
    "testField": "Hello World!"
  }
}

It means that our API works fine. Don't forget to remove from app/graphql/types/query_type.rb following lines when you'll be ready for production.

field :test_field, String, null: false,
  description: "An example field added by the generator"
def test_field
  "Hello World!"
end

We also need to update app/graphql/mutations/base_mutation.rb file and to add two additional fields - boolean success and array of errors. Now our file will look like

module Mutations
  class BaseMutation < GraphQL::Schema::RelayClassicMutation
    argument_class Types::BaseArgument
    field_class Types::BaseField
    input_object_class Types::BaseInputObject
    object_class Types::BaseObject

    field :success, Boolean # <-- add this line
    field :errors, [String] # <-- add this line
  end
end

Well, now we can start working on our API.

User model

Let's create our User model

$ rails g model User first_name last_name email password_digest

then update our migration

class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users, id: :uuid do |t|
      t.string :first_name, null: false, default: ""
      t.string :last_name, null: false, default: ""
      t.string :email, null: false, default: ""
      t.string :password_digest

      t.timestamps
    end
  end
end

and model

class User < ApplicationRecord
  EMAIL_REGEXP = /\A[^@\s]+@[^@\s]+\z/

  has_secure_password

  validates :first_name, presence: true, on: :update
  validates :last_name, presence: true, on: :update
  validates :password, presence: {on: create}, length: {minimum: 8, maximum: 128}
  validates :email, presence: true, uniqueness: {case_sensitive: false}, format: EMAIL_REGEXP

  normalizes :email, with: -> { _1.strip.downcase }

  ### Name
  def name=(full_name)
    self.first_name, self.last_name = full_name.to_s.squish.split(/\s/, 2)
  end

  def name
    [first_name, last_name].join(" ")
  end

  def to_s
    name
  end
end

I'd like to point you to the following line

normalizes :email, with: -> { _1.strip.downcase }

Earlier, before rails 7.1 we've used something like

before_validation do
  email&.downcase!&.strip!
end

but now our code look more compact and readable.

Also, we need to create UserType for our API

app/graphql/types/user_type.rb

# frozen_string_literal: true

module Types
  class UserType < Types::BaseObject
    field :id, ID, null: false
    field :first_name, String
    field :last_name, String
    field :name, String, null: false
    field :email, String, null: false
    field :created_at, GraphQL::Types::ISO8601DateTime, null: false
    field :updated_at, GraphQL::Types::ISO8601DateTime, null: false
  end
end

Let's add some basic specs in spec/models/user_spec.rb

require "rails_helper"

RSpec.describe User, type: :model do
  describe "validations" do
    it { should validate_presence_of(:first_name).on(:update) }
    it { should validate_presence_of(:last_name).on(:update) }
    it { should validate_presence_of(:email) }
    it { should validate_presence_of(:password) }
  end
end

and some code to spec/factories/users.rb

FactoryBot.define do
  factory :user do
    email { FFaker::Internet.email }
    password { SecureRandom.hex }

    first_name { FFaker::Name.first_name }
    last_name { FFaker::Name.last_name }
  end
end

Don't forget to uncomment bcrypt gem in Gemfile and run bundle install

Now, our bundle exec rspec execution should be successful.

Account registration - signUp method

First API method to develop - signUp.

Input parameters: name, email and password
Result: User in json
Errors: Array of errors if any
Description: Create User, then send email with confirmation link.

app/graphql/mutations/users/sign_up.rb:

module Mutations::Users
  class SignUp < Mutations::BaseMutation
    graphql_name "signUp"

    argument :name, String, required: true
    argument :email, String, required: true
    argument :password, String, required: true

    field :user, Types::UserType, null: true
    field :errors, Types::ValidationErrorsType, null: true

    def resolve(args)
      user = User.new(args)

      if user.save
        confirmation_token = user.generate_confirmation_token
        UserMailer.confirmation(user, confirmation_token).deliver_now

        {user: user, success: true}
      else
        {errors: user.errors, success: false}
      end
    end
  end
end

As you may see - nothing complicated, but we need to add several things.

app/graphql/types/mutation_type.rb - we need to update this file with reference to signUp mutation:

module Types
  class MutationType < Types::BaseObject
    field :sign_up, mutation: Mutations::Users::SignUp # <-- add this line
  end
end

app/graphql/types/validation_errors_type.rb - This class is responsible for representing of error messages.

module Types
  class ValidationErrorsType < Types::BaseObject
    field :details, String, null: false
    field :full_messages, [String], null: false

    def details
      object.details.to_json
    end
  end
end

Next - we need to add generate_confirmation_token method to model User:

class User < ApplicationRecord
  #################### Add those lines

  CONFIRMATION_TOKEN_EXP = 30.minutes

  def generate_confirmation_token
    signed_id expires_in: CONFIRMATION_TOKEN_EXP, purpose: :confirm_email
  end

  ####################
end

I'd like to point you to signed_in method, which is used to create expiable token with token purpose, we will use it in several other methods.

Also, we need to add UserMailer and related views.

app/mailers/user_mailer.rb

class UserMailer < ApplicationMailer
  def confirmation(user, confirmation_token)
    @user = user
    @confirmation_token = confirmation_token

    mail to: @user.email, subject: "Confirmation Instructions"
  end
end

app/views/user_mailer/confirmation.html.erb

<h1>Confirmation Instructions</h1>

<%= link_to "Click here to confirm your email.", confirmation_url(@confirmation_token) %>

app/views/user_mailer/confirmation.text.erb

Confirmation Instructions

<%= confirmation_url(@confirmation_token) %>

Let's try how it works in GraphQL console.

mutation {
  signUp(
    input: {
      name: "Alexey Poimtsev"
      email: "test@example.com"
      password: "1234567890"
    }
  ) {
    user {
      id
      email
      name
    }
    success
    errors {
      fullMessages
    }
  }
}

and voila - everything works fine:

{
  "data": {
    "signUp": {
      "user": {
        "id": "9375a213-cf56-4136-b8f8-38a5f8a8ba60",
        "email": "test@example.com",
        "name": "Alexey Poimtsev"
      },
      "success": true,
      "errors": null
    }
  }
}

If we try to use incorrect input

mutation {
  signUp(input: { name: "Alexey Poimtsev", email: "test@", password: "" }) {
    user {
      id
      email
      name
    }
    success
    errors {
      fullMessages
    }
  }
}

then we'll see following error message

{
  "data": {
    "signUp": {
      "user": null,
      "success": false,
      "errors": {
        "fullMessages": [
          "Password can’t be blank",
          "Password is too short (minimum is 8 characters)",
          "Email is invalid"
        ]
      }
    }
  }
}

And, of course we need to cover it with specs

spec/graphql/mutations/users/sign_up_spec.rb

require "rails_helper"

RSpec.describe "#signUp mutation" do
  let(:mutation) do
    <<~GQL
        mutation signUp($name: String!, $email: String!, $password: String!) {
          signUp(input: {
            name: $name
            email: $email
            password: $password
          }) {
          user {
            id
            email
            name
          }
          success
          errors {
            details
            fullMessages
          }
        }
      }
    GQL
  end

  it "is successful with correct data" do
    name = FFaker::Name.name
    email = FFaker::Internet.email
    result = GraphqlFromScratchSchema.execute(mutation, variables: {
      name: name,
      email: email,
      password: SecureRandom.hex
    })

    expect(result.dig("data", "signUp", "user", "email")).to eq(email)
    expect(result.dig("data", "signUp", "user", "name")).to eq(name)
    expect(result.dig("data", "signUp", "success")).to eq(true)
    expect(result.dig("data", "signUp", "errors")).to be_nil
  end


  it "fails in case of wrong email format" do
    wrong_email = "test.user"
    result = GraphqlFromScratchSchema.execute(mutation, variables: {
      name: FFaker::Name.name,
      email: wrong_email,
      password: SecureRandom.hex
    })

    expect(result.dig("data", "signUp", "user")).to be_nil
    expect(result.dig("data", "signUp", "success")).to eq(false)
    expect(result.dig("data", "signUp", "errors", "details")).to eq("{\"email\":[{\"error\":\"invalid\",\"value\":\"#{wrong_email}\"}]}")
    expect(result.dig("data", "signUp", "errors", "fullMessages")).to include("Email is invalid")
  end

  it "fails in case of no password" do
    result = GraphqlFromScratchSchema.execute(mutation, variables: {
      name: FFaker::Name.name,
      email: FFaker::Internet.email,
      password: ""
    })

    expect(result.dig("data", "signUp", "user")).to be_nil
    expect(result.dig("data", "signUp", "success")).to eq(false)
    expect(result.dig("data", "signUp", "errors", "details")).to eq("{\"password\":[{\"error\":\"blank\"},{\"error\":\"too_short\",\"count\":8}]}")
    expect(result.dig("data", "signUp", "errors", "fullMessages")).to include("Password can’t be blank")
    expect(result.dig("data", "signUp", "errors", "fullMessages")).to include("Password is too short (minimum is 8 characters)")
  end
end

spec/mailers/user_mailer_spec.rb

require "rails_helper"

RSpec.describe UserMailer, type: :mailer do
  describe "confirmation" do
    let(:mail) { UserMailer.confirmation(FactoryBot.create(:user, email: "to@example.org"), "confirmation-token-0123456789") }

    it "renders the headers" do
      expect(mail.subject).to eq("Confirmation Instructions")
      expect(mail.to).to eq(["to@example.org"])
      expect(mail.from).to eq(["from@example.com"])
    end

    it "renders the body" do
      expect(mail.body.encoded).to match("Click here to confirm your email.")
    end

    it "should be set to be delivered to the email passed in" do
      expect(mail).to deliver_to("to@example.org")
    end

    it "should contain a link to the confirmation link" do
      expect(mail).to have_body_text(/#{confirmation_url("confirmation-token-0123456789")}/)
    end
  end
end

spec/mailers/previews/user_mailer_preview.rb

# Preview all emails at http://localhost:3000/rails/mailers/user
class UserMailerPreview < ActionMailer::Preview
  # Preview this email at http://localhost:3000/rails/mailers/user/confirmation
  def confirmation
    UserMailer.confirmation(User.first || FactoryBot.create(:user, email: "to@example.org"), "confirmation-token-0123456789")
  end
end

Almost perfect, but when we run tests we will see NoMethodError: undefined method 'confirmation_url'. To fix it, we need to add app/helpers/urls_helper.rb

module UrlsHelper
  ### We will use those helper methods to send requests to frontend


  # Don't forget to replace `http://localhost:3000` with correct url.
  def confirmation_url(token) = "http://localhost:3000/users/confirm/#{token}"

  def confirmation_path(token) = "/users/confirm/#{token}"
end

and update app/mailers/application_mailer.rb

class ApplicationMailer < ActionMailer::Base
  default from: "from@example.com"
  layout "mailer"

  helper :urls # <-- add this line
end

Awesome! In next articles in the series, we will add new methods and improve existing code. Stay tuned!

How do I fight with professional burnout and depression

Alexey Poimtsev — Thu, 14 Sep 2023 20:26:30 +0000

Lately, I've been struggling with professional burnout and the resulting depression. It feels like a lot has piled up on me — several unsuccessful contracts have led to significant financial losses, there's tension in my family relationships (yes, even after 17 years of marriage, this can happen), and I've been questioning if I'm living my life right. I've noticed that I've been:

Struggling to get up in the morning.
Unable to focus at work.
Constantly engaged in doomscrolling.
Unwilling to go for an evening workout, and lacking the energy for a morning workout.
Despite quitting smoking 12 years ago, I've found myself thinking about lighting up again.
Slowly turning to the alcohol stash at home, which I haven't touched in years.

To address this issue, I've successfully adopted an approach that I'd like to share with you, which might prove helpful to some.

I've meticulously scheduled my day using the Reminders app on my iPhone. It looks something like this:

8:00 AM - Wake up.
8:10 AM - Brush teeth and wash up.
8:15 AM - Drink a glass of water (since we can't replenish our body's fluids at night).
8:20 AM - Workout.
8:50 AM - Meditation (thanks to Apple Fitness+).
9:00 AM - Dog walk.
9:30 AM - Breakfast and watching lectures on YouTube (I have a whole collection of lectures to watch).
10:30 AM - Sort through emails and messages in messaging apps.
11:00 AM - Work calls - project updates, client reports.
2:30 PM - Midday workout - just 20 push-ups or burpees.
3:00 PM - Lunch, then back to work.
7:00 PM - Evening dog walk.
8:00 PM - Evening workout.
11:00 PM - Reading a book.
11:50 PM - Brush teeth.
12:00 AM - Sleep.

Here are some key points I'd like to emphasize:

I make an effort to allocate plenty of time for exercise and walks because physical activity stimulates the production of neurotransmitters like dopamine, endorphins, serotonin, and oxytocin, which can help avoid the need for antidepressants.
It's essential to aim for at least 8 hours of sleep to minimize excess cortisol, the stress hormone in your body.
When your entire day is planned out, you don't have to think about what to do next. Having a clear plan provides a sense of stability.
If you happen to miss a particular task (e.g., meditation or a workout due to an early morning call from family or friends), don't stress about it. We're all human.
Try to avoid continuous news and social media consumption (unless it's part of your job). Dedicate a short time slot each day, no more than 30 minutes, for catching up on these platforms.

I hope this relatively simple approach helps you steer clear of depression and burnout.

Perks, grants and discounts for startups

Alexey Poimtsev — Mon, 22 May 2023 20:41:06 +0000

Here is a curated list of grants and perks for early-stage companies. If you have something to add to this list - please let me know.

Amazon AWS https://aws.amazon.com/activate/ - up to $100k in AWS credits to cover your AWS service usage
DigitalOcean Hatch Program https://www.digitalocean.com/hatch - 12 months of infrastructure credit
Google for Startups Cloud Program https://cloud.google.com/startup/apply - up to $200,000 in cloud credits over 2 years
Intercom https://www.intercom.com/early-stage - 10 Seats of Support Pro, 5 Seats (1,000 People Reached) of Engage Pro and Product Tours add-on for 1,000 Guided People for $65/month
JetBrains https://www.jetbrains.com/shop/eform/startup - 50% off all JetBrains Tools
Microsoft https://startups.microsoft.com/ - $150,000 in free Azure credits, free access to GitHub Enterprise, Azure OpenAI Service, VS Code, Microsoft 365 including Office and Teams, LinkedIn, and more
Miro https://miro.com/startups/ - $1000 credit and 20% discount
Retool https://retool.com/startups - up to $25K in Retool credits for a year
Twilio Segment https://segment.com/industry/startups/ - $25,000 in Segment credits
Zendesk https://www.zendesk.com/startups/ - free for six months

Running ruby on Jupiter notebooks

Alexey Poimtsev — Sat, 24 Dec 2022 21:08:43 +0000

Missed me? Don’t worry - I’m back, and I’d like to share an awesome thing I’ve found today.

You’ve maybe heard about Jupyter notebooks - an awesome web application which allows you to run python code in a browser. There are another similar project - Livebook which allow running Elixir code in browser.

But what to do if you are a ruby developer and irb and pry is not enough for you? Fortunately, with iruby gem you can run ruby code in Jupyter notebooks. So, lets start.

Firstly, you need to install Jupyter notebooks if it isn’t installed yet on your laptop.

Install python 3. Let’s check our versions

❯ python3 --version
Python 3.10.9
❯ pip3 --version
pip 22.3.1 from /Users/alec/Library/Python/3.10/lib/python/site-packages/pip (python 3.10)

Looks good. You maybe need to update installed packages.

❯ pip3 install --upgrade pip
Requirement already satisfied: pip in ./Library/Python/3.10/lib/python/site-packages (22.3.1)

Then install Jupyter

❯ pip3 install jupyter
Requirement already satisfied: jupyter in /usr/local/lib/python3.10/site-packages (1.0.0)
Requirement already satisfied: jupyter-console in /usr/local/lib/python3.10/site-packages (from jupyter) (6.4.4)
Requirement already satisfied: ipykernel in /usr/local/lib/python3.10/site-packages (from jupyter) (6.19.4)
Requirement already satisfied: nbconvert in /usr/local/lib/python3.10/site-packages (from jupyter) (7.2.7)
Requirement already satisfied: qtconsole in /usr/local/lib/python3.10/site-packages (from jupyter) (5.4.0)
Requirement already satisfied: ipywidgets in /usr/local/lib/python3.10/site-packages (from jupyter) (8.0.4)
...................

Let’s check our installation

❯ jupyter notebook
[I 22:51:29.176 NotebookApp] Serving notebooks from local directory: /Users/alec
[I 22:51:29.176 NotebookApp] Jupyter Notebook 6.5.2 is running at:
[I 22:51:29.176 NotebookApp] http://localhost:8888/?token=1234567890
[I 22:51:29.176 NotebookApp] or http://127.0.0.1:8888/?token=1234567890
[I 22:51:29.176 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 22:51:29.182 NotebookApp]

    To access the notebook, open this file in a browser:
        file:///Users/alec/Library/Jupyter/runtime/nbserver-11401-open.html
    Or copy and paste one of these URLs:
        http://localhost:8888/?token=1234567890
     or http://127.0.0.1:8888/?token=1234567890

Now you can open your browser and check - it should work now.

Well, let’s add support for ruby. Install iruby gem

❯ gem install iruby
Building native extensions. This could take a while...
Successfully installed iruby-0.7.4
1 gem installed

Then add it to Jupyter

❯ iruby register --force

That’s it. Just restart Jupyter, and now you can run ruby code.

Let’s try to write something in ruby

Well, it works! Awesome :)

Rails scaffold templates

Alexey Poimtsev — Fri, 25 Nov 2022 10:37:50 +0000

Starting from rails7, code team have changed scaffold templates and from my point of view - it is not the best change they have done. Every time I run rails g scaffold Post title:string body:text or something like this I need to change views, controller and specs to match my needs. And today I’ll show you how to customize your templates to reduce time you spend to change generated code.

Firstly, let me show you where those templates are located. If you check links below - you’ll see a source code of standard rails templates for views and controllers.

Now, let’s create our own templates. I’ll start with the scaffold controller. All you need is to create directory lib/templates/rails/scaffold_controller and put controller.rb.tt file with your template. For my needs I did some small changes - just added support for i18n to create, update and destroy actions by adding

notice: t(".create_successful")

to appropriate places.

Next, let’s change our view templates. I don’t like current ones so I took templates from rails 6.x and updated it for my needs (for bootstrap based project I’ve taken bootstrap_form gem and have changed ujs-dependent code to use hotwire). I’ve created directory lib/templates/erb/scaffold and placed my _form.html.erb.tt, edit.html.erb.tt, index.html.erb.tt, partial.html.erb.tt, new.html.erb.tt, show.html.erb.tt to that location. You can find my code below

_form.html.erb.tt

<%%= bootstrap_form_with(model: <%= model_resource_name %>) do |form| %>
  <%% if <%= singular_table_name %>.errors.any? %>
    <div style="color: red">
      <h2><%%= pluralize(<%= singular_table_name %>.errors.count, "error") %> prohibited this <%= singular_table_name %> from being saved:</h2>

      <ul>
        <%% <%= singular_table_name %>.errors.each do |error| %>
          <li><%%= error.full_message %></li>
        <%% end %>
      </ul>
    </div>
  <%% end %>

<% attributes.each do |attribute| -%>
  <div>
<% if attribute.password_digest? -%>
    <%%= form.password_field :password %>
  </div>

  <div>
    <%%= form.password_field :password_confirmation %>
<% elsif attribute.attachments? -%>
    <%%= form.<%= attribute.field_type %> :<%= attribute.column_name %>, multiple: true %>
<% else -%>
    <%%= form.<%= attribute.field_type %> :<%= attribute.column_name %> %>
<% end -%>
  </div>

<% end -%>
  <div>
    <%%= form.primary %>
  </div>
<%% end %>

edit.html.erb.tt

<h1>Editing <%= human_name.downcase %></h1>

<%%= render "form", <%= singular_table_name %>: @<%= singular_table_name %> %>

<br>

<div>
  <%%= link_to "Show this <%= human_name.downcase %>", <%= model_resource_name(prefix: "@") %> %> |
  <%%= link_to "Back to <%= human_name.pluralize.downcase %>", <%= index_helper(type: :path) %> %>
</div>

index.html.erb.tt

<h1><%= human_name.pluralize %></h1>

<table class="table" id="<%= plural_table_name %>">
  <thead>
    <tr>
<% attributes.reject(&:password_digest?).each do |attribute| -%>
<% if attribute.attachment? -%>
    <th>Download</th>
<% elsif attribute.attachments? -%>
    <th>Downloads</th>
<% else -%>
    <th><%= attribute.human_name %></th>
<% end -%>
<% end -%>
    <th colspan="3"></th>
    </tr>
  </thead>

  <tbody>
    <%%= render @<%= plural_table_name %> %>
  </tbody>
</table>

<%%= link_to "New <%= human_name.downcase %>", <%= new_helper(type: :path) %>, class: "btn btn-primary" %>

partial.html.erb.tt

<tr>
<% attributes.reject(&:password_digest?).each do |attribute| -%>
    <td>
    <% if attribute.attachment? -%>
        <%%= link_to <%= singular_name %>.<%= attribute.column_name %>.filename, <%= singular_name %>.<%= attribute.column_name %> if <%= singular_name %>.<%= attribute.column_name %>.attached? %>
    <% elsif attribute.attachments? -%>
        <%% <%= singular_name %>.<%= attribute.column_name %>.each do |<%= attribute.singular_name %>| %>
          <div><%%= link_to <%= attribute.singular_name %>.filename, <%= attribute.singular_name %> %></div>
    <% else %>
        <%%= <%= singular_table_name %>.<%= attribute.column_name %> %>
    <% end %>
    </td>
<% end -%>
        <td><%%= link_to 'Show', <%= model_resource_name %>, class: "btn btn-light btn-sm" %></td>
        <td><%%= link_to 'Edit', edit_<%= singular_route_name %>_path(<%= singular_table_name %>), class: "btn btn-warning btn-sm" %></td>
        <td><%%= link_to 'Destroy', <%= model_resource_name %>, data: {turbo_method: :delete, turbo_confirm: 'Are you sure?'}, class: "btn btn-danger btn-sm" %></td>
</tr>

new.html.erb.tt

<h1>New <%= human_name.downcase %></h1>

<%%= render "form", <%= singular_table_name %>: @<%= singular_table_name %> %>

<br>

<div>
  <%%= link_to "Back to <%= human_name.pluralize.downcase %>", <%= index_helper(type: :path) %> %>
</div>

show.html.erb.tt

<% attributes.reject(&:password_digest?).each do |attribute| -%>
<p>
  <strong><%= attribute.human_name %>:</strong>
<% if attribute.attachment? -%>
  <%%= link_to @<%= singular_table_name %>.<%= attribute.column_name %>.filename, @<%= singular_table_name %>.<%= attribute.column_name %> if @<%= singular_table_name %>.<%= attribute.column_name %>.attached? %>
<% elsif attribute.attachments? -%>
  <%% @<%= singular_table_name %>.<%= attribute.column_name %>.each do |<%= attribute.singular_name %>| %>
    <div><%%= link_to <%= attribute.singular_name %>.filename, <%= attribute.singular_name %> %></div>
  <%% end %>
<% else -%>
  <%%= @<%= singular_table_name %>.<%= attribute.column_name %> %>
<% end -%>
</p>

<% end -%>
<%%= link_to 'Edit', edit_<%= singular_table_name %>_path(@<%= singular_table_name %>) %> |
<%%= link_to 'Back', <%= index_helper %>_path %>

And the last step - let’s update rspec template for model. In my example I’ll create a template for model spec with sections fields (to put field-specific tests, such as counter cache), associations (has_many, belongs_to etc), validations and methods. All I need it to create file lib/templates/rspec/model/model_spec.rb.tt with following

require "rails_helper"

<% module_namespacing do -%>
RSpec.describe <%= class_name %>, <%= type_metatag(:model) %> do
  describe "fields" do
    pending "add some field tests (such as counter_cache) to (or delete) #{ __FILE__ }"
  end

  describe "associations" do
    pending "add some association tests to (or delete) #{ __FILE__ }"
  end

  describe "validations" do
    pending "add some validation tests to (or delete) #{ __FILE__ }"
  end

  describe "methods" do
    pending "add some method tests to (or delete) #{ __FILE__ }"
  end
end
<% end -%>

Now I’m happy, isn’t it awesome? :)

Looking for more? Check my blog https://alec-c4.com

Custom error pages in rails applications

Alexey Poimtsev — Mon, 07 Nov 2022 08:06:12 +0000

Ruby on rails is shipped with html-based error pages, but with some easy steps you can create your own erb-based pages. So, let’s do it.

Firstly you need to create controller, views and routes for your pages.

$ rails g controller errors not_found unprocessable unacceptable internal_server_error

This generator will create at least following files - app/controllers/errors_controller.rb, app/views/errors directory and add routes to your config/routes.rb

errors_controller.rb :

class ErrorsController < ApplicationController
  layout false

  def not_found
    render status: :not_found
  end

  def unprocessable
    render status: :unprocessable_entity
  end

  def unacceptable
    render status: :not_acceptable
  end

  def internal_server_error
    render status: :internal_server_error
  end
end

config/routes.rb :

  ### Errors
  match "/404", to: "errors#not_found", via: :all
  match "/406", to: "errors#unacceptable", via: :all
  match "/422", to: "errors#unprocessable", via: :all
  match "/500", to: "errors#internal_server_error", via: :all

Now, you need to disable default rails error handler. To do that, you need to add the following line to your config/application.rb

  class Application < Rails::Application

    # use custom error pages
    config.exceptions_app = routes

  end

If you want to test error pages locally, you need to set the following option in your config/environments/development.rb

  # Show full error reports.
  config.consider_all_requests_local = false

Almost perfect, but I’d like to propose you some improvements. Let’s look back to config/environments/development.rb and to some changes

  # Show full error reports.
  config.consider_all_requests_local = !Rails.root.join("tmp/errors-dev.txt").exist?

When you start your application, it will check for file tmp/errors-dev.txt and enable or disable custom error pages. Then, let’s create file lib/tasks/dev.rake with following code

namespace :dev do
  desc "Use custom error pages"
  task :errors do
    if File.exist?("tmp/errors-dev.txt")
      puts "Now you'll use default (development) error pages" if FileUtils.rm("tmp/errors-dev.txt")
    elsif FileUtils.touch("tmp/errors-dev.txt")
      puts "Now you'll use custom error pages"
    end
  end
end

Every time you need to enable custom error pages locally, just run in console

$ rake dev:errors

then restart your server, and you’ll switch error pages from default to custom and back.

Looking for more? Check my blog https://alec-c4.com

Product development guide #1

Alexey Poimtsev — Mon, 07 Nov 2022 08:05:00 +0000

Several months ago, I’ve created this guide for my colleagues to improve development process and to avoid popular mistakes. It is not a dogma, but it should help developers with better understanding of what they are working on and how to do their work better.

General Rules

The main purpose of this manual is to improve the speed and quality of the products you develop.

The code must follow all the guidelines of the development community
The code must be readable
The code must be testable
The code must be maintainable
The product being developed must be easily scalable
The code must be written inherently high performance
The code must be reusable
We make products, not just write code. This means that we should also enjoy using the product ourselves.

Statement of Objectives

Tasks are taken from the tracker and only from it. If the task came in the mail or in a messenger, it must be transferred to the tracker
If the task is not in the tracker, it does not exist. In rare cases, the task may be described post factum, but it must be necessarily described and documented
The task must have a qualitative description - its purpose, incoming values, the process taking place, and what the output should be. If there is no description, the task is submitted for reissue.
Tasks requiring frontend development must have a design. If there is no design, the task is re-designed.
Tasks must have a start and finish date (planned and actual)
Duration of the task must be not more than 1 day. If the task is longer, it must be divided into small tasks.
The task must have a priority. Tasks should be performed according to the priority

Task fulfillment (daily plan)

Before starting work, read the task, mark your participation in the tracker
Find out if nothing interferes with your work, if something interferes, ask your colleagues for help or information.
Start a new feature following the git flow process
Take a standard solution-library-platform used in the company (see the appropriate section), if you can not find - coordinate with your senior technical manager to use another solution.
If there is a ready-tested code (check the availability of code in the library) - use it
Check if any of the developers on the project has written code that can be reused. Avoid duplication of functionality.
Write tests for the code and run them
Test the implemented task
Test functions of the application that may be affected by the work done
Document the work
Test for performance
(if applicable) Check for i18n compliance
(if applicable) Check for compliance with A11y
Run automatic code check - linter, profiler and so on, correct the code if necessary
Delete unnecessary and test data from the code, make sure there are no hard-coded configuration values, keys, and passwords
Remove unnecessary git branches.
Upload code to GitHub using pull request (PR) mechanisms, designate the technical director responsible for auditing the written code
Upload completed tasks to the testing and staging area (if autodeploy is not configured) as agreed upon with the technical director
At the end of the day, even if the tasks are not completed, upload all the code to GitHub marked wip (work in progress)
Check the task done in the tracker
If the deadline is not as expected - mark it and indicate the reason
Report the work done, problems encountered, and additional requirements to the project manager and technical supervisor at the end of the day for all the tasks done

Documentation

All technical documentation is written EXCLUSIVELY in English.
The style of writing should be clear and understandable, avoiding jargon expressions and incorrect abbreviations. For example, the Australian Government’s suggested style for writing documents is https://www.stylemanual.gov.au/changelog.
A Changelog should be written for each release, conforming to the standard https://keepachangelog.com/
Commits in the git should follow the style https://www.conventionalcommits.org

Additional provisions

The code that can be used on other projects must be saved in the archive / source code library. Solutions to non-standard problems found on forums and blogs should be saved there as well (with the source link retained)
If part of the project code can be claimed and improved in other projects (including by developers of other companies), an open source project should be released on the company’s account and a senior technical manager should be contacted to promote the repository
If some tasks are regularly repeated, it makes sense to use automation tools, for example, to make a template

Looking for more? Check my blog https://alec-c4.com

Better builds with earthly

Alexey Poimtsev — Mon, 07 Nov 2022 07:52:48 +0000

I like to automate everything. It saves time which I can to spend to develop another automation :)

Today I'd like to show you how to use earthly to automate your build processes.

Installation

Installation process is very simple - (if you're using macOS like me) all you need is a docker, homebrew and git. Just run from your terminal

$ brew install earthly/earthly/earthly && earthly bootstrap

And that's it. If you are Linux or Windows user - you can check this guide.

How to use earthly

Firstly, let's define our task. I'd like to propose to you to develop a script which will build a simple astro-based application, let's say - some landing page. Later I'll write a post about benefits of astro, but now let's focus on earthly.

In most cases, all you need is to just write 2 files - Earthfile and .earthlyignore, so let's do it!

Let's start with Earthfile. I'll write the following tasks:

deps - to download dependencies
build - to build an application
docker - do create and save docker image

Earthfile looks like a mutant with a genes of Makefile and Docker, but it is a powerful creature :)

VERSION 0.6
FROM node:latest
WORKDIR /app
ARG image_name=blog

First line VERSION 0.6 defines the version of the Earthfile. Currently, it is 0.6. Lines 2 and 3 is quite similar to Dockerfile and defines parental package and working directory in our container.

deps: 
  RUN npm install -g pnpm
  COPY package.json pnpm-lock.yaml* ./
  RUN pnpm install
  SAVE ARTIFACT package.json   AS LOCAL ./package.json
  SAVE ARTIFACT pnpm-lock.yaml AS LOCAL ./pnpm-lock.yaml
  RUN pnpm add object-hash potrace find-cache-dir @astropub/codecs file-type

Line deps: - is the name of the target. You can call this target from command line with following command (just prepend name of the target with "+" sign):

$ earthly +deps

Next 3 lines (and the last one on this code block) are similar with Dockerfile - it is about to install pnpm, copy package.json and pnpm-lock.yaml files and running pnpm command. But I'd like to ask you to have a look at the next 2 lines

  SAVE ARTIFACT package.json   AS LOCAL ./package.json
  SAVE ARTIFACT pnpm-lock.yaml AS LOCAL ./pnpm-lock.yaml

Everything we've done before was in the container, but now we need to save those files locally. SAVE ARTIFACT ... AS LOCAL ... allows you to export data from the container to the local filesystem.

build:
    FROM +deps
    COPY . .
    RUN pnpm run build
    SAVE ARTIFACT dist /dist AS LOCAL dist

Another one part of our Earthfile. Nothing new for you, except FROM +deps. This line forces earthly to call deps-target before build. Note that target name must be start with "+".

docker:
    FROM nginx
    COPY +build/dist /usr/share/nginx/html
    EXPOSE 80
    SAVE IMAGE --push ${image_name}:latest

Well, the last part of our config. There are two lines you need to focus on. COPY +build/dist /usr/share/nginx/html - with this command we took everything in dist-directory we've produced in our build-target and copy it to the local environment. SAVE IMAGE --push ${image_name}:latest - uses this command we save what we've done before as a docker image, which can be used later in production environment.

Everything works fine, but there is one more thing I've mentioned before - .earthlyignore file. This file is useful when you copy directory, but you need to avoid copying of some files or directories to your container. The format of this file is similar with .dockerignore and .gitignore - everything you need to ignore is located on the new line.

Finally - the complete Earthfile

VERSION 0.6
FROM node:latest
WORKDIR /app
ARG image_name=blog

deps: 
    RUN npm install -g pnpm
    COPY package.json pnpm-lock.yaml* ./
    RUN pnpm install
    SAVE ARTIFACT package.json   AS LOCAL ./package.json
    SAVE ARTIFACT pnpm-lock.yaml AS LOCAL ./pnpm-lock.yaml
    RUN pnpm add object-hash potrace find-cache-dir @astropub/codecs file-type 

build:
    FROM +deps
    COPY . .
    RUN pnpm run build
    SAVE ARTIFACT dist /dist AS LOCAL dist

docker:
    FROM nginx
    COPY +build/dist /usr/share/nginx/html
    EXPOSE 80
    SAVE IMAGE --push ${image_name}:latest

and .earthlyignore

node_modules
.git
.gitignore
.earthlyignore
.idea
.vscode
dist

Looking for more? Check my blog https://alec-c4.com