DEV Community: Jesse vonBergen

What exactly is a Ruby binding?

Jesse vonBergen — Sun, 16 Mar 2025 18:58:00 +0000

If you're a Ruby developer, you might have encountered something like the following:

binding.pry
binding.irb
binding.break

If your code runs one of these expressions, the execution will halt, and a REPL session will start from that context.

Have you ever wondered what a "binding" is exactly? Or how to use one? I'm hoping to answer both questions here, so let's go! 🚀

What is a binding?

A Ruby binding is...

An encapsulation of the execution context at some particular place in the code.

If you'd like to see exactly how Ruby creates the Binding class, you can find the source code here.

So, a binding encapsulates or "takes a snapshot" of a particular place in the code during execution. To illustrate this, imagine holding a photograph of an old-fashioned telephone.

Photo by Eckhard Hoehmann on Unsplash

This photograph was taken before smart phones were invented. What if you could jump back into 1984? You might ask people about smart phones, to which they would give you a blank stare.

Similarly, if you jumped into a photo taken in 2010 and asked about ChatGPT, you'd also receive "deer in headlights". In this sense, the photo is like the binding.

With bindings, we can jump back into the way things were.

Using bindings

Ruby makes this easy. Simply invoke the method binding, available globally. It will return an instance of the class Binding.

b = binding
b.class
=> Binding

The class itself has no variables, constants, or methods of its own, but the instances will encapsulate the context upon instantiation.

# Capture context #1
year_1984 = binding

i_phone = :invented

# Capture context #2
year_2010 = binding

chat_gpt = :invented

# Capture context #3
year_2025 = binding

In 1984, neither technologies were invented yet. In 2010 only the iPhone was invented, and in 2025, both have been invented.

We can see this clearly through the #eval method which takes a String argument (something to evaluate) and an optional binding. If not specified, it defaults to the current context.

# evaluating from the first context...
eval("i_phone", year_1984) # => NameError
eval("chat_gpt", year_1984) # => NameError

# evaluating from the second context...
eval("i_phone", year_2010) # => :invented
eval("chat_gpt", year_2010) # => NameError

# evaluating from the third context...
eval("i_phone", year_2025) # => :invented
eval("chat_gpt", year_2025) # => :invented

A Beginner's Guide to Curl: Part 5 - Setting Headers

Jesse vonBergen — Sun, 16 Apr 2023 22:23:45 +0000

HTTP requests are sent with metadata contained in headers. This includes data such as the request method, authentication credentials, and cookies.

Headers consist of a "field name" and "field value" separated by a colon. Multi-word field names are separated by dashes and are case-insensitive.

Field-Name: Some Value or field-name: Some Value

You can see exactly which headers are being passed by adding the -v or --verbose flag to your curl requests. There is also a free service that has an API endpoint that echos your request headers back to you as a JSON response.

Type the following command to see the default headers sent by curl.

$ curl https://httpbin.org/headers

I got this JSON response in return.

{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.85.0"
  }
}

By default curl accepts any content type in return, "*/*". Normally the "Accept" header would specify the MIME type the request is expecting in return, such as "text/html" or "application/json".

The "Host" header is set because of the URL supplied to curl.

The "User-Agent" in this case is the curl application, but let's switch that now.

Send this instead.

$ curl -H 'User-Agent: Mozilla/5.0' https://httpbin.org/headers

Now, as you can see, the response shows your agent header set to 'Mozilla/5.0'. All headers can be set in Curl with the -H or --header. Headers can be placed before or after the URL.
If you want to set multiple headers at once, you'll need us use multiple flags. Here's a way you can construct a complex curl request on multiple lines using the backlash to escape newlines.

