Song of the day

HTTP

HTTP stands for The Hypertext Transfer Protocol and it helps clients (aka browsers such as Chrome/Safari/Internet explorer) to communicate with a server. A browser sends an HTTP request to a server and then the server provides a response/status back.

HTTP Verbs

There are most common HTTP verbs/request you will see are:

Now that we have a basic understanding on how request are made to the internet we can review restful routes.

A RESTful route is a route that provides mapping between HTTP verbs (get, post, put, delete, patch) to controller CRUD actions (create, read, update, delete). Instead of relying solely on the URL to indicate what site to visit, a RESTful route also depends on the HTTP verb and the URL.

WHATTTTTTT does that mean?

That means that when get a request it determines if it is a GET, POST, PATCH, PUT, or DELETE request and locates the url for it. Then it connects to the controller handling that action and url. It will then execute the code in that controller and determine what to send back to the user.

#in your application controller
get '/posts' do
    @posts = Post.all
    erb :'/posts/index'
  end

The above getting a variable @posts to all of the posts you created in your database and rendering the /posts/index page with that information. @posts will now be available on your posts/index page as a variable that you can use to iterate over and display on the page.

#in your application controller
  get '/posts/new' do
    erb :'/posts/new'
  end

The above renders the /posts/new page so that the user can fill out a form which will look similar to this:

#in your views/posts/new
<form action="/posts" method="POST" >
  <input type="text" name="content" placeholder="content"><br/>
  <input type="submit" value="Create">
</form>

The form is making a POST request with the params named "content" that you can use to create a new post, like this:

#in your application controller
  post '/posts' do
    Post.create(content: params[:content])
    redirect '/posts'
  end

To make a patch/put request you will need to find the item that you are trying to edit and then use a form to make updates and make the patch/puts request.

You would find the item that you are trying to edit by using the .find method mentioned in a past post, like this:

#in your application controller
  get '/posts/:id/edit' do
    @post = Post.find(params[:id])
    erb :'/posts/edit'
  end

In a past post I mentioned that Ruby forms do not allow a user to make patch, delete, or puts request and that we must require Rack::MethodOverride in our config.ru. What I meant by that is that when you make a request, it requires an extra step, to make the application believe that it is making a POST request when really it is making a patch, put, or delete request. For example, our edit form will look like this:

<form action="/posts/<%= @post.id %>" method="post">
  <input id="hidden" type="hidden" name="_method" value="patch">
  <input type="text" name="content" value= "<%=@post.content %>">
  <input type="submit" value="update"/>
</form>

Rack::MethodOverride is like a Ruby helper that allows us to hide the patch method under the post method so that we can make that request.

Now to make the patch request in the application controller we would do the following.

#in your application controller
  patch '/posts/:id' do
   @post = Post.find(params[:id])
   @post.update(content: params[:content])
   redirect '/posts'
 end

Lastly, to make a delete request we would provide the following:

#in your views/posts/edit
<form action="/posts/<%= @post.id %>" method="post">
  <input id="hidden" type="hidden" name="_method" value="delete">
  <input type="submit" value="update"/>
</form>

#in your application controller
 delete '/posts/:id' do
  Post.destroy(params[:id])
  redirect to '/posts'
end

Resources:
w3schools

Mozilla Developer

Wiki

Check out my #100DaysofCode Github Repo