iridakos

stup - Daily notes in the terminal

Mon, 20 Apr 2020 12:00:00 +0300

Over the past few years I have been participating in Stand-up meetings and it took me some time to find a convenient and effective way for keeping notes about what I was doing every day.

I needed to be able to:

keep notes on the issues I worked on, the meetings I participated in and stuff that blocked my work
easily access these notes based on their date
have an overview of what I did for example the last week
all of the above from inside a terminal without
- having to manually structure and update a single document
- having to manually create a document for each day

stup

I created stup (the name derives from stand-up), an opensource CLI tool that deals with these issues and allows to easily save, access and organize my notes.

The source code of the project is available on GitHub here.

Usage examples

Find below some examples showing the most important usage of stup.

Adding notes

# Adding a note to the default category at current date
stup add -n "Worked on issue #ABC123"

# Adding a note to the default category setting the current date explicitly
stup add today -n "Worked on issue #ABC123"

# Adding a note to the meetings category
stup add today -c "meetings" -n "2 hours with @phoebe for the project kick off"

# Adding a note to the blocking category for April 10th, 2020
stup add @ 2020-04-10 -c "blocking" -n "connectivity issues"

Showing notes

# Showing yesterday's notes
$ stup

# Showing yesterday's notes explicitly setting the date
$ stup yesterday

# Showing today's notes
$ stup today

# Showing notes on a specific date
$ stup show @ 2020-04-18

# Showing notes on a specific date for the meetings category
$ stup show @ 2020-04-18 -c "meetings"

Retrieving all notes for a period of time

# List current week's notes
stup log week

# List previous week's notes
stup log previous-week

# List notes between January 20th, 2020 and March 2nd, 2020
stup log --from 2020-01-20 --to 2020-03-02

# List meeting notes between January 20th, 2020 and March 2nd, 2020
stup log --from 2020-01-20 --to 2020-03-02 -c "meetings"

Behind the scenes

Notes are organized in categories.

When a new note is added, stup creates a markdown file and places it under the category’s directory in a sub-directory with a path based on the date.

CATEGORIES_ROOT_DIRECTORY/CATEGORY/YEAR/MONTH/YYYY-MM-DD.md

# For example, the notes of a category named "programming" April 18th, 2020 are saved under
CATEGORIES_ROOT_DIRECTORY/programming/2020/04/2020-04-18.md

This allows users to retrieve any notes added on a specific date or in a specific period for a specific or for all categories.

# Fetch notes for all categories
$ stup show @ 2020-04-18

# Fetch notes for a specific category for previous week
$ stup log previous-week -c programming

# Fetch notes for all categories for a specific period
$ stup log --from 2020-04-01 --to 2020-04-15

More information

You can:

visit the project repository on Github here.
view the full documentation of stup here.
browse the project’s issues here.

That’s all, thanks for reading! Cat photo.

Find palindrome dates in the Linux command line - explained

Thu, 06 Feb 2020 12:00:00 +0200

Yesterday I saw a great command that finds the palindrome dates between now and x days ago.

The command was posted on Twitter by @climagic (a great account to follow if you want to find awesome command line stuff).

In this post we are going to break it down and explain how it works.

What is a palindrome

Palindrome is a word/number/phrase or other sequence of characters that reads the same backward as forward. – Palindrome - Wikipedia

Few days ago, the date was 02/02/2020 which was a palindrome:

The command

printf "now - %d days\n" {1..332044} |date -f- +%Y%_m%_d$'\n'%Y%m%d |tr -d ' ' > alldates.txt; rev alldates.txt >revdates.txt; paste alldates.txt revdates.txt |awk '$1==$2{print $1}'

And here’s a more readable version using new lines after each pipe.

printf "now - %d days\n" {1..332044} |
date -f- +%Y%_m%_d$'\n'%Y%m%d |
tr -d ' ' > alldates.txt; rev alldates.txt >revdates.txt; paste alldates.txt revdates.txt |
awk '$1==$2{print $1}'

I am going to explain each part of the command separately.

Note that the output of each part is the input of the next part (following the pipe |).

printf "now - %d days\n" {1..332044}

The first part seems pretty straight forward but it does have an interesting part, the brace expansion mechanism, which I didn’t know of.

Open a terminal and type the following commands:

# From 1 to 10
$ echo {1..10}
1 2 3 4 5 6 7 8 9 10

# From a to z
$ echo {a..z}
a b c d e f g h i j k l m n o p q r s t u v w x y z

# From 10 to 20
$ echo Before-{10..20}-After
Before-10-After Before-11-After Before-12-After Before-13-After Before-14-After Before-15-After Before-16-After Before-17-After Before-18-After Before-19-After Before-20-After

As you can see, the brace expansion allows the generation of values based on a “sequence” we set.

Learn more about the Brace expansion mechanism here.

Part explained

we print the phrase “now - x days” so many times as the number of values expanded from the sequence
{1..332044} will generate 332044 values starting from 1 and increasing by 1
we add a new line at the end of each produced string

Output

now - 1 days
now - 2 days
now - 3 days
now - 4 days
now - 5 days
...
now - 332038 days
now - 332039 days
now - 332040 days
now - 332041 days
now - 332042 days
now - 332043 days
now - 332044 days

date -f- `+%Y%\_m%\_d$'\n'%Y%m%d`

In this part we use the date command to parse the previously piped output and print two lines for each date, one with padding zeros and one without zeros for single digit days and months.

Familiarize yourself with the command in your terminal:

# Show current date = now
$ date
Thu Feb  6 07:30:10 EET 2020

# Show yesterday
$ date --date="now - 1 days"
Wed Feb  5 07:31:22 EET 2020

# Show yesterday as dd/mm/yyyy (zero padding)
$ date --date="now - 1 days" +%d/%m/%Y
05/02/2020

# Show yesterday as dd/mm/yyyy (space padded)
$ date --date="now - 1 days" +%_d/%_m/%Y
 5/ 2/2020

# Show yesterday as dd/mm/yyyy (without padding)
$ date --date="now - 1 days" +%-d/%-m/%Y
5/2/2020

Part explained

we use the -f option to define the input of the date to be the lines of a file, followed by a hyphen - to set this file to be the stdin
we set the output format (what follows the plus + symbol) to be the numeric representation of the year (%Y), the month (padded with spaces: %_m, padded with zeros: %m) and the day of the month (padded with spaces: %_d, padded with zeros: %d)
the space padded format is %Y%\_m%\_d and the zero padded format is %Y%m%d
we combine these two formats for each date and we separate them with a new line $'\n' thus, for each date we parse, we produce two lines, one padded with zeros and one padded with spaces

Note: instead of padding with spaces (using the underscore _ in the format), we could use the hyphen - instead which would skip the padding of the field. This way wouldn’t have to remove the spaces as described in the next part.

Output

tr -d ' ' > alldates.txt; rev alldates.txt >revdates.txt; paste alldates.txt revdates.txt

In this part we remove the spaces produced in the previous step and we create two files, one with all the dates and one with all the dates reversed.

Then we combine these two files by merging each line of the first file with the corresponding line of the second file separated with a tab.

Familiarize yourself with the commands of this part in your terminal:

# Remove empty spaces
$ echo "Good night " | tr -d " "
Goodnight

# Remove hyphens
$ echo "Good-night" | tr -d "-"
Goodnight

# Print a-x-z where x is a number between 1 and 9
$ printf "a-%d-z\n" {1..9}
a-1-z
a-2-z
a-3-z
a-4-z
a-5-z
a-6-z
a-7-z
a-8-z
a-9-z

# and then reverse the order of the characters of each line
$ printf "a-%d-z\n" {1..9} | rev
z-1-a
z-2-a
z-3-a
z-4-a
z-5-a
z-6-a
z-7-a
z-8-a
z-9-a

Part explained

tr -d '': we remove the spaces of the input (which is the output of the previous part) and we save the output in a file named alldates.txt
rev: we reverse the order of the characters of each line of the alldates.txt file and we save the output in a new file named revdates.txt
paste: we merge the two files; each line of the alldates.txt file is merged with the corresponding line of the file revdates.txt separated by a tab (the two files have the exact number of lines).

Output

202025	520202
20200205	50200202
202024	420202
20200204	40200202
202023	320202
20200203	30200202
202022	220202
20200202	20200202
202021	120202
20200201	10200202

awk '$1==$2{print $1}'

In this final part, we use awk to print the palindromes.

Familiarize yourself with the usage of awk related to this post, in your terminal:

# Print the whole input (awk's default behavior) if the fields are equal
$ echo "a a" | awk '$1==$2'
a a

# Print the whole input (awk's default behavior) if the fields are not equal
$ echo "a a" | awk '$1!=$2'
# nothing here

# Print the whole input (awk's default behavior) if the fields are not equal
$ echo "a b" | awk '$1!=$2'
a b

# Print the first field if the fields are not equal
$ echo "a b" | awk '$1!=$2 {print $1}'
a

# Print the second field if the fields are not equal
$ echo "a b" | awk '$1!=$2 {print $2}'
b

Part explained

the previous output that is now the input of this part consists of lines and each line has two values separated by a TAB. With this kind of input, awk resolves two fields in each line. We can access these two fields using the $1 and $2 variables.
as described in a previous post, awk statements consist of a pattern-expression and an associated action.
```
<pattern/expression> { <action> }
```
If the pattern succeeds then the associated action is being executed. In this part the expression is translated as “if the two fields are equal” ($1==$2) and the action as “print the first field” (printf $1).
if the fields are equal we do have a palindrome since each pair of fields is actually a date and its reversed value.

Output

Cat photo

That’s all, thanks for reading.

References

Goodbye Irida

Thu, 23 Jan 2020 09:00:00 +0200

On Monday I had to put my beloved cat, Irida, to sleep.

Who is Irida

Twelve years ago, I wanted to get a pet. My friends helped me find one via a post about a stray young cat which was found under a truck in my area. After two days the cat was in my house and that's how one my most beloved beings came into my life.

I was thinking of names and I ended up naming her "Irida" (which is a variation of Iris) after a server in my university. It worked well for me that everybody thought the name was given due to her special look.

This blog is named after her.

Living with Irida

If you are a cat owner you must already know that you are the only person that really knows and understands his/her behavior. Cats are not as expressive as dogs are, but sooner or later we do feel their love and we can understand their mood and their needs.

In my case, living with Irida was as if I had another person in the house. We had conversations that always ended when her look was telling me "You do know I can't speak, you're speaking alone".

As the years were passing by, our relationship was changing and even more feelings were being expressed from both parts.

Every single post of this blog has been written with this thing on the side.

Whenever I was in the house, Irida was next to me. She was following me everywhere I was going.

After the first two or three years she started "requesting" my arm to sleep on it during the night.

In the winter, she was scratching the blankets to force me elevate my hand and create some kind of a nest for her to lay down.

So many more things to say in this section. View photos instead.

Hello.

Very interesting.

I fits.

Tddthhh

Bye sweater

Can't find Minerva

Shopping

Laundry

Who's there

Elastic

Where's Phoebe

Ehm

Kiss

I don't like reggae

Watching a thriller

The sickness

In September, while I was petting her, I noticed something like a pimple outside her mouth. After a very stressful process of tests instructed by our vet, she was diagnosed with Squamous cell Carcinoma on her jaw.

The cancer was really aggressive and we had to act fast. The doctors said that we can remove the bottom right part of the jaw which was the part that the tumor was located at. It was very hard to take a decision when you couldn't know how things would turn up. Would she be able to use her mouth afterwards? How much time would she gain? Would she be suffering after such a surgery?

We decided to have the surgery. And everything went fine.

The first days she couldn't eat on her own and we used a tube in order to feed her.

I feared that this might be it, she might not be able to use her mouth.

After 3 days she started eating on her own. And not only canned food which was soft. She started eating her dry food as if nothing had happened. The surgery went fine, the doctors did a really good job.

Everything was fine until recently. Irida was happy, she was playing with her toys, purring and doing her usual crazy moves when she was bored.

During Christmas though, she started keeping her mouth open. The scheduled tests (including scans) didn't show anything in her lungs or somewhere else. The doctors couldn't see anything developing in her mouth either. I was hoping that something else was the cause of this, like the feline asthma or the exposure to the heat of the radiators.

Few weeks ago though, she started having difficulties after eating: she was choking and she was heavily breathing. The doctors used general anesthesia and checked her larynx and that's where the problem was. There was a metastasis in her base of her tongue. The tumor was not huge but big enough to cause big discomfort.

Even if a surgery was doable, everyone was not convinced that it should be done. I didn't want her to suffer again with such a bad prognosis. When the moment came that even canned food diluted with water was hard to be consumed, putting her to sleep was what should be done.

