Forem: Raj Hawaldar

How to change author of the git commit

Raj Hawaldar — Tue, 28 Feb 2023 08:13:37 +0000

First of all, we need to understand how the author name and email are set by the git version control.

1. Set the author name and email globally

With the help of the following commands, we can set the committer's name and email globally.

$ git config --global user.name "John Doe"
$ git config --global user.email "john@doe.org"

2. Set the author name and email for each repository

We can set these details at repository level by omitting the --global flag.

git config user.name "John Doe"
git config user.email "john@doe.org"

Change the author while committing the code

We can use the flag --author="Name <email>" with the git commit command. For example,

git commit -m "New feature added" --author="John Doe <john@doe.org>"

Change author of the last commit

It's relatively easy to change the author of the last commit. Simply run the following command in the terminal, and you're done!

git commit --amend --author="author_name <email>" --no-edit

Don't forget to include email address in "<>"

Change the author of the past commits (not the latest)

This will be a little more challenging. Keep in mind that when we update the past commits , we actually rewrite the history of the git branch. We are going to use the git rebase command, which can help us update almost everything in the past commits.

First of all, we will identify the last "valid commit".

We want to update the author of the last two commits. We must specify how far back we want to rewrite commits by telling the command which commit to rebase onto.

Note: Don’t include any commit which is already pushed to a remote repository. By supplying an alternative version of the same change, we will mislead other developers.

In our case we want to update last two commits so we will pass "HEAD~2" as commit hash.

git rebase -i HEAD~2
# We can also use the parrent id of the second commit (hash of the 3rd commit)
git rebase -i 574b2bcfad6f7d347bc9a08953f037a1d8b79967

Git will now open the default editor with the similar details as shown below.

Now we will mark the commits we want to modify by replacing the word "pick" with "edit".

Git will walk us through each commit, and we can update the author details.

Stopped at 3800a1cf1... make login responsive
You can amend the commit now, with

    git commit --amend

Once you are satisfied with your changes, run

    git rebase --continue

Now use below commands to update the author and continue rebase till the last commit

git commit --amend --author="author_name <email>" --no-edit

git rebase --continue

Once done, if we again run the git log command, we will get the below output.

commit 5e679a69f5aed75d75a0a838167789d3d19431e5 (HEAD -> feature1)
Author: John Doe <john.doe@gmail.com>
Date:   Sun Feb 26 23:46:13 2023 +0530

    New feature added

commit 6293a1uk38fa37e827cc0f4355m77lck65aav965
Author: John Doe <john.doe@gmail.com>
Date:   Sun Feb 26 23:39:06 2023 +0530

    make login responsive

commit 574b2bcfad6f7d347bc9a08953f037a1d8b79967
Author: John Doe <john.doe@gmail.com>
Date:   Sun Feb 26 11:13:40 2023 +0530

    make dashboard screen

commit a0a838167789d3d194315e679a69f5aed75d75bb
Author: John Doe <john.doe@gmail.com>
Date:   Sun Feb 26 10:38:57 2023 +0530

    added border to images

commit 0a7634029ff6968a48781207acd61d74f45c35c6 (master)
Author: John Doe <john.doe@gmail.com>
Date:   Sun Feb 26 10:26:45 2023 +0530

    First commit

The important point is that the commit hashes of the last two commits have changed. If the branch is present remotely, we must force push it in order to push these changes to the git remote repository.

Using the git filter-branch

If we want to update the commits in bulk for the entire branch, we can use the following script:

#!/bin/bash

export FILTER_BRANCH_SQUELCH_WARNING=1 # This will suppress the warning shown by git

git filter-branch -f --env-filter '
    if test "$GIT_AUTHOR_EMAIL" = "richard.roe@gmail.com"
    then
        GIT_AUTHOR_NAME="John Doe"
        GIT_AUTHOR_EMAIL=john.doe@gmail.com
    fi
    if test "$GIT_COMMITTER_EMAIL" = "richard.roe@gmail.com"
    then
        GIT_COMMITTER_NAME="John Doe"
        GIT_COMMITTER_EMAIL=john.doe@gmail.com
    fi
