Ruby on Codrut Constantin Gusoi

Rails: install Administrate

Tue, 23 Jan 2024 08:21:51 +0000

Gems Link to heading

Add these to your Gemfile:

# Administration
gem 'administrate', '~> 0.20.0'

# Authentication
gem 'devise', '~> 4.9', '>= 4.9.3'

Then install your new gems:

bundle install

Generate Link to heading

bundle exec rails generate devise:install
bundle exec rails generate devise SystemOperator
bundle exec rails generate administrate:install --namespace=operations

bundle exec rails generate administrate:dashboard SystemOperator --namespace=operations

Rails: install ActiveAdmin

Mon, 22 Jan 2024 08:41:29 +0000

Gems Link to heading

Add these to your Gemfile:

# Administration
gem 'activeadmin', '~> 4.0.0.beta4'

# Authentication
gem 'devise', '~> 4.9', '>= 4.9.3'

Then install your new gems:

bundle install

Generate Link to heading

bundle exec rails generate active_admin:install \
  SystemOperator                                \
  --skip-comments                               \
  --no-registerable                             \
  --no-default-user

Create new Rails app through Docker

Sun, 21 Jan 2024 09:43:30 +0000

Shell Link to heading

You need the bigger Debian based docker image for installing Rails as it needs to have gcc and make for building naitve extensions.

docker-here ruby:3.3.0 bash

Rails Link to heading

gem install -N rails

New Link to heading

rails new "name-me"     \
  --skip-bundle         \
  --skip-docker         \
  --skip-jbuilder       \
  --database=postgresql \
  --javascript=esbuild  \
  --css=tailwind

Once this is done you can Ctrl-C to exit the docker shell.

Create a new Ruby gem

Sat, 29 Jul 2023 05:09:02 +0000

Setup Link to heading

Add this to your ~/.bundle/config

---

BUNDLE_GEM__TEST: "minitest"
BUNDLE_GEM__CI: "gitlab"
BUNDLE_GEM__MIT: "false"
BUNDLE_GEM__COC: "false"
BUNDLE_GEM__CHANGELOG: "false"
BUNDLE_GEM__LINTER: "rubocop"

Gem Name Link to heading

Use _ for CamelCase and - for Name::Spaces.

# Library gem
bundle gem <NAME>

# CLI gem
bundle gem --exe <NAME>

RSpec Instance Double

Tue, 11 Jul 2023 19:49:39 +0000

Here is how you can make an assertion on a nested call to another class:

let(:double) { instance_double('something') }

before do
  allow(SomeClass).to receive(:some_method).and_return(double)
  allow(double).to receive(:another).and_return(true)
end

it 'does something useful' do
  subject.call

  expect(SomeClass).to have_received(:some_method).with(args)
  expect(double).to have_received(:another).with(other_args)
end

Ruby Ractor: pass an arbitrary block

Sat, 21 Jan 2023 10:51:53 +0000

Let’s say you have a piece of code:

class SomeThing
  def initialize(thing)
    @thing = thing
  end

  def call
    puts @thing.inspect
  end
end

You want to execute this in parallel in a ractor:

Ractor.new { SomeThing.new(1).call }

This works if you have the block written within the Ractor. But it will fail if the block is refferenced from the outside of a ractor.

element = proc { SomeThing.new(1).call }
Ractor.new { element.call }

# <internal:ractor>:267:in `new': can not isolate a Proc because it accesses
#   outer variables (element). (ArgumentError)

To do that you need to instance_eval from a shareable object:

Ruby Version Manager: rbenv

Sun, 18 Sep 2022 10:01:05 +0000

Docker Link to heading

The best way to manage ruby for your project is by using Docker:

If you don’t have a Docker setup yet, you have to suffer, temporarily, by using rbenv. There used to be another tool called rvm for this sort of thing but it’s been abandoned for a long time now, it’s insecure to install from their website, has install errors, and it’s completely broken for newer versions of ruby and newer versions of OpenSSL. Your only real option is to use rbenv.

