DEV Community: Shehroz Irfan

Git commands to get information about changes made to your files

Shehroz Irfan — Sat, 05 Feb 2022 17:44:54 +0000

Hi,
In this article you will learn git commands which you can use to get information about the changes made to your files. Below is the list of commands that you'll learn in this article.

git log
git log -p
git show
git log --stat
git diff
git diff --staged

git log

The git log command shows the list of all commits that have been made in the current git repository.
Let's see the output when using git log:

In the image above you can see, by default the git log shows the commit id, author, date, and commit message.

git log -p

The git log shows the list of all the commits. But what if you want to see the actual lines changed in each commit?
So, in this case you can use the -p flag with git log. Here p comes from patch, because using this flag gives us the patch that was created.
Let's see the output when using git log -p:

In the image above you can see that it shows the added lines with plus(+) and removed lines with minus(-), and as the amount of output text is longer than what fits on the screen, git automatically uses a paging tool that allows you to scroll using page up, page down and arrows keys. You can quit the paging tool by entering 'q' from your keyboard. In the output you have one commit below the other and each commit takes up the different space depending on how many lines were added or removed in that commit.

git show

To see the actual lines changed in a specific commit you can use git show command. The git show command takes the commit id and then shows the files changed in that commit. You can get the commit id of a specific commit by using git log. Let say you have a commit id: '8a0d3873714c16cb8cc3810fe4861a770892ea97', now you can see the files changed to this commit using:

git show 8a0d3873714c16cb8cc3810fe4861a770892ea97

Below is the output:

In the image above you can see that it only showed the patch of that specific commit. The benefit of using git show is that you don't need to scroll to a specific commit in the output of git log -p to see the files changed. You can directly see the files changed by providing the commit id to git show command.

git log --stat

It is the interesting command that shows the stats about commits such as how many files are changed and how many lines are added or removed.
Lets see the output when using git log --stat:

In the image above you can see it showed the stats such as the number of files changed and the number of insertions and deletions.

git diff

This command shows the changes made to the files and the output is same as linux diff -u command. But one point to be noted here is that git diff only shows the un-staged(the changes that are not added to the staging area) changes.
Let's see the output when using git diff:

In the image above you can see that git diff shows the changes made to the file by plus(+) and minus(-) representing the insertions and deletions.

git diff --staged

As I mentioned above git diff only shows the un-staged changes. So, if you want to see the changed made to the files that are staged you can use --staged flag with git diff. It will show the changes made to the files present in the staging area.

Summary

There are plenty of other commands that you can use to get information about changes made. You can always use the reference documentation to find out more.
Thanks for reading!

Remote form submission and AJAX in Rails

Shehroz Irfan — Sun, 23 Jan 2022 13:00:36 +0000

Hi,
In this article, you'll learn what is Ajax and remote form submission in rails.

What is Ajax?

First of all, you need to know what actually Ajax is and for what purpose it is used. Let's understand this in simple words:

What happens when we visit a website?

When we visit a website a webpage is loaded from the server and if we want to see the new or updated information then we have to reload the webpage. So, this is a synchronous flow. The new data will be presented only when the webpage is requested from the server.

What if we don't want to reload the page or what if we only want to update some section of our current page without reloading the page?

So, this is where AJAX(Asynchronous Javascript and XML) comes in. Ajax is a mixture of several technologies and allows the client-side changes without reloading the page.

Remote form submission in Rails

Now let's dive deeply into Ajax by submitting a remote form using AJAX in Rails because adding Ajax to web forms is a common practice and Rails makes Ajax easy to implement.

In the example below, we will first create a simple form to get the user data and when the form is submitted we will save the user data and in response render a partial displaying the user information without reloading the page.

*Submitting a form using AJAX *

Controller name: Dashboard
Action which displays the form: new_user
Action which responds to Ajax request: save_new_user

Creating the form with remote true

When you're creating the form you just need to add

remote: true

in the form tag and rails automagically uses Ajax.

