Forem: Fran C.

Smart textwidth on Vim when writing comments

Fran C. — Sun, 13 Dec 2020 21:30:13 +0000

I was checking my init.vim today trying to find how to improve it a bit.

I found this case that could be interesting to share... so there it goes.

I write a lot of documentation. One thing I always try to do is to keep the comments I write well aligned and easy to read. That's why I keep them at a length of 80 characters, I find that to be easier to read than long lines.

You can use the textwidth configuration in vim to do that.

set textwidth=80

Once the text you write gets to a width of 80 characters vim will split it to the next line.

This is a very well known fact about vim, but you can read more about it if you're interested with :help textwidth

                        *'textwidth'* *'tw'*
'textwidth' 'tw'    number  (default 0)
            local to buffer
    Maximum width of text that is being inserted.  A longer line will be
    broken after white space to get this width.  A zero value disables
    this.
    'textwidth' is set to 0 when the 'paste' option is set and restored
    when 'paste' is reset.
    When 'textwidth' is zero, 'wrapmargin' may be used.  See also
    'formatoptions' and |ins-textwidth|.
    When 'formatexpr' is set it will be used to break the line.

The thing is that I don't want vim to do the same on the code I write. Mainly because it will end up splitting the code on a different place than the one I would want it to.

I needed a way to set textwidth=80 when editing comments and then set textwidth=0 when not editing comments anymore.

Enter OnSyntaxChange. This plugin allows you to define vim autocommands that execute when the syntax of the current file changes, in our case, when we're editing comments.

I use vim-plug so I install it like this:

Plug 'inkarkat/vim-OnSyntaxChange'
" This is a dependency library from the same author that includes
" some autoload functions that he uses on the plugins he writes.
Plug 'inkarkat/vim-ingo-library'

" Add a new autocommand that will activate when the cursor is on a Comment and
" it either enters or leaves insert mode.
" 1. The name: `Comment` means the autocmd will be called
" `SyntaxCommentEnter{MODE}`
" 2. A regex to max the syntax, on our case any syntax similar to `Comment`
" will match to us.
" 3. Whether we want to generate it to all buffers or only a particular one,
" we're ok with only the current buffer.
" 4. To which mode we want to link the autocommand. We're only interested in
" the insert mode
call OnSyntaxChange#Install('Comment', '^Comment$', 1, 'i')

augroup auto_wrap_comments
  " Set textwidth to 80 when editing
  autocmd User SyntaxCommentEnterI setlocal textwidth=80
  " Remove it again when leaving insert mode
  autocmd User SyntaxCommentLeaveI setlocal tw=0
augroup END

And with that code on our init.vim we now have that the split behaves like this :)

My small hook and my flow with git

Fran C. — Sat, 14 Nov 2020 18:17:13 +0000

I've just made this small git hook https://github.com/franciscoj/dot-files/blob/0825d35076ce4550db20a12ea54d73bf3d6cea63/git/hooks/commit-msg and I'm super happy because I've needed it for a long time!

It analyses the commit msg and adds a + sign at the beginning of the first line if the commit has more than 1 line. That way I can recognise commits with extended information.

When I'm coding serious stuff (like at work) I make very little and very atomic commits incrementally and I always try to keep things "green" and stable. When I say very little I really mean it. Sometimes those are things like "extract a variable" or "move this to the constructor" or "add an unused parameter".

I don't always to that as I make the change. Instead I play around a bit until I get where I want to and then I just commit small hunks little by little.

As I work on the task I extract things that are independent and can be rolled out on their own. Maybe a refactor that makes the new feature possible or a set of classes that aren't used yet but will be used by the new code I'm writing.

This way I also make sure that, on long projects, I keep sharing my code with my team as much as possible and gathering their continuous feedback.

I do that with many interactive rebases: editing, sqashing, splitting and reordering commits. I can't always do that, of course, but I try to code and commit taking that into account so that it is possible.

I normally extract stuff from my PR that can be independently rolled out and that can ease having a big feature in production without needing big last day deploys.

This way I start using the new code and capturing metrics about it before the new feature is even active for the final users, minimising the risk of performance or functional regressions.

PS: This started as a tweet explaining my silly hook and it went out of hand xD

Edit 2020 - 11 - 24: Updated the link to the hook to the latest version with some fixes I've done in the last weeks :)

My Ergodox EZ coding layout

Fran C. — Wed, 29 Jul 2020 20:36:27 +0000

2 or 3 years ago I bought an Ergodox Ez https://ergodox-ez.com/ I like mechanical keyboards a lot but I fell in love with this on the moment I saw it.

I own one of the old versions. No key backlights or any other of those fancy coloring stuff. It performs well, the cherry brown switches are great for my use and being able to position the keyboard halves the way I want has improved my posture when working a lot.

One of the things that made it a game-changer for me was the possibility to experiment with custom layouts and, lately, the support for macros.

The 4 layers

The layout is built around 4 different layers

0 or Home layer
1 or extended layer
2 or media layer
3 or numeric layer

Some of the ideas on it (like reducing the use of pinkies) comes from here https://implementsblog.com/2016/10/16/my-ergodox-ezs-custom-layout/

Layer 0 (Home)

