Forem: Kengo Hakomori

Publishing OAS-Based API Doc on GitHub Pages

Kengo Hakomori — Sun, 15 Mar 2026 22:00:22 +0000

Environment

Mac
- CPU: Apple M4
- OS: Sequoia 15.1.1
Zsh
- Version: 5.9
cURL
- Version: 8.11.1
Docker Desktop
- Version: 4.37.2
GitHub API
- Version: 2022-11-28

Dir Structure

.
├── docker
│   ├── .env
│   └── docker-compose.yml
├── index.html
├── nginx.conf
└── openapi
    └── openapi.yml

openapi/openapi.yml

* Just a sample.

openapi: 3.0.3
info:
  title: Sample API
  version: 1.0.0
paths:
  /hello:
    get:
      summary: Hello World Request
      responses:
        "200":
          description: OK
          content:
            text/plain:
              schema:
                type: string
                example: "Hello, World!"

index.html

Swagger UI

Most of the content is the same as what is written here.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="description" content="SwaggerUI" />
    <title>SwaggerUI</title>
    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css" />
  </head>
  <body>
    <div id="swagger-ui"></div>
    <script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js" crossorigin></script>
    <script>
      window.onload = () => {
        window.ui = SwaggerUIBundle({
          url: './openapi/openapi.yml',
          dom_id: '#swagger-ui'
        });
      };
    </script>
  </body>
</html>

Updated url to the relative path of the OAS file.

<html lang="en">
  <body>
    <script>
      window.onload = () => {
        window.ui = SwaggerUIBundle({
          // before
          url: 'https://petstore3.swagger.io/api/v3/openapi.json',
          // after
          url: './openapi/openapi.yml',
        });
      };
    </script>
  </body>
</html>

Using latest for version specification is also acceptable.

<html lang="en">
  <head>
    <!-- before -->
    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css" />
    <!-- after -->
    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@latest/swagger-ui.css" />
  </head>
  <body>
    <!-- before -->
    <script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js" crossorigin></script>
    <!-- after -->
    <script src="https://unpkg.com/swagger-ui-dist@latest/swagger-ui-bundle.js" crossorigin></script>
  </body>
</html>

ReDoc

Most of the content is the same as what is written here.

<!DOCTYPE html>
<html>
  <head>
    <title>Redoc</title>
    <!-- needed for adaptive design -->
    <meta charset="utf-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">

    <!--
    Redoc doesn't change outer page styles
    -->
    <style>
      body {
        margin: 0;
        padding: 0;
      }
    </style>
  </head>
  <body>
    <redoc spec-url='./openapi/openapi.yml'></redoc>
    <script src="https://cdn.redoc.ly/redoc/latest/bundles/redoc.standalone.js"> </script>
  </body>
</html>

Updated spec-url to the relative path of the OAS file.

<html>
  <body>
    <!-- before -->
    <redoc spec-url='http://petstore.swagger.io/v2/swagger.json'></redoc>
    <!-- after -->
    <redoc spec-url='./openapi/openapi.yml'></redoc>
  </body>
</html>

Specifying a specific version is also acceptable.
The list of acceptable versions should match what is written here.

<html>
  <body>
    <!-- before -->
    <script src="https://cdn.redoc.ly/redoc/latest/bundles/redoc.standalone.js"> </script>
    <!-- after -->
    <script src="https://cdn.redoc.ly/redoc/v2.0.0/bundles/redoc.standalone.js"> </script>
  </body>
</html>

nginx.conf

This file is used to serve a preview of the OAS file via Nginx.

server {
    listen 80;

    location / {
        root /usr/share/nginx/html;
        index index.html;
    }
}

The default port used by Nginx is 80, which is the standard port for HTTP.
- We will continue to use this port even after overriding the config file.

docker

The Nginx server runs inside a Docker container.

./.env

HOST_PORT={host-port}

./docker-compose.yml