new_user.html.erb
<%= form_for @user, url: save_new_user_dashboard_index_path, html: { method: :post }, remote: true do |f| %> . . . <% end %>

The actual HTML generated by the ERb is:

.
.
.

As you can see it sets the variable data-remote="true" inside the form tag, which tells Rails to allow the form to be
handled by JavaScript.

Making the controller respond to Ajax requests

As our form is ready, now we need to make our controller respond to Ajax requests and this can be done by using the respond_to method.

dashboard_controller.rb
def save_new_user @user = User.create(new_user_params) respond_to do |format| format.html {redirect_to new_user_dashboard_index_path} format.js end end

The above syntax might be confusing, but it is important to understand only one of the lines gets executed. In
this sense, respond_to is more like an if-then-else
statement than a series of sequential lines. When there is an Ajax request(i.e, when remote: true is set) then format.js will be executed otherwise format.html will be executed.

Creating Javascript embedded ruby file

When format.js will be executed, rails automatically calls a Javascript embedded ruby(.js.erb) file with the same name as the action name.
Inside a JS-ERb file, Rails automatically provides the
jQuery JavaScript helpers needed to manipulate the page
using the Document Object Model (DOM). JS-ERb files also allow the use of embedded Ruby which we apply in the save_new_user.js.erb file to render a partial with user information. We'll use the escape_javascript method.

save_new_user.js.erb
$("#show_user_information").html("<%= escape_javascript render(partial: 'dashboard/show_user_information', locales: { user: @user }) %>");

The $("#show_user_information") will select the element with id show_user_information and html will update this element with the content present in its argument. Below is the code for show_user_information partial:

_show_user_information.html.erb
`

First Name: <%= @user.first_name %>

Last Name: <%= @user.last_name %>

Email: <%= @user.email %>

So, with all this, you can enter the user information, save it in the database and then show that information on the same page without the page reload.

Before submitting the form:

After form submission:

Git rebase a remote branch in the terminal

Shehroz Irfan — Sun, 16 Jan 2022 11:42:03 +0000

Hi,
In this article, you will learn how to git rebase a remote branch in the terminal. I am dividing the whole process of rebasing into 5 steps. Let's understand this with the example below:

You are on a branch named feature and you want to rebase this branch onto the branch named main.

Step 1: Pull the latest changes from the remote of your target branch.

In the example, the target branch(the branch onto which you want to rebase the feature branch) is main.
As we are currently on feature, so first we need to checkout to the main and then we will pull the latest changes.

git checkout main

git pull origin main

Step 2: Rebasing `feature` onto `main`.

When the pull is completed, checkout out to feature and then rebase feature onto main.

git checkout feature

git rebase main

Step 3: Resolving Conflict

Sometimes, rebasing a Git branch can result in conflicting changes that need to be resolved before the action can be completed.

When there is a conflict in a file it looks like this:

In the above image you can see that Git adds some additional lines to the file having conflict:

<<<<<<< HEAD
=======
>>>>>>> updated_address

You can think of ======= as the dividing line of the conflict. Everything between <<<<<<< HEAD and ======= is the content of the current branch that the HEAD ref is pointing to, also called as Current Change. On the other hand, everything between ======= and >>>>>>> updated_address is the content in the branch being merged, also called as Incoming Change.

After resolving the conflict and saving your changes, you need to tell Git that the conflict has been resolved, you can do this with:

git add <filename>

Step 4: Rebase Continue

Now you can move on with the rebase by:

git rebase --continue

So, when the rebase is completed. Your branch feature is up-to-date with all changes which had been previously committed to the main branch.

Alternatively, if you’re unable to resolve the conflicts, or decide you don’t want to move forward with the rebase, then you can cancel the Git rebase action, with:

git rebase --abort

Now your branch is back in the state, as it was in before starting the rebase.

Step 5: Pushing rebased code to GitHub

As you've altered Git history, the usual git push origin will not work. You'll need to modify the command by "force-pushing" your latest changes:

git push origin feature -f