DEV Community: Pavs

Ruby chip cookie: Loading and Requiring

Pavs — Sat, 25 Sep 2021 11:15:33 +0000

I was reading about namespaces in Ruby the other day and came across an interesting point where it compared require and load .

Since I started writing Ruby, I did not though about the secrets behind the usage of require when other languages use load.

Let's suppose we have a file called weather_forecast.rb , that just has some functionality in it for returning weather forecasting information.
In order to execute it in our code, we could do something like load('weather_forecast.rb').

Everything looks good up to this point. We load the code, use it in our program, and move on with our lives.

However, the constants that the file defined, are not removed once the file has loaded, and can pollute our program.

To solve this problem, we could load the file as such load('weather_forecast.rb', true). The true argument, loads the file wrapping it around an anonymous namespace containing all constants that will be destroyed after the code is loaded.

On the other hand, we find require. It also loads code, but rather than loading it for execution, as load does, it imports the library avoiding those leftover class names.

As an additional fact, require tries only once to load the file, while load does it every time the file is executed.

ruby_cool_kid.rb — Meta Programming series: Dynamic dispatch

Pavs — Tue, 21 Sep 2021 21:56:20 +0000

Today, I want to start a new series of stories called: “ruby_cool_kid.rb — Meta Programming series”.

As of right now, I am reading a book called “Metaprogramming Ruby 2: Program Like the Ruby Pros” by Paolo Perrotta, where he talks about meta programming in Ruby and its advantages.

As concepts in meta programming are abstract, and sometimes hard to grasp, I am starting this series to try and explain the concepts I learned in an easy way that can be easier understood. Also, it would work as a challenge for me to see if I understood what I learned.

Please note that I will not be following Perrotta’s table of contents. I will follow my inspiration.

...

After this short purpose introduction, let’s dive into it!

Ruby, as opposed to static programming languages like Java or C, is a dynamic programming language.

Ruby is interpreted, not compiled, meaning that it can do at runtime what many static programming languages do at compilation, for example, defining new classes or methods. You might be wondering, what does dynamic dispatching have to do with all this.

Well, dynamic dispatching is the practice of dynamically calling a method based on data or information not known before. The main idea that makes the engine work is the method send (reference).

In Ruby, methods are not called on objects but rather method’s names are sent to a receiver, usually the current object.

As Alan Kay, one of the fathers of the idea of OOP used to say referring to OOP: “The big idea is sending” (reference)

Based on this idea, send is a method that helps us call object methods without having to use dot notation

Dynamic dispatching, takes advantage of this flexibility to call methods based on the data received. Let’s see an example.

Suppose you wanted to write a small program to congratulate your mom or dad on their birthday. We could write a little piece of code that would do so dynamically.

Of course, this is a very simple example that could have been done without dynamic dispatching, but it can be highly improved using Ruby’s tricks.

One of the goals or main definitions of meta programming is: Writing code that writes code, so, let’s try it.

In the previous example, there is a lot of duplicated code, that can be simplified by using define_singleton_method (reference). It takes advantage of Ruby’s dynamic nature to define singleton methods. The code above is nice and works, but, what if we got confident and also wanted to congratulate our sister, our brother, our grandma? Let’s sharpen it:

As we can see, now define_congratulations is called whenever the BirthdayCongratulations class is instantiated. This method calls define_singleton_method, which takes a method’s name and a block and creates a method just for our object. Then, by using dynamic dispatching, we can call such a method.

This has been a short concept example on how to use dynamic dispatching on Ruby. While it may not apply to all scenarios, it cannot be argued that it is a really powerful tool to have on our belt.

Also, take into account that despite being widely used by Ruby developers, send is not as good as it looks, as it exposes also private methods for the class. Use public_send (reference) instead if you want to make sure your private methods remain private.

Did you think this code could not be further improved? It sure can! Follow me along for the next story ruby_cool_kid.rb — Metaprogramming series: Ghost methods 👻 where I will explain how missing methods can be found 😉

See you around!! 👋

How to create easy Spreadsheets with FastExcel Gem

Pavs — Tue, 21 Sep 2021 21:48:20 +0000

Spreadsheets are nowadays one of the most common ways of showing and sharing organised information into a file. Whether it is to keep track of the inventory of goods in a store, or the total transactions performed by a user, spreadsheets will show the organised information in such way that it is clear.

One day, one of my managers gave me the task of allowing a store to download its entire inventory in a spreadsheet, having multiple pages regarding the different categories the user may have.
After doing some research on top popular gems used in Ruby on Rails for accomplishing this task, I ended up choosing FastExcel, that is based on Libxlsxwriter and wraps some methods around it, like formatting cells.
Even though there were some other valid gems, like Caxlsx or Write_xlsx , FastExcel seemed the most lightweight gem as well as the one that offered the best performance as it is shown under its benchmarks
...

Case Scenario

In order to show how the gem can be exploited, let’s suppose a scenario where a store has 3 categories of products each one of them holding 10 to 25 products each.

Base Case

The first task to accomplish is creating a spreadsheet that has three sheets, each one of them containing the products for each category. Let’s see how that’d go:

Let’s see what have we done here:

First, we have created a workbook named inventory.xlsx , that will be the file where we’ll write our data. After that, we loop on the different product categories the store has to offer, creating a new spreadsheet for each of them by using add_worksheet(sheet_name)

Diving into the data to be written, the headers are to be added first, formatting them in bold to highlight them. To do so, we have appended the headers by using append_row(data, format , and formatted them in bold by calling the bold_format method on our FastExcel object, that is basically a wrapper method around Libxlsxwriter’s set format method in order to format cells to bold.

Finally, we have looped inside the products for each category, appending them to the worksheet. Once all categories are filled, the workbook needs to be closed in order for us to access to it, as the constant_memory: true that we used for creating the file, saves each row to disk.

Advanced functions

Even though the base case would be a good fit for an inventory report, let’s image we are also asked for a total sum of the products we have in the shelves, so that we know how many items could be expected to sell.

Formulas

Of course, we could apply a simple SUM(ROW_A:ROW_B) formula on the file once it has been generated but, what if we could append it and save time?
Let’s see it, formulas are a special value type in excel and FastExcel has wrapped their behaviour under its own class, in order to ease its inclusion.

Supposing we wanted to include our formula to the end and the units for each product are on row B, the code for including it in the worksheet would be:

After this, we can have a better understanding of the gem and how easy it is to create xlsx files from rails and even apply formulas to them.

I hope this is of help for anybody looking for a quick xlsx file generator.

I will se you around! Keep grinding !