services:
  nginx:
    image: nginx:1.28.2
    ports:
      - "${HOST_PORT}:80"
    volumes:
      # Serve the preview page.
      - ../index.html:/usr/share/nginx/html/index.html:ro
      # Serve the OAS file.
      - ../openapi:/usr/share/nginx/html/openapi:ro
      # Override the default Nginx configuration.
      - ../nginx.conf:/etc/nginx/conf.d/default.conf:ro

As image, we specify the one provided by the official.
ro stands for read-only.

Previewing the OAS file

Open the terminal.
Move the current-dir to the location where docker-compose.yml is located.
Create and start the container.
```
docker compose up -d
```
The -d option runs the container in detached mode, allowing the terminal to remain available.
Open the preview page: http://localhost:{host-port}
Check until satisfied.
Close the preview page.
Stop and remove the container.
```
docker compose down
```

Preparation for publication

In order to send some GitHub API requests from a terminal.

Personal Access Token

Create a Personal Access Token (Classic).

repo scope is always required.

Declaring some variables

<PERSONAL_ACCESS_TOKEN>
The personal access token we created.
<OWNER>
The account owner of the repository.
<REPO>
The name of the repository.
<BRANCH>
The branch name used to publish.

PERSONAL_ACCESS_TOKEN="<PERSONAL_ACCESS_TOKEN>"
OWNER="<OWNER>"
REPO="<REPO>"
BRANCH="<BRANCH>"

Publishing

Changing repository from private to public

In a free plan account, we cannot publish GitHub Pages from a private repository. Therefore, in this case, we need to update the repository from private to public.

curl -L \
  -X PATCH \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO" \
  -d '{
    "private": false
  }'

curl -L \
  -X PATCH \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO" \
  -d '{
    "visibility": "public"
  }'

Activating GitHub Pages

curl -L \
  -X POST \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO/pages" \
  -d "{
       \"build_type\": \"legacy\",
       \"source\": {
         \"branch\": \"$BRANCH\",
         \"path\": \"/\"
       }
     }"

After GitHub Pages is enabled, the site based on index.html will be built and deployed. We can check the progress of the build by sending the following request.

curl -L \
  -X GET \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO/pages/builds/latest"

If GitHub Pages is already enabled, the 409 conflict error will be returned.

Since the BRANCH variable is used to specify the branch, the single quotes in the request body must be changed to double quotes. Assuming BRANCH="main", the differences are as follows:

BRANCH="main"

curl -L \
  # soft
  -d "{
       \"build_type\": \"legacy\",
       \"source\": {
         \"branch\": \"$BRANCH\",
         \"path\": \"/\"
       }
     }"
  # hard
  -d '{
    "build_type": "legacy",
    "source": {
      "branch": "main",
      "path": "/"
    }
  }'

The GitHub Pages URL is included in the html_url property of the response.

Retrieving GitHub Pages URL

curl -L \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO/pages"

The URL is included in the html_url property of the response.

Unpublishing

curl -L \
  -X DELETE \
  -H "Accept: application/vnd.github+json" \
  -H "Authorization: Bearer $PERSONAL_ACCESS_TOKEN" \
  -H "X-GitHub-Api-Version: 2022-11-28" \
  "https://api.github.com/repos/$OWNER/$REPO/pages"

Republishing

We just need to send the same request as when activating the site.

Sample Repositories

Remark

This publishing procedure does not depend on the number of OAS files. i.e. even if a OAS file is split into multiple files, we can follow this procedure to publish.

Using cURL Inside a Docker Container

Kengo Hakomori — Mon, 20 Jan 2025 01:05:46 +0000

Environment

Mac
- CPU: Apple M4
- OS: Sequoia 15.1.1
Zsh
- Version: 5.9
Docker Desktop
- Version: 4.37.2

Conclusion

Open a terminal.
Move to the dir containing the files used by cURL, if necessary.

Start the container with cURL installed and enter it.

docker run --rm -it -v "$PWD:/work" -w /work curlimages/curl:latest sh

Use cURL until satisfied.
Exit the container.
```
exit
```
Remove the Docker Image, if necessary.
```
docker rmi curlimages/curl:latest
```

Structure

Start the container with cURL installed and enter it.