Ruby Benchmarking

Sat, 16 Apr 2022 12:18:01 +0000

Tips Link to heading

Disable garbage collection when benchmarking for more accurate results.

GC.disable

# ------------------------------------------------------------------------------
# Code goes here

# ------------------------------------------------------------------------------

GC.enable

Basic Link to heading

require 'benchmark'

count  = 10_000
io     = StringIO.new
result = Benchmark.measure do
  count.times do
    io.puts 'Hello'
  end
end

puts result

#     user     system       toal        real
# 0.045354   0.099388   0.144742 (  0.145264)

Advanced Link to heading

require 'benchmark'
require 'stringio'
require 'pp'

count  = 10_000
io     = StringIO.new
result = Benchmark.bmbm do |benchmark|
  benchmark.report('inspect') do
    count.times do
      io.puts 'Hello'.inspect
    end
  end

  benchmark.report('pretty_inspect') do
    count.times do
      io.puts 'Hello'.pretty_inspect
    end
  end
end

# Rehearsal --------------------------------------------------
# inspect          0.007339   0.000000   0.007339 (  0.007391)
# pretty_inspect   0.625188   0.330933   0.956121 (  0.982394)
# ----------------------------------------- total: 0.963460sec
#
#                      user     system      total        real
# inspect          0.007655   0.000510   0.008165 (  0.008544)
# pretty_inspect   0.668881   0.257305   0.926186 (  0.948372)

Legendary Link to heading

Use these gems for more advanced benchmarking strategies:

How to Use: Minitest Mocks

Fri, 15 Apr 2022 20:10:16 +0000

Prerequisite Link to heading

Ruby Minitest and Simplecov starter

Usage Link to heading

# Create a mock
mock = Minitest::Mock.new

# Add expectations.
#
# Arguments:
#   1. Method name
#   2. What to return when called
#   3. Expected inputs
mock.expect(:read!, { result: 1 }, ['first'])

# Now you pass the mock around and execute your tests.
subject = described_class.new(something: mock)
subject.add(:a)

# Verify the expectations were met.
mock.verify

Limitations Link to heading

You can’t mock #respond_to? for some reason, at least I could not when I tried it. But it might have been a bug and it works now? Can somebody verify?

Ruby HTTP calls

Mon, 03 Jan 2022 09:30:29 +0000

Setup Link to heading

Use the basic, standard, bundled, ruby HTTP library, no other gem needed.

require 'net/http'

url     = 'https://www.codrut.pro'
headers = { 'X-HELLO' => 'world' }
use_ssl = true

GET Link to heading

params = { 'a' => 1 }
result = nil

uri = URI(url)
Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
  uri.query = URI.encode_www_form(params) if params
  request   = Net::HTTP::Get.new(uri)

  headers&.each_pair do |key, value|
    request[key] = value
  end

  result = http.request(request)
end

puts result.code
puts result.body

POST Link to heading

body   = { 'b' => 2 }.to_json
result = nil

uri = URI(url)
Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
  request = Net::HTTP::Post.new(uri)

  headers&.each_pair do |key, value|
    request[key] = value
  end

  result http.request(request, body)
end

puts result.code
puts result.body

Ruby: pass around a block

Mon, 25 Oct 2021 11:12:19 +0000

You have the following:

callable = proc { puts 'Hello' }

Pass it to a function like this:

def pass_me_something
  yield if block_given?
end

pass_me_something(&callable)

Or be explicit:

def pass_me_something(&block)
  block.call if block_given?
end

pass_me_something(&callable)

You can also be weird:

def pass_me_something(block)
  block.call if block&.is_a?(Proc)
end

pass_me_something(callable)

Ruby CSV manipulation

Sat, 22 May 2021 12:27:56 +0000

Read Link to heading

file = CSV.open('path/to/file.csv', col_sep: ',')
file.each do |line|
  pp line
end

Write Link to heading

header  = ['A', 'B', 'C']
content = [[1, 2, 3], [4, 5, 6]]