(By the way, you can make up your own headers, and you don't have to prefix them with an 'X'.)

$ curl https://httpbin.org/headers \
    -H 'Accept: application/json' \
    --header 'Referer: https://dev.to' \
    -H 'My-Cool-Custom-Header: foo'

Authorization Header

One of the main usages of HTTP headers is authentication. Interestingly the header for this is called 'Authorization'. I guess these two concepts are similar enough.

Authorization headers work by specifying a scheme followed by a space and the value. Here's an example.

Authorization: basic username:password

Here's an API to test out basic auth. You construct the endpoint using basic-auth as the first segment followed by the username of your choice, and finally the password. In our case, we will attempt to authenticate via the endpoint basic-auth/username/password.

The API will either return a 200 or 401 response. Supplying the -i or --include flags will reveal the response headers and status code.

$ curl -i https://httpbin.org/basic-auth/username/password \
    -H 'Authorization: basic username:password`

Huh? Why is it a 401?

HTTP/2 401

This is because the internet specifies that basic HTTP auth credentials be encoded using base64.

Base 64 is not encryption. Nothing about it is secure, it's just a different encoding. This video offers a great explanation.

You can easily encode anything you want in Base64 without leaving the command line. Just echo an expression and pipe it to the base64 cli.

$ echo -n username:password | base64

You should see the result as dXNlcm5hbWU6cGFzc3dvcmQ=.

Ok, now that we have the string 'username:password' encoded in Base64, let's try the API again, and see if we can successfully authenticate.

$ curl -i https://httpbin.org/basic-auth/username/password \
   -H 'Authorization: basic dXNlcm5hbWU6cGFzc3dvcmQ='

And here's the response!

HTTP/2 200
{
  "authenticated": true,
  "user": "username"
}

Hooray!

But that seems pretty tedious. Thankfully, the developers of Curl already thought of that. That's why Curl provides a special option for the authorization header. Just provide the -u or --user flag followed by the username:password in plain text. You can specify the the scheme with the --basic; however, it's already basic by default. Curl will then encode your username and password for you.

$ curl -i https://httpbin.org/basic-auth/apple/banana
    --user 'apple:banana'

To verify that Curl really did encode the credentials, just supply the -v or --verbose flag to see all request headers. In my case with apple and banana, my header looked like this.

authorization: Basic YXBwbGU6YmFuYW5h

Another type of HTTP authorization is called bearer. Instead of supplying a username and password, you would use the word 'bearer' followed by a space and some sort of token. Oftentimes these tokens are randomly generated keys or actual data that's gone through a hashing algorithm, such as a JSON Web Token (JWT) which contains JSON data.

Once you're confident supplying header data in your Curl requests, you'll find it easy and fast to test out APIs straight from the command line.

A Beginner's Guide to Curl: Part 4 - Json APIs

Jesse vonBergen — Sat, 04 Mar 2023 18:41:07 +0000

Now let's start using curl to interact with APIs. A popular data format that get's passed around the internet is Json (Javascript Object Notation).

Json is structured by key-value pairs inside curly brackets and lists of key-value pairs inside square brackets. It uses double quotes and colons.

{
  "name": "Jesse",
  "articles": [
    {
      "name": "A Beginner's Guide to Curl: Part 4",
      "langauge": "English"
    },
    {
      "name": "A Beginner's Guide to Curl: Part 5",
      "length": {
        "words": 27321
      }
    }
  ]
}

Let's grab a Json response from a free Pokemon API service found at https://pokeapi.co. Notice it's .co not .com.

Webservices that offer API endpoints typically namespace them with /api and the API version, in this case /v2.

Here's the command.

$ curl https://pokeapi.co/api/v2/pokemon/charizard

You should have received a large block of Json printed to your STDOUT. It's pretty hard to read isn't it?

There are several tools you could use to pipe the HTTP Json response into a human-readable format. We'll use something called "JQ". You can read about it and download it at https://stedolan.github.io/jq/.

If you're on MacOS and use Homebrew as your package manager, you can type this in your terminal.

$ brew install jq

Now curl the same endpoint but this time pipe the response into JQ.

$ curl https://pokeapi.co/api/v2/pokemon/charizard | jq

Now, the Json should be indented in a way you can read it easily. It may even have color!

Currently, our data is only printed to our STDOUT, it's not persisted anywhere. We want to keep this around for future use. Do you remember the curl option to do this? Scroll down after you take a guess.

...

If you guessed --output or -o, you're correct!

Let's save our Json to a file called charizard.json

$ curl -o charizard.json https://pokeapi.co/api/v2/pokemon/charizard

Now, let's grab another one. Pick another Pokemon and substitute the API endpoint with its name. Also change the file name to match. For instance:

$ curl -o dragonite.json https://pokeapi.co/api/v2/pokemon/dragonite

I don't know about you, but these Json payloads contain more information then I need. The JQ tool has a way to scope the data by specific fields. There is a learning curve, but if you follow along, you'll at least get a basic understanding.

The Json payload has three keys that we're interested in: "name", "id", and "types". Type this command, and you'll get the response scoped to only these attributes and printed to your console.

$ curl https://pokeapi.co/api/v2/pokemon/charizard | jq '{name, id, types}'

Now, to refine this slightly, let's only grab each type name and put it in an array. Here's what that would look like.

$ curl https://pokeapi.co/api/v2/pokemon/charizard | jq '{name, id, types: [.types[].type.name]}'

And the output should be the following:

{
  "name": "charizard",
  "id": 6,
  "types": [
    "fire",
    "flying"
  ]
}

Final modifications

To finish up, let's explore two more helpful tips.

Reformatting the .json files we've already made
An alternate way to pipe output to a file

Use Vim to modify the .json files.

Don't worry, I'll help you get out. Or, you can just purchase a book like this...

Enter the following command to start editing the charizard.json file.

$ vim charizard.json

You need to enter the command mode. You can do so by typing the colon key :.

Now your cursor should be at the bottom. Enter the following command.

Note, you can only use this if you have JQ installed.

:%!jq '.'

Hit return and the file should instantly reformat itself!

Now type colon again and the following command to save and exit.

:wq

Hit return, and you're successfully exited vim. Congratulations!

Now if you cat the charizard.json file, it should be formatted correctly. You can also trim down the file with a vim command like the following. This will remove all excess data from the file.

:%!jq '{name, id, types: [.types[].type.name]}'

Now, if you don't want reformat or trim down file in the first place, instead we'll trim and format the data before writing to a file.

In order to do this, we can't use curl's -o option. We need to first pipe the response to JQ for formatting, then pipe that output to a file.

Here's how it's done.

Notice, we're using the \ to put our command on multiple lines

$ curl https://pokeapi.co/api/v2/pokemon/lapras | \
    jq {name, id, types: [.types[].type.name]} | \
    > lapras.json

Now, the lapras.json file will have the formatted and scoped content sent to it by JQ. To do that, we just use the > key followed by the name of a file.

A Beginner's Guide to Curl: Part 3 - Seeing the Details

Jesse vonBergen — Sat, 04 Mar 2023 16:41:15 +0000

In the previous article we learned about the -o or --output flag (or option). Now we will explore the -v flag which stand for --verbose.

If we want to see all the verbose details of our request and response, we need to pass in the -v flag. The particular option takes no arguments. It's like a boolean, it's either on or off.

Now we'll see what's going on "under the hood" as the manual states. Try the following command in your terminal.

$ curl -v http://www.example.com

The top what what was printed to your STDOUT should look something like this.

* Trying 2606:2800:220:1:248:1893:25c8:1946:80...
* Connected to www.example.com (2606:2800:220:1:248:1893:25c8:1946) port 80 (#0)
> GET / HTTP/1.1
> Host: www.example.com
> User-Agent: curl/7.85.0
> Accept: */*

The lines that begin with an asterisk are helpful messages curl is telling us. The lines that begin with an angle bracket are the actual HTTP request/response details.

The Request

These are the details of the HTTP request you just made.

Let's break it down line by line.

You attempted to connect to the IP address 2606:2800... This is the full Internet Protocol Version 6 address which we referred to by the domain name example.com
Next we see that we successfully connected at port #80
This particular request method was a 'GET' request via the HTTP version 1 protocol.
The host domain name we specified in our command
An HTTP header we sent, being our User-Agent which is of course curl. 7.85.0 is my specific version. Yours may be different. You can see your version of curl by typing $ curl -V.
Lastly, another HTTP header we sent, being the Accept header which specifies what type of content (MIME type) we are willing to accept in response. It this case, everything! */*

The Response

Here are the details of the response.

* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< Age: 266872
< Cache-Control: max-age=604800
< Content-Type: text/html; charset=UTF-8
< Date: Sat, 04 Mar 2023 16:21:04 GMT
< Etag: "3147526947+ident"
< Expires: Sat, 11 Mar 2023 16:21:04 GMT
< Last-Modified: Thu, 17 Oct 2019 07:18:26 GMT
< Server: ECS (cha/8094)
< Vary: Accept-Encoding
< X-Cache: HIT
< Content-Length: 1256

* Mark bundle as not supporting multiuse. This message appears because in this case we are using HTTP version 1 which does not support multiplexing or multiuse. HTTP 2 does.
The version of HTTP and the response status code. In this case, it's successful. 200! OK!

The rest of the lines contain all the response headers sent back from example.com. If you're interested, you can find information about all HTTP headers at https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers.

How to look up specific curl options

One of the difficulties you will undoubtedly face when leaning curl is finding the right option from the manual. Let's say you want to learn about the --verbose or --output flags but you don't feel like scrolling through the manual to find them. You can search the manual with grep.

We are going to "pipe" the output of the manual into the grep utility. Grep is basically a searching tool. Try this command and then I'll explain what it's doing.

$ man curl | grep -B 5 -A 25 -e '-v, --verbose'

First, we used the vertical bar character or "pipe" to pipe the output of man curl into the grep command.

Grep takes an expression to search for. That's why we passed the -e flag with the argument -v, --verbose. We are searching for that expression in the curl manual. Grep will return all the places where that specific string occurs. There should be only one.

However, before the -e flag, we passed in two other flags and arguments: -B with argument 5 and -A with argument 25. That means we want to print out 5 lines before the expression occurs and 25 lines after the expressing occurs.

Use can use this piping trick to search for specific commands in the curl manual.

Ready to go more in depth? Read A Beginner's Guide to Curl: Part 4.

A Beginner's Guide to Curl: Part 1 - Your First Curl

Jesse vonBergen — Sat, 04 Mar 2023 16:01:53 +0000

Curl (client-URL) is a command line utility app. In the same way your web browser accesses online resources via the address bar, so curl does the same via the a command line interface.

For example, open a new tab and go to this website, www.example.com. You probably saw a very boring looking example webpage. If you inspect the HTML in your browser, you'll see it's the standard <head> and <body> with some <div>, <h1>, and <p> tags. That's because the remote server behind this domain name serves HTML back when any client makes a GET request to that specific url. Your browser is able present the HTML visually to you.

Now, do the same thing in your terminal or command prompt. Type the following command and hit return.

Don't worry about typing the "$". That just shows this is a shell command we're typing.

$ curl http://www.example.com

You should have received several lines of text as a response. In the exact same way that example.com returned HTML to your web browser, it returned the same response to your command line client. You successfully just consumed a server response by using a terminal client instead of a browser.

Curl is very powerful, because you can work with server requests and responses directly without a browser getting in your way.

If you've ever used a tool like Postman for working with APIs, you'll find that curl can do almost all the same things if you know how to use it.

Curl is very simple. You type the word curl followed by an address (URL). Hit return and you get a response!

That's not all! You can customize your command with many different options and flags. Each one accomplishes a specific purpose. You could spend months or years trying to master all the different functionalities of curl.

Are you ready? Let's get started in my next article, A Beginner's Guide to Curl: Part 2

A Beginner's Guide to Curl: Part 2 - Options

Jesse vonBergen — Sat, 04 Mar 2023 16:00:31 +0000

If you want to teach yourself how to use curl, the best resource is the manual.

Type the following command in your terminal.

$ man curl

The man command is used to read the manual for other command line utilities (like curl). To exit the manual, just type q.

You should see a brief synopsis of what curl is and what it does. As you can see, there are a lot more protocols than just http. For this guide we will only be using http since that's what the internet is built off of.

If you scroll down in the manual, you'll see a section titled "OUTPUT". By default, curl will print the response to your STDOUT (standard output or terminal screen).

For example, exit the manual by typing q, and type the following in your terminal.

$ curl http://www.example.com

You should see the HTML response printed below to your STDOUT. That's the default response when using curl. Now let's change that by adding an option.

Our first option will be the -o flag or its longer full version --output. Whenever you pass an option to curl, you can specify it with a short name (with one dash) or a full name (with two dashes).

The -o or --output option takes one argument, the name of the file you want to write to. This can be an existing file, or one that you haven't created yet.

Let's try it out! Type the following command. Notice we are changing our URL now.

$ curl --output three_sentences.txt http://metaphorpsum.com/sentences/3

Two things just happened. First, curl created the file you specified in your current directory. Second, curl wrote the response from the sever to that file.

If you edit the file, you'll see the response is there. Another way to see the contents is to cat the file, you'll see the contents of the file printed to your STDOUT.

$ cat three_sentences.txt

If you were to type the same command without the --output option and file name, what do you think would happen?

In the next article, we'll learn how to see more details contained in the request and response. A Beginner's Guide to Curl: Part 3

By the way, here are some other URLs you can try.

http://metaphorpsum/com/sentences/10
http://metaphorpsum/com/paragraphs/3
http://metaphorpsum/com/paragraphs/3/2

How fast is your ruby code?

Jesse vonBergen — Mon, 07 Nov 2022 02:24:34 +0000

Sometimes you might need a way to measure the time it takes your code to execute.

This works...

Throw in a good old Time.now and then subtract the time start time from the new Time.now after the code executes.

# let's see how long it takes the Ruby interpreter
# to string together 5 million integers.
def string_together_ten_million_integers
  start_time = Time.now

  array = []
  10_000_000.times { |num| array << num }
  array.join

  end_time = Time.now
  puts "Took #{end_time - start_time} seconds to execute"
end

For me, this takes around 1.7 seconds on average. Is yours similar?

Now, we can change things up and see if there are faster solutions. For instance, what if you convert the integers to String before you join?

# convert the integers to String before the join
array = []
10_000_000.times { |num| array << num.to_s }
array.join

Hmm... 🤔 now it's more like 1.3 seconds. Making that change seemed to shave off half a second.

But wouldn't it make more sense to just instantiate a mutable String to push integers into? Then, there is no need to join.

# instantiate a String instead of an array
string = ""
10_000_000.times { |num| string << num.to_s }

Which one is the fastest for you?

It's getting harder to keep track of all our results! Wouldn't it be great to see these methods profiled all at once and see the results neatly printed together?

That's where the Ruby Benchmark class comes in.

This is better...

Benchmark is part of the Ruby standard library, meaning that it's readily available to require and use. Just type require 'benchmark' at the top of your file or any time during your IRB session.

You can also type irb -r benchmark when you start up your IRB session.

Like every module in the Ruby StdLib you can find the documentation at ruby-doc.org.

The simplest way to use Benchmark is to send it the class method ::measure and provide a block of code as the argument.

Benchmark.measure("label") do
  # block of code to measure
end

Try inserting some of the above methods into the Benchmark block and see what the resulting times are.

You're going to see the return value as a Benchmark::Tms class with the following attributes:

cstime - children system CPU time
cutime - children user CPU time
stime - system CPU time
utime - user CPU time
total - cstime + cutime + stime + utime
real - total elapsed time

Now for a little explanation of these terms. The user time is how long it actually takes for your code to execute. The system time is the underlying system underneath your code to do what it needs to do (your computer's kernel, etc.). The total time is the addition of the system and the user times.

So what is the real time? That's adding in user input, network connections, etc. If you only care about the actual wall clock time from start to finish, just look at the real time.

The children system and user times would be for any other methods called within your block. These would be child processes.

Although using Benchmark::measure is a good way to measure the run time for one block of code, there is a way to measure different blocks side by side.

The best way...

Instead of ::measure, let's use the ::bm method. This method allows you to generate reports of multiple code blocks. Perfect! Let's use this with our three methods above.

By the way, in Ruby we use '#' before instance method names and '::' before class method names when we refer to them. Since we never have to call Benchmark.new, we use the class methods only.

require 'benchmark'

Benchmark.bm do |x|
  x.report("array/join") do
    array = []
    10_000_000.times { |num| array << num }
    array.join 
  end

  x.report("array/to_s/join") do
    array = []
    10_000_000.times { |num| array << num.to_s }
    array.join
  end

  x.report("string/to_s") do
    string = ""
    10_000_000.times { |num| string << num.to_s }
  end
end

Did the results that printed to your console align correctly? With longer labels we need to adjust the label_width of the results. It's actually the first argument to the ::bm method, so try Benchmark.bm(20) do |x| to spread out the results.

These are the results on my machine:

                           user     system      total        real
array/join             1.551520   0.168228   1.719748 (  1.789678)
array/to_s/join        1.209965   0.122323   1.332288 (  1.373220)
string/to_s            0.893824   0.047670   0.941494 (  0.949304)

Hopefully you are feeling empowered to profile your Ruby code with the Benchmark utility!

Advanced additional content

One way to challenge your understanding of the Ruby Standard Library is to peruse through the source code. You'll find that it's not as intimidating as you might think.

Don't feel pressure to understand it all at first glance. Feel encouraged that you understand any of it and with practice your understanding will grow and grow!

Where can you find it? I use RVM (Ruby Version Manager) to manage and install my rubies and gems. So for me, I have a .rvm directory in my home directory. This is where the Standard Library is housed.

For me its ~/.rvm/rubies/ruby-3.0.0/lib/ruby/3.0.0.

From there you can open open up the benchmark.rb file and see the source code. It's a small module (written over 20 years ago!) of just over 500 lines with much of that taken up with documentation.

Notes

I first noted the different parameters the various methods received. This helped me to understand how I could use the methods.

I wanted my reports to have a longer width. I saw that the Report class was instantiated with a width attribute from the ::benchmark method which is called from the ::bm method. That's how I learned I could call ::bm with '20' as the argument to spread out the report.

Another interesting note is that the magic of Benchmark really happens in the ::measure method on line 291.

def measure(label = "") # :yield:
    t0, r0 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
    yield
    t1, r1 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
    Benchmark::Tms.new(t1.utime  - t0.utime,
                       t1.stime  - t0.stime,
                       t1.cutime - t0.cutime,
                       t1.cstime - t0.cstime,
                       r1 - r0,
                       label)
  end

Just like we were inserting Time.now in our original code, that's really all Benchmark does. Only, it uses a more sophisticated approach, Process.times and Process.clock_gettime(). Then it yields the block of code supplied and calls the same Process methods again and does the subtraction. This almost exactly what we were doing.

Apparently it isn't magic, just good Ruby developers like you and me writing simple code. 👊

If you were to do a little more digging in the the Ruby Process you might be able to develop your own customized Benchmark module.

Turn a Ruby file into an executable command!

Jesse vonBergen — Tue, 01 Nov 2022 04:01:34 +0000

Don't have 20 minutes to watch? Read the 6 minute article here.

Learn how to create a Ruby executable

Jesse vonBergen — Mon, 31 Oct 2022 02:42:23 +0000

Don't like reading? Watch the video here.

If you have Ruby installed on your computer, we know that you can execute .rb files with the ruby <file name>.rb command. This is not what we are talking about in this article.

This article is about executing ruby programs without typing ruby, ./, or an .rb extension and being able to execute the command from anywhere in your file system.

Just like when you type gem, rails, or irb, and your console immediately recognizes and runs a program, we want to do this with our own custom-built Ruby file.

Writing the program

Create a new directory anywhere. Name it favorite_color. This new Ruby program is going to do one thing, tell us our favorite color.

Make two sub-directories inside favorite_color. Name them lib, and bin. The lib directory will house the logic of the program. The bin directory will house the executable file that requires and calls the program in lib.

By the way, 'lib' stands for 'library', and 'bin' stands for 'binaries' (executable files). You could also name the bin folder 'exe' for 'executables. Housing your program source code in lib and your executable in bin or exe is standard for Ruby gem packages.

Name the lib file favorite_color.rb, and name the bin file fav-color.rb. (We will eventually remove the .rb extension.)

~ mkdir -p favorite_color/{lib,bin} && touch favorite_color/lib/favorite_color.rb favorite_color/bin/fav-color.rb

Your file tree should look like this:

favorite_color
├── bin
│   └── fav-color.rb
└── lib
    └── favorite_color.rb

2 directories, 2 files

Now, add some logic to favorite_color.rb. Here's what my class will look like. Write this however you want.

  1 class FavoriteColor
  2   def initialize color
  3     @color = color
  4   end
  5
  6   def declaration
  7     "Your favorite color is #{@color}"
  8   end
  9
 10   def declare
 11     puts declaration
 12   end
 13 end

The executable file inside the bin directory is responsible for loading the FavoriteColor class, initializing it, and calling it.

  1 require_relative "../lib/favorite_color.rb"
  2
  3 favorite_color = FavoriteColor.new("teal") #insert your real favorite color.
  4
  5 favorite_color.declare

At this point, if you cd into bin you can execute the fav-color.rb file like you normally would and it should print the output to your console.

ruby fav-color.rb
Your favorite color is teal

At this point, we could implement functionality in fav-color.rb to read an argument passed in which sets the color of the class, but for now we only want to focus on making this file a true executable.

Adding the shebang

A shebang refers to the characters #!. It's the prefix used when referencing the path to the interpreter that the shell should use to execute a script from the terminal. For instance, if you look at some of the executables in your /bin directories that are written in shell scripts, you will see #!/bin/sh at the top, or something similar. For Ruby scripts, you should reference /usr/bin/env. Why is that? Because the env command here is going to search for the first ruby interpreter in your PATH. The full line will look like this.

#!/usr/bin/env ruby

You might be able to just add #! ruby or #!/usr/bin/ruby, but the safest way is to do the full reference so that the executable will work on the maximum amount of machines.

At this point, your fav-color.rb file should look something like this.

  1 #!/usr/bin/env ruby
  2
  3 require_relative "../lib/favorite_color.rb"
  4
  5 favorite_color = FavoriteColor.new("red")
  6
  7 favorite_color.declare

Now, go ahead and try to execute the file. (Hint: at this point, with the shebang line, it is a true executable). You can still use the ruby command, but in order to take advantage of the shebang you need to type ./<file-name>. Did it work?

Most likely not. You probably don't have permission to execute the file. Each file on your machine has permissions set for reading ('r'), writing ('w'), and executing ('x'). When you first create a file, it defaults to allow you as the creator to read and write to it, and others to read it. In order to see those permissions, you need to use the shell commands ls -l, the -l flag standing for long format. If you use ZSH, you can simply type the shortcut to this which is ll. You should see something like this.

total 8
-rw-r--r--  1 jvon1904  staff   132B Oct 30 20:47 fav-color

The total 8 refers to the total size of the directory in kilobytes.

On the second line, first column, you see -rw-r--r--.

Although cryptic at first, this is a very simple designation for the file permissions.

The first character is either - meaning it's a file. It could also be d for directory.

The next three characters are permissions for the owner, which in this case are read and write.

The fourth character is the slot for execute, x. If the owner could execute the file, it would be -rwx-r--r--.

The 5th-7th characters are for the group, which on my computer is called 'staff', and the 8th-10th characters are for others.

Changing the permissions for the file

In order to change the permissions, you need to use the chmod command.

The most straightforward way to add user permissions is to type chmod followed by a letter representing who is receiving the permission (u, the user/owner, g, the group, o others, or a all) followed by a + or - (adding/removing permissions) followed by the permission (r, w, or x) and finally the file name.

For us it would look like this.

chmod u+x fav-color
ls -l
total 8
-rwxr--r--  1 jvon1904  staff  132 Oct 30 21:00 fav-color

There happens to be another fantastic way to set all permissions for all people with only three numbers! For instance, if you want all people to have all permissions, you would type chmod 777 <file-name>.

If you type 000 you will remove all permissions completely. Can you figure out why?

The three numbers represent the three entities being permitted (u, g, and o).

0 -> no permissions

1 -> execute permission

2 -> write permission

4 -> read permission

Then add up those numbers for any combination of the three. So a 7 means all three permissions because 7 = 1 + 2 + 4. Cool right?!

In our case, you could type chmod 744 fav-color.rb and nothing should change.

Now that we've changed the permissions, try executing the file like ./fav-color.rb and it should work!

Adding the executable to your path

At this point, we should go ahead and take off the .rb extension because it's not needed now that we've added our shebang directive and turned the file into an executable.

mv fav-color.rb fav-color

The problem now is that you must reference the entire path of the file in order to execute it.

If you are inside the directory that contains fav-color you must type ./ before hand.

If you are inside the favorite_color root directory, you must execute it as bin/fav-color. This is not ideal. We want to be able to type fav-color from anywhere.

There are two ways to accomplish this.

Exporting the full path to the executable to your $PATH variable, or
Adding a link to the executable to one of your /bin directories already loaded into the $PATH.

If you are familiar with adding to your PATH, feel free to use the first option (adding export PATH=$PATH:path/to/favorite_color/bin to .zshrc, .zprofile or .bash_profile, etc.)

The recommended option in this case is to make the executable a binary in one of your bin directories.

You've probably noticed that when you venture underneath your HOME ~ directory, there are more than one 'bin' folder.

In order to not confound system critical binaries, you should place a custom binary in /usr/local/bin. We can do this by linking the file to that directory.

sudo ln -s ~/favorite_colors/bin/fav-color /usr/local/bin

When using the ln (link) command, make sure to reference both the executable and the bin directory as abosolute paths.

You can cd into /usr/local/bin to make sure it's there.

I have a line like this.

lrwxr-xr-x  1 root  wheel    44B Oct 30 22:26 fav-color -> /Users/jvon1904/favorite_color/bin/fav-color

It appears that linking the file to /usr/local/bin automatically allows everyone to execute it.

Give it a shot. Execute the file from anywhere in your file system simply as fav-color.

How to Wrap Around a Range of Numbers with the Modulo

Jesse vonBergen — Thu, 12 May 2022 21:47:50 +0000

We'll be using JavaScript, but this should work for any language that uses the modulo operator

TL;DR

Sometimes you have a range of numbers like 1-10. You want functions to increment and decrement the index within the range without going below the minimum or above the maximum. The modulo operator accomplishes this.

Use Case

I was recently following along the guide to Stimulus.js and ran across this problem.

If you're interested, Stimulus is a JavaScript framework that comes standard in Ruby on Rails 7. Since I like to code in Ruby and use Rails, I've been learning it. It allows you to easily manipulate DOM elements with Javascript by adding data attributes to your elements.

The guide walked through creating slideshow-like functionality where two buttons toggle through a list of four divs that either display or are hidden.

The problem is that when the current index is 0, and you click previous, the index decrements to -1. Similarly, if you are on index 3 (the fourth item in the list), the index increments to 5. The desired behavior would be for it to wrap around to the first/last elements.

increment
0 → 1 → 2 → 3 → 0 → 1

decrement
2 ← 3 ← 0 ← 1 ← 2 ← 3

You get the idea!

How to Accomplish this using Javascript!

// let's start by defining a simple class Range 

class Range {
  constructor(index) {
    this.index = index;
  }

  // here are our two methods.  We will return the index
  // so that it's easy to see what's happening
  next() {
    this.index++
    return this.index
  }

  previous() {
    this.index--
    return this.index
  }
}

So the goal here would be to instantiate a new instance of Range, and use the two methods increment and decrement the index, looping through 0-4, never going below zero or above four. Of course... this won't work.

// our class allows us to specify the starting range.
// we could have set the default to 0 as well.

let range = new Range(0);

Now let's try calling the methods and see what happens to the index.

range.index
=> 0
range.next()
=> 1
range.next()
=> 2
range.index
=> 2
// cool! it's works

range.next()
=> 3
range.next()
=> 4
range.next()
=> 5
range.next()
=> 6
// oops! too high!
// let's bring it down.
range.previous()
=> 5
range.previous()
=> 4
range.previous()
=> 3
range.previous()
=> 2
range.previous()
=> 1
range.previous()
=> 0
range.previous()
=> -1
range.previous()
=> -2
// oops!  too low!

So hopefully now what we are trying to accomplish is clear. Now let's get to the solution.

Using the Modulo Operator

What is it? TL;DR it returns the remainder after division.

3 divided by 2 is 1 with a remainder of 1. What if we only want the remainder value? Use our friend modulo. It's just the percent sign.

3 % 2 => 1
10 % 8 => 2
5 % 5 => 0
4 % 2 => 0
6 % 3 => 0
7 % 4 => 3
156 % 37 => 8

Whenever you use modulo with a larger number on the right, it will return the number on the left.

1 % 10 => 1
1 % 2 => 1
5 % 6 => 5
5 % 10000 => 5

Modulo can actually accomplish some cool things! I first saw a practical use for it while trying to code a 2D spaceship game in Ruby. The modulo operator allowed the spaceship to go off the screen and re-enter from the other side. It's going to serve a similar purpose here.

Let's say my index is 0. I want to add 1 to it but not allow it to get above the number 4. So 5 is the length of the range 0,1,2,3,4.

So what I do is this, I assign the original index (0) to the sum of itself plus the range length (5) plus the increment amount (1) modulo the range length (5).

index = (index + rangeLength + incrementAmount) % rangeLength

Mind blown yet? 🤯

Try it out!

Assign the original index to the sum of itself plus the range length plus the increment modulo the range length.

Correction! When incrementing, you don't need to add the range length. It doesn't hurt if you do though. So you could just do index = (index + 1) % rangeLength. You do need to add the range length when decrementing though.

index = 0
index = (0 + 5 + 1) % 5 => 1

Six divided by five has a remainder of 1. So now the index is 1.

index = (1 + 5 + 1) % 5 => 2
index = (2 + 5 + 1) % 5 => 3
index = (3 + 5 + 1) % 5 => 4
index = (4 + 5 + 1) % 5 => 0

It worked! Because 10 divided by 5 has no remainder the index now restarted at 0.

Now let's try the decrement method. Just assign the index to the remainder of itself plus the range length minus the decrement amount divided by the range length.

index = (index + rangeLength - decrementAmount) % rangeLength

let index = 4
index = (4 + 5 - 1) % 5 => 3
index = (3 + 5 - 1) % 5 => 2
index = (2 + 5 - 1) % 5 => 1
index = (1 + 5 - 1) % 5 => 0
index = (0 + 5 - 1) % 5 => 4

Now we can edit our Range class to implement this.

class Range {
  constructor(index) {
    this.index = index;
    this.length = 5;
    this.incrementAmount = 1;
    this.decrementAmount = 1;
  }

  next() {
    this.index = (this.index + this.length + this.incrementAmount) % this.length;
    return this.index
  }

  previous() {
    this.index = (this.index + this.length - this.decrementAmount) % this.length;
    return this.index
  }
}

Now test it out. Our next() and previous() methods should work perfectly!

Using Nokogiri and RegEx to Scan a Webpage in Ruby

Jesse vonBergen — Sat, 07 May 2022 01:59:21 +0000

TL;DR

We are going to use a gem to search for a topic in a web article to produce a list of snippets.

Read this article I wrote to get an introduction to Nokogiri.

I'm a casual fan of into baseball. ESPN has lots of MLB articles. What do they talk about? It's a mystery! We need to scan the page with Nokogiri to find out. Are you ready?

Get that Article!

➜  ~ irb --simple-prompt
>> require 'nokogiri'
=> true
>> require 'open-uri'
=> true

# I'm going to scan the article at this URL.  Feel free to 
# find one of your own, since this will probably be outdated 
# by the time you read this.

>> url = 'https://www.espn.com/mlb/story/_/id/33855507/mlb-power-rankings-week-4
-new-team-surged-our-no-1-spot'
=> "https://www.espn.com/mlb/story/_/id/33855507/mlb-power-rankings-week-4-...
>> web_page = Nokogiri::HTML5(URI(url))
=>
#(Document:0x5b4 {
...

Now we need to find the body of this article so we only scan the relevant portions. We'll use the #css method with the div and class name.

>> body = web_page.css('div.article-body')
=> [#<Nokogiri::XML::Element:0x5730 name="div" attributes=[#<Nokogiri::XML:...
>> text = body.text
=> "7:00 AM ETESPNFacebookTwitterFacebook MessengerPinterestEmailprintFour ...

Now for the fun part.

Regular Expression Scan

Ruby has a String#scan method that takes a Regular Expression as an argument and returns an array of all occurrences.

>> "don't do that dog!".scan(/do/) => ["do", "do", "do"]

But we don't really want to just get a list of occurrences. We want to get the whole context so that we can see what the article is talking about. To accomplish this, we need to find the index of each occurrence as if our string was an array of characters. Then we will slice well before and after this index to get the context of each occurrence. This brings up a (maybe lesser-known) method called #to_enum (to enumerator).

The to_enum method allows us to enumerate the String and pass a method and optional argument. Here's an example where we will get the byte code for each ASCII character in a string. We will print each to binary using to_s(2).

>> "abcdefg".to_enum(:each_byte).each { |b| p b.to_s(2) }
"1100001"
"1100010"
"1100011"
"1100100"
"1100101"
"1100110"
"1100111"

For our purposes, we will pass the :scan method with the argument being our Regular Expression. Then we will map each occurrence with Regexp.last_match.begin(0) to get the beginning index for the occurrence. This is how it works.

# remember text holds the text of the article body
# each index will go into the indices variable
# we can search for whatever we want, let's search for pitch
# this will work for pitch, pitchers, pitches, etc.
>> indices = text.to_enum(:scan, /pitch/i).map do |pitch|
     Regexp.last_match.begin(0)
>> end
=>
[1825,
...
>> indices
=>
[1825,
 3699,
 4727,
 10007,
 10127,
 10846,
 11016,
 12617,
 13734,
 14060,
 14585,
 14927,
 16019,
 17835,
 18858]

Great! This list of indices reveals to us where to slice to get our data. We'll slice 30 characters before the start and will will make the length of our slice 70 characters. We'll push these snippets of text into an array.

>> snippets = []
=> []
?> indices.each do |i|
?>   snippets << text.slice(i - 30, 70)
>> end

>> snippets
=>
["n-differential in the majors. Pitching has mostly carried them, but th",
 "st year, Milwaukee's starting pitching was basically three deep. That ",
 "rt envious: Too many starting pitchers. Clevinger is the sixth member ",
 " allowed. While he has a five-pitch repertoire, one thing he's done th",
 "eup combo. He threw those two pitches a combined 64.3% of the time las",
 "ause his swing rate and first-pitch swing rate in particular are up. H",
 "nd him he's going to get more pitches to hit. -- Schoenfield17. Chicag",
 "2 batting line this year. The pitching staff has been one of the brigh",
 "ice start. Good, right-handed pitching will stymie them this year, tho",
 "le against both hard and soft pitching, despite dominating the league ",
 " ranks among some of the best pitchers in all of baseball in WAR. -- L",
 " back to .500. Their starting pitchers have lifted them, with Zac Gall",
 ". The Rangers did have better pitching last week, moving them up the l",
 "r nine innings in 11⅓ innings pitched. -- Lee29. Washington NationalsR",
 " Colorado will do that -- but pitching was a big problem. The Reds com"]

We did it! Now let's clean them up so they start and end with full words. We'll take each snippet, split it apart by whitespace, remove the first and last partial words, then paste it back together with spaces.

snippets.map do |snippet|
?>   words = snippet.split(" ")
?>   words.pop
?>   words.shift
?>   snippet = words.join(" ")
>> end
=>
["in the majors. Pitching has mostly carried them, but",
 "year, Milwaukee's starting pitching was basically three deep.",
 "envious: Too many starting pitchers. Clevinger is the sixth",
 "While he has a five-pitch repertoire, one thing he's done",
 "combo. He threw those two pitches a combined 64.3% of the time",
 "his swing rate and first-pitch swing rate in particular are up.",
 "him he's going to get more pitches to hit. -- Schoenfield17.",
 "batting line this year. The pitching staff has been one of the",
 "start. Good, right-handed pitching will stymie them this year,",
 "against both hard and soft pitching, despite dominating the",
 "among some of the best pitchers in all of baseball in WAR. --",
 "to .500. Their starting pitchers have lifted them, with Zac",
 "The Rangers did have better pitching last week, moving them up the",
 "nine innings in 11⅓ innings pitched. -- Lee29. Washington",
 "will do that -- but pitching was a big problem. The Reds"]

There you have it! Hopefully this article revealed just some of the cool features to Ruby. Don't be afraid to explore new gems and look up new methods on the Ruby-Doc website.

What is Nokogiri?

Jesse vonBergen — Thu, 05 May 2022 01:44:22 +0000

TLDR;

A Nokogiri is a Japanese pull saw. Oh... didn't help? Keep reading.

The Gem

Nokogiri comes standard in the Gemfiles of Rails apps. I first noticed it because it showed up in a Bundler error.

Nokogiri is a low-dependency module written in C, Java, and Ruby that parses XML and HTML so that these protocols can be used by Ruby. Let's get started.

Using Nokogiri to Parse HTML

Do you want to use Ruby to extract data from a webpage?

First run nokogiri -v and see if you get a response with a verion number. If not, you'll have to run gem i nokogiri

➜  ~ irb --simple-prompt
>> require 'nokogiri'
=> true
>> Nokogiri
=> Nokogiri

Don't forget to require it, otherwise you'll get a NameError for an uninitialized constant.

First, we will start by parsing HTML we create, then we will parse an actual webpage.

# First, put some valid html into a string.
>> html = "<h1>Hello World!</h1>
<section><h2>A List of Stuff</h2>
<ul><li>Camera</li>
<li>Computer</li>
<li>Television</li>
</ul></section>"
# Now pass that string into the HTML5 module as an argument
>> document = Nokogiri::HTML5(html)

You should get a response like this

=>
#(Document:0x4c4 {
  name = "document",
  children = [
    #(Element:0x4d8 {
      name = "html",
      children = [
        #(Element:0x4ec { name = "head" }),
        #(Element:0x500 {
          name = "body",
          children = [
            #(Element:0x514 {
              name = "h1",
              children = [ #(Text "Hello World!")]
              }),
            #(Element:0x528 {
              name = "section",
              children = [
                #(Element:0x53c {
                  name = "h2",
                  children = [ #(Text "A List of Stuff")]
                  }),
                #(Element:0x550 {
                  name = "ul",
                  children = [
                    #(Element:0x564 {
                      name = "li",
                      children = [ #(Text "Camera")]
                      }),
                    #(Element:0x578 {
                      name = "li",
                      children = [ #(Text "Computer")]
                      }),
                    #(Element:0x58c {
                      name = "li",
                      children = [ #(Text "Television")]
                      })]
                  })]
              })]
          })]
      })]
  })

