• Introduction
• Change Future Commits Author
• Git Config Check
• Git Global Configuration
• Git Local Configuration
• Author Identity For the Next Commit
• Change Past Commits Author
• Git Ammend With Author Flag
• Git Interactive Rebase
• Git filter-branch Command
• Conclusion

Introduction

There are two different needs in the request of changing author for your commits. Let’s make clear what are you really looking for:

• a) Either you want to change the author before making commit.
• b) Or you want to change the author after you have made commit.

In this article, we will look at both ways how to change the commit’s author identity.

Change Future Commits Author

There are three different ways how to change identity for your Git committer. All the procedures only affect future commits and not the past commits made in the development line of your repository (commit history).

Git Config Check

Just a quick tip. To confirm your settings for global and local configuration you can type command:

git config --list

git config --list will show global system git settings. If you run it inside a repository, it will also attach and show you the local configuration.

However, using following command might be more clearer:

git config --list --show-origin

git config --list --show-origin command does all what git config --list does. Git command also attaches a path to the origin file of each config item in the list. Arguably, the attached path makes the settings look more understandable, and you can better connect items and their values for local and global Git settings.

Git Global Configuration

If you want to change your username and email by default for all project on your machine, edit global configuration settings. You can run the git config command with --global flag that will override your default Git settings and apply for all the future commits in your repositories. Git command for it looks like this:

git config --global user.name "FIRST_NAME LAST_NAME"
git config --global user.email "EMAIL@example.com"

Git Local Configuration

However, if you want to change your username and email only for single project, go to your repository and make git config adjustment like this:

git config --local user.name "FIRST_NAME LAST_NAME"
git config --local user.email "EMAIL@example.com"

Simply omit the --global flag and replace it with --local flag. git config --local makes the custom configuration valid only in the repository you made a change.

Author Identity For the Next Commit

There is at least one last way how to temporary influence the author identity of the commit. Just right before making the commit, add to commit command --author flag. When making the commit, you can override even local settings.

git commit --author="FIRST_NAME LAST_NAME "

Change Past Commits Author

Changing past commit authors in Git repositories is not so straightforward as it is for future ones. The issue lies in the fundamental idea of Git – its distributed asynchronous nature. You should be aware of one simple fact that you might cause a massive problem with synchronization if you work on the project with many team members.

When you change Git commit author identity, you create an entirely new commit with a new hash; you are rewriting commit history and development branch. And while for a single individual repository user, this might not be a problem, for big teams, this might be a cause of enormous evil.

Therefore, let me give you a piece of good advice: if you are working in a team, a change in Git commit history should be adequately communicated with the rest of the team. It might happen that other team members already based their work on the existing commits, and additional changes would cause huge synchronization problems. Communicate with your team if you feel that commits might be already used as the base for other people work. Eventually, for good or bad, it might be possible even to avoid changing commit author identity, and either do rollback commit with new commit with correct author commit or, better, leave the commit history as it is. Commit change is much more critical in the long term as a person who made it (empirical experience – people come and go from teams, code stays forever).

Git Ammend With Author Flag

git ammend command is used to patch last commit in Git’s commit history. By attaching --author flag to git ammend command you can effectively rewrite commit author identity for the last commit in commit history.

Git Interactive Rebase

Interactive rebase is a powerful feature of Git that allows you to edit Git commit history very effectively.

However, be careful with interactive rebase, it might shoot you in the foot if you will be not careful! Any changes made will affect your Git commit history. I would recommend to study deeper official Git documentation for interactive rebase before making any changes with it over console [7.6 Git Tools – Rewriting History]. Otherwise I can really recommend using interactive rebase with IDE tools such as IntelliJ.

First step, you need to find commit you consider as base for your interactive rebase. Provide to git command commit’s hash like this:

$ git rebase -i -p 9be2477a

git rebase command will open the interactive editor in which you need to mark all the commits you want to change. Selected commits will be marked with the red keyword “edit”.

edit 87bee32a Added new tests
edit 1be09dcb Merge branch with hotfix for DJ-1041
edit 9be2477a Change title tag for homepage
edit c427697c Add images support in gallery

Git will now walk you through each commit. You will have a chance to change every commit individually:

Stopped at 1be09dcb... Merge branch with hotfix for DJ-1041
You can amend the commit now, with

    git commit --amend

Once you are satisfied with your changes, run

    git rebase --continue

Now is your chance to rewrite the commit author identity. Either you will use --amend with --author flag. Or you will continue to next commit in edit mode until you have edited all commits which were marked for edit