csv = CSV.generate do |output|
  output << header

  content.each do |item|
    output << item
  end
end

File.write('result.csv', csv)

How to Use: rubocop

Tue, 04 May 2021 10:00:23 +0000

Install Link to heading

gem install rubocop

Configure Link to heading

Create a global .rubocop.yml file in your home directory:

touch ~/.rubocop.yml

And add in any general rules:

---

Layout/HashAlignment:
  EnforcedColonStyle: table

Style/WordArray:
  EnforcedStyle: brackets

Project Link to heading

Do the same thing as above, but in your project root directory.

NOTE: Do not inherit from global config inside your project, EVER!

Ruby JIT

Tue, 13 Apr 2021 10:45:39 +0000

First, make sure you have at least ruby version 2.6, then enable it with a flag:

ruby --jit ./my-ruby-script.rb

Or with an environment vairable:

RUBYOPT="--jit"

If you want to see JIT output in your console do:

RUBYOPT="--jit --jit-verbose=1"

And that’s it, now let it do it’s thing!

Concurrency primitives in Ruby

Mon, 04 Jan 2021 23:30:24 +0000

Note: for parallelism, see Ractors

There’s 3 of them:

Thread
Mutex
Condition Variable

Thread Link to heading

first  = Thread.new { puts 'Thread 1'; sleep 1 }
second = Thread.new { puts 'Thread 2'; sleep 1 }
third  = Thread.new { puts 'Thread 3'; sleep 1 }

puts 'Main Thread'

[first, second, third].map(&:join)

Takeaways:

Blocks execute concurrently, but not in parallel.
Pause a thread for a few seconds with #sleep.
Wait for threads to finish execution with the #join method.
Execution scheduling is non deterministic, output will have a different order over multiple runs.

Mutex Link to heading

Syncronize access to a shared resource with a Mutex:

True parallelism in Ruby

Mon, 28 Dec 2020 10:13:28 +0000

Prerequisites Link to heading

You need ruby 3.0.0 or later for this, if it’s not available yet, use the docker image:

docker run --rm -it ruby:3.0.0-rc1-alpine irb

Ractor Link to heading

Here is a snippet that showcases everything you need to know in practice:

receiver = Ractor.new do
  while (result = receive) != :end
    puts result.inspect
  end
end

sender = Ractor.new(receiver) do |printer|
  printer.send({a: 1, b: 2})
  printer.send('some string')

  printer.send([1, 2, 3], move: true)
end

sender.take

receiver.send(:end)
receiver.take

Key points:

Ruby templating with ERB

Mon, 16 Nov 2020 13:40:26 +0000

ERB comes by default with ruby, you only need to require it:

require 'erb'

Create a template file ./template/steak.erb:

A large steak, <%= @how_done %>, please!
<%- 3.times do -%>
And another!
<%- end -%>

And read it into a variable:

tempalte = File.read('./template/steak.erb')

Now you can bind instance variables and pass them to the renderer:

renderer = ERB.new(template, nil, '-')

@how_done = 'medium rare'
puts renderer.result(binding)

How to Use: rake

Fri, 16 Oct 2020 18:15:11 +0000

Add the rake gem to your Gemfile:

gem 'rake'

Install it by running bundle install.
Create a Rakefile containing:

# frozen_string_literal: true

Rake.add_rakelib(File.join('lib', 'tasks'))

Create a hello.rake file in ./lib/tasks containing your code:

# frozen_string_literal: true

# Require your code here:
# require_relative '../../config/environment'

namespace :hello do
  task :world do
    puts 'Hello World!'
  end

  task chain: :world do
    puts 'Chain!'
  end

  task :name, [:who] do |_task, args|
    puts "Hello #{args[:who]}!"
  end
end

Run it:

bundle exec rake hello:world
# Hello World!

bundle exec rake hello:chain
# Hello World!
# Chain!

bundle exec rake hello:name[Rake]
# Hello Rake!