What now

I cried a lot, I am in pain but as the days pass by I'm feeling a bitter sweet better. We had some really good moments till the last days. The loss would hurt me the same if not more if she died in a few years from now. I feel better thinking that she didn't die too young or in pain.

When she was two, I got another cat, Phoebe, thinking that they both would make a good company the hours that I was away from home. This never happened, Irida was the boss and Phoebe was always afraid of her. But, in hard times (ex. when the vacuum cleaner is on or when about to visit the vet) they were hiding, one next to the other as if they were hugging, under the bed.

Phoebe is now the cat of the house, enjoying a full time care. She is a totally different character, more independent but very cute.

When I feel ready again, I will get another cat so that Phoebe can hug her under the bed.

Vim

Fri, 20 Dec 2019 09:00:00 +0200

Roses are red
Violets are blue
I have stuck in vim
And so have you.

Vim ain't for newbies
But I'm a curious soul
So I went down
That shell rabbit hole.

I tried to edit hosts
Everything went wrong
The file remained open
For two hours long.

When I found the magic
Semicolon double-u q
The file was readonly
You've been there too.

The bells started ringing
As I controlled + c
What was I thinking
I WANT TO BE FREE

I had to stop the panic
Said it'll all be fine
I will just kill the process
Using minus nine.
-- iridakos

Descriptive variable names

Thu, 12 Dec 2019 09:00:00 +0200

[others]: Variable names must be descriptive.

[me]:

$help-help-help: #F1F1F1;

Movie night

Fri, 06 Dec 2019 09:00:00 +0200

Pizza commit

Wed, 04 Dec 2019 11:00:00 +0200

Me:

$ git commit -m "Closes issue #13"
  * Remove obsolete reference to core entity
  * Refactor module generating values
  * Log every ac...

Colleague: “Hey, the pizza is heeeere”

Me:

* backspaces *
$ git commit -m "Fixes"

What do you get after you lose your data from an SSD?

Wed, 04 Dec 2019 09:00:00 +0200

PTSSD

I am talking to my code

Tue, 03 Dec 2019 21:00:00 +0200

I am talking to my code but according to my cat, this is the least worrying.

i

Fri, 22 Nov 2019 17:00:00 +0200

Roses are red
Violets are blue
I was looping forever
And then I found you.

i was your name
I think j was next to you
Born inside a for
Died in there too.

I saw you getting bigger
Loop over loop over loop
And j was getting smaller
You were a great group.

And then you just vanished
You left me there alone
Condition wasn't true
At least nothing was thrown.

Mongoid - Inheritance: change embedded document's type via nested attributes

Fri, 22 Nov 2019 09:00:00 +0200

I recently faced some issues when trying to update a nested document’s type via nested attributes using the mongoid gem. Bare with me if this sentence doesn’t make any sense yet.

Use case

Suppose we have a document named Person that embeds a document that can be any of the types Book or BoardGame which inherit from the class Item.

Item

class Item
  include Mongoid::Document

  embedded_in :person, inverse_of: :item

  field :name
end

Book

class Book < Item
  field :authors, type: Array
end

BoardGame

class BoardGame < Item
  field :players, type: Integer
end

Person

class Person
  include Mongoid::Document

  embeds_one :item, inverse_of: :person
  accepts_nested_attributes_for :item, allow_destroy: true
end

The problems

To simplify the post I won’t go with the scenario of building the forms and the controller actions to demonstrate the problems but instead I will simulate the behavior in the rails console.

Let’s create a Person with a Book as an Item.

>> person = Person.create!({
  item_attributes: {
    _type: "Book",
    name: "Jitterbug Perfume",
    authors: ["Tom Robbins"]
  }
})
=> #<Person _id: 5dd7b01ec2889856ab8a619f, >
>> person.item
=> #<Book _id: 5dd7ae76c2889856ab8a619e, name: "Jitterbug Perfume", _type: "Book", authors: ["Tom Robbins"]>

Failing attribute assignments

Let’s try to change the person’s item from Book to BoardGame with 5 players.

>> person.update_attributes({
  item_attributes: {
    _type: "BoardGame",
    name: "Ticket to Ride",
    players: 5
  }
})
Traceback (most recent call last):
        1: from (irb):9
Mongoid::Errors::UnknownAttribute ()
message:
  Attempted to set a value for 'players' which is not allowed on the model Book.
summary:
  Without including Mongoid::Attributes::Dynamic in your model and the attribute does not already exist in the attributes hash, attempting to call Book#players= for it is not allowed. This is also triggered by passing the attribute to any method that accepts an attributes hash, and is raised instead of getting a NoMethodError.
resolution:
  You can include Mongoid::Attributes::Dynamic if you expect to be writing values for undefined fields often.

This didn’t work, the assignment of the nested attributes item_attributes as you can see from the error message were applied in the model Book.

The fact that we changed the _type attribute of the document doesn’t mean that the object in memory also was magically transformed from a Book to a BoardGame.

Document attribute leftovers

Let’s try to change the person’s item from Book to BoardGame but this time without the players to see if this fixes the issue.

>> person.update_attributes({
  item_attributes: {
    _type: "BoardGame",
    name: "Ticket to Ride"
  }
})
=> true
>> person.item
=> #<Book _id: 5dd7b270c2889858a08a619e, name: "Ticket to Ride", _type: "BoardGame", authors: ["Tom Robbins"]>

This seems to have worked even though the result of the person.item accessor gave a Book document with _type of a BoardGame and with an attribute authors present.

Let’s reload to see if the document is going to be properly instantiated.

>> person.reload.item
=> #<BoardGame _id: 5dd7b270c2889858a08a619e, name: "Ticket to Ride", _type: "BoardGame", players: nil>

Seems to be fine but what is going on with the actual document attributes?

>> person.item.attributes
=> {"_id"=>BSON::ObjectId('5dd7b270c2889858a08a619e'), "_type"=>"BoardGame", "name"=>"Ticket to Ride", "authors"=>["Tom Robbins"]}

As you can see, the authors attribute (that we had initially set) hasn’t been removed when we changed the type of the Item from Book to BoardGame.

Wrong validators

Let’s change the BoardGame document so that it validates the presence of players

class BoardGame < Item
  field :players, type: Integer

  validates :players, presence: true
end

Our person now has an item of type BoardGame. We will now try to change it to a Book

>> person.attributes = {
  item_attributes: {
    _type: "Book",
    name: "Jitterbug Perfume"
  }  
}
=> {:item_attributes=>{:_type=>"Book", :name=>"Jitterbug Perfume"}}
>> person.valid?
=> false
>> person.errors.full_messages
=> ["Item is invalid"]
>> person.item.errors.full_messages
=> ["Players can't be blank"]

As described in the previous section, the fact that the _type attribute changed doesn’t mean that the actual object in memory changed accordingly. Upon save of the parent document, the item is still an instance of the previous _type which was BoadGame thus the validations that take place are not the ones defined in the new Book class but those defined in the BoardGame.

This also means that if we had validations in the Book class too, they wouldn’t execute in this scenario as well.

Investigation

I tried to google the issue (I couldn’t even construct a proper query) to see how others dealt with this but I didn’t find anything helpful and I decided to dive in the source of mongoid in order to locate the code that deals with the nested assignments and possibly create a monkey patch.

First, I searched for the file that defines the accepts_nested_attributes_for method that we used in the Person class.

Found in mongoid/attributes/nested.rb

def accepts_nested_attributes_for(*args)
  options = args.extract_options!.dup
  options[:autosave] = true if options[:autosave].nil?

  options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
  args.each do |name|
    meth = "#{name}_attributes="
    self.nested_attributes["#{name}_attributes"] = meth
    association = relations[name.to_s]
    raise Errors::NestedAttributesMetadataNotFound.new(self, name) unless association
    autosave_nested_attributes(association) if options[:autosave]

    re_define_method(meth) do |attrs|
      _assigning do
        if association.polymorphic? and association.inverse_type
          options = options.merge!(:class_name => self.send(association.inverse_type))
        end
        association.nested_builder(attrs, options).build(self)
      end
    end
  end
end

The line that is mostly related to our issue from the above snippet is this:

association.nested_builder(attrs, options).build(self)

which is executed upon attribute assignment.

Since the item association defined in the Person document is of type embeds_one, I located its code to find the nested_builder method.

Found it at mongoid/association/embedded/embeds_one.rb

def nested_builder(attributes, options)
  Nested::One.new(self, attributes, options)
end

Ok, now we have to see what is going on inside the #build method of the mongoid/association/nested/one.rb file.

def build(parent)
  return if reject?(parent, attributes)
  @existing = parent.send(association.name)
  if update?
    attributes.delete_id
    existing.assign_attributes(attributes)
  elsif replace?
    parent.send(association.setter, Factory.build(@class_name, attributes))
  elsif delete?
    parent.send(association.setter, nil)
  end
end

def replace?
  !existing && !destroyable? && !attributes.blank?
end

def update?
  existing && !destroyable? && acceptable_id?
end

The part that is related to the behavior we want to alter is the one inside the if update? .. elsif replace? block:

...
if update?
  attributes.delete_id
  existing.assign_attributes(attributes)
elsif replace?
  parent.send(association.setter, Factory.build(@class_name, attributes))
...  

This is where the attribute assignment in the existing embedded document takes place.

Desired behavior

Since we are talking about embedded documents, when changing the type instead of updating the existing document’s attributes we can easily replace it at once with a new instance of the proper class.

From that point on, we won’t have to deal with

the invalid attribute assignments
removing the old attributes that are not present in the new document type
fixing the usage of wrong validators.

The replaced object will be properly instantiated and assigned to the parent.

Solution

To change to the desired aforementioned behavior, I patched the Mongoid::Association::Nested::One class.

I created a module (I suggest you read this great article about monkey patching without making a mess) under lib/core_extensions/mongoid/association/nested/one/embedded_one_change_type.rb with the following contents:

module CoreExtensions
  module Mongoid
    module Association
      module Nested
        module One
          module EmbeddedOneChangeType
            attr_accessor :changing_type

            def build(parent)
              return if reject?(parent, attributes)

              @existing = parent.send(association.name)
              # Retrieve the new class
              new_class = attributes.dig(:_type)&.constantize
              # Resolve whether we should be changing type or not
              @changing_type = new_class && @existing.class != new_class && association.embedded?

              if update?
                attributes.delete_id
                existing.assign_attributes(attributes)
              elsif replace?
                parent.send(association.setter, ::Mongoid::Factory.build(@class_name, attributes))
              elsif delete?
                parent.send(association.setter, nil)
              end
            end

            def replace?
              # Replace if the association hasn't been set or if we are changing type.
              (!existing || changing_type) && !destroyable? && !attributes.blank?
            end

            def update?
              # Don't update the document if we are changing type
              existing && !changing_type && !destroyable? && acceptable_id?
            end
          end
        end
      end
    end
  end
end

and inside an initializer I patched the proper mongoid class with:

Mongoid::Association::Nested::One.prepend CoreExtensions::Mongoid::Association::Nested::One::EmbeddedOneChangeType

Explanation

We override the build method in order to additionally resolve if we are changing type in an embedded association or not:

@changing_type = new_class && @existing.class != new_class && association.embedded?

We are changing type if:

there’s a _type attribute present and
the _type’s value is different than the existing object’s one and
the association is embedded

Then we alter the methods that decide whether a document should be updated or replaced, so that they take in consideration if we are @changing_type (as calculated above) or not:

def update?
  # Don't update the document if we are changing type
  existing && !changing_type && !destroyable? && acceptable_id?
end

and

def replace?
  # Replace if the association hasn't been set or if we are changing type.
  (!existing || changing_type) && !destroyable? && !attributes.blank?
end

Feedback and comments

I am not very fond of monkey patching but this was my quick workaround. If you believe that the desired behavior as described here (for the `embedded_one` associations) is invalid or if you deal with this problem in any other way, I'd be glad to here about it.

For suggestions, feedback, comments, typos etc. please use this issue on GitHub.

Thanks for visiting!

Almost forgot, cat photo.

Two step authentication in Ubuntu

Mon, 04 Nov 2019 09:00:00 +0200

There are two cat beds, many chairs, a sofa but no. She will sit there.

That’s how I have two step authentication for my Ubuntu.

Hug the cat

Fri, 01 Nov 2019 10:00:00 +0200

This cat has been in my life for 12 years now.

Whenever I get back home and sit on the sofa, she jumps on my chest and starts licking my nose and my eyebrows.

She stays there until the moment she realizes I could be feeding her instead of relaxing.

Mountains

Mon, 14 Oct 2019 17:00:00 +0300