$ git commit --amend --author="FIRST_NAME LAST_NAME " --no-edit
$ git rebase --continue

Git filter-branch

Last option is to use Git filter-branch command. filter-branch will allow you to go through a large chunk of commits with the help of simple script. Let us show you a simple script:

$ git filter-branch --env-filter '
OLD_COMMITTER_EMAIL="OLD_EMAIL@example.com"
NEW_COMMITTER_NAME="FIRST_NAME LAST_NAME"
NEW_COMMITTER_EMAIL="NEW_EMAIL@example.com"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_COMMITTER_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$NEW_COMMITTER_NAME"
    export GIT_COMMITTER_EMAIL="$NEW_COMMITTER_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_COMMITTER_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$NEW_COMMITTER_NAME"
    export GIT_AUTHOR_EMAIL="$NEW_COMMITTER_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

However, same as with interactive rebase, it is necessary to be aware that by using filter-branch, you will create entirely new sort of commits and change Git commit history. The new commit history might have severe consequences when synchronizing with your team, so you should do this preferably only on repositories that haven’t been published or shared.

Conclusion

In summary, we divided the methods of changing the commit author identity into two different approaches based on the commit stage. We showed three different ways to change the author information before making a commit, and we explained another three ways to change the author information after making a commit.

Did you find commands easy? Do you have your trick or know another way how to change global and local Git settings? Let us know in the comments below the article. We would like to hear your ideas and stories.

As I am a software developer, IntelliJ IDE is, for me, a must. IDE is in front of me opened all the time. Therefore it is a chance for me to write a lot of content in the IDE. It is a better choice to use IDE instead of switching to another text editor or using another means of word processing.

Since I am also aiming to work on several articles or documents simultaneously, every decrease in ambiguity and complexity counts towards faster results. The creative process is not possible to automatize. But what it is possible to automatize are redundant tasks during text handling and editing.

Why turn IntelliJ Idea IDE into your word processor?

First of all, IntelliJ Idea IDE already comes in its 2020 version with very, very good support for English vocabulary. So writing in English in IDE was never easier than now.

Plus, when implementing the advantage of multiple IntelliJ shortcuts, the word processing is swift. Especially if you write your text in .html, .adoc or .md format.

Overall, IntelliJ IDE comes in all versions with Git support, which is an additional advantage against traditional word processors. You can easily version your articles’ state and keep a history of your edits in one place. Article versioning is a feature that is available only in very advanced mode in cloud SaaS.

However, what I have found very tedious was text formatting in IntelliJ. As expected, I was using IntelliJ Idea IDE for coding, mostly Java, and thus the text was supposed to be wrapped automatically after 120 characters. When I then copied my articles to other word processors in my pipelines, such as Microsoft Word or Grammarly, I always needed painfully deleted every single break line to make a single continuous line of text. That was also one of the most common mistakes I had after publishing articles through WordPress – linebreaks were always in places where they should not be.

After enough time spent doing this pointless work, fixing many wrong break lines, I have decided to end it and figure out how to speed up the process. Because every second I spend editing an article is second, I could use it towards another article’s creative process.

How to turn IntelliJ Idea into text editor?

First of all, go to Settings > Editor > General and check all checkboxes in Soft Wraps section.

Then go to Settings > Code Style and select Scheme Project. Here unselect the checkbox “Wrap on typing”.

I would recommend this change be saved under the current project scheme, not under the IDE scheme. If you are using the same IntelliJ for coding, wrapping will conflict with your code clarity if you save the change under the IDE scheme.

Hit Apply button to apply all the changes.

Initialize soft-wrap in IntelliJ code editor

In the active editor tab, on the left side of the text line panel, after the right-click, there is an option soft-wrap to initiate the wrapping. Soft-wrap is not initialized automatically on every new file open. Therefore you will need to initialize soft-wrap on every new file open.

Tip for shortcut

When you open a new file, the text is, by default, unwrapped. You can either right-click on the newly opened line meter on the left side and hit Soft-Wrap from the menu option. Or you can set up a special shortcut for soft-wrapping, while the shortcut is not set by default.

To set up your shortcut, go to File > Settings > Keymap and search for “Soft-Wrap” in Main Menu > View > Active Editor. Add to action key shortcut. I personally use Alt + P key shortcut. That is not a conflicting key shortcut with keys combinations easy to remember.

How to install Azure CosmosDB Emulator

First of all, we need to install Azure CosmosDB Emulator locally. Go to https://docs.microsoft.com/en-us/azure/cosmos-db/local-emulator#installation, download the windows installation package and install Azure Cosmos DB Emulator.