' HEAD

The script mentioned above will change the author of every commit that meets the condition.

What is the difference between a committer and an author?

The "author" is the person who originally wrote the code, and the "committer" is the person who committed the code on behalf of the original author. For instance, if a project maintainer receives a patch and applies it, the author of the patch still receives credit for the work.

The git-filter-branch is such a powerful command that it can easily corrupt repositories or leave you with a mess worse than you began with. Avoid using it with the public or shared repositories.

Thanks for reading, I hope this is helpful.

Why chrome shows so many processes in Task Manager for only one tab?

Raj Hawaldar — Sun, 09 Aug 2020 05:24:19 +0000

Chrome applies the same kind of process isolation which we found in Operating System. Chrome by default launches each website you open in its own process. It keeps web apps and plugins in separate processes from the browser itself.

Browsers that put everything in one process face real challenges. If one web app causes a crash in the rendering engine, it will take the rest of the browser with it, including any other web apps that are open. Chrome avoids this by isolating each plugin and tab in separate processes.

Interestingly, Google Chrome has its own Task Manager which you can get to by right clicking on the browser's title bar(Or Press shift+Esc). This Task Manager lets you track resource usage for each web app and plug-in, rather than for the entire browser.

Read the Chome Introduction Comic for more details!

let's understand git diff

Raj Hawaldar — Sun, 26 Jul 2020 08:12:10 +0000

Have you ever used git diff command? git diff is multi-use command which will help you to find out the difference between git data sources. These data sources can be commits, branches, files.

First understand some key-terms,

Working directory: Git working directory implies the area where we do all our changes. Git continously monitor this area for changes. If you execute command 'git status' you can see the changes present in working directory.

Staging area(also known as git index): staging area contains all the changes which are ready for the commit. You can add/remove files from staging area using command git add or git rm.

HEAD: It is pointer which points to the last commit of your current branch.

Local Repository(.git): Once we commit the changes from staging area usin git commit command they will get stored in your local repository.

tracked file: It is any file which git tracks actively. For example:Files which are already commited or files present in staging area.

untracked file: A newly created file which is not under git's version control.

Now lets move to the git diff command,

git diff: It shows only those changes of tracked files which are present in working directory.

git diff --cached: It shows only those changes of tracked files which are present in staging area.

git diff HEAD: It shows all changes of tracked files which are present in working directory and staging area.

git diff branch1..branch2: Git will compare the HEAD of both branches and display a 'diff' recap that you can use to see modifications. It will show you all the commits that 'branch2” has that are not in 'branch1'.

git diff branch1...branch2: Using 'git diff' with three dots compares the HEAD of the second branch with the common ancestor of the two branches. (It will show the changes made only in branch2).

Note: If we provide file name at the end of all the above commands, the diff operation will be scoped to the specified file.

I hope this is helpful.

Updating to the latest version of Azure DevOps Server from TFS 2018

Raj Hawaldar — Sun, 19 Jul 2020 05:29:25 +0000

With Azure DevOps 2019, Microsoft renamed Visual Studio Team Foundation Server to Azure DevOps Server and Visual Studio Team Services(VSTS) to Azure DevOps Services.

Now due to this similar naming people often gets confused. So lets understand this in simple words,

Azure DevOps Server is the on-premises offering. It is a new release of Team Foundation Server 2018.
Azure DevOps Services is the cloud offering. It is a new name given to Visual Studio Team Services.

In this article we will discuss how we can update our on-premises TFS Server to Azure DevOps Server. Lets begin!