This option is used to automatically remove the container (and its associated anonymous volumes) after it stops running. Since a container created to execute cURL does not need to be retained after execution, this option ensures the system is kept clean.

`-it`

This option consists of -i and -t. -i option enables STDIN within a container, and -t option attaches a pseudo-TTY to the container.

If we run the command without -i option (i.e. with only -t option), a pseudo-TTY will be allocated and the shell will start, but no commands can be accepted and we cannot continue the operation because STDIN is disabled. To forcefully exit from a container in this state, we need to send three consecutive SIGINT signals by pressing cmd + . same times. And this exiting does not trigger the automatic container removal provided by --rm option, so we need to trigger it by stopping the container or remove the container directly.

If we run the command without -t option (i.e. with only -i option), we can run commands using STDIN, but operations that rely on interpreting ANSI escape sequences cannot be performed because a pseudo-TTY is not attached. For example, we will be unable to move the cursor using keyboard, and output results will not be colorized.

-v "$PWD:/work"

This option is used to mount a dir from the host machine into a container.

-v <host-dir-path>:<container-dir-path>

$PWD is an env variable supported by POSIX-compliant shells, representing the Present Working Directory on the host machine. In this article, the command is executed in Zsh, which also supports this env variable.

The purpose of using this option is to allow the container to access files located on the host machine. For instance, when transferring files with the -T option in cURL, it ensures that host files can be referenced directly from the container.

-w /work

By specifying this option, we can set the dir, mounted from the host dir, as the current dir.

curlimages/curl:latest

official docker image for curl

sh

sh command is executed in a container when explicitly specified in docker run command.

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

By specifying sh in the [COMMAND] section, a shell is launched immediately after the container starts, allowing us to execute subsequent commands interactively.

Test

For example, If we want to test sending HTTP requests, we can use the service httpbin.

Display Dir Structure in Tree Format.

Kengo Hakomori — Mon, 09 Dec 2024 01:05:31 +0000

Environment

Mac
- CPU: Apple M4
- OS: Sequoia 15.1.1
Zsh
- Version: 5.9
Homebrew
- Version: 4.4.10

Sample

Run the following command to create the sample directories and files.

mkdir -p ./dir1/dir2
touch ./file0.txt ./dir1/file1.txt ./dir1/dir2/file2.txt

Flow

Install tree command.
```
brew install tree
```
We can check the version of this command by running the following command.
```
tree --version
```
As of the time of writing, the version is 2.2.1.

Run the command.

tree

The result is as follow.

.
├── dir1
│   ├── dir2
│   │   └── file2.txt
│   └── file1.txt
└── file0.txt

Manual

Running the following command will display the manual page for the tree command in Zsh.

man tree

After reading, press the q key to return to Zsh.

The source for tree v2.2.1 manual is here.

Swagger UI + Docker: Initial Setup

Kengo Hakomori — Mon, 14 Oct 2024 01:54:52 +0000

Environment

Mac
- CPU: Apple M1
- OS: Sonoma 14.6.1
Docker Desktop
- Version: 4.34.2

Dir Structure

* Drawn by mermaid.

graph TD;
    subgraph top["top"]
        subgraph docker["docker"]
            env[".env"]
            docker_compose["docker-compose.yml"]
        end
        subgraph openapi["openapi"]
            openapi_file["openapi.yml"]
        end
    end

docker/.env

SWAGGER_UI_HOST_PORT={host-port}

docker/docker-compose.yml

services:
  swagger-ui:
    image: swaggerapi/swagger-ui:v5.17.14
    environment:
      SWAGGER_JSON: /oas/openapi.yml
    ports:
      - "${SWAGGER_UI_HOST_PORT}:8080"
    volumes:
      - ../openapi:/oas

As image, We specify the one provided by the official.
If the version is specified as latest, the image will be created based on the latest version.
As environment, we specify the absolute path of the OAS file mounted inside the Docker container.
The reason why the property name contains the string 'JSON' is that in the early days, only the .json extension was used for the file.
Now that .yml can also be used, even if the property name does not include the string 'YAML', we can still specify the path of a .yml file there.
As ports, we specify port 8080 mentioned in the documentation as the container port.
As volumes, we share the OAS file between the host machine and the Docker container.
This mapping allows the file on the host machine to be accessible inside the container.