When installing Azure Cosmos DB Emulator passed successfully on your Windows machine, start the emulator (if it did not start automatically).

If it is already running you can find it minimized in the system hidden in the running application system and either click Open Data Explorer … or visit https://localhost:8081/_explorer/index.html page. You can now get finally into the Azure CosmosDB Emulator.

Exporting security certificates

Azure Cosmos DB Emulator uses a secure connection with your application. We need to extract and register your certificate for communication with the emulator.

Let’s type “Manage user certificates” into Windows Start console or open Windows Certificate Manager (running certlm.msc in the run prompt). Go to Personal->Certificates folder and export certificate with DocumentDbEmulatorCertificate name. The whole tutorial how to do it can be found at Microsoft Azure website explaining how to export the Azure Cosmos DB SSL certificate.

You can name your file when exporting arbitrary. However, we will name it for our example documentdbemulatorcert.cer.

Now when I have extracted the SSL certificate, I need to upload it into the correct Java SDK location.

Check which version of Java do you use in your project. In IntelliJ idea you can use either keyword shortcut [ctrl] + [shift] + [alt] + [s] or go to File->Project Structure->SDKs and check which version your Spring Boot application uses or where SDK is located.

Copy certificate into the Java SDK directory. It should be copied into the %JAVA_HOME%/jre/lib/security location.

If you use OpenJDK, OpenJDK does not contain jre folder. Just copy it into %JAVA_HOME%/lib/security location.

Registering certificate

The nearly last thing we need to do is to register the certificate into the system.

We need to open the Windows Command prompt as an administrator and navigate at JDK’s folder at jdk\jre\lib\security.

Hint: A little hint if you are more familiar with Linux based systems than Windows. If you open a folder in Windows, copy the path to the folder and place it into quotation marks in the command prompt. Executing the command changes the directory instantly.

Then, upon the folder, we need just to run the following command to register the certificate into the keystore on your system:

keytool -keystore cacerts -importcert -alias documentdbemulator -file documentdbemulatorcert.cer

Hint: Keytool is a tool located in your Java installation, so you need to have jdk/bin on your PATH for this to work.

If you need a hint with registration, check this tutorial at Microsoft Azure website where you learn how to add a root certificate to the certification authority certificates storage. However instead of bc2025.cer name in tutorial use name of your certificate.

Otherwise, when the prompt asks for a password, type your password. More likely you didn’t change it, so default password is changeit. Following, you get a question, if you trust this certificate. Answer it simply yes.

That is it. The certificate is registered, and Azure Cosmos DB Emulator should be now created securely and with ease.

Using emulator with local Spring Boot app development

And all we need to do now is just run the Spring Boot application. If you implemented a connection to Cosmos DB and registered connection properties to application.properties or application.yml you can successfully run the application.

azure:
   cosmosdb:
    uri: https://localhost:8081
    key: VERY_LONG_KEY
    database: YOUR_DB_NAME

To fill up application.yml you will need to implement your own data:

You can find VERY_LONG_KEY in your Azure Cosmos DB Emulator Data Explorer under the Quick start tab.

And all we need to do now is just run the Spring Boot application. If you check now Data Explorer under Explorer tab, you can find now your database with all the defined structures.

Troubleshooting

In case you already successfully installed the Azure CosmosDB Emulator and you want to restart the database, you have an option to reset data. Data reset comes handy when you get an authentication issue over HTTPS with your Azure CosmosDB certificate on the application run.

Pick up “Reset data” from the Azure CosmosDB Emulator mini-panel dialogue window from your start button. Operation is not reversible; it will clean up all your caches and the internal state of the Azure CosmosDB Emulator database and reset the certificate.

Then it would be best if you continued extracting the certificate from the list of certificates according to the description in Exporting Security Certificates. However, before registering the certificate back to Java keytool, you need to remove the old alias on the certificate with a command like this:

keytool -delete -alias documentdbemulator -keystore cacerts -storepass changeit

Notes: behind -alias you place the name of the certificate, -keystore is the name of a file containing the certificates and behind -storepass is your password (default is changeit).

In the last couple of months, I had a problem with the XAMPP MySQL database. Without any particular reason, from one day to another, it just failed. XAMPP UI does not show any error.

DB recovery does not help, and it seems that every StackOverflow solution does not work. And digging deeper into the database stack did not bring any working solution.

The only solution which seems to work is to delete the XAMPP entirely and create a fresh new installation. Of course, this is a very tedious and time-consuming solution.