After painting the meadow with acrylic colors, I bought oil colors which are the ones Bob Ross uses in “The joy of painting” show. This time I followed the episode 10 from season 13 of the show, called “Mountain Summit”.

I am very satisfied by the outcome but being a beginner, I faced a lot of difficulties and the painting has a number of errors.

Facts

I used

the wet-on-wet technique
oil colors
50x80 canvas

Difficulties

My paintbrushes were not the same as Bob Ross’ ones (size and material) and the paint didn’t apply the way I wanted (I will search for tips and tricks when it comes to buying paintbrushes for oil colors)
I couldn’t find all the colors listed in the episode and I had to mix mine many times to achieve something similar
I had such a huge difficulty creating the bushes. I am still not sure what the exact problem was but I believe it is a combination of the following three items:
- wrong paintbrush
- very thick paint (according to Bob Ross, thin paint sticks on thick)
- wrong moves by me (maybe more/less pressure on the paintbrush)
The mountains, even though they look nice, were so hard to be created with the palette knife. It surely has to do with practice.

Errors

The tallest mountain has an unnatural curve on its bottom side which doesn’t make sense
The left side of the mountains ends somewhere behind the trees without a logical explanation (in the episode the trees cover all the left part of the painting)
The path in the front right section of the painting is a failure. In case you don’t locate it (which is very reasonable), I am talking about the black and gray waterfall that starts at the root of a tree. Yes, that is supposed to be a path.
In the same part of the painting, the bushes didn’t want to stick at all. I cleaned and re-painted the section at least 3 times.

Resources

Bob Ross - Mountain Summit (Season 13 Episode 10): https://www.youtube.com/watch?v=kasGRkfkiPM
Bob Ross - Final Reflections (Season 1 Episode 13) A "must see" episode because it's actually Q&A of what might go wrong.: https://www.youtube.com/watch?v=IEQWfszfRlA

Meadow

Fri, 11 Oct 2019 10:00:00 +0300

I have always liked painting but I had never devoted any time to this hobby. I was painting once every 2 or more years but with dissappointing results. Few days ago I tried to create a painting of my cat and I enjoyed both the process and the result.

I decided to pursue this hobby and yesterday, I followed an episode of Bob Ross’ show “The joy of painting” (most if not all episodes are available on Youtube). I surprised myself with the outcome even though it’s not perfect, it’s not professional and it’s very different compared to the one that Bob Ross created in the episode.

I really enjoyed painting this meadow. I was listening to some of my favorite music and I felt so focused and relaxed leaving every other thought on the side for about 5 hours (I didn’t realize the time passing by so fast).

Facts

I followed the “Meadow Stream” episode which is the episode 13 from season 5
I used water colors (tempera) instead of oil colors (that are used in the episode)
I skipped the stream because I wasn’t brave enough, I felt that I would destroy the painting
The clouds are happy little accidents, I don’t have an answer if you ask me to tell you how I created them. They were not supposed to look like this but they turned out OK
I need to buy some equipment (angled palette knife and some paintbrushes) because the ones I had, couldn’t produce the same results as shown in the episode
If I was asked to paint a meadow, I would draw nothing looking like this. Having a guide, especially if you are a newbie like me is great and really helpful. I believe that practicing this way is essential before diving to custom creations (at least for me).

Resources

Bob Ross - Meadow Stream (Season 5 Episode 13): https://www.youtube.com/watch?v=87MMbN1bQCs

Drawing my cat

Mon, 07 Oct 2019 10:00:00 +0300

On Saturday I felt like drawing and (no surprises here) I decided to create a painting of my cat.

Without further ado, this is the result.

At the top center and right section of the photo you may notice the paws of my cat which was present during the whole process and which actually is responsible for some of the inconsistencies of the painting (blaming the cat). Imagine a cat having a moving paint brush in front of her and not touching it (never happens).

I would have taken photos showing the progress of the painting but everything was a mess. There was paint everywhere: on my hands, on my clothes, on the cat, on the table I put the canvas on and on the floor too. Everything I touched was turning to blue, brown or white.

I used a painting set that was given to me as a present which had many stuff inside. At some point I mixed acrylic with watercolor paints because they looked the same and I realized it only after bubbles started showing up. The victim was the sky in the window. I tried to remove the pimples but still the new paint didn’t apply well afterwards. I’m very curious to see if the sky will look like this as the days pass by.

Given the outcome, it’s pretty obvious that I am a newbie and I’m missing a lot of basics. I have no technique. I paint rarely but this time I really enjoyed it and even though this looks nothing like Irida (my cat), at least it does look like a cat and I find it “presentable” as opposed to my previous painting attempts. That is a personal success.

I decided to devote some time to learn at least the basics, view some tutorials and of course to practice on plain objects before moving to more complex scenes.

Post Scriptum

You are allowed to laugh with the fact that I used the art tag in this post.

This is Irida on the table of art on a previous attempt.

Interesting painting resources

https://www.youtube.com/watch?v=VufykZdkmZ0: A really good video showing how to draw a cat (I watched the video today, level of personal disappointment: 100%).
https://www.youtube.com/watch?v=oWuwxSJTyeQ: Another beautiful video showing how to easily create a painting with a very nice landscape with relatively simple steps.

Another Friday has arrived

Fri, 13 Sep 2019 00:00:00 +0300

How to write better emails

Wed, 26 Jun 2019 16:30:00 +0300

Email communication is not my favorite but since I can’t avoid it, I am trying to compose messages in a way that I think it makes it easier for both me and the recipient:

to quickly address what is being communicated
avoid misunderstandings
save time

Here are some tips. They don’t apply to all type of messages, I provide before and after examples to better describe each case.

Emphasize text with bold/underlined font

Emphasizing the appropriate parts of a message, especially when it’s a long one, you help readers quickly get an idea of what the email is about and easily locate the important stuff after going back to it at some point in the future.

Examples

Before

Hello all,

I noticed that there are many logs for blabla the last few days and I don't think that it is normal. I believe the problem is the updated version of gem blabla.