This is the default layer. It is built as a QWERTY keyboard but in order to minimize the use of the pinky finger it has dual function keys on the home row (those are the keys on light blue for a, s, d, f, j, k, l and ; that way SHIFT, ALT, CTRL and SUPER/CMD are mapped on parallel on each hand and pinkies use is reduced.

This is weird at the beginning but once you get used to it it is so much better than the regular keyboard distribution that I would never want to get back to it.

The next thing that is worth mentioning here is the set of macros I have. Those are the purple keys at the top and at the bottom of the layout.

The ones on the left hand are for Vim and going from top left to bottom right they:

Open git status
Open horizontal split
Open vertical split
Fuzzy file finder
Grep on project
Close current buffer
Repeat last test (with https://github.com/vim-test/vim-test)
Run the tests on this file

For the right hand I had tmux macros and from top left to bottom right:

Rename tab
Open new tab
Open vertical split
Open horizontal split
Change to previous tab
Change to next tab
Switch to next split
Zoom split
Enter search mode
Close current split/window

I know, you're wondering "do you really use all that?" well, after some time yes. I use it all. Besides, so far I've not lost my muscular memory so I can still use a regular keyboard.

Layer 1 (Extended)

The most important thing about this layer is that it has some programming symbols like [ or ] and that it has the numbers (and all the symbols they have on SHIFT) but in the home row instead of the top row.

I'm currently studying how can I change some of the other coding symbols to a more comfortable position, like the row on top of the home one on the right hand. But I have still not decided.

Layer 2 (Media)

This one is easy. It has the arrows on the home row and on the same position as Vim hjkl + the media keys on the row on top of the home one + mouse movement on the left hand.

I actually don't use that mouse a lot, but it helps having it around.

It has all the F keys on the position where the numbers would be on a regular keyboard... I don't use them that much but I still want to have them around in some cases.

Layer 3 (Numeric)

This layer is pretty simple. It works as a numeric pad. I don't use it that much but it gets useful when you need to do things with excels for example.

WIP

This is still unfinished. I change it from time to time and try to time and regularly go through it to try to find ways to improve. Mainly to make things more comfortable or to reduce typos.

Can I use it?

I wouldn't recommend it if you're starting with an ergodox keyboard. That's already a bit hard on its own. But if you want to give it a spin you can find it here https://configure.ergodox-ez.com/ergodox-ez/layouts/KrKNl/latest/0

A trick with the Ruby documentation

Fran C. — Tue, 28 Jul 2020 06:28:47 +0000

I've never been able to remember the arguments for Array#reduce. Every time I think I've managed to do it I just get it wrong.

Luckily for me, Ruby has very good documentation on its standard library and, what's even better, it ships with a CLI to explore it so I don't even need to Google it 😬

ri "Array#reduce"

= Array#reduce

(from ruby core)
=== Implementation from Enumerable
------------------------------------------------------------------------
  enum.reduce(initial, sym) -> obj
  enum.reduce(sym)          -> obj
  enum.reduce(initial) { |memo, obj| block }  -> obj
  enum.reduce          { |memo, obj| block }  -> obj

------------------------------------------------------------------------

Combines all elements of enum by applying a binary operation,
specified by a block or a symbol that names a method or operator.

The inject and reduce methods are aliases. There
is no performance benefit to either.

If you specify a block, then for each element in enum the block
is passed an accumulator value (memo) and the element. If you
specify a symbol instead, then each element in the collection will be
passed to the named method of memo. In either case, the result
becomes the new value for memo. At the end of the iteration, the
final value of memo is the return value for the method.

If you do not explicitly specify an initial value for
memo, then the first element of collection is used as the
initial value of memo.

  # Sum some numbers
  (5..10).reduce(:+)                             #=> 45
  # Same using a block and inject
  (5..10).inject { |sum, n| sum + n }            #=> 45
  # Multiply some numbers
  (5..10).reduce(1, :*)                          #=> 151200
  # Same using a block
  (5..10).inject(1) { |product, n| product * n } #=> 151200
  # find the longest word
  longest = %w{ cat sheep bear }.inject do |memo, word|
     memo.length > word.length ? memo : word
  end
  longest                                        #=> "sheep"

It has a very good interactive mode as well (ri -i) In which you can search whatever you want :)

Oh, and if you use Vim you can access it by using K over any word. Check this out:

TIL: How my complicated alias works

Fran C. — Sun, 12 Jul 2020 08:05:12 +0000

This post comes from this comment: https://dev.to/nflamel/comment/11o72. You can read the whole thread here:

Fran C. • Jul 10 '20

I think that my 2 favortites and the 2 I use more are, no doubt:

alias e='${(z)VISUAL:-${(z)EDITOR}}'
alias g='git'

I've had this alias on my dot-files for some time. I use it to open my editor of choice (neovim).

alias e='${(z)VISUAL:-${(z)EDITOR}}'

I didn't know what it was exactly doing until recently. I've had it copy/pasted around my dot-files many times.

EDIT: I mean... I know I always use e to open nvim. What I didn't know was why was I using such a complex alias to do it.

TL;DR:

It uses $VISUAL or $EDITOR and makes sure that it properly handles any extra parameter given to it. So something line vim -a -b -c works.

Detailed explanation

Got it from here https://github.com/sorin-ionescu/prezto/blob/f4ca9ebfc913453f98ba6912a8c42684fd742cc1/modules/utility/init.zsh#L55

What it does If I'm not mistaken is to alias e to either the value of $VISUAL or $EDITOR. But to only do that it would be enough with:

alias e='${VISUAL:-${EDITOR}}`

There's also this (z) that I just learned on ZSH is an expansion flag. Looking into ZSH manual it says:

z

    Split the result of the expansion into words using shell parsing to find
    the words, i.e. taking into account any quoting in the value. Comments are
    not treated specially but as ordinary strings, similar to interactive
    shells with the INTERACTIVE_COMMENTS option unset (however, see the Z flag
    below for related options)

    Note that this is done very late, even later than the ‘(s)’ flag. So to
    access single words in the result use nested expansions as in
    ‘${${(z)foo}[2]}’. Likewise, to remove the quotes in the resulting words
    use ‘${(Q)${(z)foo}}’.

but I still didn't know what it means... so I tried to do:

VISUAL='nvim -v' # This just writes the nvim version
alias e='${VISUAL:-${EDITOR}}'

If I then I've tried

$ e
zsh: command not found: nvim -v

That doesn't happen if I try with (z) flag on the expansion alias e='${(z)VISUAL:-${(z)EDITOR}}'.

Thanks to https://dev.to/nocnica for asking the right question and for suggesting that I extracted the comment into this post.

How i install Arch Linux on my dev machine

Fran C. — Wed, 20 May 2020 20:48:36 +0000

I use ArchLinux on my 2 dev machines. One is an old Alienware M17xR4 that somehow is still alive and that I can only use plugged in (or on battery for like 20 minutes) and a powerful desktop machine that I share with Windows for playing videogames.

The reasons why I use Linux for development are basically because I enjoy it. I've never used Windows for development so I don't know if I would enjoy it and I've used Mac... and I just don't like it. I feel MacOS gets in my way all the time and doesn't always allow me to do what I want to do.

The reason why I use Arch? ... I don't know and I honestly ask myself this question every time I need to reinstall the system. But whenever I try something else I end up coming back to my Arch setup. It is just customized the way I like it.

Installing Arch isn't easy or straightforward, you normally need to know what you're doing and last time I tried it took me around 3 hours because I'm dummy and lazy and I still don't understand EFI or how to make Grub work with it (spoiler: I used refind).

In order to avoid this pain again I've decided to write this down so that I don't need to go through the same again 🤷

Most of it is just copied from the awesome Arch installation guide, with just a pinch of what I want and explaining the same steps just for myself (if you want to install Arch please go and use the installation guide instead of this!)

https://wiki.archlinux.org/index.php/Installation_guide

1. Bootstrap from the live USB

2. Get internet

If wifi just works

wifi-menu

If not, make sure your Ethernet cable or mobile tethering is connected. Arch will enable DHCP for the Ethernet devices it finds them (that includes USB tethering) while it boots. You only need to:

systemctl restart dhcpcd@enps0swhatever

check you have ping to ping archlinux.org

3. Sync time

timedatectl set-ntp true

4. Partition

Use cfdisk. Important, make sure /var is not on the SSD. There's probably no reason for that on modern SSDs? I don't know, it just scares me.

Laptop

I use these partitions. /dev/sda is the normal HDD and /dev/sdb is the 32GB SSD.

/dev/sda1, 1G, /boot/efi
/dev/sda2, 1G, /boot
/dev/sda3, 100G, /var
/dev/sda4, all, /home

/dev/sdb1, all, /

Desktop partition schema

/dev/sda is the Windows installation disk on SSD
/dev/sdb is the Windows storage HDD
/dev/sdc is the Linux SSD
/dev/sdd is the Linux storage HDD

EFI exists already from the Windows partition, don't format it, just mount it.

/dev/sda2, /boot/efi
/dev/sdc1, all,  /
/dev/sdd1, 300G, /var
/dev/sdd2, all, /media/store
/dev/sda4, exists, /media/windows
/dev/sdb2, exists, media/store_win

5. Bootstrap the system

pacstrap /mnt base linux linux-firmware neovim vi zsh networkmanager sudo
genfstab -U /mnt >> /mnt/etc/fstab

On desktop remember to add linux-headers base-devel broadcom-wl-dkms to the list of pacstrap packages. Because I have a broadcom wireless card and otherwise I don't have wifi on my first boot (and it is a pain to configure it later!)

6. Chroot

arch-chroot /mnt
ln -sf /usr/share/zoneinfo/Europe/Madrid /etc/localtime
hwclock --systohc
nvim /etc/locale.gen # uncomment en_US.UTF-8 and es_ES.UTF-8
locale-gen
echo "LANG=en_US.UTF-8" > /etc/locale.conf
echo "my-hostname" > /etc/hostname

Setup hosts nvim /etc/hosts

127.0.0.1   localhost
::1     localhost
127.0.1.1   my-hostname

passwd

7. Boot manager

I tipically install grub, but last time I wasn't able to do it and ended up installing refind.

Install grub

This just worked on the laptop 🤷

pacman -S grub efibootmgr
grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi
grub-mkconfig -o /boot/grub/grub.cfg

Or refind

pacman -S refind
refind-install

Edit /boot/refind_linux.conf and make sure it has a line that refers to the / partition

    "Boot using default options"   "root=PARTUUID=978e3e81-8048-4ae1-8a06-aa727458e8ff rw quiet splash"

PARTUUID can be found with blkid

Sometimes I add this theme https://github.com/bobafetthotmail/refind-theme-regular

8. Restart!

Exit from chroot

umount -R /mnt
reboot

9. Connect wifi

systemctl enable NetworkManager
systemctl restart NetworkManager
nmcli device wifi rescan
nmcli device wifi list
nmcli device wifi connect SSID-Name password wireless-password

10. Create my new user

visudo # to enable sudo to members of wheel group
userad -m -G wheel -s /bin/zsh username
passwd username

Then exit and login with this new user

11. Bootstrap the new system

If you're here and you're not me, ⚠️stop⚠️. This is how to install my own personal dot-files and you don't want them, believe me.

sudo pacman -S python python-pip python-neovim git base-devel
git clone https://github.com/franciscoj/dot-files ~/Documents/src/dot-files
cd ~/Documents/src/dot-files
./boostrap/linux.sh
sudo DIFFPROG="nvim -d" pacdiff
sudo pip install dotbot
dotbot -c install.conf.yaml

Enable lightdm

sudo systemctl enable lightdm

Done!

Enjoy!

Some reasons to avoid Hashes in Ruby and some alternatives to them.

Fran C. — Mon, 16 Mar 2020 08:23:28 +0000

So, hashes, uh?

What's good about them?

They are easy to build
They are cheap (short-term cheap at least)
They help interfacing with shapeless data (like JSON) in an easy way.
They are good to build simple/cheap key-value stores in memory.

What's not so good about them?

They are shapeless (in a bad way, you never know what you expect from them)
They are mutable (in a bad way as well, how do you know nobody else will mutate this or nobody has already mutated it?)
They are dummy (unlike objects, they know nothing, they have no way to interface with except for Enumerable)
They are impossible to type (🤷‍♂️)
They need a lot of defensive code with nil checks. (even when they are getting better at this with things like hash.dig(:key1, :key2) it is not enough and you always need extra checks here and there, which makes the code difficult to read and to change).

So, what should we do with them?

I propose that we all agree on a small set of guidelines to help us answer the question "Should I use a Hash for this?". TL;DR

Avoid using Hashes as input to methods. Try to have shaped inputs.
Avoid using Hashes as return values. Try to have shaped return values.
If you receive a Hash, isolate it. Build a layer to interface with instead of the Hash.
- Get the data directly if it is a small hash.
- Build objects if it has an heterogeneous structure.

1. Avoid using hashes as input to methods.

There's no easy way to know what's inside params here..

MyInteractor.new(
  author: author,
  params: params
).call

Instead use this:

MyInteractor.new(
  author: author,
  value: params[:value],
  question_id: params[:question_id]
).call

You now have an explicit knowledge of the input for that interactor which is:

simpler to use (you don't need a Hash now, only values which can come from any object)
Intention revealing
Typable
Easier to document

Try to avoid substituting the Hash with a T::Struct or a plain Struct if you don't use sorbet. You will be adding an extra layer and having very little in return. You avoid the hash, which is good, but you add an extra layer and win very little in return. That does not justify a new layer.

Instead, type the parameters you're receiving individually with Sorbet. If you don't use sorbet, just avoid the struct and pass them individually.

You might think:

But I have A TON of parameters and a Hash is a nice and convenient way to
make my object easier to use!

It isn't. You're sacrificing a lot in exchange for almost nothing and your code will suffer for it.

Another reason to avoid this is that it can imply security holes. There's a very simple example which is mass assignment model attributes from the controller params.

# NOTE: This is not how our code works, this is an example of how NOT to do it
current_user = current_company
  .users
  .find(session[:current_user])

current_access.update!(params[:user])

Can you spot the issue? It is subtle but it is there. An attacker could just send a company_id and inject themselves on any company 😱. Not good.

This kind of issue is what made Rails end up adding the strong parameters API: https://guides.rubyonrails.org/action_controller_overview.html#strong-parameters but that isn't enough. Strong parameters are focused on avoiding mass assignment. But you massively pass params from a controller into any object as parameters you're exposed to this kind of problem as well.

In short: Be as explicit as possible with contracts. Pass unfurled parameters as a preference and type as much as you can.

2. Avoid using hashes as return values.

If whoever uses the code you write doesn't know what to expect from your return value, they'll have a hard time using you. Make it easy for them.

If you need a dummy object, use a T::Struct instead (or a Struct). They are very good for transferring data, they have a defined shape and they are highly typable.

3. If you receive a Hash, isolate it.

Let's give an example, you get a Hash from reading a YAML file, a JSON response from an API or even on a controller action.

This is, by far, the hardest to solve among all the cases because each one will need a different solution.

There are however some guidelines you can follow which help a bit:

1. Isolating hashes: Get their values

If you only need to get some keys from the Hash, e.g. reading the params on a controller. You're good to go. Slice the keys you need and then read them.

class MyController
  def create
    MyCreateInteractor.new(
      author: current_access,
      value: create_params[:value],
      description: create_params[:description]
    ).call.unwrap!
  end

  def create_params
    params.slice(:value, :description)
  end
end

Soon we will be able to use sorbet for this, which will give use shaped and typed params. Until that moment arrives, we need to deal with it.

2. Isolating hashes: Build a defensive layer

If the Hash has layers with more hashes inside of it and you need to extract data from it through Enumerable methods (find, map, select...) then wrap that hash on an object and interface with that object instead.

There's an example of this on our PdfParser library. Its configuration is a YAML file with a shape like this:

---
some_data_table:
  min_x: 55
  min_y: 111
  max_x: 532
  max_y: 167
  transform:
    type: table
    arguments:
      - name: column1
        transform: text
        max_x: 214
      - name: column2
        transform: text
        max_x: 372
      - name: column3
        transform: money_es
        max_x: 532

some_numeric_field:
  min_x: 217
  min_y: 81
  max_x: 265
  max_y: 99
  transform: money_es

Interfacing with a hash like this is problematic because you don't know what to expect. Have a look at the transform for example. On the numeric field, it only has a name. But on the table; it has a type, a list of arguments and more nested transforms.

Let's first understand the problem:

This file represents the format for a PDF file. A format has many different fields inside (some_numeric_field and some_data_table for example) in this case.
Each field has boundaries to where it is found on the PDF
Each field defines a transformation to be applied to it after reading the text on it. E.g.: money_es means that it is money formatted like 1.000,00 and it has to be transformed into a BigDecimal

How did we get over this? Interfacing with a Hash like this could have been really complex so we started by separating the parts that change from the parts that stay the same.

All fields have boundaries
All fields have a name
All fields have a transform

What is the changing part? The transform can be different per field so we defined something like this:

Field = Struct.new(:name, :boundaries, :transform)
Box = Struct.new(:min_x, :min_y, :max_x, :max_y)
Transform = Struct.new(:type, :arguments) do
  # @param args [Hash]
  # @option args [String, Hash] :transform the name of the transform or a
  #   Hash describing it
  # @option :transform [String] :type the name of the transform
  # @option :transform [Hash] :arguments a hash with the arguments for the
  #   transform
  def self.from_hash(args)
    type, arguments =
      case args[:transform]
      when String
        [args[:transform], nil]
      else
        [
          args[:transform][:type],
          args[:transform][:arguments]
        ]
      end

    new(type, arguments)
  end

With that we build objects from reading the file into a Hash like this:


# name is the key of the YAML definition for a field and arguments is a hash
# with its content.
read_file.map do |name, arguments|
  Field.new(
    name,
    Transform.from_hash(arguments),
    Boundaries.new(
      arguments[:min_x].to_i,
      arguments[:min_y].to_i,
      arguments[:max_x].to_i,
      arguments[:max_y].to_i
    )
  )
end

We only read from the hash in 1 place (when parsing the configuration).
We have a specific initializer for the case in which we need to pass a hash around (Transform.from_hash) and we use a case...when to map it into objects.

It is indeed more work but saves you from a lot of pain later on. Nobody will know this all came from a Hash, nobody will try to read a shapeless object and nobody will try to mutate it.

What are Hashes good for?

They are good as in-memory key-value stores. But even in that case, build a layer to isolate yourself from it. As an example:

We use this object to store an in-memory cache of the hierarchical relations between employees and their managers. Fetching them is costly and because of our permissions architecture, we do it a lot.

class HierarchyCache
  def initialize
    @cache = {}
  end

  # If a key has value, return it
  # if it doesn't store the return value of `block` and return the value
  def fetch(key, employee, &block)
    value = get(key, employee)

    return value unless value.nil?

    set(key, employee, block.call)
  end

  # Get the value stored on a key
  def get(key, employee)
    @cache.dig(employee.id, key)
  end

  # Sore a value for a key
  def set(key, employee, value)
    new_cache_entry = { key => value }

    if @cache[employee.id]
      @cache[employee.id].merge!(new_cache_entry)
    else
      @cache[employee.id] = new_cache_entry
    end

    get(key, employee)
  end
end

We use a hash here but we take care of not letting anybody know we do and most importantly, we don't leak how the hash is structured and we provide a programmatic API to interface it.

Summary (AKA TL;DR)

Avoid using Hashes as input to methods. Try to have shaped inputs.
Avoid using Hashes as return values. Try to have shaped return values.
If you receive a Hash, isolate it. Build a layer to interface with instead of the Hash.
- Get the data directly if it is a small hash.
- Build objects if it has a heterogeneous structure.
Use them as long as nobody can call [] or any other Enumerable method on them.

Last, but not least, don't serialize things into hashes if you intend to use them later on. If you find yourself using [] on different layers of your code check if you can enforce any of the previous points.

Summarized even more

Don't use them to build contracts (as inputs/outputs). No problem as intermediate values (as long as you isolate them well enough).

A trick with Ruby anonymous classes

Fran C. — Fri, 14 Feb 2020 14:47:12 +0000

Since everything in Ruby is an object it is only normal that classes are objects too. Which means they just have regular constructors with initializers, as any other object would do.

Class.new do
  def hello
    puts "Hello world!"
  end
end.new.hello

# prints -> Hello world!

What can I use it for?

Anonymous classes are an amazing candidate for testing mixings.

# callable_test.rb
# run it with:
# ruby callable_test.rb

module Callable
  def call(*args)
    new(*args).call
  end
end

require "minitest/autorun"

class TestCallable < Minitest::Test
  def setup
    @klass = Class.new do
      extend Callable

      def initialize(arg1, arg2)
        @arg1 = arg1
        @arg2 = arg2
      end

      def call
        [@arg1, @arg2]
      end
    end
  end

  def test_same_return
    assert_equal @klass.new(1, 2).call, @klass.call(1, 2)
  end
end

# Run options: --seed 3295
#
# # Running:
#
# .
#
# Finished in 0.000605s, 1651.9615 runs/s, 1651.9615 assertions/s.
# 1 runs, 1 assertions, 0 failures, 0 errors, 0 skips

There's a caveat though... You need to be aware that anonymous classes have no name (they are anonymous after all ;) ) so any call to Class.new.name will return nil.

Classes only acquire a name when you assign them to a constant. That is:

klazz = Class.new
klazz.name
# => nil

MyClass = klazz
klazz.name
# => "MyClass"

So, if you need to test things which depend on the class name you can't use anonymous classes, although they still have a benefit over regular declarations on tests, which is that they can be assigned to variables, while regular class...end declarations can't.

my_class = class MyClass; end
my_class
# => nil

other_class = OtherClass = Class.new
other_class
# => OtherClass

So, if you need a class with a name on a test you can still use this, only remember to remove the constant on your test's teardown.

Object.send(:remove_const, :MyClass)

If you're on a Rails app and use RSpec, it even has a helper to test things with anonymous controllers: https://relishapp.com/rspec/rspec-rails/v/3-9/docs/controller-specs/anonymous-controller, which is especially useful to test things like login/logout flows independently.

A trick with Ruby Hash.new

Fran C. — Wed, 12 Feb 2020 06:54:29 +0000

Hashes are used a lot in Ruby (sometimes even abused) and they have a very interesting functionality that is rarely used: Hash.new has 3 different forms

Regular form

It just returns an empty hash whose unexisting keys return always nil.

h = Hash.new # Or h = {}
h[:hello] # => nil

This is just equivalent to using an empty Hash literal also known as {}.

Fixed default

It allows for a parameter which is returned in case the key doesn't exist.

h = Hash.new('world')
h[:hello] # => 'world'

This form needs to be used carefully though since you always return the same object, which means if you modify it, you modify it for all subsequent calls:

h[:hello].upcase! # "WORLD"
h[:foo] # "WORLD"

That is why only recommend using this option in a case: maps of classes.

POLICIES = Hash.new(ForbidAllPolicy).merge({
  admin: AccessAllPolicy,
  user: RestrictedPolicy
})

policy = POLICIES[current_user.role]

POLICIES[:user]
# => RestrictedPolicy

POLICIES[:hacker]
# => ForbidAllPolicy

Why classes but not other objects? Because classes are singletons (a singleton is an object that only has one instance at the same time) so you do not care that you're always going to get the very same object all the time.

Calculated default

This form gives the biggest freedom since it allows us to pass a block to calculate the value and even to store it on the hash. So the next call to that same key will already have a value.

h = Hash.new do |hash, key|
  value = key.upcase
  puts "'#{key}' => '#{value}'"

  hash[key] = value
end
h["hello"]
# prints -> 'hello' => 'HELLO'
# => "HELLO

# Next call to the same key is already assigned, the block isn't executed

h["hello"]
# => "HELLO"

My preferred use case for this is to protect myself from nils and to avoid continuous nil checks.

In a case like this:

h = {}
h[:hello] << :world
# => NoMethodError (undefined method `<<' for nil:NilClass)

You can either ensure the key is initialized

h = {}
h[:hello] ||= []
h[:hello] << :world
h
# => {:hello=>[:world]}

Or use the trick we just learned to ensure you will never have a nil and you get a sane default instead.

h = Hash.new { |h, k| h[k] = [] }
h[:hello] << :world
h
# => {:hello=>[:world]}

Take into account that passing around a Hash like this might be dangerous as well. Nobody will expect that a Hash returns something for a key that doesn't exist, it can be confusing and hard to debug.

If we get keys for the previous hash:

h.keys
# => [:hello]

How to use it then? Just do not let the rest of the world know it is a Hash 😬

class CachedUser
  def initialize
    @cache = Hash.new { |h, id| h[id] = User.find(k) }
  end

  def fetch(id)
    @cache[id]
  end
end

cache = CachedUser.new

cache.fetch(1)
# => select * from users where id=1
# => <User: @id=1>

cache.fetch(1)
# => <User: @id=1>

Although the example is extremely simple it showcases how you can safely use a Hash as a container object safely without exposing some of its drawbacks but profiting from its flexibility.

A trick with Ruby array literals

Fran C. — Mon, 10 Feb 2020 09:49:24 +0000

Declaring an array in Ruby is simple:

ary = ["foo", "bar"]
# => ["foo", "bar"]

but did you know you can save the array elements as variables the same time you declare them?

ary = [
  foo = "foo",
  bar = "bar"
]

foo # => "foo"
bar # => "bar"

Looks like magic? Well, it is not magic. This happens because assigning a value to a variable is an expression in Ruby. This is applicable to many other cases, like assigning a value on a conditional

if user = User.find(params[:id])
  puts "User is #{user.name}"
end

Or even crazier: to save the parameter you pass to a method!

def some_method(arg)
  puts arg
end

some_method(value = "Hola")
# prints -> "Hola"

value
# => "Hola"

Disclaimer: ☝️ those 2 might be bad ideas. I wouldn't use it regularly on any code I write but knowing it is possible is always a good thing.

What can I use this for?

It plays quite well with constants that can then be used as some kind of enums:

COLORS = [
  COLOR_RED = "RED",
  COLOR_BLUE = "BLUE",
  COLOR_GREEN = "GREEN",
  COLOR_YELLOW = "YELLOW"
]
# => ["RED", "BLUE", "GREEN", "YELLOW"]

On rails apps they are especially useful to declare scopes:

scope :non_red, -> { where(color: COLORS - [COLOR_RED]) }
scope :blue, -> { where(color: COLOR_BLUE) }

5 Vim productivity tips to improve your workflow

Fran C. — Tue, 15 Oct 2019 17:47:56 +0000

1. Remap the leader key to the space bar

let mapleader      = ' '

It might look strange, but think about how little you use it on normal mode. The space bar is a pretty accessible key on your keyboard and it will reduce your pinky pain.

2. Use `Localvimrc` to customize your vim per project

embear / vim-localvimrc

Search local vimrc files (".lvimrc") in the tree (root dir up to current dir) and load them.

Localvimrc

This plugin searches for local vimrc files in the file system tree of the currently opened file. It searches for all ".lvimrc" files from the directory of the file up to the root directory. By default those files are loaded in order from the root directory to the directory of the file. The filename and amount of loaded files are customizable through global variables.

For security reasons it the plugin asks for confirmation before loading a local vimrc file and loads it using |:sandbox| command. The plugin asks once per session and local vimrc before loading it, if the file didn't change since previous loading.

It is possible to define a whitelist and a blacklist of local vimrc files that are loaded or ignored unconditionally.

The plugin can be found on Bitbucket, GitHub and VIM online.

Commands

The `LocalVimRC` command

Resource all local vimrc files for the…

View on GitHub

I have lot of customizations for Vim, but making them work on each and every project I work is nearly impossible. For example for JavaScript/TypeScript. In some projects I just use plain JS, in others JS with Flow, in others TypeScript but a bit of plain JS too... and setting up vim with specific linters, shortcuts, etc for each one of them is painful.

Besides that, sometimes I don't want to make certain configurations public, so adding them to my public dot-files is not an option.

With this plugin you can easily (and more or less safely) keep those configurations scoped to the projects where you need them.

3. Spell check your markdown and git commits

augroup setSpelling
  autocmd!

  autocmd FileType gitcommit setlocal spell spelllang=en_us
  autocmd FileType markdown setlocal spell spelllang=en_us
augroup END

If (like me) you're not a native English speaker it is even more helpful to have spell checking. This simple piece of config will spell check your git commit messages and the markdown you write.

Remember when Vim marks a spelling issue you can see the available options with z=. You want to know more about spelling? Check :help spell on Vim.

4. Use mnemonics for your shortcuts

I have a lot of shorcuts on Vim. Remembering them all is impossible. I group them with mnemonics which are simpler to remember. For example, all my git related mnemonics are grouped under <leader>g so <leader>gs means :Gstatus. Most are obvious, but I've added some comments where not.

nnoremap <leader>gs :Gstatus<CR>
nnoremap <leader>gc :Gcommit<CR>
nnoremap <leader>gC :Gcommit -n<CR> " commit but ignore hooks
nnoremap <leader>gP :Gpush<CR>
nnoremap <leader>gfP :Gpush --force-with-lease<CR>
nnoremap <leader>gp :Gpull<CR>
nnoremap <leader>gf :Gfetch<CR>
nnoremap <leader>gl :GV!<CR> " Git log for the current file
nnoremap <leader>gL :GV<CR> " Full git log
nnoremap <leader>gd :Gvdiff<CR>
nnoremap <leader>gb :Gblame<CR>
nnoremap <leader>gm :Git checkout master<CR>
nnoremap <leader>g- :Git checkout -<CR>
nnoremap <leader>grm :Grebase -i master<CR>

BTW, If you are interested those 2 use fugitive and gv

tpope / vim-fugitive

fugitive.vim: A Git wrapper so awesome, it should be illegal

fugitive.vim

Fugitive is the premier Vim plugin for Git. Or maybe it's the premier Git plugin for Vim? Either way, it's "so awesome, it should be illegal". That's why it's called Fugitive.

The crown jewel of Fugitive is :Git (or just :G), which calls any arbitrary Git command. If you know how to use Git at the command line, you know how to use :Git. It's vaguely akin to :!git but with numerous improvements:

The default behavior is to directly echo the command's output. Quiet commands like :Git add avoid the dreaded "Press ENTER or type command to continue" prompt.
:Git commit, :Git rebase -i, and other commands that invoke an editor do their editing in the current Vim instance.
:Git diff, :Git log, and other verbose, paginated commands have their output loaded into a temporary buffer. Force this behavior for any command with…

View on GitHub

junegunn / gv.vim

A git commit browser in Vim

gv.vim

A git commit browser.

gitv is nice. But I needed a faster, and possibly simpler alternative that I can use with a project with thousands of commits.

Installation

Requires fugitive.

Using vim-plug:

Plug 'tpope/vim-fugitive'
Plug 'junegunn/gv.vim'

Usage

Commands

:GV to open commit browser
- You can pass git log options to the command, e.g. :GV -S foobar -- plugins.
:GV! will only list commits that affected the current file
:GV? fills the location list with the revisions of the current file

:GV or :GV? can be used in visual mode to track the changes in the selected lines.

Mappings

o or <cr> on a commit to display the content of it
o or <cr> on commits to display the diff in the range
O opens a new tab instead
gb for :Gbrowse
]] and [[ to move between commits
. to start command-line with…

View on GitHub

From 2 of my favorite vim plugin authors. Tim Pope and Junegunn Choi

5. Learn how to navigate the help.

Vim's help is great. Not only that, most plugins you install come with a very well crafted help. Understanding how to navigate it makes your life easier. It is pretty easy:

:help to see the global vim help (yeah, that's pretty obvious)
:help command/topic/shortcut to see its help. E.g. :help :Gstatus, :help CTRL-W or :help sort
You'll see some words on the help are highlighted. Those are links and you can follow them with CTRL+]. If you want to go back to where you were you can use CTRL+o

Bonus: You don't know what you don't know...

Let me explain that: Vim can do A LOT, you don't know how much (and neither do I). The only way to do it is to research and play with it. Many of the things I do on my .vimrc come from other people's dotfiles.

There are literally thousands of dotfiles out there, people shares them (I do share mines!). If you are interested on improving your Vim's workflow go check them. Find famous Vim authors and check what they do. You'll be amazed on how much you will learn!

How to have HTTPs on development with Docker, Traefik v2 and mkcert

Fran C. — Sun, 13 Oct 2019 16:09:21 +0000

Docker is cool

I've discovered Docker recently. I know... it's been there for a while, but I've never added it to my workflow until very recently and I'm quite happy with the solutions it gives me to the problems I have. I'm still a newbie with it and enjoying a lot what I'm learning.

One of the things I like about Docker is that it allows me to carry the stack definition I want for my project between different computers and reduces a lot the amount of effort I need to setup my dev env when I'm playing with some side projects.

This article is meant for Docker newbies like myself who need to solve this fairly common web development problem.

HTTPs and domain names in development are important

Making sure that your development environment looks similar to your production one is important. It helps reducing unexpected issues when going live.

I've used nginx in the past for this and it is still a very solid solution. But in development and just for a simple development reverse proxy I prefer to use traefik these days. Mainly because it works pretty well with Docker.

In addition to that, to simply generate signed certificates in development I use mkcert, which is super simple to use. Many also propose and use Let's Encrypt and traefik itself has some support for it, but we won't use in this example.

Stop it already! what do I need?

You need an application of some sort. Ours is going to be ruby -run -e httpd . -p 3000 which is a server showing the current folder's contents. Note as well that I don't run my apps inside Docker itself during development. I don't do it because I run things like linters, test suites, etc from my editor and running the app inside Docker is usually a barrier for that.

If you run the app inside docker check the traefik documentation because having this same proxy in your case is even easier!
You need Docker running on your machine.
Some way to resolve the domain you want to your app. In my case I just add the domain I need to my /etc/hosts but you might prefer other solutions like using dnsmasq.

The config!

You need something like this in your docker-compose.yml.

You don't need to have only that. I typically declare other stuff there like databases or other infrastructure pieces that I need in development.
This is the static configuration for traefik.
And this is the dynamic one, which defines the routing between the different parts.
Last but not least you need to install mkcert and run it to generate a couple of mock certs for you. What I usually do is that I keep a devcerts folder in my projects that I ignore. And then I generate a new cert on each new dev machine. In this case with:
```
mkcert mkcert my-app.com "*.my-app.com"
```
To have *.my-app.com available.

Note however that you could avoid that by using Let's Encrypt, but I've not needed it, so I don't use it.

Put it all together! This is how I organize the code in this example:

example
├── devcerts
│   ├── my-app.com+1-key.pem
│   └── my-app.com+1.pem
├── docker-compose.yml
├── traefik.config.toml
└── traefik.toml

Run your app (ruby -run -e httpd . -p 3000 or whatever your app incantation is!)
Run docker-compose up and see the magic happen!

You can now go go http://my-app.com and see how you're automatically redirected to https://my-app.com and have your app working there :D

Remember to check http://my-app.com:8080 to see traefik's dashboard.

Finally kudos to my mate gtrias for showing me what I can do with Docker!

(Spoiler, he's on dev.to too!)

Genar Trias OrtizFollow

/gtrias

Forem: Fran C.

Smart textwidth on Vim when writing comments

My small hook and my flow with git

My Ergodox EZ coding layout

The 4 layers

Layer 0 (Home)

Layer 1 (Extended)

Layer 2 (Media)

Layer 3 (Numeric)

WIP

Can I use it?

A trick with the Ruby documentation

TIL: How my complicated alias works

TL;DR:

Detailed explanation

How i install Arch Linux on my dev machine

1. Bootstrap from the live USB

2. Get internet

3. Sync time

4. Partition

Laptop

Desktop partition schema

5. Bootstrap the system

6. Chroot

7. Boot manager

Install grub

Or refind

8. Restart!

9. Connect wifi

10. Create my new user

11. Bootstrap the new system

Enable lightdm

Done!

Some reasons to avoid Hashes in Ruby and some alternatives to them.

What's good about them?

What's not so good about them?

So, what should we do with them?

1. Avoid using hashes as input to methods.

2. Avoid using hashes as return values.

3. If you receive a Hash, isolate it.

1. Isolating hashes: Get their values

2. Isolating hashes: Build a defensive layer

What are Hashes good for?

Summary (AKA TL;DR)

Summarized even more

A trick with Ruby anonymous classes

What can I use it for?

A trick with Ruby Hash.new

Regular form

Fixed default

Calculated default

A trick with Ruby array literals

What can I use this for?

5 Vim productivity tips to improve your workflow

1. Remap the leader key to the space bar

2. Use Localvimrc to customize your vim per project

embear / vim-localvimrc

Search local vimrc files (".lvimrc") in the tree (root dir up to current dir) and load them.

Localvimrc

Commands

The LocalVimRC command

3. Spell check your markdown and git commits

4. Use mnemonics for your shortcuts

tpope / vim-fugitive

fugitive.vim: A Git wrapper so awesome, it should be illegal

fugitive.vim

junegunn / gv.vim

A git commit browser in Vim

gv.vim

Installation

Usage

Commands

Mappings

5. Learn how to navigate the help.

Bonus: You don't know what you don't know...

How to have HTTPs on development with Docker, Traefik v2 and mkcert

Docker is cool

HTTPs and domain names in development are important

Stop it already! what do I need?

The config!

2. Use `Localvimrc` to customize your vim per project

The `LocalVimRC` command