openapi/openapi.yml

Define a minimal API documentation conforming to OAS 3.0.3.

openapi: 3.0.3
info:
  title: Sample API
  version: 1.0.0
paths:
  /hello:
    get:
      summary: Hello World Request
      responses:
        "200":
          description: OK
          content:
            text/plain:
              schema:
                type: string
                example: "Hello, World!"

Docker

Create Container and Image.

Open the terminal.
Move the current-dir to the location where docker-compose.yml is located.
Execute docker compose create.
```
docker compose create
```

Open Swagger UI.

Start the container.
```
docker compose start
```
Open http://localhost:{SWAGGER_UI_HOST_PORT}.
Stop the container once satisfied.
```
docker compose stop
```

MySQL + Docker: Initial Setup

Kengo Hakomori — Mon, 30 Sep 2024 11:24:16 +0000

Environment

Mac
- CPU: Apple M1
- OS: Sonoma 14.6.1
Docker Desktop
- Version: 4.34.2

Dir Structure

* Drawn by mermaid.

graph TB;
    subgraph "top"
        A["docker-compose.yml"]
        B[".env"]
    end

docker-compose.yml

services:
  mysql:
    image: mysql:8.0.39
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
    ports:
      - "${MYSQL_HOST_PORT}:3306"
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

Structure

First, Define required attributes.

services:
  mysql:
    image: mysql:8.0.39
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}

As image, we specify MySQL Docker Official Image.
If the version of MySQL is specified as latest, the image will be created based on the latest version.
The latest version as of this writing is 9.0.1.
The reason for specifying version 8.0.39 is that it is the most recent version compatible with MySQL Workbench.
As environment, we set the root user password.
The root user is automatically created when MySQL is installed.
The list of environment variables that can be specified is written in docker hub.

Next, Mapping ports.

services:
  mysql:
    image: mysql:8.0.39
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
    # new attribute.
    ports:
      - "${MYSQL_HOST_PORT}:3306"

3306 is the default port number for MySQL to listen on for TCP/IP.
This port is used by MySQL Workbench to connect to the container.

Finally, Make DB data persistent.

services:
  mysql:
    image: mysql:8.0.39
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
    ports:
      - "${MYSQL_HOST_PORT}:3306"
    # new attribute.
    volumes:
      - db-data:/var/lib/mysql

# new element.
volumes:
  db-data:

Create persistent data stores by defining volumes element.
In this case, we create the volume named db-data.
The default data-dir for MySQL is /var/lib/mysql and we mount it to the volume.

.env

MYSQL_HOST_PORT={host-port}
MYSQL_ROOT_PASSWORD={root-user-password}

Docker

Create Container, Image, and Volume.

Open the terminal.
Move the current-dir to the location where docker-compose.yml is located.
Execute docker compose create.
```
docker compose create
```

Check the Version of MySQL.

Start the container.
```
docker compose start
```
Check the name of the container.
```
docker ps
```
The Names column corresponds to it.

Check the version in the container.

docker exec <container-name> mysql -V

For example, the following response is returned.

mysql  Ver 8.0.39 for Linux on aarch64 (MySQL Community Server - GPL)

Stop the container.
```
docker compose stop
```

MySQL Workbench

Download.

Download. The version to be downloaded is 8.0.38. The M1 chip uses the ARM architecture, so the appropriate one is macOS (ARM, 64-bit), DMG Archive.

Add Connection.

Start the container to connect to MySQL.
```
docker compose start
```
Open it and Click the PLUS button.
The following dialog opens.

Enter any value for Connection Name, and update Port with .env.MYSQL_HOST_PORT.
Click the Test Connection button.
After entering .env.MYSQL_ROOT_PASSWORD, a connection test will be conducted.
If successful, click the OK button to close this dialog.
Stop the container.
```
docker compose stop
```