How to Use: guard

Thu, 15 Oct 2020 18:25:25 +0000

Add these gems to your Gemfile:

group :development do
  gem 'guard'
  gem 'guard-shell'
end

Install it by running bundle install.
Create a Guardfile containing:

# frozen_string_literal: true

clearing :on

guard :shell do
  watch(%r{(?:lib|test)/(.*)\.rb}) { |_m| `bundle exec rake test` }
end

Create the following entry in a Makefile:

.PHONY: guard
guard:
	@bundle exec guard

Run it when doing development:

make guard

Enjoy auto-executing tests and tasks!

Set up a console for Ruby projects

Tue, 13 Oct 2020 22:41:29 +0000

With IRB Link to heading

Add irb to your Gemfile (yes you need to do this)!

# frozen_string_literal: true

gem 'irb'

Run bundle install of course!
Create a ./bin/console file containing:

#!/usr/bin/env ruby
# frozen_string_literal: true

require 'rubygems'
require 'bundler/setup'
require 'irb'

require_relative '../config/environment.rb'

IRB.start

Be sure you require all your project files in config/environment.rb.
Make your file executable:

chmod +x ./bin/console

Now you can run it like any other program:

./bin/console

# irb(main):001:0>

Optional but fancy: create a Makefile with this content so you can execute make console instead.

.PHONY: console
console:
	@./bin/console

Pro Tip: use load 'path/to/file.rb' to reload file instead of restarting the shell on every edit.

With Pry Link to heading

Step 1. becomes:

Inline Bundler for single file Ruby scripts

Sun, 04 Oct 2020 13:58:08 +0000

To set up Gemfile functionality do this:

#!/usr/bin/env ruby
# frozen_string_literal: true

ENV['GEM_HOME'] = File.join(Dir.pwd, 'vendor', 'ruby')
Gem.clear_paths

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'

  gem 'minitest'
end

Now you can define and test your code in the same file:

def quick_maths(a, b)
  a + b
end

require 'minitest/autorun'

describe '#quick_maths' do
  it '1 + 1 = 2' do
    assert_equal(2, quick_maths(1, 1))
  end
end

Ruby Minitest and Simplecov starter

Wed, 30 Sep 2020 18:38:47 +0000

Add these gems to your Gemfile:

# frozen_string_literal: true

group :development, :test do
  gem 'minitest'
  gem 'rake'
  gem 'simplecov'
end

Run bundle install to install them.
Create a test/test_helper.rb file containing:

# frozen_string_literal: true

require 'simplecov'
SimpleCov.start do
  enable_coverage :branch
end

$LOAD_PATH.unshift File.expand_path('../lib', __dir__)

require 'minitest/autorun'

Add the following lines to your Rakefile:

# frozen_string_literal: true

require 'rake/testtask'

Rake::TestTask.new(:test) do |t|
  t.libs << 'test'
  t.libs << 'lib'
  t.test_files = FileList['test/**/*_test.rb']
end

Create a sample test at test/unit/trial_test.rb to try it out:

# frozen_string_literal: true

require 'test_helper'

describe 'trial' do
  it 'is worthy' do
    assert(true)
  end
end

Run the tests with bundle exec rake test

Quick way to format numbers in Ruby

Sun, 27 Sep 2020 10:58:53 +0000

number = 12345678
number.to_s.gsub(/\B(?=(...)*\b)/, ',')

# => "12,345,678"

This does not work if your number has a negative sign (-1234), neither if it has a decimal separator (1.234). I said it was a quick way, not a good way ;).

Temporary files and directories in Ruby

Thu, 23 Jul 2020 20:13:45 +0000

File Link to heading

Create a temporary file in your current directory:

require 'tempfile'

Tempfile.create('', Dir.pwd) do |file|
  puts File.path(file)

  File.write(file, 'I am temporary!')
  puts File.read(file)
end

Directory Link to heading

For directory it’s similar, but no require needed:

Dir.mktmpdir(nil, Dir.pwd) do |dir|
  puts File.path(dir)