I have opened an issue describing the case in Redmine (#455) in the current version.
Feel free to change its priority in case blabla.

Thanks,
Lazarus

After

Hello all,

I noticed that there are many logs for blabla the last few days and I don't think that it is normal. I believe the problem is the updated version of gem blabla.

I have opened a Redmine issue (#455) describing the case in the current version.
Feel free to change its priority in case blabla.

Thanks,
Lazarus

Use specific dates instead of `yesterday`, `tomorrow` etc

The moment you send an email is not the moment that it will be read by its recipients. Avoid using only temporal adverbs/nouns like yesterday, today, tomorrow, two hours ago etc but include also the specific dates/times otherwise they might be misunderstood or require from recipients to check the email’s sent date/time to calculate the actual time.

Examples

Before

Dear QA,

Yesterday we released a fix for the bug 455 on staging and we plan to release it next Monday if you give us the green light by tomorrow end of day.

Thanks,
Lazarus

After

Dear QA,

Yesterday, June 25th, 2019 we released a fix for the bug #455 on staging and we plan to release it on production next Monday (July 1st, 2019) if you give us the green light by tomorrow (June 27th, 2019) end of day.

Thanks,
Lazarus

Use links for references

Use bookmarkable links when you refer to something that would eventually require from the recipient to search for in another platform.

This has two benefits:

Save time
Eliminate ambiguous references

Examples

Before

Dear Phoebe,

I didn't understand the process described on the issue about the logging bug. Irida's comment was not very clear either. Can you please help me?

Thanks,
Lazarus

After

Dear Phoebe,

I didn't understand the process described on the issue about the logging bug (Redmine #453). This comment from Irida was not very clear either. Can you please help me?

Thanks,
Lazarus

Structure long messages

Long messages are in general not very effective and parts of them are prone to be ignored.

When I have to compose such a message I try to categorize the text in contextual sections and then structure them using headers and paragraphs allowing readers to navigate to them at a glance.

Examples

Before

Dear team,

Last week we had a problem with the logs in the production environment. I am talking about the Redmine issue #453. We noticed a huge increase in the log messages blabla leading to delayed responses because blah blah blah. At some point the server run out of disk and everything fell apart blah blah blah. Administrators backed up the logs and removed them from the server to blah blah blah. We started investigating what is going on immediately and after two days we managed to reproduce the error in the staging environment as well. The problem was the usage of an external library that had a bug which blah blah blah. We removed the library and the bug was no longer reproducable in the staging environment. The buggy library was blah blah blah. We released the fix yesterday and everything seems to be back to normal. We also added some scripts that will notify us immediately if such conditions start to emerge.

Thank you for your time,
Lazarus

After

Dear team,

Background
Last week we had a problem with the logs in the production environment. We noticed a huge increase in the log messages blabla.

Consequences
The increase led to delayed responses because blah blah blah. At some point the server run out of disk and everything fell apart blah blah blah.

Cause of the problem
We started investigating what is going on immediately and after two days we managed to reproduce the error in the staging environment as well.
The problem was the usage of an external library that had a bug which blah blah blah. The buggy library was blah blah blah.

Actions taken

1. Administrators backed up the logs and removed them from the server to blah blah blah.
2. We removed the library and the bug was no longer reproducible in the staging environment.
3. We released the fix yesterday, June 26th, 2019.
4. We also added some scripts that will notify us on time if such conditions start to emerge.

Current status
The server is up and running, everything seems to be back to normal.

More info
Related Redmine issue #453
External library - Official bug report

Thank you for your time,
Lazarus

Be specific on what you request from whom

I have seen many many many emails for which:

the sender wanted something by someone
the recipients
- didn’t think they were the ones to provide it
- understood something else than what the sender asked for

I try to be very specific and provide details (when possible) on what I need and when there’s more than one recipients I refer to each one explicitly using @.

Examples

Before

Dear all,

I have pushed a commit that possibly fixes the bug with the logging in staging. I won't be here tomorrow so can you review and release if ok?

Bye.

After

Hey,

I have pushed a commit that possibly fixes the bug (Redmine #453) with the logging in staging.

Since I won't be here tomorrow, June 27th, can you please:

@captain: review the commit
@qa: run the suite to validate the fix
@devs: proceed with the production release on June 28th given the green light by the QA team?

Sorry for the inconvenience,
Lazarus

Thank you,

Lazarus

Post Scriptum

Find attached a photo of my cats.

Comments and feedback

For feedback, comments, typos etc. please use this issue.

Thanks for visiting!

Pair programming

Wed, 12 Jun 2019 00:00:00 +0300

Monday Motivation

Mon, 03 Jun 2019 00:00:00 +0300

How to remove duplicate lines from files preserving their order

Thu, 16 May 2019 11:30:00 +0300

Suppose you have a text file and you need to remove all of its duplicate lines.

TL;DR

To remove the duplicate lines preserving their order in the file use:

awk '!visited[$0]++' your_file > deduplicated_file

How it works

The script keeps an associative array with indices equal to the unique lines of the file and values equal to their occurrences. For each line of the file, if the line occurrences are zero then it increases them by one and prints the line, otherwise it just increases the occurrences without printing the line.

I was not familiar with awk and I wanted to understand how is this accomplished with such a short script (awkward). I did my research and here is what is going on:

the awk “script” !visited[$0]++ is executed for each line of the input file
visited[] is a variable of type associative array (a.k.a. Map). We don’t have to initialize it, awk will do this for us the first time we access it.
the $0 variable holds the contents of the line currently being processed
visited[$0] accesses the value stored in the map with key equal to $0 (the line being processed), a.k.a. the occurrences (which we set below)
the ! negates the occurrences value:
- In awk, any nonzero numeric value or any nonempty string value is true
- By default, variables are initialized to the empty string, which is zero if converted to a number
- That being said:
  - if visited[$0] returns a number greater than zero, this negation is resolved to false.
  - if visited[$0] returns a number equal to zero or an empty string, this negation is resolved to true.
the ++ operation increases the variable’s value (visited[$0]) by one.
- If the value is empty, awk converts it to 0 (number) automatically and then it gets increased.
- Note: the operation is executed after we access the variable’s value.

Summing up, the whole expression evaluates to:

true if the occurrences are zero/empty string
false if the occurrences are greater than zero

awk statements consist of a pattern-expression and an associated action.

<pattern/expression> { <action> }

If the pattern succeeds then the associated action is being executed. If we don’t provide an action, awk by default prints the input.

An omitted action is equivalent to { print $0 }

Our script consists of one awk statement with an expression, omitting the action. So this:

awk '!visited[$0]++' your_file > deduplicated_file

is equivalent to this:

awk '!visited[$0]++ { print $0 }' your_file > deduplicated_file

For every line of the file, if the expression succeeds the line is printed to the output. Otherwise, the action is not executed, nothing is printed.

Why not use the `uniq` command?

The uniq commands removes only the adjacent duplicate lines. Demonstration:

$ cat test.txt
A
A
A
B
B
B
A
A
C
C
C
B
B
A
$ uniq < test.txt
A
B
A
C
B
A

Other approaches

Using the `sort` command

We can also use the following sort command to remove the duplicate lines but the line order is not preserved.

sort -u your_file > sorted_deduplicated_file

Using `cat`, `sort` and `cut`

The previous approach would produce a de-duplicated file whose lines would be sorted based on the contents. Piping a bunch of commands we can overcome this issue:

cat -n your_file | sort -uk2 | sort -nk1 | cut -f2-

How it works

Suppose we have the following file:

abc
ghi
abc
def
xyz
def
ghi
klm

cat -n test.txt prepends the order number in each line.

abc
ghi
abc
def
xyz
def
ghi
klm

sort -uk2 sorts the lines based on the second column (k2 option) and keeps only the first occurrence of the lines with the same second column value (u option)

abc
def
ghi
klm
xyz

sort -nk1 sorts the lines based on their first column (k1 option) treating the column as a number (-n option)

abc
ghi
def
xyz
klm

Finally, cut -f2- prints each line starting from the second column until its end (-f2- option: note the - suffix which instructs to include the rest of the line)

abc
ghi
def
xyz
klm

References

That’s all. Cat photo.

Comments and feedback

For feedback, comments, typos etc. please use this issue.

Thanks for visiting!

How to manage nested objects in Elasticsearch documents

Thu, 02 May 2019 15:30:00 +0300

In this post we are going to manage nested objects of a document indexed with Elasticsearch.

The nested type is a specialised version of the object datatype that allows arrays of objects to be indexed in a way that they can be queried independently of each other. – Nested datatype - Official Elasticsearch reference

Prerequisites

To follow this post you need:

an up and running Elasticsearch instance
- I use 6.7 here
an up and running Kibana instance to interact with Elasticsearch

Preparation

The document of our index will represent a human and its nested objects will be cats (no surprises).

Create the index

Open your Kibana dev console and type the following to create the index.

# Create the index
PUT iridakos_nested_objects
{
  "mappings": {
    "human": {
      "properties": {
        "name": {
          "type": "text"
        },
        "cats": {
          "type": "nested",
          "properties": {
            "colors": {
              "type": "integer"
            },
            "name": {
              "type": "text"
            },
            "breed": {
              "type": "text"
            }
          }
        }
      }
    }
  }
}

Human has:

a name property of type text
a cats property of type nested

Each cat has:

a colors property of type integer
a name property of type text
a breed property of type text

Add a human

In the Kibana console, execute the following to add a human with three cats.

# Index a human
POST iridakos_nested_objects/human/1
{
  "name": "iridakos",
  "cats": [
    {
      "colors": 1,
      "name": "Irida",
      "breed": "European Shorthair"
    },
    {
      "colors": 2,
      "name": "Phoebe",
      "breed": "European"
    },
    {
      "colors": 3,
      "name": "Nino",
      "breed": "Aegean"
    }
  ]
}

Confirm the insertion with:

GET iridakos_nested_objects/human/1

You should see something like this:

{
  "_index": "iridakos_nested_objects",
  "_type": "human",
  "_id": "1",
  "_version": 1,
  "found": true,
  "_source": {
    "name": "iridakos",
    "cats": [
      {
        "colors": 1,
        "name": "Irida",
        "breed": "European Shorthair"
      },
      {
        "colors": 2,
        "name": "Phoebe",
        "breed": "European"
      },
      {
        "colors": 3,
        "name": "Nino",
        "breed": "Aegean"
      }
    ]
  }
}

Done, moving on.

Managing nested objects

Add a new nested object

Suppose that iridakos got a new Persian cat named Leon. To add it in iridakos’ collection of cats we will use the Update API.

In Kibana:

# Add a new cat
POST iridakos_nested_objects/human/1/_update
{
  "script": {
    "source": "ctx._source.cats.add(params.cat)",
    "params": {
      "cat": {
        "colors": 4,
        "name": "Leon",
        "breed": "Persian"
      }
    }
  }
}

Notes:

We accessed the nested cat objects of our human with ctx._source.cats. This gave us a collection
We executed the add method on the collection to add a new cat
The properties of the new cat (params.cat) were passed as parameters in the params attribute of the request under the attribute cat.

Confirm the addition with:

GET iridakos_nested_objects/human/1

Cat added:

{
  "_index": "iridakos_nested_objects",
  "_type": "human",
  "_id": "1",
  "_version": 2,
  "found": true,
  "_source": {
    "name": "iridakos",
    "cats": [
      {
        "colors": 1,
        "name": "Irida",
        "breed": "European Shorthair"
      },
      {
        "colors": 2,
        "name": "Phoebe",
        "breed": "European"
      },
      {
        "colors": 3,
        "name": "Nino",
        "breed": "Aegean"
      },
      {
        "colors": 4,
        "name": "Leon",
        "breed": "Persian"
      }
    ]
  }
}

Remove a nested object

Suppose we want to remove Nino from the human’s cat collection.

In Kibana:

# Remove Nino
POST iridakos_nested_objects/human/1/_update
{
  "script": {
    "source": "ctx._source.cats.removeIf(cat -> cat.name == params.cat_name)",
    "params": {
      "cat_name": "Nino"
    }
  }
}

Notes:

We accessed the nested cat objects of our human with ctx._source.cats. This gave us a collection
We executed the removeIf method on the collection to conditionally remove an item
We provided a Predicate to the removeIf method in which we specify which items we want to remove. This predicate will be executed on each item of the collection and resolves to a Boolean value. If the resolution is true then the item will be removed. In our case, the condition is a simple equality check on the cat’s name attribute.
The cat_name was passed as a parameter (params.cat_name) instead of fixing it to the script source.

Confirm the addition with:

GET iridakos_nested_objects/human/1

Cat removed:

{
  "_index": "iridakos_nested_objects",
  "_type": "human",
  "_id": "1",
  "_version": 3,
  "found": true,
  "_source": {
    "name": "iridakos",
    "cats": [
      {
        "colors": 1,
        "name": "Irida",
        "breed": "European Shorthair"
      },
      {
        "colors": 2,
        "name": "Phoebe",
        "breed": "European"
      },
      {
        "colors": 4,
        "name": "Leon",
        "breed": "Persian"
      }
    ]
  }
}

Update a nested object

Suppose we want to change all cat breeds from European to European Shorthair (Phoebe is the only one in our case).

# Update breed
POST iridakos_nested_objects/human/1/_update
{
  "script": {
    "source": "def targets = ctx._source.cats.findAll(cat -> cat.breed == params.current_breed); for(cat in targets) { cat.breed = params.breed }",
    "params": {
      "current_breed": "European",
      "breed": "European Shorthair"
    }
  }
}

Notes:

We accessed the nested cat objects of our human with ctx._source.cats. This gave us a collection
We executed the findAll method on the collection to select specific items
We provided a Predicate to the findAll method in which we specify which items we want to select. This predicate will be executed on each item of the collection and resolves to a Boolean value. If the resolution is true then the item will be selected. In our case, the condition is a simple equality check on the cat’s breed attribute.
The current_breed was passed as a parameter (params.current_breed) instead of fixing it to the script source.
We then loop on the selected cats (whose breed attribute has value European) and change their breed to the new value which we passed by another parameter breed.

Confirm the change:

GET iridakos_nested_objects/human/1

Cat updated:

{
  "_index": "iridakos_nested_objects",
  "_type": "human",
  "_id": "1",
  "_version": 5,
  "found": true,
  "_source": {
    "name": "iridakos",
    "cats": [
      {
        "colors": 1,
        "name": "Irida",
        "breed": "European Shorthair"
      },
      {
        "colors": 2,
        "name": "Phoebe",
        "breed": "European Shorthair"
      },
      {
        "colors": 4,
        "name": "Leon",
        "breed": "Persian"
      }
    ]
  }
}

Update multiple attributes of nested objects fulfilling multiple conditions

Now, in a more advanced example, we are going to use a more flexible script to:

target objects based on multiple conditions (here colors and breed)
update more than one attributes (here colors and breed)

Suppose we want to change the breed of cats who have 4 colors and their breed is Persian to Aegean and their colors to 3.

The script we will use is the following:

# Update multiple attributes with multiple conditions
POST iridakos_nested_objects/human/1/_update
{
  "script": {
    "source": "def targets = ctx._source.cats.findAll(cat -> { for (condition in params.conditions.entrySet()) { if (cat[condition.getKey()] != condition.getValue()) { return false; } } return true; }); for (cat in targets) { for (change in params.changes.entrySet()) { cat[change.getKey()] = change.getValue() } }",
    "params": {
      "conditions": {
        "breed": "Persian",
        "colors": 4
      },
      "changes": {
        "breed": "Aegean",
        "colors": 3
      }
    }
  }
}

For convenience, here’s the script source with proper indentation.

def targets = ctx._source.cats.findAll(cat -> {
                                         for (condition in params.conditions.entrySet()) {
                                           if (cat[condition.getKey()] != condition.getValue()) {
                                             return false;
                                           }
                                         }
                                         return true; });
for (cat in targets) {
 for (change in params.changes.entrySet()) {
   cat[change.getKey()] = change.getValue()
 }
}

Notes:

We select which cats we want to update by checking that their properties have the value specified in the params.conditions parameter.
For each selected cat, we change its attributes’ values as specified in the params.changes parameter.

Confirm:

GET iridakos_nested_objects/human/1

Cat updated.

{
  "_index": "iridakos_nested_objects",
  "_type": "human",
  "_id": "1",
  "_version": 5,
  "found": true,
  "_source": {
    "name": "iridakos",
    "cats": [
      {
        "colors": 1,
        "name": "Irida",
        "breed": "European Shorthair"
      },
      {
        "colors": 2,
        "name": "Phoebe",
        "breed": "European Shorthair"
      },
      {
        "name": "Leon",
        "colors": 3,
        "breed": "Aegean"
      }
    ]
  }
}

Useful links

That’s all! Cat photo.

Comments and feedback

For feedback, comments, typos etc. please use this issue.

Thanks for visiting!

Monday. Again.

Mon, 15 Apr 2019 00:00:00 +0300

How to alias and navigate to directories with autocomplete in Linux

Wed, 10 Apr 2019 16:00:00 +0300

I use the terminal a lot and in my day to day work I tend to navigate to the same bunch of directories.

There are some awesome tools out there (like autojump or z) but sometimes, especially when the directories are similarly named, there is a need to be explicit to navigate to the proper one.

I decided to write a script to overcome this issue and to avoid having to edit my .bash* files to manage aliases each time I wanted to add or remove a directory.

goto

goto is a shell utility to quickly navigate to aliased directories with autocomplete (tab completion).

goto repo at GitHub

User registers directory aliases, for example:

goto --register dev /home/iridakos/development

and then cds to that directory with:

goto dev

Find below documentation on the script but make sure you check the script’s documentation page for updates.

Sorry for the name, I know it brings back memories but it’s not what it seems :)

Installation

To install goto all you have to do is clone the repository locally:

git clone https://github.com/iridakos/goto.git

navigate to it

cd goto

and execute:

sudo ./install

You need to restart your shell after installation.

Usage

Change to an aliased directory
Register an alias
Unregister an alias
List aliases
Expand an alias
Cleanup
Help
Version
Extras
- Push before changing directories
- Revert to a pushed directory

Change to an aliased directory

To change to an aliased directory, type:

goto <alias>

Example

goto dev

Register an alias

To register a directory alias, type:

goto -r <alias> <directory>

goto --register <alias> <directory>

Example

goto -r blog /mnt/external/projects/html/blog

goto --register blog /mnt/external/projects/html/blog

Notes

goto expands the directories hence you can easily alias your current directory with:
```
goto -r last_release .
```
and it will automatically be aliased to the whole path.
Pressing the tab key after the alias name, you have the default directory suggestions by the shell.

Unregister an alias

To unregister an alias, use:

goto -u <alias>

goto --unregister <alias>

Example

goto -u last_release

goto --unregister last_release

Notes

Pressing the tab key after the command (-u or --unregister), the completion script will prompt you with the list of registered aliases for your convenience.

List aliases

To get the list of your currently registered aliases, use:

goto -l

goto --list

Expand an alias

To expand an alias to its value, use:

goto -x <alias>

goto --expand <alias>

Example

goto -x last_release

goto --expand last_release

Cleanup

To cleanup the aliases from directories that are no longer accessible in your filesystem, use:

goto -c

goto --cleanup

Help

To view the tool’s help information, use:

goto -h

goto --help

Version

To view the tool’s version, use:

goto -v

goto --version

Extras

Push before changing directories

To first push the current directory onto the directory stack before changing directories, type:

goto -p <alias>

goto --push <alias>

Revert to a pushed directory

To return to a pushed directory, type:

goto -o

goto --pop

Notes

This command is equivalent to popd, but within the goto command.

Behind the scenes

Upon installation, a line is appended to your .bashrc file which sources the script, registering a goto function responsible for changing the directory based on the defined aliases of the database.

The script creates a directory alias database file under ~/.goto. Every register or unregister action modifies this file.

The script also uses the Bash programmable completion feature to define tab completions resolved via extraction of the aliases defined in the goto database file.

That’s all! Cat photo.

Code and comments

You can find the code of goto at https://github.com/iridakos/goto.

For feedback, comments, typos etc. please open an issue in the repository.

Thanks for visiting!

Dockerizing a Rails application

Sun, 07 Apr 2019 04:00:00 +0300

Hey!

In this post we are going to:

create a docker image for the Rails chat application that we created in the previous post
configure the Docker environment and run the application by:
- creating a container for the PostgreSQL database
- creating a container for the Redis server
- creating a container with the required configuration from the image we built

Prerequisites

Install docker

The first thing you need in order to follow this tutorial is to install Docker on your machine.

We are going to use the Docker Community Edition. Follow the installation instructions matching your system.

I’m on Ubuntu 18.04 LTS so following the instructions, I had to:

Uninstall previous versions with:

sudo apt-get remove docker docker-engine docker.io containerd runc

I chose to install the application using the repository.

sudo apt-get update

sudo apt-get install \
     apt-transport-https \
     ca-certificates \
     curl \
     gnupg-agent \
     software-properties-common

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

and I verified that I had the key with the proper fingerprint after executing:

sudo apt-key fingerprint 0EBFCD88

I set up the repository with:

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

The installation took place with these commands:

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

I checked that the installation was successful with:

$ sudo docker run hello-world

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:...
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Important note

Upon installation, a new user group was created with the name docker. If you want to allow users to do docker stuff without using sudo, you have to do some extra configuration (read more here) but keep in mind that:

The docker group grants privileges equivalent to the root user. For details on how this impacts security in your system, see Docker Daemon Attack Surface. – Post-installation steps for Linux - Official Docker installation instructions

We are going to use sudo in this tutorial.

Clone the rails chat tutorial from GitHub

Navigate to your development directory on your machine and clone the sample Rails chat application with:

git clone https://github.com/iridakos/rails-chat-tutorial

Done.

Configure the application to use PostgreSQL for the production environment

The application is configured to use the predefined sqlite database adapter. For the purpose of this tutorial we will change the adapter to postgresql and at the second part of the post we will create a container running the PostgreSQL database.

Open the file config/database.yml file and change the production configuration as described below:

production:
  <<: *default
  adapter: postgresql
  host: <%= ENV.fetch('DATABASE_HOST') %>
  port: <%= ENV.fetch('DATABASE_PORT') %>
  username: <%= ENV.fetch('DATABASE_USERNAME') %>
  password: <%= ENV.fetch('DATABASE_PASSWORD') %>

Open the application’s Gemfile and add the following lines:

group :production do
  gem 'pg'
end

to install the adapter. The pg gem requires to have the package libpq-dev installed on the machine. We will satisfy this requirement when building the image.

Building the docker image

We are going to build the image gradually in order to understand what’s going on with every command we use.

Create the Dockerfile

Whenever we want to create a new image in docker we use a file named Dockerfile. It is a text file with instructions to be followed sequentially to assemble an image.

Navigate to the Rails chat tutorial (from now I will call this application directory) directory and create the file.

touch Dockerfile

and before continuing let’s try to build the image with just that empty file:

sudo docker build . -t rails-chat-tutorial

Of course we get an error, but take a look at the first line of the log:

Sending build context to Docker daemon  46.39MB
Error response from daemon: the Dockerfile (Dockerfile) cannot be empty

When building an image, Docker creates a build context which is actually the files that will be available when the Dockerfile’s commands get executed.

The . (dot) part of the build command that we used tells Docker to try to build the image using the current directory for its build context.

Since we didn’t explicitly specified in the command which Dockerfile to use, Docker will use the one that is located in the root of the context.

Define the parent image

A parent image is the image that your image is based on. It refers to the contents of the FROM directive in the Dockerfile. Each subsequent declaration in the Dockerfile modifies this parent image. Most Dockerfiles start from a parent image, rather than a base image. However, the terms are sometimes used interchangeably. – Create a base image - Official Docker Documentation

Building the image from scratch is out of the context of this tutorial but if you want to familiarize your self with this aspect, read more here.

Docker provides official Ruby images and we are going to use the version that the Rails chat tutorial uses which is 2.6.2 as our parent image.

Open Dockerfile and add the following line:

FROM ruby:2.6.2-stretch

and run the build command again:

$ sudo docker build . -t rails-chat-tutorial
Sending build context to Docker daemon  46.39MB
Step 1/1 : FROM ruby:2.6.2-stretch
2.6.2-stretch: Pulling from library/ruby
e79bb959ec00: Pull complete
d4b7902036fe: Pull complete
1b2a72d4e030: Pull complete
d54db43011fd: Pull complete
69d473365bb3: Pull complete
84ed2a0dc034: Pull complete
75df5efa5606: Pull complete
f0d10aea813b: Pull complete
Digest: sha256:d5af6b19da8381014f59e79245ae242dd5ea8dfe1a8a6c0e2bc481366f1e92b9
Status: Downloaded newer image for ruby:2.6.2-stretch
 ---> 8d6721e9290e
Successfully built 8d6721e9290e
Successfully tagged rails-chat-tutorial:latest

Execute the following command to see which images Docker has.

$ sudo docker image list
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
rails-chat-tutorial   latest              8d6721e9290e        10 days ago         870MB
ruby                  2.6.2-stretch       8d6721e9290e        10 days ago         870MB
hello-world           latest              fce289e99eb9        3 months ago        1.84kB

The hello-world is the Docker’s image that we used after installing Docker. The other image, the ruby one is the parent image of our image. Since the Dockerfile didn’t have any custom instructions other that just defining a parent image, the resulting image rails-chat-tutorial is actually the same as the parent image and has the same IMAGE ID, CREATED and SIZE properties. Time to change this.

Copying the application code

The purpose of the image that we are building is to serve the Rails chat tutorial application. Eventually, to do so it’s pretty obvious that the image must contain the code of the application.

We will use the COPY command to copy the code inside the image.

Open the Dockerfile and append the following line:

COPY . /application

This command will copy all files from inside the build context to the image.

the first argument is the location of the build context to be copied
the second argument is the target location inside the image

Build the image again and execute the following command to confirm that we are good.

docker run -i -t rails-chat-tutorial

If you take a look at the ruby’s docker image, you will see that the last line is:

CMD [ "irb" ]

Since we don’t define something different in our image, the same command is being executed and that’s why the execution of the previous command brought us to Ruby’s irb console.

Let’s see what the /application directory of the container has.

Dir['/application/*']
=> ["/application/config.ru", "/application/Rakefile", "/application/lib", "/application/storage", "/application/test", "/application/Gemfile", "/application/app", "/application/Gemfile.lock", "/application/LICENSE", "/application/log", "/application/public", "/application/tmp", "/application/vendor", "/application/bin", "/application/README.md", "/application/config", "/application/package.json", "/application/Dockerfile", "/application/db"]

Cool, the application directory has been copied. Moving on.

Install application dependencies

Before starting the server (puma in our case), we have to install the dependencies of the application. To do so, add the following line to the Dockerfile.

RUN bundle install --deployment --without development test

and rebuild the image.

build . -t rails-chat-tutorial
Sending build context to Docker daemon  46.39MB
Step 1/3 : FROM ruby:2.6.2-stretch
 ---> 8d6721e9290e
Step 2/3 : COPY . /application
 ---> f9b9d813d6a0
Step 3/3 : RUN bundle install --deployment --without development test
 ---> Running in a6c8c25da3f5
Could not locate Gemfile
The command '/bin/sh -c bundle install --deployment --without development test' returned a non-zero code: 10

We have an error because for the bundle command to succeed we must first change to the application’s root directory that does contain the Gemfile file.

Change the contents of the Dockerfile to the following:

FROM ruby:2.6.2-stretch

# Copy application code
COPY . /application
# Change to the application's directory
WORKDIR /application

# Install gems
RUN bundle install --deployment --without development test

and rebuild. Now the gems are being installed and we are ready to start the server.

$ docker build . -t rails-chat-tutorial
Sending build context to Docker daemon  46.39MB
Step 1/4 : FROM ruby:2.6.2-stretch
 ---> 8d6721e9290e
Step 2/4 : COPY . /application
 ---> b1aae569faf4
Step 3/4 : WORKDIR /application
 ---> Running in ab90edf73be5
Removing intermediate container ab90edf73be5
 ---> 6bbdaa9942e3
Step 4/4 : RUN bundle install --deployment --without development test
 ---> Running in 22724a3684fe
The dependency tzinfo-data (>= 0) will be unused by any of the platforms Bundler is installing for. Bundler is installing for ruby but the dependency is only for x86-mingw32, x86-mswin32, x64-mingw32, java. To add those platforms to the bundle, run bundle lock --add-platform x86-mingw32 x86-mswin32 x64-mingw32 java.
Fetching gem metadata from https://rubygems.org/............
Fetching rake 12.3.2
Installing rake 12.3.2
Fetching concurrent-ruby 1.1.5
...
...
...
Fetching sqlite3 1.4.0
Installing sqlite3 1.4.0 with native extensions
Fetching uglifier 4.1.20
Installing uglifier 4.1.20
Bundle complete! 21 Gemfile dependencies, 69 gems now installed.
Gems in the groups development and test were not installed.
Bundled gems are installed into ./vendor/bundle
...
...
...

Removing intermediate container 22724a3684fe
 ---> d0d3163a8cca
Successfully built d0d3163a8cca
Successfully tagged rails-chat-tutorial:latest

Asset compilation

In the production environment, assets have to be pre-compiled.

We will add this task in our ENTRYPOINT script (see below) because during asset compilation Rails initializes the application and if we executed the task upon building the image, the initialization would fail since some components (like database connection, configuration of services based on environment variables like cable.yml) are not available.

We must install a Javascript environment in the container though or else when the time comes and the task is executed, will get the following error:

ExecJS::RuntimeUnavailable: Could not find a JavaScript runtime. See https://github.com/rails/execjs for a list of available runtimes.

We will install nodejs, add the following line:

RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
    apt install -y nodejs

Rebuild and you should be fine.

Start the server

We want to start the application in the production environment. Rails can resolve this via the environment variable RAILS_ENV.

To set it in the image, add in Dockerfile:

ENV RAILS_ENV production

The last instruction in the Dockerfile will be our ENTRYPOINT.

Add the following line:

ENTRYPOINT ./entrypoint.sh

What’s left to do is to configure the entrypoint.sh script to do the following:

compile the assets
start the server

Create a file named entrypoint.sh in the root application directory and add:

# Compile the assets
bundle exec rake assets:precompile

# Start the server
bundle exec rails server

This file has to be executable, so in your terminal:

chmod +x ./entrypoint.sh

That’s all.

Since there are no more modifications to be done in our Dockerfile, make sure its contents are the following:

FROM ruby:2.6.2-stretch

# Copy application code
COPY . /application
# Change to the application's directory
WORKDIR /application

# Install gems
RUN bundle install --deployment --without development test

# Set Rails environment to production
ENV RAILS_ENV production

RUN curl -sL https://deb.nodesource.com/setup_10.x | bash - \
    && apt install -y nodejs

# Start the application server
ENTRYPOINT ./entrypoint.sh

Compacting the Dockerfile

We will optimize the Dockerfile since each RUN command creates a new image (read more here).

We will merge the RUN commands in one and move the ENV command just before it. The resulting Dockerfile is:

FROM ruby:2.6.2-stretch

# Copy application code
COPY . /application
# Change to the application's directory
WORKDIR /application

# Set Rails environment to production
ENV RAILS_ENV production

# Install gems, nodejs and precompile the assets
RUN bundle install --deployment --without development test \
    && curl -sL https://deb.nodesource.com/setup_10.x | bash - \
    && apt install -y nodejs

# Start the application server
ENTRYPOINT ['./entrypoint.sh']

Running the application in the Docker environment

Creating the PostgreSQL container

We are going to create a container for the PostgreSQL database.

We need to specify two environment variables to configure a user for our application: POSTGRES_USER and POSTGRES_PASSWORD. The values of these environment variables will be used later on when creating the application’s container.

sudo docker run --name rails-chat-tutorial-pg
            -e POSTGRES_USER=postgres
            -e POSTGRES_PASSWORD=postgres
            -p 5432:5432
            -d postgres

Since the image doesn’t exist locally, Docker will fetch it from the Official Docker images and then it will create a container, binding the PostgreSQL default port 5432 to the same port of the host.

Notes: I suggest you read this documentation if you want to familiarize yourself with the options you have for customizing the container (volumes/database configuration etc).

Creating the Redis container

To create the redis container, all we have to do is run the following command:

sudo docker run --name rails-chat-tutorial-redis \
            -p 6379:6379 \
            -d redis

Again, since the image doesn’t exist locally, Docker will fetch it from the Official Docker images and then it will create a container, binding its 6376 to the same port of the host.

Creating the application’s container

At this point, your docker running containers should look like this:

$ sudo docker ps

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
<a container id>    redis               "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes        0.0.0.0:6379->6379/tcp   rails-chat-tutorial-redis
<a container id>    postgres            "docker-entrypoint.s…"   2 minutes ago       Up 2 minutes        0.0.0.0:5432->5432/tcp   rails-chat-tutorial-pg

The Rails chat tutorial in production mode needs the following environmental variables:

database.yml
- DATABASE_HOST: 172.17.0.1
- DATABASE_PORT: 5432
- DATABASE_USERNAME: postgres
- DATABASE_PASSWORD: postgres
cable.yml
- REDIS_URL: redis://172.17.0.1:6379/1

To create the container for the image that we created in this post passing the required environment variables, use:

sudo docker run --name rails-chat-tutorial-web \
            -e DATABASE_HOST=172.17.0.1 \
            -e DATABASE_PORT=5432 \
            -e DATABASE_USERNAME=postgres \
            -e DATABASE_PASSWORD=postgres \
            -e REDIS_URL=redis://172.17.0.1:6379/1 \
            -p 3000:3000 \
            rails-chat-tutorial

Note: we bound the container’s 3000 port on the same port of the host.

Navigate to http://localhost:3000 and see what happens.

We don’t get very helpful information on the error since the application is running in production mode (at least this worked :P). Let’s connect to the container and check the logs:

$ sudo docker exec -it rails-chat-tutorial-web bash

Now you are connected to the container. Check the /application/production.log file. Somewhere among all these lines you will see the following:

ActiveRecord::StatementInvalid (PG::UndefinedTable: ERROR:  relation users does not exist

We set up the database server but we didn’t create/migrate the database. Since we are already connected to the container we will execute the required rake tasks.

bundle exec rake db:create db:migrate

Reload the page and voilà

What’s next

In the next tutorial we are going to:

refactor this image for production (use volume for postgreSQL, asset precompilation)
use nginx to serve them
use docker compose to bind them all.

Thanks

I am very grateful for your feedback (like this one from DeusOtiosus @ Reddit).

That’s all! Cat photo.

Code and comments

You can find the code of this tutorial on https://github.com/iridakos/rails-chat-tutorial on branch docker.

For feedback, comments, typos etc. please open an issue in the repository.

Thanks for visiting!

Creating a chat application from scratch using Rails and WebSockets

Thu, 04 Apr 2019 23:00:00 +0300

Hey! It’s been a while since my last post.

I recently familiarized myself with the awesomeness of WebSockets and I finally found the time to write a tutorial about it. I hope you find it helpful.

Update: I also published another post for dockerizing the application of this tutorial, you can find it here.

Introduction

In this tutorial we are going to create a chat web application from scratch using Rails and WebSockets.

Code and comments

You can find the code of this tutorial on GitHub.

For feedback, comments, typos etc. please open an issue in the repository.

What are WebSockets

WebSocket is actually a protocol that enables bidirectional communication between the client and the server of a web application over a single long living TCP connection.

The WebSocket protocol enables interaction between a web browser (or other client application) and a web server with lower overheads, facilitating real-time data transfer from and to the server.

This is made possible by providing a standardized way for the server to send content to the client without being first requested by the client, and allowing messages to be passed back and forth while keeping the connection open. In this way, a two-way ongoing conversation can take place between the client and the server.

The communications are done over TCP port number 80 (or 443 in the case of TLS-encrypted connections), which is of benefit for those environments which block non-web Internet connections using a firewall. Similar two-way browser-server communications have been achieved in non-standardized ways using stopgap technologies such as Comet. – WebSocket @ Wikipedia

Why WebSockets

Suppose you have to create a web page that shows the statuses of running processes. Without WebSockets you would have to either:

Use AJAX with Javascript intervals to request and render the latest state of the processes or
Automatically reload the page every x seconds (<meta http-equiv="refresh" content="x">) or
Add a message on the page “The statuses are not updated automatically ¯\_(ツ)_/¯ Press here to reload the page.”

All of these methods would request the process statuses from the server even if nothing has changed.

WebSockets are here to allow this communication to take place on demand. The cost is having to keep alive TCP connections between the server and all its clients (each for every open browser tab).

Building the application

We are going to build the web application using:

Ruby: version 2.6.2
Rails: version 5.2.3

Setting up the environment

We are going to install the proper ruby and rails versions.

Install ruby

I use rvm to manage the Ruby versions installed on my system. To install the desired ruby version use:

rvm install ruby 2.6.2

Install rails

Create a directory in your system with the name rails-chat-tutorial.

Navigate to that directory and create the following two files:

.ruby-version

ruby-2.6.2

.ruby-gemset

rails-chat-tutorial

With these file we are letting rvm know that when working on this directory, we want to use the specific ruby version (.ruby-version) and the gems from the specific gemset (.ruby-gemset)

Now, re-entering in the directory you should see something like this:

$ cd .

ruby-2.6.2 - #gemset created /home/iridakos/.rvm/gems/ruby-2.6.2@rails-chat-tutorial
ruby-2.6.2 - #generating rails-chat-tutorial wrappers...........

Install the desired rails version with:

gem install rails -v 5.2.3

Create the rails application

We are ready to create our new rails application:

rails new .

Note: We didn’t define a name for the application and rails will resolve it using the directory name: rails-chat-tutorial.

Rails will create all the application’s files and install the required gems.

Let’s start the application to make sure that everything is fine.

rails server

You should see something like:

=> Booting Puma
=> Rails 5.2.3 application starting in development
=> Run `rails server -h` for more startup options
Puma starting in single mode...
* Version 3.12.1 (ruby 2.6.2-p47), codename: Llamas in Pajamas
* Min threads: 5, max threads: 5
* Environment: development
* Listening on tcp://localhost:3000
Use Ctrl-C to stop

Open a browser and visit http://localhost:3000, if you see this we are good to go.

Users and devise

We are going to use the awesome devise solution for authentication.

Append the following gem requirement at the bottom of the Gemfile file located at the root of the application’s directory.

gem 'devise'

On your terminal, install the new gem by executing:

bundle

Finish integration with devise using:

rails generate devise:install

We will create the model representing our users using the devise generators.

On your terminal, execute:

rails generate devise User username:string

Note: we have added an extra attribute username to our model (besides the defaults generated by devise) so that we have something more friendly to present when displaying users instead of their email.

Open the generated migration which you will find under db/migrate/<datetime>_devise_create_users.rb and append the username’s unique index definition with^[4]:

  add_index :users,  :username,             unique: true

Find the line in the file that defines the username column and change it to:

t.string :username, null: false

to make the attribute required.

Then in the User model which is located at app/models/user.rb add the validation rule for uniqueness and presence:

  validates :username, uniqueness: true, presence: true

Finally, apply the database migration using:

rails db:migrate

Rooms and messages

Each chat message is going to take place in the context of a room.

Let’s build them all.

Use the following command to create the Room:

rails generate resource Room name:string:uniq

and the following command to create the RoomMessage:

rails generate resource RoomMessage room:references user:references message:text

We are now going to define the appropriate relations^[7].

Open app/models/room.rb and add the relation inside the class:

has_many :room_messages, dependent: :destroy,
                         inverse_of: :room

Open app/models/room_message.rb and add the relations inside the class:

belongs_to :user
belongs_to :room, inverse_of: :room_messages

Migrate the database with:

rails db:migrate

We can now setup our routes so that the root request is served by the RoomsController#index action.

Open your config/routes.rb file and change its contents to:

Rails.application.routes.draw do
  devise_for :users

  root controller: :rooms, action: :index

  resources :room_messages
  resources :rooms
end

Restart the server and try to navigate to the application’s root url.

You should see an error message, no worries:

We have to create the index action in the RoomsController. Open the controller app/controllers/rooms_controller.rb and change its contents to the following:

class RoomsController < ApplicationController
  def index
  end
end

Then create the file app/views/rooms/index.html.erb and for now just add the following:

<h1>Rooms index</h1>

Reload and voilà.

Adding authentication

We want all users to be authenticated before start chatting, so we are going to add the following line in the ApplicationController located at app/controllers/application_controller.rb:

  before_action :authenticate_user!

If we navigate to http://localhost:3000 now we should be redirected to the sign in page ^[10].

Before continuing with the good stuff, let’s gear up the application with some good features.

Add bootstrap

We are going to use Bootstrap and we will integrate it in the application using the bootstrap-rubygem gem.

Following the instructions of the gem, append the dependencies in your Gemfile.

gem 'bootstrap', '~> 4.3.1'
gem 'jquery-rails'

and execute bundle to fetch and install it.

Change the app/assets/stylesheets/application.css file’s extension to scss and replace its contents with:

@import "bootstrap";

Add the following lines to the app/assets/javascript/application.js just before the //= require_tree . line^[9]:

//= require jquery3
//= require popper
//= require bootstrap-sprockets

Add simple_form

We are going to use this great gem to generate forms easily.

Append the gem dependency in your Gemfile and bundle to install it.

gem 'simple_form'

Then complete the integration using:

rails generate simple_form:install --bootstrap

Note: We used the –bootstrap directive since that’s the framework we are using.

Devise views with bootstrap and simple form

Devise uses its own views for sign in, register etc. But we do have a way to customize these views and now that we have ended up using bootstrap and simple forms, we can generate these views in a way that our choices are respected.

In your terminal:

rails generate devise:views

The view for signing in is under app/views/devise/sessions/new.html.erb and for signing up is under app/views/devise/registrations/new.html.erb. Open these two files and change the submit button’s class by replacing the following line^[6]:

<%= f.button :submit, "Sign up" %>

with

<%= f.button :submit, "Sign up", class: 'btn btn-success' %>

to render the buttons bootstrap style.

Before viewing our changes, let’s do one last thing in our default layout.

Open app/views/layouts/application.html.erb and replace its contents with:

<!DOCTYPE html>
<html>
  <head>
    <title>RailsChatTutorial</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body>
    <div class="container">
      <div class="row">
        <div class="col-12">
          <%= yield %>
        </div>
      </div>
    </div>
  </body>
</html>

This last one was to use Bootstrap’s grid in our views.

Navigate to http://localhost:3000 and view what we have created.

Let’s try to sign up following the Sign up link of the form:

As you can see, there is no field to fill in the username. For that to work we have to:

Add the field in the sign up form
Configure devise to accept the new attribute (username) or else the ApplicationController will ignore it once submitted from the form.

To add the field in the sign up form, open app/views/devise/registrations/new.html.erb and add these lines between the email and password fields.

  <%= f.input :username,
              required: true %>

Then, open the app/controllers/application_controller.rb file to configure the new attribute. Change the contents to:

class ApplicationController < ActionController::Base
  before_action :authenticate_user!

  before_action :configure_permitted_parameters, if: :devise_controller?

  protected

  def configure_permitted_parameters
    devise_parameter_sanitizer.permit(:sign_up, keys: [:email, :username])
  end
end

Done, reload and sign up^[5].

Cleanup unused components

We will not be using coffee script or turbolinks so let’s remove all the related stuff.

Open Gemfile and remove the following lines:

# Use CoffeeScript for .coffee assets and views
gem 'coffee-rails', '~> 4.2'
# Turbolinks makes navigating your web application faster. Read more: https://github.com/turbolinks/turbolinks
gem 'turbolinks', '~> 5'

Open app/assets/javascripts/application.js and remove the following line:

//= require turbolinks

Open app/views/layouts/application.html.erb and change the following lines ^[3]:

    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>

    <%= stylesheet_link_tag    'application', media: 'all' %>
    <%= javascript_include_tag 'application' %>

Check that your app/assets/javascripts folder doesn’t have any files with extension .coffee and if you find any, remove them.²

In the terminal, also execute the following command:

rails tmp:cache:clear

to clear any cached compiled coffee scripts.

Done. Restart you server.

To improve the usability of the web pages will add a top navigation bar.

Create the directory app/views/shared and a file inside it named _navigation_bar.html.erb. This is going to be the partial responsible for rendering the navigation bar and which later on we will add to the application’s default layout in order to be rendered on all web pages. Add these contents:

<nav class="navbar navbar-expand-lg navbar-dark bg-dark justify-content-between">
  <a class="navbar-brand" href="#">Rails chat tutorial</a>
  <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#nav-bar-collapse" aria-controls="navbarColor01" aria-expanded="false" aria-label="Toggle navigation">
    <span class="navbar-toggler-icon"></span>
  </button>

  <% if current_user %>
    <div class="dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
        <img class="avatar" src="<%= gravatar_url(current_user) %>">
        <%= current_user.username %>
      </a>

      <div class="dropdown-menu dropdown-menu-right" aria-labelledby="navbarDropdown">
        <%= link_to 'Logout', destroy_user_session_path, method: :delete, class: 'dropdown-item' %>
      </div>
    </div>
  <% end %>
</nav>

Mind the gravatar_url(current_user) line. This is a helper method that we are going to use in order to resolve the gravatar url of the signed in user. This is not a builtin method, we have to defined it but it’s pretty straightforward.

Edit app/helpers/application_helper.rb and add the following method:

def gravatar_url(user)
  gravatar_id = Digest::MD5::hexdigest(user.email).downcase
  url = "https://gravatar.com/avatar/#{gravatar_id}.png"
end

Note:

As you can see, the user’s username, avatar and sign out link will only be rendered if the user is signed in.

The avatar image has a css class avatar. We have to define this class in the application’s stylesheets. Create a css file in which we will gather all css class that we will use in the application under the name app/assets/stylesheets/rails-chat-tutorial.scss.

For now add the rule for the avatar:

.avatar {
  max-height:30px;
  border-radius: 15px;
  width:auto;
  vertical-align:middle;
}

and open application.scss to import the newly created stylesheet. Add the line:

@import "rails-chat-tutorial"

We have to add this partial in the application layout. Edit app/views/layouts/application.html.erb and change its contents to:

<!DOCTYPE html>
<html>
  <head>
    <title>RailsChatTutorial</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag    'application', media: 'all' %>
    <%= javascript_include_tag 'application' %>
  </head>

  <body>
    <div class="container">
      <div class="row">
        <div class="col-12">
          <%= render partial: 'shared/navigation_bar' %>
          <div class="my-3">
            <%= yield %>
          </div>
        </div>
      </div>
    </div>
  </body>
</html>

Reload to view the bar.

Awesome. Fill in with your desired credentials and submit the form.

Room management

We are going to create a simple layout for groups.

One narrow column displaying vertically all the available rooms
One wide column which is going to host the chat messages and form.

The rooms index page will have the second column empty since this column will be present only when user is inside a specific room.

In the index page we will provide the option to create a room.

Room index

First we have to load all rooms in the RoomsController. Open app/controllers/rooms_controller.rb and change the index action as:

def index
  @rooms = Room.all
end

Open app/views/rooms/index.html.erb and change its contents to^[8]:

<div class="row">
  <div class="col-12 col-md-3">
    <div class="mb-3">
      <%= link_to new_room_path, class: "btn btn-primary" do %>
        Create a room
      <% end %>
    </div>

    <% if @rooms.present? %>
      <nav class="nav flex-column">
        <% @rooms.each do |room| %>
          <%= link_to room.name, room_path(room), class: "nav-link room-nav-link" %>
        <% end %>
      </nav>
    <% else %>
      <div class="text-muted">
        The are no rooms
      </div>
    <% end %>
  </div>

  <div class="col">
    <div class="alert alert-primary">
      <h4 class="alert-heading">
        Welcome to the RailsChatTutorial!
      </h4>

      <p>
        We need to talk.
      </p>

      <hr />

      <p>
        You can create or join a room from the sidebar.
      </p>
    </div>
</div>

If there are rooms, the left column of the page will render a vertical navigation with links leading to each room’s page. The right column displays a simple welcome message.

Pressing the Create a room button we get the expected error for the non-existent action.

Room new/edit

We have to define the actions for creating and updating a room.

Open the app/controllers/rooms_controller.rb and change its contents to:

class RoomsController < ApplicationController
  # Loads:
  # @rooms = all rooms
  # @room = current room when applicable
  before_action :load_entities

  def index
    @rooms = Room.all
  end

  def new
    @room = Room.new
  end

  def create
    @room = Room.new permitted_parameters

    if @room.save
      flash[:success] = "Room #{@room.name} was created successfully"
      redirect_to rooms_path
    else
      render :new
    end
  end

  def edit
  end

  def update
    if @room.update_attributes(permitted_parameters)
      flash[:success] = "Room #{@room.name} was updated successfully"
      redirect_to rooms_path
    else
      render :new
    end
  end

  protected

  def load_entities
    @rooms = Room.all
    @room = Room.find(params[:id]) if params[:id]
  end

  def permitted_parameters
    params.require(:room).permit(:name)
  end
end

Note: we preload the @rooms and the @room variables making them available to all actions with the before_action :load_entities hook.

We will create a simple form for the Room object and we will use it both when creating and editing a room. Create the app/views/rooms/_form.html.erb and add:

<%= simple_form_for @room do |form| %>
  <%= form.input :name %>
  <%= form.submit "Save", class: 'btn btn-success' %>
<% end %>

Then, create the views for the new/edit action accordingly:

app/views/rooms/new.html.erb

<h1>
  Creating a room  
</h1>

<%= render partial: 'form' %>

app/views/rooms/edit.html.erb

<h1>
  Editing room <%= @room.name %>
</h1>

<%= render partial: 'form' %>

Time to create the first room. From the rooms’ index page, press the Create a room

Save and here it is.

Add this class in app/assets/stylesheets/rails-chat-tutorial.scss to improve the display of the rooms.

.room-nav-link {
  border: 1px solid lighten($primary, 40%);
  background: lighten($primary, 45%);

  & + .room-nav-link {
    border-top: 0 none;
  }
}

Note: We will add the edit link in the room’s page a.k.a. show action.

Before moving on to the Room page, we will refactor the index page so as to be able to use the left column’s content inside the room page as well.

Create the partial app/views/rooms/_rooms.html.erb with contents:

<div class="mb-3">
  <%= link_to new_room_path, class: 'btn btn-primary' do %>
    Create a room
  <% end %>
</div>

<% if @rooms.present? %>
  <nav class="nav flex-column">
    <% @rooms.each do |room| %>
      <%= link_to room.name, room_path(room), class: 'nav-link room-nav-link' %>
    <% end %>
  </nav>
<% else %>
  <div class="text-muted">
    The are no rooms
  </div>
<% end %>

and change the app/views/rooms/index.html.erb to use it:

<div class="row">
  <div class="col-12 col-md-3">
    <%= render partial: 'rooms' %>
  </div>

  <div class="col">
    <div class="alert alert-primary">
      <h4 class="alert-heading">
        Welcome to the RailsChatTutorial!
      </h4>

      <p>
        We need to talk.
      </p>

      <hr />

      <p>
        You can create or join a room from the sidebar.
      </p>
    </div>
  </div>
</div>

Room page

Add the show action in the app/controllers/rooms_controller.rb:

def show
  @room_message = RoomMessage.new room: @room
  @room_messages = @room.room_messages.includes(:user)
end

Notes:

We construct a new room message which we are going to use in the view to build a form for creating the chat messages.
When displaying the room message, we access its user’s email attribute to resolve the gravatar hash. We used .includes(:user) in the query for the @room_messages to fetch them along with their users avoiding N+1 queries^[1].

Create the view app/views/rooms/show.html.erb:

<h1>
  <%= @room.name %>
</h1>

<div class="row">
  <div class="col-12 col-md-3">
    <%= render partial: 'rooms' %>
  </div>

  <div class="col">
    <div class="chat">
      <% @room_messages.each do |room_message| %>
        <%= room_message %>
      <% end %>
    </div>

    <%= simple_form_for @room_message, remote: true do |form| %>
      <div class="input-group mb-3">
        <%= form.input :message, as: :string,
                                 wrapper: false,
                                 label: false,
                                 input_html: {
                                   class: 'chat-input'
                                 } %>
        <div class="input-group-append">
          <%= form.submit "Send", class: 'btn btn-primary chat-input' %>
        </div>
      </div>

      <%= form.input :room_id, as: :hidden %>
    <% end %>
  </div>
</div>

Notes:

We reused the app/views/rooms/_rooms.html.erb partial that we created in the previous step
We added a div with class .chat and this is where the room’s messages are rendered.
We added a form for the @room_message that we instantiated in the controller. We also used the directive remote: true when we instantiated the form thus the form is going to be submitted by Ajax.
We added a hidden field for the attribute :room_id so that the value reaches the RoomMessagesController once we submit the form.

Style the chat components by adding the following lines to the app/assets/stylesheets/rails-chat-tutorial.scss:

.chat {
  border: 1px solid lighten($secondary, 40%);
  background: lighten($secondary, 50%);
  height: 50vh;
  border-radius: 5px 5px 0 0;
  overflow-y: auto;
}

.chat-input {
  border-top: 0 none;
  border-radius: 0 0 5px 5px;
}

Navigate to a room to see what has been done.

Pressing the Send button nothing happens on the page but if you check the server’s console you will notice:

AbstractController::ActionNotFound (The action 'create' could not be found for RoomMessagesController):

Let’s fix that.

Creating room messages

This is going to be easy. All we have to do is implement the create action in the RoomMessagesController.

app/controllers/room_messages_controller.rb

class RoomMessagesController < ApplicationController
  before_action :load_entities

  def create
    @room_message = RoomMessage.create user: current_user,
                                       room: @room,
                                       message: params.dig(:room_message, :message)
  end

  protected

  def load_entities
    @room = Room.find params.dig(:room_message, :room_id)
  end
end

Notes:

we preload the room using the room_id parameter that we added as a hidden field in the form in the previous step
we create a new message for the room setting its user to the currently signed in user

If you try to submit a message now, again you will see nothing but in the server console you can see from the log that the room message has been created.

Started POST "/room_messages" for ::1 at 2019-04-04 19:24:33 +0300
Processing by RoomMessagesController#create as JS
  Parameters: {"utf8"=>"✓", "room_message"=>{"message"=>"My first message", "room_id"=>"8"}, "commit"=>"Send"}
  User Load (0.2ms)  SELECT  "users".* FROM "users" WHERE "users"."id" = ? ORDER BY "users"."id" ASC LIMIT ?  [["id", 1], ["LIMIT", 1]]
  ↳ /home/iridakos/.rvm/gems/ruby-2.6.2@rails-chat-tutorial/gems/activerecord-5.2.3/lib/active_record/log_subscriber.rb:98
  Room Load (0.2ms)  SELECT  "rooms".* FROM "rooms" WHERE "rooms"."id" = ? LIMIT ?  [["id", 8], ["LIMIT", 1]]
  ↳ app/controllers/room_messages_controller.rb:13
   (0.1ms)  begin transaction
  ↳ app/controllers/room_messages_controller.rb:5
  RoomMessage Create (0.7ms)  INSERT INTO "room_messages" ("room_id", "user_id", "message", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)  [["room_id", 8], ["user_id", 1], ["message", "My first message"], ["created_at", "2019-04-04 16:24:33.456641"], ["updated_at", "2019-04-04 16:24:33.456641"]]
  ↳ app/controllers/room_messages_controller.rb:5
   (4.0ms)  commit transaction
  ↳ app/controllers/room_messages_controller.rb:5
No template found for RoomMessagesController#create, rendering head :no_content
Completed 204 No Content in 88ms (ActiveRecord: 5.1ms)

A user would expect to have the message field cleared after sending a new message. We don’t disappoint users.

Create a file app/assets/javascripts/room.js and add the following:

$(function() {
  $('#new_room_message').on('ajax:success', function(a, b,c ) {
    $(this).find('input[type="text"]').val('');
  });
});

We bind to the ajax:success event triggered by Rails on successful submission of the form and all we want to do is clear the text field’s value.

Reload the page and try submitting again and check it out. The field value should be emptied after sending the message.

Displaying room messages

If you reload the page you will see something like this:

Let’s beautify the messages.

Replace the contents of app/views/rooms/show.html.erb with:

<h1>
  <%= @room.name %>
</h1>

<div class="row">
  <div class="col-12 col-md-3">
    <%= render partial: 'rooms' %>
  </div>

  <div class="col">
    <div class="chat">
      <% @room_messages.each do |room_message| %>
        <div class="chat-message-container">
          <div class="row no-gutters">
            <div class="col-auto text-center">
              <img src="<%= gravatar_url(room_message.user) %>" class="avatar" alt="">
            </div>

            <div class="col">
              <div class="message-content">
                <p class="mb-1">
                  <%= room_message.message %>
                </p>

                <div class="text-right">
                  <small>
                    <%= room_message.created_at %>
                  </small>
                </div>
              </div>
            </div>
          </div>
        </div>
      <% end %>
    </div>

    <%= simple_form_for @room_message, remote: true do |form| %>
      <div class="input-group mb-3">
        <%= form.input :message, as: :string,
                                 wrapper: false,
                                 label: false,
                                 input_html: {
                                   class: 'chat-input'
                                 } %>
        <div class="input-group-append">
          <%= form.submit "Send", class: 'btn btn-primary chat-input' %>
        </div>
      </div>

      <%= form.input :room_id, as: :hidden %>
    <% end %>
  </div>
</div>

and add the following css classes inside the .chat class:

.chat-message-container {
  padding: 5px;

  .avatar {
    margin: 5px;
  }

  .message-content {
    padding: 5px;
    border: 1px solid $primary;
    border-radius: 5px;
    background: lighten($primary, 10%);
    color: $white;
  }

  & + .chat-message-container {
    margin-top: 10px;
  }
}

Reload the page. Magic.

Introducing WebSockets - ActionCable

Time to start using WebSockets with ActionCable.

Action Cable seamlessly integrates WebSockets with the rest of your Rails application. It allows for real-time features to be written in Ruby in the same style and form as the rest of your Rails application, while still being performant and scalable. It’s a full-stack offering that provides both a client-side JavaScript framework and a server-side Ruby framework. You have access to your full domain model written with Active Record or your ORM of choice. – Action Cable Overview @ Ruby on Rails Guides (v5.2.3)

Install redis

We are going to use the redis adapter which is a safe option for production environments unlike the async one.

You first must install redis on your system.

To install it on Ubuntu you just have to execute the following commands in your terminal:

sudo apt update
sudo apt install redis-server

To check that installation is successful, in your terminal make sure you get a PONG:

$ redis-cli
127.0.0.1:6379> ping
PONG

Configure ActionCable

Since we are working on the development environment, open your config/cable.yml and replace its contents with:

development:
  adapter: redis
  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
  channel_prefix: rails-chat-tutorial_development

test:
  adapter: async

production:
  adapter: redis
  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
  channel_prefix: rails-chat-tutorial_production

Note: we have added an option channel_prefix because:

Additionally, a channel_prefix may be provided to avoid channel name collisions when using the same Redis server for multiple applications – Action Cable Overview # Redis Adapter @ Ruby on Rails Guides (v5.2.3)

Finally, we are going to add the dependency in the Gemfile:

gem 'redis'

Don’t forget to bundle after altering the Gemfile.

Configure Devise for authenticating websocket connections

When establishing a websocket connection, we don’t have access to the user session but we do have access to the cookies. So, in order to be able to authenticate the user we need to do some devise related stuff first (credits to Greg Molnar).

Create an initializer for warden hooks under the name config/initializers/warden_hooks.rb and add the following lines:

Warden::Manager.after_set_user do |user,auth,opts|
  scope = opts[:scope]
  auth.cookies.signed["#{scope}.id"] = user.id
end

Warden::Manager.before_logout do |user, auth, opts|
  scope = opts[:scope]
  auth.cookies.signed["#{scope}.id"] = nil
end

Explain: We add a cookie with the user’s id upon successful sign in and we remove it once the user logs out.

Configure the websocket connection

Open app/channels/application_cable/connection.rb and change its contents to the following:

module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
    end

    private

    def find_verified_user
      if verified_user = User.find_by(id: cookies.signed['user.id'])
        verified_user
      else
        reject_unauthorized_connection
      end
    end
  end
end

Explain:

Here identified_by is a connection identifier that can be used to find the specific connection later. Note that anything marked as an identifier will automatically create a delegate by the same name on any channel instances created off the connection. – Action Cable Overview # Connection setup @ Ruby on Rails Guides (v5.2.3)

In the find_verified_user method we access the cookie that we previously set in the warden hook.

Create the room channel

A channel encapsulates a logical unit of work, similar to what a controller does in a regular MVC setup. – Action Cable Overview # Channels @ Ruby on Rails Guides (v5.2.3)

We will create the RoomChannel in which all Room pages will subscribe to.

Create app/channels/room_channel.rb with the following contents:

class RoomChannel < ApplicationCable::Channel
  def subscribed
    room = Room.find params[:room]
    stream_for room

    # or
    # stream_from "room_#{params[:room]}"
  end
end

Explain:

The subscribed method gets called once a subscription to the channel is established and it is responsible to setup the stream from which data will be sent back and forth.

We are going to configure the room page code later on to request subscriptions to this channel passing the room parameter.

We have two options:

Use stream_for: this way Rails automatically generates a stream name for the given object (room in our case), for example: “room:asdfwer234”. When we want afterwards to broadcast data to the stream, all we have to do is call RoomChannel.broadcast_to(room_object, data) in which case Rails resolves the stream name from the room_object. In other words, we don’t have to manually resolve the stream name in which the data have to be send (see next item).
- This option is available when the channel handles subscriptions bound to models like in our case, a specific room
Use stream_from: we manually define the name of the stream and later on, when we want to broadcast to the stream, we have to use: ActionCable.server.broadcast("room_#{a_room_id_here}", data).

Broadcast room messages

Every time a room message is being created, we just need to broadcast to the message’s room stream. To do so, alter the create action of the app/controllers/room_messages_controller.rb to this:

def create
  @room_message = RoomMessage.create user: current_user,
                                     room: @room,
                                     message: params.dig(:room_message, :message)

  RoomChannel.broadcast_to @room, @room_message
end

Explain: we added the line RoomChannel.broadcast_to @room, @room_message which will broadcast to the room’s specific stream (as explained above) the @room_message transformed to json via the to_json method.

So, on the other side, the client side, we are going to be receiving the json representation of the RoomMessage model. Let’s see what that is:

{
  "id":29,
  "room_id":8,
  "user_id":1,
  "message":"My first message",
  "created_at":"2019-04-04T17:09:00.637Z",
  "updated_at":"2019-04-04T17:09:00.637Z"
}

We plan to add the new messages in the room’s page via Javascript and this information is not adequate. The only thing we are missing is the user avatar. Time to refactor.

Open app/models/user.rb and add the following method:

def gravatar_url
  gravatar_id = Digest::MD5::hexdigest(email).downcase
  "https://gravatar.com/avatar/#{gravatar_id}.png"
end

We had already implemented this in the app/helpers/application_helper.rb file and we won’t be using it anymore so remove it.

Update app/views/shared/_navigation_bar.html.erb and change the previous gravatar resolution to this:

<img class="avatar" src="<%= current_user.gravatar_url %>">

Update app/views/rooms/show.html.erb and change it there too, with:

<img src="<%= room_message.user.gravatar_url %>" class="avatar" alt="">

Finally, we will change the JSON representation of the RoomMessage to include the user’s url:

app/models/room_message.rb

def as_json(options)
  super(options).merge(user_avatar_url: user.gravatar_url)
end

Let’s confirm that the new JSON transformation is valid:

{
  "id":29,
  "room_id":8,
  "user_id":1,
  "message":"My first message",
  "created_at":"2019-04-04T17:09:00.637Z",
  "updated_at":"2019-04-04T17:09:00.637Z",
  "user_avatar_url":"https://gravatar.com/avatar/02a28db6886d578f75a820b50f2dd334.png"
}

Great, moving on.

We are going to add some data in the room page in order to use them via Javascript to subscribe to the appropriate streams each time we visit a room.

Open the file app/views/rooms/show.html.erb and alter the line in which we define the chat div, to this:

<div class="chat" data-channel-subscribe="room" data-room-id="<%= @room.id %>">

Explain: We added two data attributes, one defining to which channel we want to subscribe and one defining to which room we are.

At the end of the file, add the following snippet:

<div class="d-none" data-role="message-template">
  <div class="chat-message-container">
    <div class="row no-gutters">
      <div class="col-auto text-center">
        <img src="" class="avatar" alt="" data-role="user-avatar">
      </div>

      <div class="col">
        <div class="message-content">
          <p class="mb-1" data-role="message-text"></p>

          <div class="text-right">
            <small data-role="message-date"></small>
          </div>
        </div>
      </div>
    </div>
  </div>
</div>

This snippet is going to be used as a template for each incoming message. Every time a message arrives, we will

clone this html
alter the appropriate elements’ values and
append the resulting html to the end of the chat div.

Now we will create the Javascript that will do the work of subscribing and handling incoming channel data.

Create the file app/assets/javascripts/channels/room_channel.js and add the following code:

$(function() {
  $('[data-channel-subscribe="room"]').each(function(index, element) {
    var $element = $(element),
        room_id = $element.data('room-id')
        messageTemplate = $('[data-role="message-template"]');

    $element.animate({ scrollTop: $element.prop("scrollHeight")}, 1000)        

    App.cable.subscriptions.create(
      {
        channel: "RoomChannel",
        room: room_id
      },
      {
        received: function(data) {
          var content = messageTemplate.children().clone(true, true);
          content.find('[data-role="user-avatar"]').attr('src', data.user_avatar_url);
          content.find('[data-role="message-text"]').text(data.message);
          content.find('[data-role="message-date"]').text(data.updated_at);
          $element.append(content);
          $element.animate({ scrollTop: $element.prop("scrollHeight")}, 1000);
        }
      }
    );
  });
});

Explain:

For each element that has a data attribute channel-subscribe with value room
- Create a subscription to the “RoomChannel” passing the element’s room-id data attribute as a parameter with name room (remember this line of the RoomChannel: Room.find params[:room] ?)
  - When data is received, clone the template snippet and alter its contents based on the incoming object attributes.
  - Append the newly generated content to the chat div and finally
  - Do some animation to impress by scrolling smoothly to the bottom of the div.

Acknowledgments

Thank you very much for your feedback.

[1] Armando Andini - N+1 queries
[2] Rodolfo Ruiz - Coffeescript leftovers
[3] Felix Wolfsteller - Turbolinks leftovers
[4] Maria Kravtsova - Migration typo
[5][7][8] Tony Dehnke - Sign up step, Missing step for adding model relations, Missing line from html code block
[6] keytonw - Devise view missing button class
[9] Martin - Mention order of requirements in application.js
[10] Sumak - Remove duplicate authentication related code

That’s all! Long post, tired cat photo.

Code and comments

You can find the code of this tutorial on GitHub.

For feedback, comments, typos etc. please open an issue in the repository.

Thanks for visiting!

Vacuum cleaner

Sat, 24 Nov 2018 00:00:00 +0200

Terminator

Sat, 24 Nov 2018 00:00:00 +0200

Nightmare

Sat, 24 Nov 2018 00:00:00 +0200

Monday

Sat, 24 Nov 2018 00:00:00 +0200

iridakos

stup - Daily notes in the terminal

stup

Usage examples

Adding notes

Showing notes

Retrieving all notes for a period of time

Behind the scenes

More information

Find palindrome dates in the Linux command line - explained

What is a palindrome

The command

printf "now - %d days\n" {1..332044}

Part explained

Output

date -f- +%Y%\_m%\_d$'\n'%Y%m%d

Part explained

Output

tr -d ' ' > alldates.txt; rev alldates.txt >revdates.txt; paste alldates.txt revdates.txt

Part explained

Output

awk '$1==$2{print $1}'

Part explained

Output

Cat photo

References

Goodbye Irida

Who is Irida

Living with Irida

The sickness

What now

Vim

Descriptive variable names

Movie night

Pizza commit

What do you get after you lose your data from an SSD?

PTSSD

I am talking to my code

i

Mongoid - Inheritance: change embedded document's type via nested attributes

Use case

Item

Book

BoardGame

Person

The problems

Failing attribute assignments

Document attribute leftovers

Wrong validators

Investigation

Desired behavior

Solution

Explanation

Two step authentication in Ubuntu

Hug the cat

Mountains

Facts

Difficulties

Errors

Resources

Meadow

Facts

Resources

Drawing my cat

Post Scriptum

Interesting painting resources

Another Friday has arrived

How to write better emails

Emphasize text with bold/underlined font

Examples

Before

After

Use specific dates instead of yesterday, tomorrow etc

Examples

Before

After

Use links for references

Examples

Before

After

date -f- `+%Y%\_m%\_d$'\n'%Y%m%d`

Use specific dates instead of `yesterday`, `tomorrow` etc

Why not use the `uniq` command?

Using the `sort` command

Using `cat`, `sort` and `cut`