Operate.

Start the container.
```
docker compose start
```
Click the connection.
Enter .env.MYSQL_ROOT_PASSWORD if not saved in keychain.
Operate until satisfied.
Stop the container.
```
docker compose stop
```

Optimize Huge Virtual Hard Disk.

Kengo Hakomori — Mon, 16 Sep 2024 04:10:38 +0000

Environment

Docker Desktop for Windows
- Version: 4.29.0? (I accidentally upgraded it before writing this article.)
- Used backend: WSL2
Windows
- Edition: 11 Pro
- Version: 23H2

Target File Example

C:\Users\{user}\AppData\Local\Docker\wsl\data\ext4.vhdx

Background

Docker Desktop for Windows uses a virtual machine (typically virtualization technologies like WSL or Hyper-V) to run Linux containers on Windows.
The file system used within this virtual machine is generally in the ext4 format, which is commonly used in Linux.
VHDX is a type of virtual hard disk format developed by Microsoft, used as a disk image for virtual machines in virtualized environments.
Docker Desktop for Windows uses this format files to provide storage for Linux containers.
ext4.vhdx is a virtual hard disk in VHDX format that hosts the ext4 file system.
Docker Desktop for Windows uses this file to store data such as containers, images, and volumes that are mounted.
This file will grow as the disk usage by WSL2 (i.e. Docker Desktop for Windows) increases, but it will not automatically shrink even if the disk usage decreases.

Remove Dangling Docker Objects.

As written above, doing this does not reduce the size of ext4.vhdx.
However, doing this makes optimization more efficient.

We simply open PowerShell and execute following commands.

Remove dangling images.
```
docker image prune
```
Remove dangling build cache.
```
docker builder prune
```

Optimizing with diskpart

Open PowerShell as admin.
The reason for admin is that UAC pops up and Command Prompt opens if we start diskpart as a normal user.
Shut down WSL to block access from it to a virtual hard disk.
```
wsl --shutdown
```
Enter diskpart.
```
diskpart
```

Specify the virtual hard disk to be optimized.

select vdisk file="C:\Users\{user}\AppData\Local\Docker\wsl\data\ext4.vhdx"

Attach the specified virtual hard disk.
Since there is no need to change that data, we do it as read-only to prevent operational errors.
```
attach vdisk readonly
```
Optimize.
```
compact vdisk
```
Detach the specified virtual hard disk.
```
detach vdisk
```
Exit diskpart.
```
exit
```

Optimizing with Hyper-V

* The Hyper-V does not exist on Home Edition.

We need to activate Hyper-V before we optimize.

Open Turn Windows features on or off dialog.
We just press the Windows key and the R key at the same time, then input optionalfeatures and click OK.
Turn on Hyper-V.

Now we can execute the command to optimize it.

Open PowerShell as admin.
This is because the command can only be executed by admin.
Shut down WSL to block access from it to a virtual hard disk.
```
wsl --shutdown
```
Move current dir to the location where ext4.vhdx is located.
```
cd C:\Users\{user}\AppData\Local\Docker\wsl\data
```
Optimize.
Since VHDX is optimized in Quick mode by default, we will specify Full mode explicitly for maximum optimization.
```
Optimize-VHD -Path .\ext4.vhdx -Mode Full
```

Identify Which Files are Large.

Kengo Hakomori — Sat, 07 Sep 2024 12:17:15 +0000

Environment

Windows
- Edition: 11 Pro
- Version: 23H2
PowerShell
- Edition: Desktop
- Version: 5.1.22621.4111

Target Dir Example

C drive.

Conclusion

Open PowerShell as administrator.
Some files require admin auth to retrieve info.
Thus, by doing so, these are more accurate.

Execute the following command.

Get-ChildItem "C:\" -Recurse -Force 2>$null | Select-Object FullName, Length | Sort-Object Length -Descending | Select-Object -First 3

Check the result.

Structure

Execute the Most Basic Command.

Get-ChildItem is a cmdlet that specifies a dir path and retrieves information about files and directories at that path.

