We interact with the program world by sening it messages. In response to our messages, objects return something. When we’re using the REPL, the program world treats us, the programmer, as if we were just another object in the object world.

The only way to send messages to objects in Ruby is with the . (dot): it means 'send this object a message', for instance: 2.integer? or 5.positive? means "send the object referenced (by the numbers 1 and 5 respectively) amessages asking it to answer if it’s an integer or not."

So 1 + 2 is actually translated to 1.+(2)

When a messaged object requires something else to answer the message, we call that something else the argument, for instance: 1.+ ⇒ "add what?"/"what should I add?" that missing element in the message is what we call the argument.

It’s ok to send lots of messages to objects, one after the other:

four.+(five).+(seven).-(one)

the queing up of messages is known as "chaining".

Most games are built around loops, with some 'break' condition being 'the end of the game':

An object might want to keep track of some value during a while loop. The object can’t just define a variable inside the loop:

An object can execute procedures in a while loop forever, if we tell it to run while true.

return says to an object:

Stop from executing this procedure. Return this value as the 'return value' from the procedure. It’s typically used inside a method, to say "this is what should come back from calling this method". However, we can use it to manage the control flow because instructions after a return will never be executed:

nil is an object that represents nothing. It can’t do much much: it just says : "there is absence of anything here"

<1>This method takes two arguments, the first argument is the starting index, the last argument is the length of the slice.

<1>This is an example of syntactic sugar. If we create a new string with string="this is a string", then behind the scenes it does the above.

Arrays can contain arrays.

Because this app will be really simple, we will only use this file to store all of BookList source code inside.

we run the server with: ruby server.rb

However that command does not work, so we use the following instead:

brew services stop mongodb-community@6.0

We reinstall mongosh and we get this message after putting in the following command: db.enableFreeMonitoring()

The reason we are using mongodb is because we need it create the api, but if we were interacting with a thrid party api we would need this.

To keep this README simple, you should refer to the actual tutorial to check if everything is in tune and inline with the tutorial

the equivalent of rails console in Sinatra (apparently, according to this tutorial) is irb though that isn’t quite true, since irb is Ruby’s REPL

By doing the following:

Directly inside the irb, It outputs the information for us.

touch Gemfile

We populate it with the necessary information:

We add one more gem sinatra-contrib to use the namespace feature later on. Finally, we run bundle install to get everything in place. From now on, we will use bundle exec server.rb to start our web API.

We could also have created a config.ru file and run the application with Rack but to keep this tutorial short, simply using the bundle command is easier.

The reason this is important if we want to be able to version it and add a v2 later, for example.

The best practice here is usually to define the API version using HTTP headers. However, for tutorials, it’s much simpler to have it in the URL because we can easily test some endpoints using a browser.

Two resources on namespaces in Ruby: - geeks for geeks - the role of namespace in ruby on rails

When we try to run the new site with the new endpoint, we get the following error:

So we look it up and find this possible solution to the problem: stackoverflow.com/questions/67615800/ruby-sinatra-compile-error-server-handler-thin-puma-reel-http-webrick-not-fo

The solution proposes adding these things to the gemfile:

We will put them in the Gemfile instead and then run bundle install, to see if this fixes the problem.

After doing so, we run the command bundle install but get the following error:

We try various things, but since there does not seem to be any requirement that we should be using this, we decide to remove 'thin' from the Gemfile. We then run the command and the api works.

We get this message in the terminal

And the api returns, exactly what we asked for:

We want people to be able to filter by name, isbn, and author. How do we do that? We are going to use a combination of scopes and just use URL parameters to let the client filter the books. We are going to have to add some code. We are using regex to return the titles that match:

/^#{title}/

where ^ indicates the beginning of the text. It can also be turned to a case insensitive search if we use /^#{title}/i

This means that we can search for a book without giving its entire name, for instance: localhost:4567/api/v1/books?title=Foun localhost:4567/api/v1/books?isbn=[insert isbn number here]`

The search is working for the specific search queries, but the problem is that we don’t necessarily want to send all the book attributes to the client. To fix this, we are hoing to create a small Ruby class that will serialize books into JSON documents.

Our serializer is going to be a PORO (Plain-Old Ruby Obect) with one method called as_json that will be called whenever to_json is called on an instance.

We go from having this:

To this:

Now lets add the show endpoint to access the details of one specific book. If the books i not found, we want to tell the client using the HTTP status 404.

Being able to add books is an important feature for BookList. We will follow best practices for our create endpoint and return 201 to the client while using the Location header to tell the client where it can find the newly created book, if it wants to

We are going to need to create the base url, so let’s add a helper to do this. We also need a helper to parse the request body and return an error to the client if the parsing fails.

It’s a mix between the hosw and the create endpoint.

We first retrieve the book, then update the attributes before returning the updated book.

We update the server.rb file with a new patch method inside our namespace

We use the curl command to verify the result we get from that To test the endpoint, to run those we will need to change the id used by an ide we have in our database

We’re now 0n the last endpoint that we need. Here, we will retrieve a book, delete it if it exists and return 204 No Content to the client.

We make the curl request to delete the book from BookList

We can see alot of repeated code in our endpoints. We can change this by using some helpers and refactoring a bit of the code of each endpoint.

First part:

Second part:

Usually, user account will be stored in a database. User accounts can also be considered a resource: we can create a new user account (signing up), read its information (account page), update it, etc.

Something to keep in mind when storing user account information, especially when it contains sensitive data (like a password), is encryption. A password should never be stored in plain text in a database, as even databases can be subjected to security breaches and attacks.

You can use the bcrypt gem in Ruby to achieve this. Make sure you store the encrypted password when inserting the user account in the databse, and check against the correct encrypted value when authenticating the user.

By design, web server can’t remember information about specific client = it only receives requests, and sends back a response.

In order to keep track about a specific client, we can use a feature of Sinatra called the session. By storing information in the sessoinm we can make it available in any subsequent requests from the same client.

Authentication is a very good example on how sessoins can be useful - here is a typical HTTP flow of a user signing in:

So the session is a way to "remember" information about a specific user, even though the client they are using is sending many different requests to the server.