Moreover new MacOS update Catalina just made things worse, and XAMPP MySQL failed instantly. Instead of starting using MAMP, which is just the same way of doing things as XAMPP, I have decided it is the right time to start utilizing the power of Docker for WordPress development.

Using Docker for WordPress development

I have decided to create this simple tutorial for WordPress development with Docker for whoever would like to need it. This tutorial is written for macOS/Unix systems based operating systems. However, it is helpful for Windows users as well.

Here is a simple list of steps necessary for starting WordPress development with Docker:

Step no. 1 – Install Docker

Well, of course, the first step is to install Docker itself. I will step over this step while this could be a stand-alone tutorial for that. However, it is super easy, and it can complete even beginner PC user alone.

Step no. 2 – Think what do you need for WordPress development

We will need three containers for WordPress development with Docker. These containers will be:

• PHP server running WordPress
• MySQL or MariaDB database based on your choice
• Access to database (over phpMyAdmin GUI)

Accessing the database over GUI is optional. Same as selecting the database of your choice. MySQL or MariaDB is up to your preference. So based on what are your needs, you should check the appropriate section in the next step.

Step no. 2 – Create docker-compose.yml file

Create a new directory for a project you want to develop. It will be the location of your choice. This folder should contain single file docker-compose.yml.

TIP: There is a nice hack for doing all the steps in one. Just type in your terminal this command mkdir NEW_PROJECT_NAME && cd $_ && touch docker-compose.yml and you will all do this in one line.

Copy code below to docker-compose.yml

version: "3.1"

networks:
  wp:

volumes:
  db_storage:

services:

  wordpress:
    container_name: CUSTOM_PROJECT_NAME_wordpress
    image: wordpress
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
        - ./:/var/www/html/wp-content
    ports:
      - 80:80
      - 443:443
    networks:
      - wp
    depends_on:
      - db

  db:
    container_name: CUSTOM_PROJECT_NAME_db
    image: mariadb
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    volumes:
      - db_storage:/var/lib/mysql
    ports:
      - 3306:3306
    networks:
      - wp

  phpmyadmin:
    container_name: CUSTOM_PROJECT_NAME_db_gui
    image: phpmyadmin
    restart: always
    environment:
      PMA_HOST: db
      MYSQL_ROOT_PASSWORD: password
    ports:
      - 8080:80
    networks:
      - wp
    depends_on:
      - db

Let’s cut down the composer file to pieces and figure out what it does.

version: "3.1"

networks:
  wp:

volumes:
  db_storage:

services:

wordpress:
    container_name: CUSTOM_PROJECT_NAME_wordpress
    image: wordpress
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./:/var/www/html/wp-content
    ports:
      - 80:80
      - 443:443
    networks:
      - wp
    depends_on:
      - db

With just a simple change of DB image from MariaDB to MySQL, you can get different database engine according to your needs. Otherwise, everything is the same for both containers.

db:
    container_name: CUSTOM_PROJECT_NAME_db
    image: mariadb
    # image: mysql
    restart: always
    environment:
        MYSQL_ROOT_PASSWORD: password
        MYSQL_DATABASE: wordpress
        MYSQL_USER: wordpress
        MYSQL_PASSWORD: wordpress
    volumes:
        - db_storage:/var/lib/mysql
    ports:
        - 3306:3306
    networks:
        - wp

phpmyadmin:
  container_name: CUSTOM_PROJECT_NAME_db_gui
  image: phpmyadmin
  restart: always
  environment:
    PMA_HOST: db
    MYSQL_ROOT_PASSWORD: password
  ports:
    - 8080:80
  networks:
    - wp
  depends_on:
    - db

Step no. 3 – Run Docker with docker-compose up -d

From now on all will go quickly. Just type docker-compose up -d and after initial download of all dependencies everything goes smoothly. When all your containers will shine as done you are ready to proceed.

If you run docker ps, you should now see three services with the name you defined in the docker-compose.yml file.

Step no. 4 – Install WordPress

You can find the new WordPress installation at http://localhost:8080/ address. Just proceed with the installation as usual and create a new WordPress installation in your local directory. From now on, you can access this WordPress installation as usual.

If you want to access database with phpMyAdmin use http://localhost:8080/index.php address. If you do not change password in yaml file, use name:password and password:password as login information.

So remember, to access:

• http://localhost:80/ – WordPress
• http://localhost:8080/ – phpMyAdmin (name: password, password: password)

Step no. 5 – Load your Git theme/plugin repository

Everything works as if you would be developing any other WordPress project now. If you have your project versioned in Git, go to themes or plugin folder and Git clone your project there. Any change made there will reflect as git diff in Git.