Specifying nothing is the same as specifying current dir.

Get-ChildItem

Our target is C drive in this example, so we of course specify it.

Get-ChildItem "C:\"

Include Hidden Items as well.

Hidden files are not reduced to zero size.
Thus, we need to retrieve those as well.

Get-ChildItem "C:\" -Force

Select Information We Want.

As I write this, the default output properties do not include file size.
So we will use Select-Object to include it in the output.
Name property is included in the default output, so we will include that as well.

Get-ChildItem "C:\" -Force | Select-Object Name, Length

We can use Get-Member to find out the names of the properties we can specify.
We can also add -MemberType to remove non-properties, and if we want to know the meaning of each element we can specify as -MemberType, we can check the other page.

Sort by Size.

Our goal is to identify files that are large.
For this purpose, the output should be ordered by size.

Get-ChildItem "C:\" -Force | Select-Object Name, Length | Sort-Object Length -Descending

Filter Only Larger.

It is enough for us to check only large files.
In other words, we do not need to check small ones.

In this example, we consider displaying the top 3 files.
And we can use -First option of Select-Oblect.

Get-ChildItem "C:\" -Force | Select-Object Name, Length | Sort-Object Length -Descending | Select-Object -First 3

By applying this after Sort-Object, we can retrieve the first elements for the array after it has been ordered.

Search Recursively.

Targeting the C drive means, of course, targeting within the folders on the C drive as well.
We can do it by adding option -Recurse.

Get-ChildItem "C:\" -Recurse -Force | Select-Object Name, Length | Sort-Object Length -Descending | Select-Object -First 3

Index can save PowerShell from overwork.
This is why we did not add this option in first step.

Get Absolute Path.

Since it is a recursive search, without the absolute path of the file, we cannot arrive to it.
To do so, we can replace Name with FullName.

Get-ChildItem "C:\" -Recurse -Force | Select-Object FullName, Length | Sort-Object Length -Descending | Select-Object -First 3

Supress Premission Denied.

There are some items that cannot be retrieved.
Their absolute paths are revealed by the error stream, but the size is not written of course.
So it is natural for us to try to hide them.

Error stream is assigned the number 2 and we can have them sent to a specified file by the > redirection operator.
Furthermore we can discard them by specifying $null as specified file.

Get-ChildItem "C:\" -Recurse -Force 2>$null | Select-Object FullName, Length | Sort-Object Length -Descending | Select-Object -First 3

Git Command Cheat Sheet

Kengo Hakomori — Sun, 01 Sep 2024 14:28:18 +0000

Environment

Git
- Version: 2.45.0

Commands

git add

Add file contents to staging.

git add <pathspec>

We can specify a file path for <pathspec>.
Or we can add all files insted of a specific file.

git add .

cf. Git - git-add Documentation

git branch

List local branches.

git branch

We can use option --remotes in order to list remote branches.

git branch --remotes

We can use -r instead of --remotes.

git branch -r

cf. Git - git-branch Documentation

delete

Option --delete can be used to delete a branch.

git branch --delete <branch>

We can use -d instead of --delete.

git branch -d <branch>

If a branch has not been fully merged into its upstream branch, we cannot delete it.
However, combined with option --force, we can delete it irrespective of its merged status.

git branch --delete --force <branch>

We can use -f instead of --force.

git branch -d -f <branch>

Furthermore, we can use -D instead of -d -f.

git branch -D <branch>

git checkout

Switch current branch to another branch on local.

git checkout <branch>

If the branch specified by <branch> does not exist, the switching will fail of course.
However, with option -b, a new branch is created based on current branch.

git checkout -b <new-branch>

Or we can explicitly specify a base branch or commit hash as <start-point>.

git checkout -b <new-branch> <start-point>

We can also specify a remote branch as base branch.

git checkout -b <new-branch> origin/<remote-branch>

cf. Git - git-checkout Documentation

git clone

Clone a repository into current directory.

git clone <repository>

The cloned repository is named origin, and we specify that name as <repository> when we execute git push.
Instead of the name origin, we can give it another name.