end

Pretty Printing in ruby

Wed, 22 Jul 2020 18:39:28 +0000

Say you have a complex object like:

state = {a: 1, b: '2', c: [3, 4, 5]}

And you want to display it nicely to standard output. Then you do:

require 'pp'

pp state
# {:a=>1, :b=>"2", :c=>[3, 4, 5]}

Amazing! But you might want to save that into a string so it can be used later, like in the ouput of your logger. For this usecase you can call .pretty_inspect on any object and pass that result around.

Docker Images: basic Ruby setup

Thu, 16 Jul 2020 18:51:03 +0000

Use this as a template for ruby apps:

#-------------------------------------------------------------------------------
# Base

FROM ruby:2.7.2-alpine

SHELL ["/bin/ash", "-c"]

#-------------------------------------------------------------------------------
# Packages

RUN set -exo pipefail              && \
                                      \
    echo 'Install system packages' && \
    apk add --update --no-cache \
      build-base                \
      shadow

#-------------------------------------------------------------------------------
# Workspace

RUN set -exo pipefail       && \
                               \
    echo 'Create workspace' && \
    mkdir -p /work

WORKDIR /work

#-------------------------------------------------------------------------------
# User

ARG HOST_USER_UID=1000
ARG HOST_USER_GID=1000

RUN set -exo pipefail                                  && \
                                                          \
    echo 'Create the notroot user and group from host' && \
    groupadd -g $HOST_USER_GID notroot                 && \
    useradd -lm -u $HOST_USER_UID -g notroot notroot   && \
                                                          \
    echo 'Set direcotry permissions'                   && \
    chown notroot:notroot /work

#-------------------------------------------------------------------------------
# Gems

COPY --chown=notroot:notroot Gemfile* /work/

USER notroot

RUN set -exo pipefail                 && \
                                         \
    echo 'Install gems'               && \
    cd /work                          && \
    bundle install --jobs 3 --retry 3

#-------------------------------------------------------------------------------
# Command

CMD ["sh"]

Build it like this:

Serve HTML files with Ruby

Mon, 13 Jul 2020 20:44:08 +0000

Python has:

python3 -m http.server

But I like Ruby, so I do this instead:

# Basic:
ruby -run -e httpd

# With arguments:
ruby -run -e httpd -- -b 0.0.0.0 -p 9090

Note: there is no such thing as a -run flag for ruby, you’re doing -r for require and you’re loading the un.rb file from the ruby core. Then -e to evaluate the httpd function in that file.

Easter Eggs: ruby

Sun, 12 Jul 2020 12:55:20 +0000

Ruby is amazing! Here’s one easter egg:

ruby -r irb -e 'IRB.send(:easter_egg)'

Or start a ruby shell, type RubyVM and press Tab twice.

It also works in Docker, sort of, you need to provide the :dancing argument.

docker run --rm -it ruby:2.7.1-alpine ruby -r irb -e 'IRB.send(:easter_egg, :dancing)'

Ruby string interpolation

Wed, 10 Jun 2020 22:01:20 +0000

The bad way:

count = 3.to_s
puts 'I ate ' + count + ' burgers today!'

The lame way:

yuck = 'salad'
puts "No #{yuck} for me please!"

The woke way (notice where the .chomp call goes):

template = <<~TEMPLATE.chomp
  A large steak, %{how_done}, please!
TEMPLATE

puts template % { how_done: 'medium rare' }

For templating, follow this link:

Ruby templating with ERB

How to Use: pry-byebug

Sun, 12 Apr 2020 12:19:57 +0000

Add the pry-byebug gem, together with irb, to your Gemfile:

group :development, :test do
  gem 'irb'
  gem 'pry-byebug'
end

Add a .pryrc file to your project containing:

# frozen_string_literal: true

