feat: v4.0.0

With the addition of the `json` format, I chose to make the default
output
cleaner. It is way easier to read this way! \o/

Note that this format is also available using the `--format=table` flag.

It looks like this:
```shell script
$ npx code-complexity . --sort=ratio --limit=3

┌──────────────────────────────┬────────────┬───────┬───────┐
│ file                         │ complexity │ churn │ ratio │
├──────────────────────────────┼────────────┼───────┼───────┤
│ src/cli.ts                   │ 103        │ 8     │ 824   │
├──────────────────────────────┼────────────┼───────┼───────┤
│ test/code-complexity.test.ts │ 107        │ 7     │ 749   │
├──────────────────────────────┼────────────┼───────┼───────┤
│ .idea/workspace.xml          │ 123        │ 6     │ 738   │
└──────────────────────────────┴────────────┴───────┴───────┘
```

While handy, this solution was a rather naive approach to filtering.
I've removed them in favor of a `--filter` flag supporting globs. The
implementation is using [micromatch][1].

Example:
```shell script
$ npx code-complexity . --filter='!test/**','src/*.ts'
```

While interesting, these flags were not adding much value since you
usually want
to list the highest ratio/churn/complexity values. A combination of
`--sort=ratio` and `--limit=5` would usually do the trick.

They'd be interesting if min/max could be targeted on a metric (eg:
`ratio`,
`churn` or `complexity`). But since they were only targeting `ratios`, I
don't
see them adding much value. And they add more code to maintain.

I'll add an issue about adding them back and wait to see if it gets
traction.

The new `table` stdout is clearer to read and already show these
information
so we don't need these flags anymore. Yay, less code to maintain!

Using `--first-parent` was causing problems where `git log` would not
output
all the files. Using `no-first-parent` is now the default.

With the addition of the `json` support, I chose to make the `text`
output
a bit more opinionated. Metrics like `complexity`, `churn` and `ratio`
will
always be shown from now on.

See `--format`.

I've added this flag to support more output format. It currently allows
`table`
and `json`.

The `table` format is the default one.
The `json` format will ease integration with other softwares.

Example with `--format=table`:
```shell script
$ npx code-complexity . --sort=ratio --limit=3

┌──────────────────────────────┬────────────┬───────┬───────┐
│ file                         │ complexity │ churn │ ratio │
├──────────────────────────────┼────────────┼───────┼───────┤
│ src/cli.ts                   │ 103        │ 8     │ 824   │
├──────────────────────────────┼────────────┼───────┼───────┤
│ test/code-complexity.test.ts │ 107        │ 7     │ 749   │
├──────────────────────────────┼────────────┼───────┼───────┤
│ .idea/workspace.xml          │ 123        │ 6     │ 738   │
└──────────────────────────────┴────────────┴───────┴───────┘
```

Example with `--format=json`:
```sh
$ npx code-complexity . --format=json --limit=3

[{"path":"bin/code-complexity.ts","churn":1,"complexity":6,"ratio":6},{"path":".eslintignore","churn":1,"complexity":1,"ratio":1},{"path":".eslintrc.js","churn":1,"complexity":19,"ratio":19}]
```

I'm also thinking about an `html` format in order to display a
complexity/churn
graph but it's a bit of work so I'm not sure when that will lend.

As mentioned above, it replaces both `--excludes` and `--includes` whil
adding
glob support using [micromatch][1]. Good job me!

If you're interested in metrics and what's going on without having to
look at the
source code, you can use the `DEBUG=*` environment variable.

[1]: https://www.npmjs.com/package/micromatch

Author: Simon Renoult

.eslintrc.js

@@ -14,6 +14,7 @@ module.exports = {
   rules: {
     "prettier/prettier": "error",
     "no-console": "off",
-    "@typescript-eslint/no-use-before-define": "off"
+    "@typescript-eslint/no-use-before-define": "off",
+    "@typescript-eslint/no-explicit-any": "off"
   }
 };

README.md

@@ -16,50 +16,43 @@ $ npx code-complexity <path-to-git-directory>
 ## Help
 
 ```sh
-  Usage: code-complexity <dir> [options]
-  
-  Measure projects complexity based on files sloc and commit count.
-  
-  Options:
-    -l, --limit [limit]    Limit the number of files to output
-    -d, --details          Show the number of commit and computed sloc
-    -c, --commit           Show the number of commits
-    -s, --sloc             Show the computed sloc
-    -i, --since [since]    Limit the age of the commit analyzed
-    -n, --no-first-parent  Do not use the git-log flag '--first-parent' when counting commits
-    --sort [sort]          Sort results by commit, complexity, file or sloc
-    --min [min]            Exclude results below <min>
-    --max [max]            Exclude results above <max>
-    --excludes <strings>   List of strings (comma separated) used in filenames to exclude
-                           (executed after '--includes') (default: [])
-    --includes <strings>   List of strings (comma separated) used in filenames to include
-                           (executed before '--excludes') (default: [])
-    -h, --help             display help for command
-  
-  Examples:
-  
+    Usage: code-complexity <dir> [options]
+    
+    Measure the churn/complexity ratio. Higher values mean hotspots where refactorings should happen.
+    
+    Options:
+      -V, --version          output the version number
+      --filter <strings>     list of globs (comma separated) to filter
+      -f, --format [format]  format results using table or json
+      -l, --limit [limit]    limit the number of files to output
+      -i, --since [since]    limit the age of the commit analyzed
+      -s, --sort [sort]      sort results (allowed valued: ratio,
+                             churn, complexity or file)
+      -h, --help             display help for command
+    
+    Examples:
+    
     $ code-complexity <dir>
     $ code-complexity <dir> --limit 3
-    $ code-complexity <dir> --details
-    $ code-complexity <dir> --min 10 --max 50
-    $ code-complexity <dir> --sort complexity
-    $ code-complexity <dir> --excludes lib,test
-    $ code-complexity <dir> --includes users
-    $ code-complexity <dir> --details --limit 10 --sort complexity --excludes test
+    $ code-complexity <dir> --sort ratio
+    $ code-complexity <dir> --filter 'src/**','!src/front'
+    $ code-complexity <dir> --limit 10 --sort ratio
 ```
 
 ## Output
 
 ```sh
-$ npx code-complexity . --details --sort complexity --limit 10 
+$ npx code-complexity . --sort=ratio --limit=3
 
-test/code-complexity.test.ts 535 (commits: 5, sloc: 107)
-src/cli.ts 402 (commits: 6, sloc: 67)
-src/services/prepare-stdout.ts 348 (commits: 4, sloc: 87)
-src/services/compute-complexity.ts 108 (commits: 4, sloc: 27)
-src/services/count-commits-per-file.ts 83 (commits: 1, sloc: 83)
-src/services/compute-complexity-per-file.ts 36 (commits: 1, sloc: 36)
-.eslintrc.js 19 (commits: 1, sloc: 19)
+┌──────────────────────────────┬────────────┬───────┬───────┐
+│ file                         │ complexity │ churn │ ratio │
+├──────────────────────────────┼────────────┼───────┼───────┤
+│ src/cli.ts                   │ 103        │ 8     │ 824   │
+├──────────────────────────────┼────────────┼───────┼───────┤
+│ test/code-complexity.test.ts │ 107        │ 7     │ 749   │
+├──────────────────────────────┼────────────┼───────┼───────┤
+│ .idea/workspace.xml          │ 123        │ 6     │ 738   │
+└──────────────────────────────┴────────────┴───────┴───────┘
 ```
 
 ## Troubleshooting

bin/code-complexity.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import computeCodeComplexity from "../src/io";
+
+computeCodeComplexity().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});