Husky 0.2.1

Husky.Net

Introduction

Husky improves your commits and more 🐶 woof!

You can use it to lint your commit messages, run tests, lint code, etc... when you commit or push.

Features

• 🔥 Internal task runner!
• 🔥 Multiple file states (staged, committed, lastCommit, glob)
• 🔥 Compatible with dotnet-format
• 🔥 Customizable tasks
• 🔥 Supports task for specific branches
• 🔥 CSharp scripts (csx)!
• 🔥 Supports gitflow hooks
• 🔥 User-define arg variables 🆕
• Supports all Git hooks
• Powered by modern new Git feature (core.hooksPath)
• User-friendly messages
• Supports macOS, Linux and Windows
• Git GUIs
• Custom directories
• Monorepo

If you already know what is the lint-staged or Husky (npm packages), this is very similar but you can use Husky.Net without having node, yarn, etc.. installed, with a lot of more features! 🚀🚀

Why use Hooks and Husky.Net?

We, as developers, love platforms like GitHub, GitLab, Atlassian, Azure DevOps etc., as our managed git system and collaboration platform. We also love clean code and keep inventing new linters and rules to enforce it. In my opinion, every commit should allow the codebase to deploy to production. There is nothing worse than commits like “fixed style errors” or “fixed build”. These are often small mistakes you want to know as early as possible in your development cycle. You don’t want to break the build for the next developer because he pulled your ‘mistake’ or waste precious build minutes of your CI server. Say you have asked your teammate to review your code; in the meantime, the build server rejects your code. That means you have to go back and fix this, and your teammate has to come back and possibly review again after the changes (i.e., approvals reset on new commit). Doing so would waste a lot of time and effort. Husky.Net offers a very simple way to start using git hooks or running certain tasks, write custom scripts using c# and more ...

A lot of features are coming soon, stay tuned! 👁️‍🗨️👀

Installation

# local installation (recommended)
cd <Your project root directory>
dotnet new tool-manifest
dotnet tool install Husky

# global installation
dotnet tool install --global Husky

Note: With the global installation, you don't need to add the dotnet prefix to the commands.

Setup husky for your project

cd <Your project root directory>
dotnet husky install

Add your first hook

dotnet husky add .husky/pre-commit "echo 'Husky is awesome!'"
git add .husky/pre-commit

Make a commit

git commit -m "Keep calm and commit"
# `echo 'Husky is awesome!'` will run every time you commit

Automate husky installation for other contributors

If you installed husky locally, just add the below code to one of your projects (*.csproj *.vbproj).

Important: Just make sure to update the working directory depending on your folder structure.

<Target Name="husky" BeforeTargets="Restore;CollectPackageReferences">
   <Exec Command="dotnet tool restore"  StandardOutputImportance="Low" StandardErrorImportance="High"/>
   <Exec Command="dotnet husky install" StandardOutputImportance="Low" StandardErrorImportance="High"
         WorkingDirectory="../../" />  
</Target>

If you have only one multiple target project (TargetFrameworks) add the bellow condition IsCrossTargetingBuild to the target tag to prevent multiple execution

<Target Name="husky" BeforeTargets="Restore;CollectPackageReferences" Condition="'$(IsCrossTargetingBuild)' == 'true'">
   ...

Or If you are using the npm, add the below code to your package.json file to automatically install husky after the installation process:

 "scripts": {
    "prepare": "dotnet tool restore && dotnet husky install"
 }

Task runner

Linting makes more sense when run before committing your code. By doing so you can ensure no errors go into the repository and enforce code style. But running a lint process on a whole project is slow, and linting results can be irrelevant. Ultimately you only want to lint files that will be committed.

After installation, you must have task-runner.json file in your .husky directory that you can use to define your tasks.

you can run and test your tasks with husky run command. Once you are sure that your tasks are working properly, you can add it to the hook.

e.g.

dotnet husky add .husky/pre-commit "dotnet husky run"

<details> <summary>A simple real-world example <code>task-runner.json</code></summary> <p>

{
   "tasks": [
      {
         "command": "dotnet",
         "group": "backend",
         "args": ["dotnet-format", "--include", "${staged}"],
         "include": ["**/*.cs", "**/*.vb"]
      },
      {
         "name": "eslint",
         "group": "frontend",
         "command": "npm",
         "pathMode": "absolute",
         "cwd": "Client",
         "args": ["run", "lint", "${staged}"],
         "include": ["**/*.ts", "**/*.vue", "**/*.js"]
      },
      {
         "name": "prettier",
         "group": "frontend",
         "command": "npx",
         "pathMode": "absolute",
         "cwd": "Client",
         "args": ["prettier", "--write", "${staged}"],
         "include": [
            "**/*.ts",
            "**/*.vue",
            "**/*.js",
            "**/*.json",
            "**/*.yml",
            "**/*.css",
            "**/*.scss"
         ]
      },
      {
         "name": "Welcome",
         "output": "always",
         "command": "bash",
         "args": ["-c", "echo  🌈 Nice work! 🥂"],
         "windows": {
            "command": "cmd",
            "args": ["/c", "echo  🌈 Nice work! 🥂"]
         }
      }
   ]
}

</p> </details>

<br>

Task supported configurations

Using bellow configuration you can define your task with a lot of options.

Glob patterns

Husky.Net supports the standard dotnet FileSystemGlobbing patterns for include or exclude task configurations. read more here

Arg Variables

There are some variables that you can use in your task arguments.

• ${staged}
  • returns the list of currently staged files
• ${last-commit}
  • returns last commit changed files
• ${git-files}
  • returns the output of (git ls-files)
• ${all-files}
  • returns the list of matched files using include/exclude, be careful with this variable, it will return all the files if you don't specify include or exclude
• ${args}
  • returns the arguments passed directly to the husky run command using --args option

e.g."args": [ "${staged}" ]

user-defined variables

You can define your own variables by adding a task to the variables section in task-runner.json.

e.g: defining custom ${root-dir} variable to access root directory files

{
   "variables": [
      {
         "name": "root-dir",
         "command": "cmd",
         "args": ["/c", "dir", "/b"]
      }
   ],
   "tasks": [
      {
         "command": "cmd",
         "args": ["/c", "echo", "${root-dir}"]
      }
   ]
}

Using C# code in your git hooks

You can use the exec command to execute a C# script.

e.g.

dotnet husky exec .husky/csx/hello.csx

Also, you can use your csx scripts in your tasks.

e.g task

{
   "command": "dotnet",
   "args": [ "husky", "exec", ".husky/csx/hello.csx"  ],
}

Notes

• Consider all bellow 1.x versions as beta. ( we need a lot of tests before major release )

• Don't forget to give a ⭐ on GitHub

• This library inspired of husky & lint-staged and a few other tools, for DotNet, so make sure to support them too!

Known issues

• husky run command doesn't have color when executed from hooks.