Step no. 6 – Shutdown the Docker processes when you finished

Finally, to proceed and stop Docker container lifecycle, you need to learn a few more commands. They are:

• docker-compose up – run the processes, however they are attached to life of your terminal window. Docker process will be terminated on the terminal window close up.
• docker-compose up -d – leaves the processes running without being attached to your terminal window. Use -d as “detach” for Docker to starts the containers in the background and leaving them running, independently on your terminal window life. Docker reference for up
• docker-compose stop – stop the processes
• docker-compose down – stop and removes the processes
• docker-compose rm -v – docker cleanup
• CTRL+C – killing processes, terminal key shortcut

I recommend you kill the Docker processes for your theme every time you think you finished the day. It is advice based on experience from life. If you kill the processes the next day, you can be sure they are not working because they are down, but not because something else went wrong. Plus, if you switch often projects as I do, it is good to keep the system utilization low and order everything.

Known issues

While dealing with Docker, some things can go wrong. However, we will not go through all of them here. Let’s take a look only at the most occurring issues.

Error establishing a database connection

If you get an error saying Error establishing a database connection check the name interconnecting database credentials and database name between WordPress and database.

Conclusion

I hope you liked this simple tutorial explaining how to quickly and effectively set up Docker for WordPress development. If you have any comments or constructive criticism or have other ideas on enhancing this YML file or tutorial, please write me a comment. I will appreciate it.

Commiting wrong files to repository

Sometimes, I accidentally start versioning some files or folders that should not be part of the repository. After that, I do not notice the wrong files being versioned, the commit is made, and the content is pushed to the Git repository. I am sure this happens to everybody from time to time.

How to remove unwanted files and folders from a repository?

There is only one way, a new fixing commit or patchset is necessary.

Beginner mistake is often to use only git rm DIRECTORY for directory removal. However, this Git command removes not only a directory from the repository but also physically removes it from the local file system.

Adding -r flag to the command, we create a Git command which recursively removes the content of the directory (including the directory folder itself) from the Git repository without the directory and its content being physically removed from the local file system.

Be aware that we must use the --cached flag in the Git command. This correct command formulation removes the content from the Git index.

Here is a command for removing everything from the Git repository within the specific directory:

git rm --cached -r DIRECTORY

For the single file removal:

git rm --cached -r FILE.TXT

Quick hack: You can also remove files from the repository based on your .gitignore without deleting them from the local file system :

git rm --cached `git ls-files -i -X .gitignore`

Alternatively on Windows Powershell:

git rm --cached $(git ls-files -i -X .gitignore)

So if you have some folders or files that do not belong to the repository, you can now make a fixing commit or patchset with files or folder removal.

This article focuses only on users with Mac or Linux. For creating new repository or pairing existing with GitHub account or custom GitLab on Windows, please visit official tutorial at GitHub website.

Setting global git config credentials

First of all, we need to be sure that we have set global config information. This is one-time configuration.

git config --global user.name "Your Name"
git config --global user.email "your.name@email.com"

Creating the new repository and pushing new it to GitHub or GitLab

This is the short list of terminal commands for creating a new local repository and syncing the changes with GitHub or GitLab repository.

cd folder
# Change to desired directory 
git init
# Initiate local Git repository
git remote add origin git@github.com:UserName/project.git || git@gitlab.domain.com:UserName/project.git
# Sets the new origin repository
git remote -v
# Verifies the new remote URL
git add .
# Adds all files in the local repository to stage for commit. To unstage a file, use 'git reset HEAD YOUR-FILE'.
git commit -m "init commit"
# First local commit with message. It commits the tracked changes and prepares them to be pushed to a remote repository. 
# To remove this commit and modify the file, use 'git reset --soft HEAD~1'; and commit and add the file again.
git push -u origin master
# Pushes the changes in your local repository up to the remote repository you specified as the origin

Repository SSH link can be found at GitHub or GitLab project landing page or quick setup page.

Copy/Clone existing GitHub or GitLab repository to local folder

This is the short list of terminal commands for cloning existing GitHub or GitLab repository to local repository.

cd folder
# Change to desired directort
git clone git@github.com:UserName/project.git || git@gitlab.domain.com:UserName/project.git
# Clone/Copy all files

Cloning the repository does not make automatically git repository. For that, we need to repeat the step (above) of initializing local Git repository and setting the origin repository on GitHub or GitLab.

Security reminder

Never git add, commit, push sensitive information (like passwords, keys, configs, credit card numbers PINs and numbers, etc.) to your remote repository.