if defined?(PryByebug)
  Pry.commands.alias_command('c', 'continue')
  Pry.commands.alias_command('f', 'finish')
  Pry.commands.alias_command('n', 'next')
  Pry.commands.alias_command('s', 'step')
  Pry.commands.alias_command('w', 'whereami')

  Pry.commands.alias_command('q', '!!!')

  Pry::Commands.command(/^$/, 'repeat last command') do
    _pry_.run_command(Pry.history.to_a.last)
  end
end

Now you can start debugging your code:

require 'pry'
binding.pry

Install Ruby gems in home directory

Sun, 05 Apr 2020 15:26:35 +0000

Create the ~/.gemrc file with the following content:

gem: --no-rdoc --no-ri --user-install

Add these lines to your .bash_profile:

for entry in ~/.gem/ruby/*; do PATH=$entry/bin:$PATH; done
export PATH

export BUNDLE_PATH=~/.gem/bundle

Now you can install gems without needing your root password:

gem install rspec

which rspec
# /home/me/.gem/ruby/2.7.0/bin/rspec

Bundler with a Gemfile:

source 'https://rubygems.org'

gem 'rspec'

You can prefix your commands with bundle exec:

bundle install

bundle exec which rspec
# /home/me/.gem/bundle/ruby/2.7.0/bin/rspec

Don’t forget to clean up your old ruby gems directories:

Linear regression in Ruby

Mon, 30 Mar 2020 22:52:42 +0000

Let’s say you have the following 5 numbers:

values = [100, 200, 300, 400, 500]

To predict the next 3 in this series you need linear regression:

def linear_regression(pairs)
  n = pairs.size

  sum_x = pairs.map { |x, _| x }.sum.to_f
  sum_y = pairs.map { |_, y| y }.sum.to_f

  sum_xx = pairs.map { |x, _| x * x }.sum.to_f
  sum_xy = pairs.map { |x, y| x * y }.sum.to_f

  a = (    n * sum_xy - sum_x * sum_y ) / (n * sum_xx - sum_x**2)
  b = (sum_y * sum_xx - sum_x * sum_xy) / (n * sum_xx - sum_x**2)

  [a, b]
end

Call the function above with pairs of [index, value]:

Ruby on Codrut Constantin Gusoi

Rails: install Administrate

Gems Link to heading

Generate Link to heading

Changes Link to heading

Rails: install ActiveAdmin

Gems Link to heading

Generate Link to heading

Changes Link to heading

Create new Rails app through Docker

Prerequisites Link to heading

Shell Link to heading

Rails Link to heading

New Link to heading

Create a new Ruby gem

Setup Link to heading

Gem Name Link to heading

Permissions Link to heading

RSpec Instance Double

Ruby Ractor: pass an arbitrary block

Ruby Version Manager: rbenv

Docker Link to heading

Ruby Benchmarking

Tips Link to heading

Basic Link to heading

Advanced Link to heading

Legendary Link to heading

How to Use: Minitest Mocks

Prerequisite Link to heading

Usage Link to heading

Limitations Link to heading

Ruby HTTP calls

Setup Link to heading

GET Link to heading

POST Link to heading

Ruby: pass around a block

Ruby CSV manipulation

Read Link to heading

Write Link to heading

How to Use: rubocop

Install Link to heading

Configure Link to heading

Project Link to heading

Ruby JIT

Concurrency primitives in Ruby

Thread Link to heading

Mutex Link to heading

True parallelism in Ruby

Prerequisites Link to heading

Ractor Link to heading

Ruby templating with ERB

How to Use: rake

How to Use: guard

Set up a console for Ruby projects

With IRB Link to heading

With Pry Link to heading

Inline Bundler for single file Ruby scripts

Ruby Minitest and Simplecov starter

Quick way to format numbers in Ruby

Temporary files and directories in Ruby

File Link to heading

Directory Link to heading

Pretty Printing in ruby

Docker Images: basic Ruby setup

Serve HTML files with Ruby

Easter Eggs: ruby

Ruby string interpolation

How to Use: pry-byebug

Install Ruby gems in home directory

Linear regression in Ruby