Nokogiri's HTML5 module took our HTML string and returned a Document class to us that has it's own set of methods. Let's look at a couple. (Remember you can always list all the methods by using Document.methods.sort.)

Document#children

This will will return an array-like XML::NodeSet. It only has a length of one because it's the <html>...</html> element that we never included in our string. This child has two children, the <head>...</head> and the <body>...</body> tags.

>> body = document.children.children.last
=>
#(Element:0x80c {
...
>> ul = body.children.children.children
=> [#<Nokogiri::XML::Text:0x8c0 "A List of Stuff">, #<Nokogiri::XML::Elemen...
?> => [#<Nokogiri::XML::Text:0x8c0 "A List of Stuff">, #<Nokogiri::XML::Elemen..
.
>> >> ul.children.length
>> => 3
?> ?> ul.children.each do |child|
>> ?>   puts child.text
>> >> end
>> Camera
>> Computer
>> Television

Parsing HTML from the Internet

I've heard the Internet is a good place to find HTML documents to parse. You can capture some of this HTML by using the Client URL command in your terminal.

Ruby-Doc.org is a great resource to learn about all Ruby objects.

Capture it like this.

➜  ~ curl 'https://ruby-doc.org'

While it's cool to see the HTML populate the terminal, it's even better when it comes back as a Ruby object for us to use the data. To do so, let's use Nokogiri!

# You'll need the open-uri gem in addition to Nokogiri
# Open-uri allows you to open a URI as if it was a file in Ruby

>> require 'nokogiri'
=> true
>> require 'open-uri'
=> true

>> doc = Nokogiri::HTML5(URI.open('https://ruby-doc.org'))
=>
#(Document:0x9998 {
...
>>

Now we can use the #css method to query the html by elements and classes.

>> puts doc.css('h1')
<h1><a href="/">Ruby-Doc.org</a></h1>
=> nil
>> puts doc.css('p').first
<p>Help and documentation for the Ruby programming language.</p>

Query class this way.

>> rails = Nokogiri::HTML5(URI('https://rubyonrails.org'))
=>
#(Document:0x1f1bc {
...
>> headline = rails.css('div.heading__headline')
=> [#<Nokogiri::XML::Element:0x1fb94 name="div" attributes=[#<Nokogiri::XML...
>> puts headline.text

        Compress the complexity of modern web apps.
        Learn just what you need to get started, then keep leveling up as you go. Ruby on Rails scales from HELLO WORLD to IPO.

        You’re in good company.
        Over the past two decades, Rails has taken countless companies to millions of users and billions in market valuations.

        Building it together.

        Over six thousand people have contributed code to Rails, and many more have served the community through evangelism, documentation, and bug reports. Join us!

        Everything you need.
        Rails is a full-stack framework. It ships with all the tools needed to build amazing web apps on both the front and back end.

        Optimized for happiness.

        Let’s get started.

Great! Now you have a general idea of how Nokogiri works!

And now for free bonus content...

Let's search a webpage's content. For instance, it's basketball season at the time of this writing, so let's see if the homepage to ESPN talks about basketball.

>> espn = Nokogiri::HTML5(URI('https://www.espn.com'))
=>
#(Document:0x259e0 {
...
# For this we will use a Regular Expression (RegEx)
# The Regular Expression goes between forward slashes
# And the 'i' flag makes the search case-insensitive
>> espn.text.scan(/basketball/i).count
=> 32

There you have it! And we didn't even have to visit the website to find out that ESPN refers to basketball 32 times on it's homepage! Wow...