-
-
Notifications
You must be signed in to change notification settings - Fork 278
/
crate-status.md
823 lines (731 loc) · 34.7 KB
/
crate-status.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
### gitoxide
**gix** is a command-line interface (*CLI*) to access git repositories in various ways best described as low-level
for use by experts or those validating functionality in real-world scenarios. Performance and efficiency are staples
of the implementation.
**ein** is reserved for one-off tools that are useful to many, and will one day implement a truly unique workflow
with the potential to become the preferred way to interact with git repositories.
Please note that all functionality comes from the `gitoxide-core` library, which mirrors these capabilities
and itself relies on all `git-*` crates. It's not meant for consumption, for application development, please use `gix`.
* **the `ein` program** - convenient and for humans
* [x] **init** - initialize a new non-bare repository with a `main` branch
* [ ] **clone** - initialize a local copy of a remote repository
* **tools**
* [x] **organize** - find all git repositories and place them in directories according to their remote paths
* [x] **find** - find all git repositories in a given directory - useful for tools like [skim][skim]
* [x] **estimate-hours** - estimate the time invested into a repository by evaluating commit dates.
* Based on the [git-hours] algorithm.
* See the [discussion][git-hours-discussion] for some performance data.
* **the `gix` program** _(plumbing)_ - lower level commands for use in automation
* **progress** - provide an overview of what works and what doesn't from the perspective of the git configuration.
This is likely to change a lot over time depending on actual needs, but maybe useful for you to see
if particular git-configuration is picked up and where it deviates.
* **config** - list the complete git configuration in human-readable form and optionally filter sections by name.
* **exclude**
* [x] **query** - check if path specs are excluded via gits exclusion rules like `.gitignore`.
* **verify** - validate a whole repository, for now only the object database.
* **commit**
* [x] **describe** - identify a commit by its closest tag in its past
* **tree**
* [x] **entries** - list tree entries for a single tree or recursively
* [x] **info** - display tree statistics
* **odb**
* [x] **info** - display odb statistics
* [x] **entries** - display all object ids in the object database
* **mailmap**
* [x] **entries** - display all entries of the aggregated mailmap git would use for substitution
* **revision**
* [x] **list** - list plain revision hashes from a starting point, similar to a very simple version of `git rev-list`.
* [x] **explain** - show what would be done while parsing a revision specification like `HEAD~1`
* [x] **resolve** - show which objects a revspec resolves to, similar to `git rev-parse` but faster and with much better error handling
* [x] **previous-branches** - list all previously checked out branches, powered by the ref-log.
* **remote**
* [x] **refs** - list all references available on the remote based on the current remote configuration.
* [x] **ref-map** - show how remote references relate to their local tracking branches as mapped by refspecs.
* [x] **fetch** - fetch the current remote or the given one, optionally just as dry-run.
* **clone**
* [x] initialize a new **bare** repository and fetch all objects.
* [x] initialize a new repository, fetch all objects and checkout the main worktree.
* **credential**
* [x] **fill/approve/reject** - The same as `git credential`, but implemented in Rust, calling helpers only when from trusted configuration.
* **free** - no git repository necessary
* **pack**
* [x] [verify](https://asciinema.org/a/352942)
* [x] [index verify](https://asciinema.org/a/352945) including each object sha1 and statistics
* [x] [explode](https://asciinema.org/a/352951), useful for transforming packs into loose objects for inspection or restoration
* [x] verify written objects (by reading them back from disk)
* [x] [receive](https://asciinema.org/a/359321) - receive a whole pack produced by **pack-send** or _git-upload-pack_, useful for `clone` like operations.
* [x] **create** - create a pack from given objects or tips of the commit graph.
* [ ] **send** - create a pack and send it using the pack protocol to stdout, similar to 'git-upload-pack',
for consumption by **pack-receive** or _git-receive-pack_
- **multi-index**
* [x] **info** - print information about the file
* [x] **create** - create a multi-index from pack indices
* [x] **verify** - check the file for consistency
* [x] **entries** - list all entries of the file
- **index**
* [x] [create](https://asciinema.org/a/352941) - create an index file by streaming a pack file as done during clone
* [x] support for thin packs (as needed for fetch/pull)
* **commit-graph**
* [x] **verify** - assure that a commit-graph is consistent
* **mailmap**
* [x] **verify** - check entries of a mailmap file for parse errors and display them
* **index**
* [x] **entries** - show detailed entry information for human or machine consumption (via JSON)
* [x] **verify** - check the index for consistency
* [x] **info** - display general information about the index itself, with detailed extension information by default
* [x] detailed information about the TREE extension
* [ ] …other extensions details aren't implemented yet
* [x] **checkout-exclusive** - a predecessor of `git worktree`, providing flexible options to evaluate checkout performance from an index and/or an object database.
[skim]: https://github.com/lotabout/skim
[git-hours]: https://github.com/kimmobrunfeldt/git-hours/blob/8aaeee237cb9d9028e7a2592a25ad8468b1f45e4/index.js#L114-L143
[git-hours-discussion]: https://github.com/Byron/gitoxide/discussions/78
### gix-actor
* [x] read and write a signature that uniquely identifies an actor within a git repository
* [x] a way to parse `name <email>` tuples (instead of full signatures) to facilitate parsing
commit trailers.
* [x] a way to write only actors, useful for commit trailers.
### gix-hash
* types to represent hash digests to identify git objects.
* used to abstract over different kinds of hashes, like SHA1 and the upcoming SHA256
* [x] API documentation
* [ ] Some examples
### gix-chunk
* [x] decode the chunk file table of contents and provide convenient API
* [x] write the table of contents
### gix-hashtable
* [x] hashmap
* [x] hashset
### gix-utils
* **filesystem**
* [x] probe capabilities
* [x] symlink creation and removal
* [x] file snapshots
### gix-fs
* [x] probe capabilities
* [x] symlink creation and removal
* [x] file snapshots
* [x] stack abstraction
### gix-object
* *decode (zero-copy)* borrowed objects
* [x] commit
* [ ] parse [trailers](https://git-scm.com/docs/git-interpret-trailers#_description)
* [x] tree
* encode owned objects
* [x] commit
* [x] tree
* [x] tag
* [x] [name validation][tagname-validation]
* [x] transform borrowed to owned objects
* [x] API documentation
* [ ] Some examples
### gix-pack
* **packs**
* [x] traverse pack index
* [x] 'object' abstraction
* [x] decode (zero copy)
* [x] verify checksum
* [x] simple and fast pack traversal
* [ ] [fast pack traversal works with ref-deltas](https://github.com/Byron/gitoxide/blob/8f9a55bb31af32b266d7c53426bc925361a627b2/gix-pack/src/cache/delta/from_offsets.rs#L101-L105)
* [x] decode
* [x] full objects
* [x] deltified objects
* **decode**
* _decode a pack from `Read` input_
* [x] Add support for zlib-ng for 20% faster _decompression_ performance
* [x] `Read` to `Iterator` of entries
* _read as is, verify hash, and restore partial packs_
* [x] create index from pack alone (_much faster than git_)
* [x] resolve 'thin' packs
* **encode**
* [x] Add support for zlib-ng for 2.5x _compression_ performance
* [x] objects to entries iterator
* [x] input objects as-is
* [x] pack only changed objects as derived from input
* [x] base object compression
* [ ] delta compression
* [ ] respect the `delta=false` attribute
* [x] create 'thin' pack, i.e. deltas that are based on objects the other side has.
* [x] parallel implementation that scales perfectly
* [x] entries to pack data iterator
* [ ] write index along with the new pack
* [x] **verify** pack with statistics
* [x] brute force - less memory
* [x] indexed - optimal speed, but more memory
* **advanced**
* [x] Multi-Pack index file (MIDX)
* [x] read
* [x] write
* [x] verify
* [ ] 'bitmap' file
* [ ] [special handling for networked packs](https://github.com/git/git/blob/89b43f80a514aee58b662ad606e6352e03eaeee4/packfile.c#L949:L949)
* [ ] [detect and retry packed object reading](https://github.com/git/git/blob/89b43f80a514aee58b662ad606e6352e03eaeee4/packfile.c#L1268:L1268)
* [x] API documentation
* [ ] Some examples
### gix-odb
* **loose object store**
* [x] traverse
* [x] read
* [x] into memory
* [x] streaming
* [x] verify checksum
* [x] streaming write for blobs
* [x] buffer write for small in-memory objects/non-blobs to bring IO down to open-read-close == 3 syscalls
* [ ] read object header (size + kind) without full decompression
* **dynamic store**
* [x] auto-refresh of on-disk state
* [x] handles alternates
* [x] multi-pack indices
* [x] perfect scaling with cores
* [x] support for pack caches, object caches and MRU for best per-thread performance.
* [x] prefix/short-id lookup, with optional listing of ambiguous objects.
* [x] object replacements (`git replace`)
* [x] high-speed packed object traversal without wasted CPU time
- [ ] user defined filters
* [ ] read object header (size + kind) without full decompression
* **sink**
* [x] write objects and obtain id
* **alternates**
* _resolve links between object databases_
* [x] safe with cycles and recursive configurations
* [x] multi-line with comments and quotes
* **promisor**
* It's vague, but these seems to be like index files allowing to fetch objects from a server on demand.
* [x] API documentation
* [ ] Some examples
### gix-diff
Check out the [performance discussion][gix-diff-performance] as well.
* **tree**
* [x] changes needed to obtain _other tree_
* **patches**
* There are various ways to generate a patch from two blobs.
* [ ] any
* **lines**
* [x] Simple line-by-line diffs powered by the `imara-diff` crate.
* diffing, merging, working with hunks of data
* find differences between various states, i.e. index, working tree, commit-tree
* [x] API documentation
* [ ] Examples
[gix-diff-performance]: https://github.com/Byron/gitoxide/discussions/74
### gix-traverse
Check out the [performance discussion][gix-traverse-performance] as well.
* **trees**
* [x] nested traversal
* **commits**
* [x] ancestor graph traversal similar to `git revlog`
* [ ] `commitgraph` support
* [x] API documentation
* [ ] Examples
[gix-traverse-performance]: https://github.com/Byron/gitoxide/discussions/76
### gix-url
* As documented here: https://www.git-scm.com/docs/git-clone#_git_urls
* **parse**
* [x] ssh URLs and SCP like syntax
* [x] file, git, and SSH
* [x] paths (OS paths, without need for UTF-8)
* [x] username expansion for ssh and git urls
* [x] convert URL to string
* [x] API documentation
* [ ] Some examples
### gix-packetline
* [PKT-Line](https://github.com/git/git/blob/master/Documentation/technical/protocol-common.txt#L52:L52)
* [x] encode
* [x] decode (zero-copy)
* [x] [error line](https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L28:L28)
* [x] [V2 additions](https://github.com/git/git/blob/master/Documentation/technical/protocol-v2.txt#L35:L36)
* [x] [side-band mode](https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L467:L467)
* [x] `Read` from packet line with (optional) progress support via sidebands
* [x] `Write` with built-in packet line encoding
* [x] `async` support
* [x] API documentation
* [ ] Some examples
### gix-transport
* No matter what we do here, timeouts must be supported to prevent hanging forever and to make interrupts destructor-safe.
* **client**
* [x] general purpose `connect(…)` for clients
* [x] _file://_ launches service application
* [x] _ssh://_ launches service application in a remote shell using _ssh_
* [x] _git://_ establishes a tcp connection to a git daemon
* [x] _http(s)://_ establishes connections to web server
* [x] via `curl` (blocking only)
* [x] via `reqwest` (blocking only)
* [ ] pass context for scheme specific configuration, like timeouts
* [x] git://<service>
* [x] V1 handshake
* [x] send values + receive data with sidebands
* [ ] ~~support for receiving 'shallow' refs in case the remote repository is shallow itself (I presume)~~
* Since V2 doesn't seem to support that, let's skip this until there is an actual need. No completionist :D
* [x] V2 handshake
* [x] send command request, receive response with sideband support
* [x] http(s)://<service>
* [x] set identity for basic authentication
* [x] V1 handshake
* [x] send values + receive data with sidebands
* [x] V2 handshake
* [x] send command request, receive response with sideband support
* [ ] ~~'dumb'~~ - _we opt out using this protocol seems too slow to be useful, unless it downloads entire packs for clones?_
* [x] authentication failures are communicated by io::ErrorKind::PermissionDenied, allowing other layers to retry with authentication
* [x] `async` support
* **server**
* [ ] general purpose `accept(…)` for servers
* [x] API documentation
* [ ] Some examples
#### Advanced HTTP transport features
| **feature** | **curl** | **reqwest** |
|-------------|----------|-------------|
| 01 | | |
| 02 | X | |
| 03 | | X |
| 04 | X | |
| 05 | | |
* **01** -> async
* **02** -> proxy support
* **03** -> custom request configuration via fn(request)
* **04** -> proxy authentication
* **05** -> [reauthentication after redirect](https://github.com/git/git/blob/eea7033409a0ed713c78437fc76486983d211e25/http.c#L1931)
### gix-protocol
* _abstract over protocol versions to allow delegates to deal only with a single way of doing things_
* [x] **credentials**
* [x] via gix-credentials
* [ ] via pure Rust implementation if no git is installed
* [x] handshake
* parse initial response of V1 and V2 servers
* [x] ls-refs
* [x] parse V1 refs as provided during handshake
* [x] parse V2 refs
* [ ] handle empty refs, AKA PKT-LINE(zero-id SP "capabilities^{}" NUL capability-list)
* [x] fetch
* [x] detailed progress
* [x] control credentials provider to fill, approve and reject
* [x] initialize and validate command arguments and features sanely
* [x] abort early for ls-remote capabilities
* [x] packfile negotiation
* [x] delegate can support for all fetch features, including shallow, deepen, etc.
* [x] receive parsed shallow refs
* [ ] push
* [x] API documentation
* [ ] Some examples
### gix-attributes
* [x] parse `.gitattribute` files
* [ ] an attributes stack for matching paths to their attributes, with support for built-in `binary` macro for `-text -diff -merge`
### gix-ignore
* [x] parse `.gitignore` files
* [x] an attributes stack for checking if paths are excluded
### gix-quote
* **ansi-c**
* [x] quote
* [ ] unquote
### gix-mailmap
* [x] parsing
* [x] lookup and mapping of author names
### gix-path
* [x] transformations to and from bytes
* [x] conversions between different platforms
* [x] virtual canonicalization for more concise paths via `absolutize()`
* [x] more flexible canonicalization with symlink resolution for paths which are partially virtual via `realpath()`
* **spec**
* [ ] parse
* [ ] check for match
### gix-pathspec
* [x] parse
* [ ] matching of paths
### gix-refspec
* [x] parse
* [x] matching of references and object names
* [x] for fetch
* [ ] for push
### gix-command
* [x] execute commands directly
* [x] execute commands with `sh`
* [ ] support for `GIT_EXEC_PATH` environment variable with `gix-sec` filter
### gix-prompt
* [x] open prompts for usernames for example
* [x] secure prompts for password
* [x] use `askpass` program if available
* [ ] signal handling (resetting and restoring terminal settings)
* [ ] windows prompts for `cmd.exe` and mingw terminals
### gix-note
A mechanism to associate metadata with any object, and keep revisions of it using git itself.
* [ ] CRUD for git notes
### gix-negotiate
* **algorithms**
- [x] `noop`
- [x] `consecutive`
- [x] `skipping`
### gix-fetchhead
* [ ] parse `FETCH_HEAD` information back entirely
* [ ] write typical fetch-head lines
### gix-discover
* [x] check if a git directory is a git repository
* [x] find a git repository by searching upward
* [x] define ceilings that should not be surpassed
* [x] prevent crossing file-systems (non-windows only)
* [x] handle linked worktrees
* [ ] a way to handle `safe.directory`
- note that it's less critical to support it as `gitoxide` allows access but prevents untrusted configuration to become effective.
### gix-date
* [ ] parse git dates
* [ ] serialize `Time`
### gix-credentials
* [x] launch git credentials helpers with a given action
- [x] built-in `git credential` program
- [x] as scripts
- [x] as absolute paths to programs with optional arguments
- [x] program name with optional arguments, transformed into `git credential-<name>`
* [x] `helper::main()` for easy custom credential helper programs written in Rust
### gix-filter
Provide base-implementations for dealing with smudge and clean filters as well as filter processes, facilitating their development.
* [ ] clean filter base
* [ ] smudge filter base
* [ ] filter process base
### gix-sec
Provides a trust model to share across gitoxide crates. It helps configuring how to interact with external processes, among other things.
* **integrations**
* [x] gix-config
* [x] gix
### gix-rebase
* [ ] obtain rebase status
* [ ] drive a rebase operation
### gix-sequencer
Handle human-aided operations which cannot be completed in one command invocation.
### gix-lfs
Implement git large file support using the process protocol and make it flexible enough to handle a variety of cases.
Make it the best-performing implementation and the most convenient one.
### gix-glob
* [x] parse pattern
* [x] a type for pattern matching of paths and non-paths, optionally case-insensitively.
### gix-worktree
* handle the working **tree/checkout**
- [x] checkout an index of files, executables and symlinks just as fast as git
- [x] forbid symlinks in directories
- [ ] handle submodules
- [ ] handle sparse directories
- [ ] handle sparse index
- [x] linear scaling with multi-threading up to IO saturation
- supported attributes to affect working tree and index contents
- [ ] eol
- [ ] working-tree-encoding
- …more
- **filtering**
- [ ] `text`
- [ ] `ident`
- [ ] filter processes
- [ ] single-invocation clean/smudge filters
* manage multiple worktrees
* access to per-path information, like `.gitignore` and `.gitattributes` in a manner well suited for efficient lookups
* [x] _exclude_ information
* [ ] attributes
### gix-revision
* [x] `describe()` (similar to `git name-rev`)
* parse specifications
* [x] parsing and navigation
* [x] revision ranges
* [ ] full date parsing support (depends on `gix-date`)
### gix-revision
* [x] primitives to help with graph traversal, along with commit-graph acceleration.
### gix-submodule
* CRUD for submodules
* try to handle with all the nifty interactions and be a little more comfortable than what git offers, lay a foundation for smarter git submodules.
### gix-bitmap
A plumbing crate with shared functionality regarding EWAH compressed bitmaps, as well as other kinds of bitmap implementations.
* **EWAH**
* `Array` type to read and write bits
* [x] execute closure for each `true` bit
* [x] decode on-disk representation
* [ ] encode on-disk representation
### gix-index
The git staging area.
* read
* [x] V2 - the default, including long-paths support
* [x] V3 - extended flags
* [x] V4 - delta-compression for paths
* optional threading
* [x] concurrent loading of index extensions
* [x] threaded entry reading
* extensions
* [x] TREE for speeding up tree generation
* [x] REUC resolving undo
* [x] UNTR untracked cache
* [x] FSMN file system monitor cache V1 and V2
* [x] EOIE end of index entry
* [x] IEOT index entry offset table
* [x] 'link' base indices to take information from, split index
* [x] 'sdir' [sparse directory entries](https://github.blog/2021-08-16-highlights-from-git-2-33/) - marker
* [x] verification of entries and extensions as well as checksum
* write
* [x] V2
* [x] V3 - extension bits
* [ ] V4
* extensions
* [x] TREE
* [ ] REUC
* [ ] UNTR
* [ ] FSMN
* [x] EOIE
* [x] 'sdir'
* [ ] 'link'
- **note** that we currently **dissolve** any shared index we read so when writing this extension is removed.
* `stat` update
* [ ] optional threaded `stat` based on thread_cost (aka preload)
* [x] handling of `.gitignore` and system file exclude configuration
* [ ] handle potential races
* maintain extensions when altering the cache
* [ ] TREE for speeding up tree generation
* [ ] REUC resolving undo
* [ ] UNTR untracked cache
* [ ] FSMN file system monitor cache V1 and V2
* [ ] EOIE end of index entry
* [ ] IEOT index entry offset table
* [ ] 'link' base indices to take information from, split index
* [ ] 'sdir' sparse directory entries
* add and remove entries
* [x] API documentation
* [ ] Some examples
### gix-commitgraph
* [x] read-only access
* [x] Graph lookup of commit information to obtain timestamps, generation and parents, and extra edges
* [ ] [Corrected generation dates](https://github.com/git/git/commit/e8b63005c48696a26f976f5f9b0ccaf1983e439d)
* [ ] Bloom filter index
* [ ] Bloom filter data
* [ ] create and update graphs and graph files
* [x] API documentation
* [ ] Some examples
### gix-tempfile
See its [README.md](https://github.com/Byron/gitoxide/blob/main/gix-tempfile/README.md).
### gix-lock
See its [README.md](https://github.com/Byron/gitoxide/blob/main/gix-lock/README.md).
### gix-config-value
* **parse**
* [x] boolean
* [x] integer
* [x] color
* [ ] ANSI code output for terminal colors
* [x] path (incl. resolution)
* [ ] date
* [ ] [permission][https://github.com/git/git/blob/71a8fab31b70c417e8f5b5f716581f89955a7082/setup.c#L1526:L1526]
### gix-config
* [x] read
* zero-copy parsing with event emission
* all config values as per the `gix-config-value` crate
* **includeIf**
* [x] `gitdir`, `gitdir/i`, and `onbranch`
* [ ] `hasconfig`
* [x] access values and sections by name and sub-section
* [x] edit configuration in memory, non-destructively
* cross-platform newline handling
* [x] write files back for lossless round-trips.
* keep comments and whitespace, and only change lines that are affected by actual changes, to allow truly non-destructive editing
* [x] cascaded loading of various configuration files into one
* [x] load from environment variables
* [x] load from well-known sources for global configuration
* [x] load repository configuration with all known sources
* [x] API documentation
* [x] Some examples
### gix
* [x] utilities for applications to make long running operations interruptible gracefully and to support timeouts in servers.
* [ ] handle `core.repositoryFormatVersion` and extensions
* [x] support for unicode-precomposition of command-line arguments (needs explicit use in parent application)
* **Repository**
* [x] discovery
* [x] option to not cross file systems (default)
* [x] handle git-common-dir
* [x] support for `GIT_CEILING_DIRECTORIES` environment variable
* [ ] handle other non-discovery modes and provide control over environment variable usage required in applications
* [x] rev-parse
* [x] rev-walk
* [x] include tips
* [ ] exclude commits
* [x] instantiation
* [x] access to refs and objects
* **credentials**
* [x] run `git credential` directly
* [x] use credential helper configuration and to obtain credentials with `gix_credentials::helper::Cascade`
* **config**
* [ ] facilities to apply the [url-match](https://git-scm.com/docs/gix-config#Documentation/gix-config.txt-httplturlgt) algorithm and to
[normalize urls](https://github.com/git/git/blob/be1a02a17ede4082a86dfbfee0f54f345e8b43ac/urlmatch.c#L109:L109) before comparison.
* **traverse**
* [x] commit graphs
* [ ] make [git-notes](https://git-scm.com/docs/git-notes) accessible
* [x] tree entries
* **diffs/changes**
* [x] tree with other tree
* [ ] respect case-sensitivity of host filesystem.
* [x] a way to access various diff related settings or use them
* [ ] respect `diff.*.textconv`, `diff.*.cachetextconv` and external diff viewers with `diff.*.command`,
[along with support for reading `diff` gitattributes](https://github.com/git/git/blob/73876f4861cd3d187a4682290ab75c9dccadbc56/Documentation/gitattributes.txt#L699:L699).
* **rewrite tracking**
* **deviation** - git keeps up to four candidates whereas we use the first-found candidate that matches the similarity percentage.
This can lead to different sources being found. As such, we also don't consider the filename at all.
* [ ] handle binary files correctly, and apply filters for that matter
* [x] computation limit with observable reduction of precision when it is hit, for copies and renames separately
* **by identity**
* [x] renames (sym-links are only ever compared by identity)
* [x] copies
* **by similarity** - similarity factor controllable separately from renames
* [x] renames
* [x] copies
* [x] 'find-copies-harder' - find copies with the source being the entire tree.
* [ ] tree or index with working tree
* [x] diffs between modified blobs with various algorithms
* [ ] tree with index
* [x] initialize
* [x] Proper configuration depending on platform (e.g. ignorecase, filemode, …)
* **Id**
* [x] short hashes with detection of ambiguity.
* **Commit**
* [x] `git describe` like functionality, with optional commit-graph acceleration
* [x] create new commit from tree
* **Objects**
* [x] lookup
* [x] peel to object kind
* [ ] create [signed commits and tags](https://github.com/Byron/gitoxide/issues/12)
* **trees**
* [x] lookup path
* **references**
* [x] peel to end
* [x] ref-log access
* [x] remote name
* [x] find remote itself
- [ ] respect `branch.<name>.merge` in the returned remote.
* **remotes**
* [x] clone
* [x] shallow
* [ ] include-tags when shallow is used (needs separate fetch)
* [ ] prune non-existing shallow commits
* [ ] [bundles](https://git-scm.com/docs/git-bundle)
* [x] fetch
* [x] shallow (remains shallow, options to adjust shallow boundary)
* [ ] a way to auto-explode small packs to avoid them to pile up
* [x] 'ref-in-want'
* [ ] 'wanted-ref'
* [x] standard negotiation algorithms `consecutive`, `skipping` and `noop`.
* [ ] push
* [x] ls-refs
* [x] ls-refs with ref-spec filter
* [x] list, find by name
* [x] create in memory
* [ ] groups
* [ ] [remote and branch files](https://github.com/git/git/blob/master/remote.c#L300)
* [ ] execute hooks
* **refs**
* [ ] run transaction hooks and handle special repository states like quarantine
* [ ] support for different backends like `files` and `reftable`
* **main or linked worktree**
* [ ] add files with `.gitignore` handling
* [ ] checkout with conversions like clean + smudge as in `.gitattributes`
* [ ] _diff_ index with working tree
* [ ] sparse checkout support
* [ ] read per-worktree config if `extensions.worktreeConfig` is enabled.
* **index**
* [ ] tree from index
* [ ] index from tree
* **worktrees**
* [x] open a repository with worktrees
* [x] read locked state
* [ ] obtain 'prunable' information
* [x] proper handling of worktree related refs
* [ ] create, move, remove, and repair
* [x] access exclude information
* [x] access attribute information
* [x] respect `core.worktree` configuration
- **deviation**
* The delicate interplay between `GIT_COMMON_DIR` and `GIT_WORK_TREE` isn't implemented.
* **config**
* [x] read the primitive types `boolean`, `integer`, `string`
* [x] read and interpolate trusted paths
* [x] low-level API for more elaborate access to all details of `gix-config` files
* [ ] a way to make changes to individual configuration files
* [x] mailmap
* [x] object replacements (`git replace`)
* [ ] configuration
* [ ] merging
* [ ] stashing
* [ ] Use _Commit Graph_ to speed up certain queries
* [ ] subtree
* [ ] interactive rebase status/manipulation
* submodules
* [ ] API documentation
* [ ] Some examples
### gix-archive
* [ ] `write_to()` for creating an archive with various container formats
* [ ] add custom entries to the archive
* [ ] handling of archive specific filters
* [ ] filter files of tree (with access to attributes)
* [ ] support for worktree conversion (via attributes and filters)
* [ ] API documentation
* [ ] Some examples
### gix-bundle
* [ ] create a bundle from an archive
* [ ] respect `export-ignore` and `export-subst`
* [ ] extract a branch from a bundle into a repository
* [ ] API documentation
* [ ] Some examples
### gix-validate
* [x] validate ref names
* [x] [validate][tagname-validation] tag names
### gix-ref
* [ ] Prepare code for arrival of longer hashes like Sha256. It's part of the [V2 proposal][reftable-v2] but should work for loose refs as well.
* **Stores**
* [ ] disable transactions during [quarantine]
* [x] namespaces
* a server-side feature to transparently isolate refs in a single shared repository, allowing all forks to live in the same condensed repository.
* **loose file**
* [x] ref validation
* [x] find single ref by name
* [ ] special handling of `FETCH_HEAD` and `MERGE_HEAD`
* [x] iterate refs with optional prefix
* **worktree support**
* [x] support multiple bases and classify refs
* [x] support for ref iteration merging common and private refs seamlessly.
* [x] avoid packing refs which are worktree private
* ~~symbolic ref support, using symbolic links~~
* This is a legacy feature which is not in use anymore.
* **transactions**
* [x] delete, create or update single ref or multiple refs while handling the _reflog_
* [x] set any valid ref value (not just object ids)
* [x] reflog changes can be entirely disabled (i.e. for bare repos)
* [ ] rename or copy references
* [x] transparent handling of packed-refs during deletion
* [x] writing loose refs into packed-refs and optionally delete them
* [ ] initial transaction optimization (a faster way to create clones with a lot of refs)
* **log**
* [x] forward iteration
* [x] backward iteration
* [ ] expire
* **ref**
* [x] peel to id
* **packed**
* [x] find single ref by name
* [x] iterate refs with optional prefix
* [x] handle unsorted packed refs and those without a header
* [ ] **[reftable][reftable-spec]**,
* see [here for a Go/C implementation][reftable-impl]
* [x] API documentation
* [ ] Some examples
[reftable-spec]: https://github.com/eclipse/jgit/blob/master/Documentation/technical/reftable.md
[reftable-impl]: https://github.com/google/reftable
[reftable-v2]: https://github.com/google/reftable/blob/master/reftable-v2-proposal.md
[quarantine]: https://github.com/git/git/blob/master/Documentation/git-receive-pack.txt#L223:L223
### gix-features
* **io-pipe** feature toggle
* a unix like pipeline for bytes
* **parallel** feature toggle
* _When on…_
* `in_parallel`
* `join`
* _When off all functions execute serially_
* **fast-sha1**
* provides a faster SHA1 implementation using CPU intrinsics
* [x] API documentation
### gix-tui
* _a terminal user interface seeking to replace and improve on `tig`_
* Can display complex history in novel ways to make them graspable. Maybe [this post] can be an inspiration.
### gix-tix
A re-implementation of a minimal `tig` like UI that aims to be fast and to the point.
### gix-lfs
Definitely optimize for performance and see how we fare compared to [oxen](https://github.com/Oxen-AI/oxen-release/blob/main/Performance.md).
Right now, `git lfs` is 40x slower, due to sequential uploads and lack of fast compression. It seems this can be greatly improved to get
close to 6min for 200k images (1.4GB). GitHub seems to cap upload speeds to 100kb/s, one major reason it's so slow, and it can only do
it sequentially as `git-lfs` doesn't use the new `filter-process` protocol which would allow parallelization.
Oxen uses the XXH3 (30gb/s) which greatly outperforms SHA1 - however, it doesn't look like the hash is necessarily the bottleneck in typical benchmarks.
[tagname-validation]: https://github.com/git/git/blob/master/Documentation/technical/protocol-common.txt#L23:L23
[this post]: http://blog.danieljanus.pl/2021/07/01/commit-groups/