git clone --origin <name> <repository>

We can use -o instead of --origin.

git clone -o <name> <repository>

cf. Git - git-clone Documentation

git commit

Apply changes to the repository.

git commit

We can use option --message in order to write commit message.

git commit --message <msg>

We can use -m instead of --message.

git commit -m <msg>

cf. Git - git-commit Documentation

git log

Show commit logs.

git log

cf. Git - git-log Documentation

git merge

Merge the commit history of a branch to current branch.

git merge <branch>

cf. Git - git-merge Documentation

git push

Update remote branch using local branch.

git push <repository> <refspec>

<refspec> can be specified in the format <src>:<dst>.

git push <repository> <src>:<dst>

We can specify local branch for <src> and remote branch for <dst>.

git push <repository> <local-branch>:<remote-branch>

If the names <local-branch> and <remote-branch> are the same, we can be written once.

git push <repository> <branch>

cf. Git - git-push Documentation

force

If the commit history has been updated by git rebase, the push might fail.
In this case, option --force-with-lease can be used to overwrite the commit history of the remote branch.

git push --force-with-lease <repository> <refspec>

If someone else had updated the remote branch, even if we used --force-with-lease, the push will fail.
Even if someone else has done, using option --force instead of --force-with-lease, we can update if we want.

git push --force <repository> <refspec>

We can use -f instead of --force.

git push -f <repository> <refspec>

git pull

Incorporate changes from a remote repository into the current branch.

git pull

cf. Git - git-pull Documentation

git rebase

Reapply commits on the commit history of the specified branch.

git rebase <base-branch>

cf. Git - git-rebase Documentation

git reset

Reset file contents from staging.
This command is opposite of git add.
We can specify a file path for <pathspec>.

git reset <pathspec>

We can use this command to roll back the current branch head as well.

The current branch head is represented as HEAD.
Using this notation, we can specify the commit we want to roll back to relatively.

One method is to use the format HEAD~\d+.
\d+ indicates the number of generations relative to the current branch head.
For example, HEAD~2 refers to the commit 2 generations prior to the current branch head, and HEAD~0 has the same meaning as HEAD.

git reset HEAD~2

Another method is to use the format HEAD\^+.
^ represents the parent commit of the starting commit.
For instance, HEAD^^ refers to the parent of the parent commit of the current branch head.
This is equivalent to HEAD~2.

git reset HEAD^^

The changed files are removed from staging and returned to the working tree.
This is the same as specifying --mixed option.

git reset --mixed  HEAD^^

If we want to leave them in staging, use --soft option.

git reset --soft  HEAD^^

If we want to discard them, use --hard option.

git reset --hard  HEAD^^

cf. Git - git-reset Documentation

git revert

Revert changes in a commit.

git revert <commit>

We specify a commit hash as <commit>.

cf. Git - git-revert Documentation

git stash

Save uncommitted changes and revert working dir to match the HEAD commit.

git stash push

push can be omitted.

git stash

To save paths that are not tracked in Git (e.g. newly added ones) as well, we can use option --include-untracked.

git stash --include-untracked

We can use -u instead of --include-untracked.

git stash -u

Saved changes can be displayed by executing with list.

git stash list

A saved changes are named stash@{n}.
n is an index starting from 0 and newer saved change has smaller index.

We can restore a change by specifying the name above.

git stash pop stash@{n}

A restored change is deleted from stash list.
If we want to keep that in the list, use apply instead of pop.

git stash apply stash@{n}

Then we delete it when we want.

git stash drop stash@{n}

cf. Git - git-stash Documentation

git status

Show the working tree status include following.

Changes to be committed.
paths that have differences between the staging file and the current HEAD commit.
Changed not staged for commit.
paths that have differences between the working tree and the staging file.
Untracked files.
paths in the working tree that are not tracked by Git.

The former one is committed when git commit is executed, but the latter two are not.

git status

cf. Git - git-status Documentation

git --version

Show the version of Git installed in a local environment.

git --version

We can use -v instead of --version.

git -v

cf. Git - git Documentation