Download the latest version of Azure DevOps Server here.
Install downloaded setup.
Once installation is complete. Configuration wizard will appear on the screen. Here it will ask for a deployment type, as we are updating the release version, select option "I have an existing database to use for this Azure DevOps Server deployment".
Now configuration wizard will show the databases tab. Here we will take a backup of the existing database. It is important, if something goes wrong we can restore these backups and roll back to our previous version of TFS.
Select databases which you want to backup and click on "Backup Now".
After database backups, we will choose our deployment scenario. Select "Production Upgrade" and click on the next button.
On the account tab we will setup a user account from the given options. You can use your existing user.
In the application tier tab will show the existing site configuration. We can make changes if we want to otherwise just click on next.
If our existing on-premises server has some Search configuration settings you can configure them now.
After this configuration wizard will ask to review your configuration.
Once reviewed, click on the configure button.
After the configuration process finishes, click on the next button.
Once the configuration process gets complete. It will show a success message.
Review the results and click on next.

We have successfully updated to the Azure DevOps Server 2019.

Note: In case you want to rollback to previous version perform below steps,

Uninstall Azure DevOps Server 2019.
Restore the database backup on database server which we took in the beginning of the process.
Now just install TFS 2018 again and select existing database option and your good to go!

I hope this will be helpful!

Use Git Hooks to ease your development workflow

Raj Hawaldar — Fri, 17 Jul 2020 14:59:43 +0000

Git hooks allow us to run custom scripts whenever certain important events occur in the git repository such as commit, push, merge. Basically git hooks are stored in the .git/hook directory of your local repository.

Initially all hook files contain .sample as extension, which indicate those are disabled. These sample hooks are stored in one of the below locations as per your operating system,

Linux: /usr/share/git-core/templates
Windows: C:\Program Files\Git\mingw64\share\git-core\templates
Mac OS: /usr/local/git/libexec/git-core

Whenever you initialize a local git repository these sample hooks templates which are already stored on your machine get copied into your local repository.

All hooks pre-fix with pre label will execute before the particular event happens and hooks with pre-fix post will execute after the event.

For Example: pre-push hook will execute before the push operation.

As hooks are disabled by default, we need to perform below steps to enable them ,

Remove .sample extension from the hook name.
Make that hook file executable using command chmod +x

Before we start remember this:

As we see here hooks present inside .git/hook/ directory which means these are not source control. You can use symbolic link.
You can bypass pre-commit git hook locally by adding --no-verify flag.

Lets start with the practical use of git hooks.

Scenario 1: In one of the projects we used to create a feature-branch from the environment branch(master,dev,release). We should not commit our code directly on the environment branches.

Solution: pre-commit hook is run first, so we will use this hook. copy below code snippet in your pre-commit hook.

#!/bin/sh
# Avoid doing commit in environment branches.


BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
forbidden_branchs="^(master|dev|release)$"


message="You should not commit directly into ${BRANCH_NAME} branch.\nPlease create a new branch from '$BRANCH_NAME' and Try again."


if [[ $BRANCH_NAME =~ $forbidden_branchs ]]
then
    echo -e $message
    exit 1
fi

In windows operating system instead of #!bin/sh use #!C:\Program Files\Git\bin\sh.exe path where git installed its shell script.

Now git provides you the freedom to select scripting language. If you are comfortable with other scripting languages like python, ruby, powershell you just need to add the path of its library on the first line of the hook.

Always remember, If your hooks returns zero means that it is succeed. If it exists with any other number it is failed. In the above code snippet we exit code 1 which means hook failed so commit will not happen.

Scenario 2:

Sometimes we amend commits multiple times and in later stages we need one of the previous state of commits. If we write a script which will make stash before committing code every time then we will get state if each and every commit in our stash.

Solution:

if [[ $(git diff --cached --exit-code) ]];then
  BRANCH_NAME=$(git branch --show-current)
  STASH_NAME="pre-commit-on-$BRANCH_NAME-$(date +"%m-%d-%y::%T")"
  git stash save -q --keep-index $STASH_NAME
  echo "Stash:${STASH_NAME} saved!"       
fi

$(git diff --cached --exit-code) will check whether there is any code present in staging area. As there is no point running this code for empty commit. $(git branch --show-current ) gives us current branch name.
We will use the same pre-commit hook. Add below line your pre-commit hook.

Scenario 3:

Before pushing our branches to remote lets create a hook which will execute build and tests before pushing your code to remote branch.

Solution:

We can use pre-push or pre-commit hook for this scenario.

echo "Running Build"
sh run-test-scripts.sh

if [ $? -ne 0 ]; then
  echo "Build must be succeed before commit!"
  exit 1
fi

Here, $? stores the exit value of last command. Add test cases and build commands in run-test-scripts.sh file. You can use this hook for automatic code quality checks.

How to deploy these git hooks ?

As git hooks are stored in .git/hook directory so developers will not be able to commit these hooks. We will create our own .githooks directory in our code base. We will copy our created hooks into this newly created directory and ensure permissions are correctly set on the file.

chmod a+x ~/.githooks/pre-commit

Done!

There is another way, from git version 2.9.0 you can set core.hookspath which will allow you to set a global directory for hooks on your machine. So all your local repository will point to that directory and use hooks present over there.

To set core.hookspath use below command:

git config --global core.hookspath <hooks-directory-path>

Note: Keep your hooks folder outside of local repository. Otherwise if you delete local repository for some reason. Your other project will not able to access the hooks.

With git hooks imagination is the limit! You can find my original article on LinkedIn(here).

Let me know if the article is useful.
Happy coding!

Angular Modules

Raj Hawaldar — Sun, 03 May 2020 10:40:19 +0000

Module is one of the fundamental concepts of Angular. Today we are going to understand the types of module and their uses in Angular.

In simple words, Module is mechanism to group components, pipes, directives, services that are related.
These individual modules can be combined together to create an application.

We use @NgModule decorator to declare class as module.
@NgModule decorator contains below properties:

declarations: It includes component, directives, pipes that belongs to this module.
exports: It include component, directives, pipes which can be accessible to other NgModule.
imports: Contains Modules whose exported classes needed by this module.
providers: Contains the services generated by this module.
bootstrap: Initialize root component

Module Encapsulation:

Similar to ES module, angular module also provide encapsulation. We cannot use component from other module unless we define that component in imports list of current module.

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    AppRoutingModule,
    SharedModule, 
    DashboardModule, //  Imported members from feature module are now accessible in AppModule.
    CoreModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

So to use exported component from other module we need to import that module first.

According to type of module we are going to use above properties.

There are different types of Angular Modules:

RootModule: Each angular application has at least one module called as Root Module. Conventionally named as AppModule. We launch our by bootstrapping the root module.(check main.ts)
Routing Module: We use this module to load and configure angular routes. The name of the routing module should match the name of its companion module.
- It does not use declarations property inside @NgModule decorator.
- Always exports RouterModule.

const routes: Routes = [
  {path: '', component: HomeComponent}
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule],
  entryComponents: []
})
export class AppRoutingModule { }Javascript

Use more than one routing module for better organization and lazy loading.

Feature Module: As App gets more feature we can group those feature and create feature modules.
- It contains declaration, providers (only services related to the feature)
- As per the standards it should export only the top component.

@NgModule({
  declarations: [DashboardComponent],
  imports: [
    CommonModule
  ]
})
export class DashboardModule { }

Shared Module: Almost similar to Feature Module. The only difference is they add all their declarations to the exports as well so they can be used in other module. Mostly includes UI element like (spinners, toasters, Alerts)

@NgModule({
  declarations: [AlerComponent],
  exports: [AlertComponent]
  imports: [
    CommonModule
  ]
})
export class SharedModule { }

Core Module: Also known as service module. This module does not have any declaration property as it only focuses on services. Inside Core module we can create any service that provides data globally through out the app. Example: AuthService


@NgModule({
  providers: [
    AuthService,
    UserServcie
  ]
})
export class CoreModule { }

Once you understand the use of each module it will be easy to plan development.

How to create module?

ng generate module <module-name> --module=module

   ng generate module shared --module=app

Here --module=app line will register SharedModule in the imports array of the AppModule.

Most of the time developer just starts coding without second thought. Take a pause design your application with modular approach then start coding!!!