cybercyst/carapace-bin
1
0
Fork 0
mirror of https://github.com/rsteube/carapace-bin.git synced 2025-05-05 15:32:53 +00:00
Code Issues Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
rsteube 2020-04-20 22:49:42 +02:00
commit 1557fe94c2
149 changed files with 3956 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
exa_completer/exa_completer
git_completer/git_completer

21
LICENSE Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2020 rsteube
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

65
exa_completer/cmd/root.go Normal file
View File

@ -0,0 +1,65 @@
package cmd
import (
"github.com/rsteube/carapace"
"github.com/spf13/cobra"
)
var rootCmd = &cobra.Command{
Use: "exa",
}
func Execute() error {
return rootCmd.Execute()
}
func init() {
// DISPLAY OPTIONS
rootCmd.Flags().BoolP("online", "1", false, "display one entry per line")
rootCmd.Flags().BoolP("long", "l", false, "display extended file metadata as table")
rootCmd.Flags().BoolP("grid", "G", false, "display entries as grid (default)")
rootCmd.Flags().BoolP("across", "x", false, "sort the grid across, rather than downwards")
rootCmd.Flags().BoolP("recurse", "R", false, "recurse into directories")
rootCmd.Flags().BoolP("tree", "T", false, "recurse inte directories as tree")
rootCmd.Flags().BoolP("classify", "F", false, "display type indicator by file names")
rootCmd.Flags().String("color", "", "when to use terminal colours (always, auto, never)")
rootCmd.Flags().String("colour", "", "when to use terminal colours (always, auto, never)")
rootCmd.Flags().String("color-scale", "", "highlight levels of file sizes distinctly")
rootCmd.Flags().String("colour-scale", "", "highlight levels of file sizes distinctly")
// FILTERING AND SORTING OPTIONS
rootCmd.Flags().BoolP("all", "a", false, "show hidden and 'dot' files")
rootCmd.Flags().BoolP("list-dirs", "d", false, "list directories like regular files")
rootCmd.Flags().Int32P("level", "L", 0, "limit the depth of recursion")
rootCmd.Flags().BoolP("reverse", "r", false, "reverse the sort order")
rootCmd.Flags().StringP("sort", "s", "", "which field to sort by")
rootCmd.Flags().Bool("group-directories-first", false, "list directories before other files")
rootCmd.Flags().BoolP("only-dirs", "D", false, "list only directories")
rootCmd.Flags().StringP("ignore-glob", "I", "", "glob patterns (pipe-separated) of files to ignore")
rootCmd.Flags().Bool("git-ignore", false, "Ignore files mentioned in '.gitignore'")
// LONG VIEW OPTIONS
rootCmd.Flags().BoolP("binary", "b", false, "list file sizes with binary prefixes")
rootCmd.Flags().BoolP("bytes", "B", false, "list file sizes in bytes, without any prefixes")
rootCmd.Flags().BoolP("group", "g", false, "list each file's group")
rootCmd.Flags().BoolP("header", "h", false, "add a header row to each column")
rootCmd.Flags().BoolP("links", "H", false, "list each file's number of hard links")
rootCmd.Flags().BoolP("inode", "i", false, "list each file's inode number")
rootCmd.Flags().BoolP("modified", "m", false, "use the modified timestamp field")
rootCmd.Flags().BoolP("blocks", "S", false, "show number of file system blocks")
rootCmd.Flags().StringP("time", "t", "", "which timestamp field to list (modified, accessed, created)")
rootCmd.Flags().BoolP("accessed", "u", false, "use the accessed timestamp field")
rootCmd.Flags().BoolP("created", "U", false, "use the created timestamp field")
rootCmd.Flags().Bool("time-style", false, "use the created timestamp field")
rootCmd.Flags().Bool("git", false, "list each file's Git status, if tracked or ignored")
rootCmd.Flags().BoolP("extended", "@", false, "list each file's extended attributes and sizes")
carapace.Gen(rootCmd).FlagCompletion(carapace.ActionMap{
"color": carapace.ActionValues("always", "auto", "never"),
"colour": carapace.ActionValues("always", "auto", "never"),
"sort" : carapace.ActionValues("name", "Name", "size", "extension", "Extension", "modified", "changed", "accessed", "created", "inode", "type", "none"),
"time": carapace.ActionValues("modified", "accessed", "created"),
})
carapace.Gen(rootCmd).Standalone()
}

7
exa_completer/main.go Normal file
View File

@ -0,0 +1,7 @@
package main
import "github.com/rsteube/carapace-completers/exa_completer/cmd"
func main() {
cmd.Execute()
}

33
git_completer/cmd/add_generated.go Normal file
View File

@ -0,0 +1,33 @@
package cmd
import (
"github.com/spf13/cobra"
)
var addCmd = &cobra.Command{
Use: "add",
Short: "Add file contents to the index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
addCmd.Flags().BoolP("all", "A", false, "add changes from all tracked and untracked files")
addCmd.Flags().String("chmod", "", "override the executable bit of the listed files")
addCmd.Flags().BoolP("edit", "e", false, "edit current diff and apply")
addCmd.Flags().BoolP("force", "f", false, "allow adding otherwise ignored files")
addCmd.Flags().Bool("ignore-errors", false, "just skip files which cannot be added because of errors")
addCmd.Flags().Bool("ignore-missing", false, "check if - even missing - files are ignored in dry run")
addCmd.Flags().Bool("ignore-removal", false, "ignore paths removed in the working tree (same as --no-all)")
addCmd.Flags().BoolP("interactive", "i", false, "interactive picking")
addCmd.Flags().BoolP("dry-run", "n", false, "dry run")
addCmd.Flags().BoolP("intent-to-add", "N", false, "record only the fact that the path will be added later")
addCmd.Flags().Bool("pathspec-file-nul", false, "with --pathspec-from-file, pathspec elements are separated with NUL character")
addCmd.Flags().String("pathspec-from-file", "", "read pathspec from file")
addCmd.Flags().BoolP("patch", "p", false, "select hunks interactively")
addCmd.Flags().Bool("refresh", false, "don't add, only refresh the index")
addCmd.Flags().Bool("renormalize", false, "renormalize EOL of tracked files (implies -u)")
addCmd.Flags().BoolP("update", "u", false, "update tracked files")
addCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(addCmd)
}

48
git_completer/cmd/am_generated.go Normal file
View File

@ -0,0 +1,48 @@
package cmd
import (
"github.com/spf13/cobra"
)
var amCmd = &cobra.Command{
Use: "am",
Short: "Apply a series of patches from a mailbox",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
amCmd.Flags().BoolP("3way", "3", false, "allow fall back on 3way merging if needed")
amCmd.Flags().Bool("abort", false, "restore the original branch and abort the patching operation.")
amCmd.Flags().StringP("C", "C", "", "pass it through git-apply")
amCmd.Flags().Bool("committer-date-is-author-date", false, "lie about committer date")
amCmd.Flags().Bool("continue", false, "continue applying patches after resolving a conflict")
amCmd.Flags().BoolP("scissors", "c", false, "strip everything before a scissors line")
amCmd.Flags().String("directory", "", "pass it through git-apply")
amCmd.Flags().String("exclude", "", "pass it through git-apply")
amCmd.Flags().Bool("ignore-date", false, "use current timestamp for author date")
amCmd.Flags().Bool("ignore-space-change", false, "pass it through git-apply")
amCmd.Flags().Bool("ignore-whitespace", false, "pass it through git-apply")
amCmd.Flags().BoolP("interactive", "i", false, "run interactively")
amCmd.Flags().String("include", "", "pass it through git-apply")
amCmd.Flags().Bool("keep-cr", false, "pass --keep-cr flag to git-mailsplit for mbox format")
amCmd.Flags().Bool("keep-non-patch", false, "pass -b flag to git-mailinfo")
amCmd.Flags().BoolP("keep", "k", false, "pass -k flag to git-mailinfo")
amCmd.Flags().BoolP("message-id", "m", false, "pass -m flag to git-mailinfo")
amCmd.Flags().Bool("no-keep-cr", false, "do not pass --keep-cr flag to git-mailsplit independent of am.keepcr")
amCmd.Flags().String("patch-format", "", "format the patch(es) are in")
amCmd.Flags().StringP("p", "p", "", "pass it through git-apply")
amCmd.Flags().BoolP("quiet", "q", false, "be quiet")
amCmd.Flags().Bool("quit", false, "abort the patching operation but keep HEAD where it is.")
amCmd.Flags().Bool("reject", false, "pass it through git-apply")
amCmd.Flags().Bool("rerere-autoupdate", false, "update the index with reused conflict resolution if possible")
amCmd.Flags().String("resolvemsg", "", "override error message when patch failure occurs")
amCmd.Flags().BoolP("resolved", "r", false, "synonyms for --continue")
amCmd.Flags().StringP("gpg-sign", "S", "", "GPG-sign commits")
amCmd.Flags().String("show-current-patch", "", "show the patch being applied")
amCmd.Flags().Bool("skip", false, "skip the current patch")
amCmd.Flags().BoolP("signoff", "s", false, "add a Signed-off-by line to the commit message")
amCmd.Flags().BoolP("utf8", "u", false, "recode into utf8 (default)")
amCmd.Flags().String("whitespace", "", "pass it through git-apply")
rootCmd.AddCommand(amCmd)
}

43
git_completer/cmd/annotate_generated.go Normal file
View File

@ -0,0 +1,43 @@
package cmd
import (
"github.com/spf13/cobra"
)
var annotateCmd = &cobra.Command{
Use: "annotate",
Short: "Annotate file lines with commit information",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
annotateCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
annotateCmd.Flags().BoolP("b", "b", false, "Show blank SHA-1 for boundary commits (Default: off)")
annotateCmd.Flags().Bool("color-by-age", false, "color lines by age")
annotateCmd.Flags().Bool("color-lines", false, "color redundant metadata from previous line differently")
annotateCmd.Flags().String("contents", "", "Use <file>'s contents as the final image")
annotateCmd.Flags().StringP("C", "C", "", "Find line copies within and across files")
annotateCmd.Flags().BoolP("c", "c", false, "Use the same output mode as git-annotate (Default: off)")
annotateCmd.Flags().BoolP("show-email", "e", false, "Show author email instead of name (Default: off)")
annotateCmd.Flags().BoolP("show-name", "f", false, "Show original filename (Default: auto)")
annotateCmd.Flags().String("ignore-rev", "", "Ignore <rev> when blaming")
annotateCmd.Flags().String("ignore-revs-file", "", "Ignore revisions from <file>")
annotateCmd.Flags().Bool("incremental", false, "Show blame entries as we find them, incrementally")
annotateCmd.Flags().Bool("line-porcelain", false, "Show porcelain format with per-line commit information")
annotateCmd.Flags().StringP("L", "L", "", "Process only line range n,m, counting from 1")
annotateCmd.Flags().BoolP("l", "l", false, "Show long commit SHA1 (Default: off)")
annotateCmd.Flags().Bool("minimal", false, "Spend extra cycles to find better match")
annotateCmd.Flags().StringP("M", "M", "", "Find line movements within and across files")
annotateCmd.Flags().BoolP("show-number", "n", false, "Show original linenumber (Default: off)")
annotateCmd.Flags().BoolP("porcelain", "p", false, "Show in a format designed for machine consumption")
annotateCmd.Flags().Bool("progress", false, "Force progress reporting")
annotateCmd.Flags().Bool("root", false, "Do not treat root commits as boundaries (Default: off)")
annotateCmd.Flags().Bool("score-debug", false, "Show output score for blame entries")
annotateCmd.Flags().StringP("S", "S", "", "Use revisions from <file> instead of calling git-rev-list")
annotateCmd.Flags().Bool("show-stats", false, "Show work cost statistics")
annotateCmd.Flags().BoolP("s", "s", false, "Suppress author name and timestamp (Default: off)")
annotateCmd.Flags().BoolP("t", "t", false, "Show raw timestamp (Default: off)")
annotateCmd.Flags().BoolP("w", "w", false, "Ignore whitespace differences")
rootCmd.AddCommand(annotateCmd)
}

44
git_completer/cmd/apply_generated.go Normal file
View File

@ -0,0 +1,44 @@
package cmd
import (
"github.com/spf13/cobra"
)
var applyCmd = &cobra.Command{
Use: "apply",
Short: "Apply a patch to files and/or to the index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
applyCmd.Flags().BoolP("3way", "3", false, "attempt three-way merge if a patch does not apply")
applyCmd.Flags().Bool("allow-overlap", false, "allow overlapping hunks")
applyCmd.Flags().Bool("apply", false, "also apply the patch (use with --stat/--summary/--check)")
applyCmd.Flags().String("build-fake-ancestor", "", "build a temporary index based on embedded index information")
applyCmd.Flags().Bool("cached", false, "apply a patch without touching the working tree")
applyCmd.Flags().Bool("check", false, "instead of applying the patch, see if the patch is applicable")
applyCmd.Flags().StringP("C", "C", "", "ensure at least <n> lines of context match")
applyCmd.Flags().String("directory", "", "prepend <root> to all filenames")
applyCmd.Flags().String("exclude", "", "don't apply changes matching the given path")
applyCmd.Flags().Bool("ignore-space-change", false, "ignore changes in whitespace when finding context")
applyCmd.Flags().Bool("ignore-whitespace", false, "ignore changes in whitespace when finding context")
applyCmd.Flags().Bool("inaccurate-eof", false, "tolerate incorrectly detected missing new-line at the end of file")
applyCmd.Flags().String("include", "", "apply changes matching the given path")
applyCmd.Flags().Bool("index", false, "make sure the patch is applicable to the current index")
applyCmd.Flags().BoolP("intent-to-add", "N", false, "mark new files with `git add --intent-to-add`")
applyCmd.Flags().Bool("no-add", false, "ignore additions made by the patch")
applyCmd.Flags().Bool("numstat", false, "show number of added and deleted lines in decimal notation")
applyCmd.Flags().StringP("p", "p", "", "remove <num> leading slashes from traditional diff paths")
applyCmd.Flags().Bool("recount", false, "do not trust the line counts in the hunk headers")
applyCmd.Flags().Bool("reject", false, "leave the rejected hunks in corresponding *.rej files")
applyCmd.Flags().BoolP("reverse", "R", false, "apply the patch in reverse")
applyCmd.Flags().Bool("stat", false, "instead of applying the patch, output diffstat for the input")
applyCmd.Flags().Bool("summary", false, "instead of applying the patch, output a summary for the input")
applyCmd.Flags().Bool("unidiff-zero", false, "don't expect at least one line of context")
applyCmd.Flags().Bool("unsafe-paths", false, "accept a patch that touches outside the working area")
applyCmd.Flags().BoolP("verbose", "v", false, "be verbose")
applyCmd.Flags().String("whitespace", "", "detect new or modified lines that have whitespace errors")
applyCmd.Flags().BoolP("z", "z", false, "paths are separated with NUL character")
rootCmd.AddCommand(applyCmd)
}

17
git_completer/cmd/archimport_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var archimportCmd = &cobra.Command{
Use: "archimport",
Short: "Import a GNU Arch repository into Git",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(archimportCmd)
}

27
git_completer/cmd/archive_generated.go Normal file
View File

@ -0,0 +1,27 @@
package cmd
import (
"github.com/spf13/cobra"
)
var archiveCmd = &cobra.Command{
Use: "archive",
Short: "Create an archive of files from a named tree",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
archiveCmd.Flags().BoolP("0", "0", false, "store only")
archiveCmd.Flags().BoolP("1", "1", false, "compress faster")
archiveCmd.Flags().BoolP("9", "9", false, "compress better")
archiveCmd.Flags().String("exec", "", "path to the remote git-upload-archive command")
archiveCmd.Flags().String("format", "", "archive format")
archiveCmd.Flags().BoolP("list", "l", false, "list supported archive formats")
archiveCmd.Flags().BoolP("output", "o", false, "<file> write the archive to this file")
archiveCmd.Flags().String("prefix", "", "prepend prefix to each pathname in the archive")
archiveCmd.Flags().String("remote", "", "retrieve the archive from remote repository <repo>")
archiveCmd.Flags().BoolP("verbose", "v", false, "report archived files on stderr")
archiveCmd.Flags().Bool("worktree-attributes", false, "read .gitattributes in working directory")
rootCmd.AddCommand(archiveCmd)
}

17
git_completer/cmd/bisect_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var bisectCmd = &cobra.Command{
Use: "bisect",
Short: "Use binary search to find the commit that introduced a bug",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(bisectCmd)
}

43
git_completer/cmd/blame_generated.go Normal file
View File

@ -0,0 +1,43 @@
package cmd
import (
"github.com/spf13/cobra"
)
var blameCmd = &cobra.Command{
Use: "blame",
Short: "Show what revision and author last modified each line of a file",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
blameCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
blameCmd.Flags().BoolP("b", "b", false, "Show blank SHA-1 for boundary commits (Default: off)")
blameCmd.Flags().Bool("color-by-age", false, "color lines by age")
blameCmd.Flags().Bool("color-lines", false, "color redundant metadata from previous line differently")
blameCmd.Flags().String("contents", "", "Use <file>'s contents as the final image")
blameCmd.Flags().StringP("C", "C", "", "Find line copies within and across files")
blameCmd.Flags().BoolP("c", "c", false, "Use the same output mode as git-annotate (Default: off)")
blameCmd.Flags().BoolP("show-email", "e", false, "Show author email instead of name (Default: off)")
blameCmd.Flags().BoolP("show-name", "f", false, "Show original filename (Default: auto)")
blameCmd.Flags().String("ignore-rev", "", "Ignore <rev> when blaming")
blameCmd.Flags().String("ignore-revs-file", "", "Ignore revisions from <file>")
blameCmd.Flags().Bool("incremental", false, "Show blame entries as we find them, incrementally")
blameCmd.Flags().Bool("line-porcelain", false, "Show porcelain format with per-line commit information")
blameCmd.Flags().StringP("L", "L", "", "Process only line range n,m, counting from 1")
blameCmd.Flags().BoolP("l", "l", false, "Show long commit SHA1 (Default: off)")
blameCmd.Flags().Bool("minimal", false, "Spend extra cycles to find better match")
blameCmd.Flags().StringP("M", "M", "", "Find line movements within and across files")
blameCmd.Flags().BoolP("show-number", "n", false, "Show original linenumber (Default: off)")
blameCmd.Flags().BoolP("porcelain", "p", false, "Show in a format designed for machine consumption")
blameCmd.Flags().Bool("progress", false, "Force progress reporting")
blameCmd.Flags().Bool("root", false, "Do not treat root commits as boundaries (Default: off)")
blameCmd.Flags().Bool("score-debug", false, "Show output score for blame entries")
blameCmd.Flags().StringP("S", "S", "", "Use revisions from <file> instead of calling git-rev-list")
blameCmd.Flags().Bool("show-stats", false, "Show work cost statistics")
blameCmd.Flags().BoolP("s", "s", false, "Suppress author name and timestamp (Default: off)")
blameCmd.Flags().BoolP("t", "t", false, "Show raw timestamp (Default: off)")
blameCmd.Flags().BoolP("w", "w", false, "Ignore whitespace differences")
rootCmd.AddCommand(blameCmd)
}

45
git_completer/cmd/branch_generated.go Normal file
View File

@ -0,0 +1,45 @@
package cmd
import (
"github.com/spf13/cobra"
)
var branchCmd = &cobra.Command{
Use: "branch",
Short: "List, create, or delete branches",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
branchCmd.Flags().BoolP("all", "a", false, "list both remote-tracking and local branches")
branchCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
branchCmd.Flags().BoolP("C", "C", false, "copy a branch, even if target exists")
branchCmd.Flags().BoolP("copy", "c", false, "copy a branch and its reflog")
branchCmd.Flags().String("color", "", "use colored output")
branchCmd.Flags().String("column", "", "list branches in columns")
branchCmd.Flags().String("contains", "", "print only branches that contain the commit")
branchCmd.Flags().Bool("create-reflog", false, "create the branch's reflog")
branchCmd.Flags().BoolP("D", "D", false, "delete branch (even if not merged)")
branchCmd.Flags().BoolP("delete", "d", false, "delete fully merged branch")
branchCmd.Flags().Bool("edit-description", false, "edit the description for the branch")
branchCmd.Flags().BoolP("force", "f", false, "force creation, move/rename, deletion")
branchCmd.Flags().String("format", "", "format to use for the output")
branchCmd.Flags().BoolP("ignore-case", "i", false, "sorting and filtering are case insensitive")
branchCmd.Flags().BoolP("list", "l", false, "list branch names")
branchCmd.Flags().String("merged", "", "print only branches that are merged")
branchCmd.Flags().BoolP("move", "m", false, "move/rename a branch and its reflog")
branchCmd.Flags().BoolP("M", "M", false, "move/rename a branch, even if target exists")
branchCmd.Flags().String("no-contains", "", "print only branches that don't contain the commit")
branchCmd.Flags().String("no-merged", "", "print only branches that are not merged")
branchCmd.Flags().String("points-at", "", "print only branches of the object")
branchCmd.Flags().BoolP("quiet", "q", false, "suppress informational messages")
branchCmd.Flags().BoolP("remotes", "r", false, "act on remote-tracking branches")
branchCmd.Flags().Bool("show-current", false, "show current branch name")
branchCmd.Flags().String("sort", "", "field name to sort on")
branchCmd.Flags().BoolP("track", "t", false, "set up tracking mode (see git-pull(1))")
branchCmd.Flags().Bool("unset-upstream", false, "unset the upstream info")
branchCmd.Flags().BoolP("set-upstream-to", "u", false, "<upstream> change the upstream info")
branchCmd.Flags().BoolP("verbose", "v", false, "show hash and subject, give twice for upstream branch")
rootCmd.AddCommand(branchCmd)
}

17
git_completer/cmd/bundle_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var bundleCmd = &cobra.Command{
Use: "bundle",
Short: "Move objects and refs by archive",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
bundleCmd.Flags().BoolP("verbose", "v", false, "be verbose; must be placed before a subcommand")
rootCmd.AddCommand(bundleCmd)
}

30
git_completer/cmd/cat_file_generated.go Normal file
View File

@ -0,0 +1,30 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cat_fileCmd = &cobra.Command{
Use: "cat-file",
Short: "Provide content or type and size information for repository objects",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
cat_fileCmd.Flags().Bool("allow-unknown-type", false, "allow -s and -t to work with broken/corrupt objects")
cat_fileCmd.Flags().Bool("batch-all-objects", false, "show all objects with --batch or --batch-check")
cat_fileCmd.Flags().String("batch-check", "", "show info about objects fed from the standard input")
cat_fileCmd.Flags().String("batch", "", "show info and content of objects fed from the standard input")
cat_fileCmd.Flags().Bool("buffer", false, "buffer --batch output")
cat_fileCmd.Flags().BoolP("e", "e", false, "exit with zero when there's no error")
cat_fileCmd.Flags().Bool("filters", false, "for blob objects, run filters on object's content")
cat_fileCmd.Flags().Bool("follow-symlinks", false, "follow in-tree symlinks (used with --batch or --batch-check)")
cat_fileCmd.Flags().String("path", "", "use a specific path for --textconv/--filters")
cat_fileCmd.Flags().BoolP("p", "p", false, "pretty-print object's content")
cat_fileCmd.Flags().BoolP("s", "s", false, "show object size")
cat_fileCmd.Flags().Bool("textconv", false, "for blob objects, run textconv on object's content")
cat_fileCmd.Flags().BoolP("t", "t", false, "show object type")
cat_fileCmd.Flags().Bool("unordered", false, "do not order --batch-all-objects output")
rootCmd.AddCommand(cat_fileCmd)
}

20
git_completer/cmd/check_attr_generated.go Normal file
View File

@ -0,0 +1,20 @@
package cmd
import (
"github.com/spf13/cobra"
)
var check_attrCmd = &cobra.Command{
Use: "check-attr",
Short: "Display gitattributes information",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
check_attrCmd.Flags().BoolP("all", "a", false, "report all attributes set on file")
check_attrCmd.Flags().Bool("cached", false, "use .gitattributes only from the index")
check_attrCmd.Flags().Bool("stdin", false, "read file names from stdin")
check_attrCmd.Flags().BoolP("z", "z", false, "terminate input and output records by a NUL character")
rootCmd.AddCommand(check_attrCmd)
}

22
git_completer/cmd/check_ignore_generated.go Normal file
View File

@ -0,0 +1,22 @@
package cmd
import (
"github.com/spf13/cobra"
)
var check_ignoreCmd = &cobra.Command{
Use: "check-ignore",
Short: "Debug gitignore / exclude files",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
check_ignoreCmd.Flags().BoolP("non-matching", "n", false, "show non-matching input paths")
check_ignoreCmd.Flags().Bool("no-index", false, "ignore index when checking")
check_ignoreCmd.Flags().BoolP("quiet", "q", false, "suppress progress reporting")
check_ignoreCmd.Flags().Bool("stdin", false, "read file names from stdin")
check_ignoreCmd.Flags().BoolP("verbose", "v", false, "be verbose")
check_ignoreCmd.Flags().BoolP("z", "z", false, "terminate input and output records by a NUL character")
rootCmd.AddCommand(check_ignoreCmd)
}

17
git_completer/cmd/check_mailmap_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var check_mailmapCmd = &cobra.Command{
Use: "check-mailmap",
Short: "Show canonical names and email addresses of contacts",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
check_mailmapCmd.Flags().Bool("stdin", false, "also read contacts from stdin")
rootCmd.AddCommand(check_mailmapCmd)
}

17
git_completer/cmd/check_ref_format_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var check_ref_formatCmd = &cobra.Command{
Use: "check-ref-format",
Short: "Ensures that a reference name is well formed",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(check_ref_formatCmd)
}

38
git_completer/cmd/checkout_generated.go Normal file
View File

@ -0,0 +1,38 @@
package cmd
import (
"github.com/spf13/cobra"
)
var checkoutCmd = &cobra.Command{
Use: "checkout",
Short: "Switch branches or restore working tree files",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
checkoutCmd.Flags().BoolP("ours", "2", false, "checkout our version for unmerged files")
checkoutCmd.Flags().BoolP("theirs", "3", false, "checkout their version for unmerged files")
checkoutCmd.Flags().StringP("b", "b", "", "create and checkout a new branch")
checkoutCmd.Flags().StringP("B", "B", "", "create/reset and checkout a branch")
checkoutCmd.Flags().String("conflict", "", "conflict style (merge or diff3)")
checkoutCmd.Flags().BoolP("detach", "d", false, "detach HEAD at named commit")
checkoutCmd.Flags().BoolP("force", "f", false, "force checkout (throw away local modifications)")
checkoutCmd.Flags().Bool("guess", false, "second guess 'git checkout <no-such-branch>' (default)")
checkoutCmd.Flags().Bool("ignore-other-worktrees", false, "do not check if another worktree is holding the given ref")
checkoutCmd.Flags().Bool("ignore-skip-worktree-bits", false, "do not limit pathspecs to sparse entries only")
checkoutCmd.Flags().BoolP("l", "l", false, "create reflog for new branch")
checkoutCmd.Flags().BoolP("merge", "m", false, "perform a 3-way merge with the new branch")
checkoutCmd.Flags().String("orphan", "", "new unparented branch")
checkoutCmd.Flags().Bool("overlay", false, "use overlay mode (default)")
checkoutCmd.Flags().Bool("overwrite-ignore", false, "update ignored files (default)")
checkoutCmd.Flags().Bool("pathspec-file-nul", false, "with --pathspec-from-file, pathspec elements are separated with NUL character")
checkoutCmd.Flags().String("pathspec-from-file", "", "read pathspec from file")
checkoutCmd.Flags().BoolP("patch", "p", false, "select hunks interactively")
checkoutCmd.Flags().Bool("progress", false, "force progress reporting")
checkoutCmd.Flags().BoolP("quiet", "q", false, "suppress progress reporting")
checkoutCmd.Flags().String("recurse-submodules", "", "control recursive updating of submodules")
checkoutCmd.Flags().BoolP("track", "t", false, "set upstream info for new branch")
rootCmd.AddCommand(checkoutCmd)
}

26
git_completer/cmd/checkout_index_generated.go Normal file
View File

@ -0,0 +1,26 @@
package cmd
import (
"github.com/spf13/cobra"
)
var checkout_indexCmd = &cobra.Command{
Use: "checkout-index",
Short: "Copy files from the index to the working tree",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
checkout_indexCmd.Flags().BoolP("all", "a", false, "check out all files in the index")
checkout_indexCmd.Flags().BoolP("force", "f", false, "force overwrite of existing files")
checkout_indexCmd.Flags().BoolP("no-create", "n", false, "don't checkout new files")
checkout_indexCmd.Flags().String("prefix", "", "when creating files, prepend <string>")
checkout_indexCmd.Flags().BoolP("quiet", "q", false, "no warning for existing files and files not in index")
checkout_indexCmd.Flags().String("stage", "", "copy out the files from named stage")
checkout_indexCmd.Flags().Bool("stdin", false, "read list of paths from the standard input")
checkout_indexCmd.Flags().Bool("temp", false, "write the content to temporary files")
checkout_indexCmd.Flags().BoolP("index", "u", false, "update stat information in the index file")
checkout_indexCmd.Flags().BoolP("z", "z", false, "paths are separated with NUL character")
rootCmd.AddCommand(checkout_indexCmd)
}

18
git_completer/cmd/cherry_generated.go Normal file
View File

@ -0,0 +1,18 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cherryCmd = &cobra.Command{
Use: "cherry",
Short: "Find commits yet to be applied to upstream",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
cherryCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
cherryCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(cherryCmd)
}

34
git_completer/cmd/cherry_pick_generated.go Normal file
View File

@ -0,0 +1,34 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cherry_pickCmd = &cobra.Command{
Use: "cherry-pick",
Short: "Apply the changes introduced by some existing commits",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
cherry_pickCmd.Flags().Bool("abort", false, "cancel revert or cherry-pick sequence")
cherry_pickCmd.Flags().Bool("allow-empty-message", false, "allow commits with empty messages")
cherry_pickCmd.Flags().Bool("allow-empty", false, "preserve initially empty commits")
cherry_pickCmd.Flags().String("cleanup", "", "how to strip spaces and #comments from message")
cherry_pickCmd.Flags().Bool("continue", false, "resume revert or cherry-pick sequence")
cherry_pickCmd.Flags().BoolP("edit", "e", false, "edit the commit message")
cherry_pickCmd.Flags().Bool("ff", false, "allow fast-forward")
cherry_pickCmd.Flags().Bool("keep-redundant-commits", false, "keep redundant, empty commits")
cherry_pickCmd.Flags().BoolP("mainline", "m", false, "<parent-number> select mainline parent")
cherry_pickCmd.Flags().BoolP("no-commit", "n", false, "don't automatically commit")
cherry_pickCmd.Flags().Bool("quit", false, "end revert or cherry-pick sequence")
cherry_pickCmd.Flags().Bool("rerere-autoupdate", false, "update the index with reused conflict resolution if possible")
cherry_pickCmd.Flags().StringP("gpg-sign", "S", "", "GPG sign commit")
cherry_pickCmd.Flags().Bool("skip", false, "skip current commit and continue")
cherry_pickCmd.Flags().BoolP("signoff", "s", false, "add Signed-off-by:")
cherry_pickCmd.Flags().String("strategy", "", "merge strategy")
cherry_pickCmd.Flags().BoolP("x", "x", false, "append commit name")
cherry_pickCmd.Flags().BoolP("strategy-option", "X", false, "<option> option for merge strategy")
rootCmd.AddCommand(cherry_pickCmd)
}

17
git_completer/cmd/citool_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var citoolCmd = &cobra.Command{
Use: "citool",
Short: "Graphical alternative to git-commit",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(citoolCmd)
}

17
git_completer/cmd/clang_format_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var clang_formatCmd = &cobra.Command{
Use: "clang-format",
Short: "",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(clang_formatCmd)
}

24
git_completer/cmd/clean_generated.go Normal file
View File

@ -0,0 +1,24 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cleanCmd = &cobra.Command{
Use: "clean",
Short: "Remove untracked files from the working tree",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
cleanCmd.Flags().BoolP("d", "d", false, "remove whole directories")
cleanCmd.Flags().BoolP("exclude", "e", false, "<pattern> add <pattern> to ignore rules")
cleanCmd.Flags().BoolP("force", "f", false, "force")
cleanCmd.Flags().BoolP("interactive", "i", false, "interactive cleaning")
cleanCmd.Flags().BoolP("dry-run", "n", false, "dry run")
cleanCmd.Flags().BoolP("quiet", "q", false, "do not print names of files removed")
cleanCmd.Flags().BoolP("x", "x", false, "remove ignored files, too")
cleanCmd.Flags().BoolP("X", "X", false, "remove only ignored files")
rootCmd.AddCommand(cleanCmd)
}

49
git_completer/cmd/clone_generated.go Normal file
View File

@ -0,0 +1,49 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cloneCmd = &cobra.Command{
Use: "clone",
Short: "Clone a repository into a new directory",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
cloneCmd.Flags().BoolP("ipv4", "4", false, "use IPv4 addresses only")
cloneCmd.Flags().BoolP("ipv6", "6", false, "use IPv6 addresses only")
cloneCmd.Flags().Bool("bare", false, "create a bare repository")
cloneCmd.Flags().BoolP("branch", "b", false, "<branch> checkout <branch> instead of the remote's HEAD")
cloneCmd.Flags().BoolP("config", "c", false, "<key=value> set config inside the new repository")
cloneCmd.Flags().String("depth", "", "create a shallow clone of that depth")
cloneCmd.Flags().Bool("dissociate", false, "use --reference only while cloning")
cloneCmd.Flags().String("filter", "", "object filtering")
cloneCmd.Flags().BoolP("jobs", "j", false, "<n> number of submodules cloned in parallel")
cloneCmd.Flags().BoolP("local", "l", false, "to clone from a local repository")
cloneCmd.Flags().Bool("mirror", false, "create a mirror repository (implies bare)")
cloneCmd.Flags().BoolP("no-checkout", "n", false, "don't create a checkout")
cloneCmd.Flags().Bool("no-hardlinks", false, "don't use local hardlinks, always copy")
cloneCmd.Flags().Bool("no-tags", false, "don't clone any tags, and make later fetches not to follow them")
cloneCmd.Flags().BoolP("origin", "o", false, "<name> use <name> instead of 'origin' to track upstream")
cloneCmd.Flags().Bool("progress", false, "force progress reporting")
cloneCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
cloneCmd.Flags().String("recurse-submodules", "", "initialize submodules in the clone")
cloneCmd.Flags().String("recursive", "", "initialize submodules in the clone")
cloneCmd.Flags().String("reference-if-able", "", "reference repository")
cloneCmd.Flags().String("reference", "", "reference repository")
cloneCmd.Flags().Bool("remote-submodules", false, "any cloned submodules will use their remote-tracking branch")
cloneCmd.Flags().String("separate-git-dir", "", "separate git dir from working tree")
cloneCmd.Flags().String("server-option", "", "option to transmit")
cloneCmd.Flags().String("shallow-exclude", "", "deepen history of shallow clone, excluding rev")
cloneCmd.Flags().String("shallow-since", "", "create a shallow clone since a specific time")
cloneCmd.Flags().Bool("shallow-submodules", false, "any cloned submodules will be shallow")
cloneCmd.Flags().Bool("single-branch", false, "clone only one branch, HEAD or --branch")
cloneCmd.Flags().Bool("sparse", false, "initialize sparse-checkout file to include only files at root")
cloneCmd.Flags().BoolP("shared", "s", false, "setup as shared repository")
cloneCmd.Flags().String("template", "", "directory from which templates will be used")
cloneCmd.Flags().BoolP("upload-pack", "u", false, "<path> path to git-upload-pack on the remote")
cloneCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
rootCmd.AddCommand(cloneCmd)
}

23
git_completer/cmd/column_generated.go Normal file
View File

@ -0,0 +1,23 @@
package cmd
import (
"github.com/spf13/cobra"
)
var columnCmd = &cobra.Command{
Use: "column",
Short: "Display data in columns",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
columnCmd.Flags().String("command", "", "lookup config vars")
columnCmd.Flags().String("indent", "", "Padding space on left border")
columnCmd.Flags().String("mode", "", "layout to use")
columnCmd.Flags().String("nl", "", "Padding space on right border")
columnCmd.Flags().String("padding", "", "Padding space between columns")
columnCmd.Flags().String("raw-mode", "", "layout to use")
columnCmd.Flags().String("width", "", "Maximum width")
rootCmd.AddCommand(columnCmd)
}

51
git_completer/cmd/commit_generated.go Normal file
View File

@ -0,0 +1,51 @@
package cmd
import (
"github.com/spf13/cobra"
)
var commitCmd = &cobra.Command{
Use: "commit",
Short: "Record changes to the repository",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
commitCmd.Flags().BoolP("all", "a", false, "commit all changed files")
commitCmd.Flags().Bool("ahead-behind", false, "compute full ahead/behind values")
commitCmd.Flags().Bool("amend", false, "amend previous commit")
commitCmd.Flags().String("author", "", "override author for commit")
commitCmd.Flags().Bool("branch", false, "show branch information")
commitCmd.Flags().String("cleanup", "", "how to strip spaces and #comments from message")
commitCmd.Flags().BoolP("reedit-message", "c", false, "<commit> reuse and edit message from specified commit")
commitCmd.Flags().BoolP("reuse-message", "C", false, "<commit> reuse message from specified commit")
commitCmd.Flags().String("date", "", "override date for commit")
commitCmd.Flags().Bool("dry-run", false, "show what would be committed")
commitCmd.Flags().BoolP("edit", "e", false, "force edit of commit")
commitCmd.Flags().BoolP("file", "F", false, "<file> read message from file")
commitCmd.Flags().String("fixup", "", "use autosquash formatted message to fixup specified commit")
commitCmd.Flags().BoolP("include", "i", false, "add specified files to index for commit")
commitCmd.Flags().Bool("interactive", false, "interactively add files")
commitCmd.Flags().Bool("long", false, "show status in long format (default)")
commitCmd.Flags().BoolP("message", "m", false, "<message> commit message")
commitCmd.Flags().BoolP("no-verify", "n", false, "bypass pre-commit and commit-msg hooks")
commitCmd.Flags().Bool("no-post-rewrite", false, "bypass post-rewrite hook")
commitCmd.Flags().BoolP("only", "o", false, "commit only specified files")
commitCmd.Flags().Bool("pathspec-file-nul", false, "with --pathspec-from-file, pathspec elements are separated with NUL character")
commitCmd.Flags().String("pathspec-from-file", "", "read pathspec from file")
commitCmd.Flags().Bool("porcelain", false, "machine-readable output")
commitCmd.Flags().BoolP("patch", "p", false, "interactively add changes")
commitCmd.Flags().BoolP("quiet", "q", false, "suppress summary after successful commit")
commitCmd.Flags().Bool("reset-author", false, "the commit is authored by me now (used with -C/-c/--amend)")
commitCmd.Flags().StringP("gpg-sign", "S", "", "GPG sign commit")
commitCmd.Flags().Bool("short", false, "show status concisely")
commitCmd.Flags().String("squash", "", "use autosquash formatted message to squash specified commit")
commitCmd.Flags().BoolP("signoff", "s", false, "add Signed-off-by:")
commitCmd.Flags().Bool("status", false, "include status in commit message template")
commitCmd.Flags().BoolP("template", "t", false, "<file> use specified template file")
commitCmd.Flags().StringP("untracked-files", "u", "", "show untracked files, optional modes: all, normal, no. (Default: all)")
commitCmd.Flags().BoolP("verbose", "v", false, "show diff in commit message template")
commitCmd.Flags().BoolP("null", "z", false, "terminate entries with NUL")
rootCmd.AddCommand(commitCmd)
}

17
git_completer/cmd/commit_graph_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var commit_graphCmd = &cobra.Command{
Use: "commit-graph",
Short: "Write and verify Git commit-graph files",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
commit_graphCmd.Flags().String("object-dir", "", "The object directory to store the graph")
rootCmd.AddCommand(commit_graphCmd)
}

20
git_completer/cmd/commit_tree_generated.go Normal file
View File

@ -0,0 +1,20 @@
package cmd
import (
"github.com/spf13/cobra"
)
var commit_treeCmd = &cobra.Command{
Use: "commit-tree",
Short: "Create a new commit object",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
commit_treeCmd.Flags().StringP("F", "F", "", "read commit log message from file")
commit_treeCmd.Flags().StringP("m", "m", "", "commit message")
commit_treeCmd.Flags().StringP("p", "p", "", "id of a parent commit object")
commit_treeCmd.Flags().StringP("gpg-sign", "S", "", "GPG sign commit")
rootCmd.AddCommand(commit_treeCmd)
}

48
git_completer/cmd/config_generated.go Normal file
View File

@ -0,0 +1,48 @@
package cmd
import (
"github.com/spf13/cobra"
)
var configCmd = &cobra.Command{
Use: "config",
Short: "Get and set repository or global options",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
configCmd.Flags().Bool("add", false, "add a new variable: name value")
configCmd.Flags().String("blob", "", "read config from given blob object")
configCmd.Flags().Bool("bool-or-int", false, "value is --bool or --int")
configCmd.Flags().Bool("bool", false, "value is \"true\" or \"false\"")
configCmd.Flags().String("default", "", "with --get, use default value when missing entry")
configCmd.Flags().BoolP("edit", "e", false, "open an editor")
configCmd.Flags().Bool("expiry-date", false, "value is an expiry date")
configCmd.Flags().BoolP("file", "f", false, "<file> use given config file")
configCmd.Flags().Bool("get-all", false, "get all values: key [value-regex]")
configCmd.Flags().Bool("get-colorbool", false, "find the color setting: slot [stdout-is-tty]")
configCmd.Flags().Bool("get-color", false, "find the color configured: slot [default]")
configCmd.Flags().Bool("get", false, "get value: name [value-regex]")
configCmd.Flags().Bool("get-regexp", false, "get values for regexp: name-regex [value-regex]")
configCmd.Flags().Bool("get-urlmatch", false, "get value specific for the URL: section[.var] URL")
configCmd.Flags().Bool("global", false, "use global config file")
configCmd.Flags().Bool("includes", false, "respect include directives on lookup")
configCmd.Flags().Bool("int", false, "value is decimal number")
configCmd.Flags().BoolP("list", "l", false, "list all")
configCmd.Flags().Bool("local", false, "use repository config file")
configCmd.Flags().Bool("name-only", false, "show variable names only")
configCmd.Flags().Bool("path", false, "value is a path (file or directory name)")
configCmd.Flags().Bool("remove-section", false, "remove a section: name")
configCmd.Flags().Bool("rename-section", false, "rename section: old-name new-name")
configCmd.Flags().Bool("replace-all", false, "replace all matching variables: name value [value_regex]")
configCmd.Flags().Bool("show-origin", false, "show origin of config (file, standard input, blob, command line)")
configCmd.Flags().Bool("show-scope", false, "show scope of config (worktree, local, global, system, command)")
configCmd.Flags().Bool("system", false, "use system config file")
configCmd.Flags().BoolP("type", "t", false, "<> value is given this type")
configCmd.Flags().Bool("unset-all", false, "remove all matches: name [value-regex]")
configCmd.Flags().Bool("unset", false, "remove a variable: name [value-regex]")
configCmd.Flags().Bool("worktree", false, "use per-worktree config file")
configCmd.Flags().BoolP("null", "z", false, "terminate values with NUL byte")
rootCmd.AddCommand(configCmd)
}

18
git_completer/cmd/count_objects_generated.go Normal file
View File

@ -0,0 +1,18 @@
package cmd
import (
"github.com/spf13/cobra"
)
var count_objectsCmd = &cobra.Command{
Use: "count-objects",
Short: "Count unpacked number of objects and their disk consumption",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
count_objectsCmd.Flags().BoolP("human-readable", "H", false, "print sizes in human readable format")
count_objectsCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(count_objectsCmd)
}

18
git_completer/cmd/credential_cache_generated.go Normal file
View File

@ -0,0 +1,18 @@
package cmd
import (
"github.com/spf13/cobra"
)
var credential_cacheCmd = &cobra.Command{
Use: "credential-cache",
Short: "Helper to temporarily store passwords in memory",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
credential_cacheCmd.Flags().String("socket", "", "path of cache-daemon socket")
credential_cacheCmd.Flags().String("timeout", "", "number of seconds to cache credentials")
rootCmd.AddCommand(credential_cacheCmd)
}

17
git_completer/cmd/credential_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var credentialCmd = &cobra.Command{
Use: "credential",
Short: "Retrieve and store user credentials",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(credentialCmd)
}

17
git_completer/cmd/credential_store_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var credential_storeCmd = &cobra.Command{
Use: "credential-store",
Short: "Helper to store credentials on disk",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
credential_storeCmd.Flags().String("file", "", "fetch and store credentials in <path>")
rootCmd.AddCommand(credential_storeCmd)
}

17
git_completer/cmd/crypt_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cryptCmd = &cobra.Command{
Use: "crypt",
Short: "",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(cryptCmd)
}

17
git_completer/cmd/cvsexportcommit_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cvsexportcommitCmd = &cobra.Command{
Use: "cvsexportcommit",
Short: "Export a single commit to a CVS checkout",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(cvsexportcommitCmd)
}

17
git_completer/cmd/cvsimport_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var cvsimportCmd = &cobra.Command{
Use: "cvsimport",
Short: "Salvage your data out of another SCM people love to hate",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(cvsimportCmd)
}

17
git_completer/cmd/daemon_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var daemonCmd = &cobra.Command{
Use: "daemon",
Short: "A really simple server for Git repositories",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(daemonCmd)
}

30
git_completer/cmd/describe_generated.go Normal file
View File

@ -0,0 +1,30 @@
package cmd
import (
"github.com/spf13/cobra"
)
var describeCmd = &cobra.Command{
Use: "describe",
Short: "Give an object a human readable name based on an available ref",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
describeCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
describeCmd.Flags().Bool("all", false, "use any ref")
describeCmd.Flags().Bool("always", false, "show abbreviated commit object as fallback")
describeCmd.Flags().String("broken", "", "append <mark> on broken working tree (default: \"-broken\")")
describeCmd.Flags().String("candidates", "", "consider <n> most recent tags (default: 10)")
describeCmd.Flags().Bool("contains", false, "find the tag that comes after the commit")
describeCmd.Flags().Bool("debug", false, "debug search strategy on stderr")
describeCmd.Flags().String("dirty", "", "append <mark> on dirty working tree (default: \"-dirty\")")
describeCmd.Flags().Bool("exact-match", false, "only output exact matches")
describeCmd.Flags().String("exclude", "", "do not consider tags matching <pattern>")
describeCmd.Flags().Bool("first-parent", false, "only follow first parent")
describeCmd.Flags().Bool("long", false, "always use long format")
describeCmd.Flags().String("match", "", "only consider tags matching <pattern>")
describeCmd.Flags().Bool("tags", false, "use any tag, even unannotated")
rootCmd.AddCommand(describeCmd)
}

17
git_completer/cmd/diff_files_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var diff_filesCmd = &cobra.Command{
Use: "diff-files",
Short: "Compares files in the working tree and the index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(diff_filesCmd)
}

17
git_completer/cmd/diff_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var diffCmd = &cobra.Command{
Use: "diff",
Short: "Show changes between commits, commit and working tree, etc",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(diffCmd)
}

17
git_completer/cmd/diff_index_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var diff_indexCmd = &cobra.Command{
Use: "diff-index",
Short: "Compare a tree to the working tree or index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(diff_indexCmd)
}

17
git_completer/cmd/diff_tree_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var diff_treeCmd = &cobra.Command{
Use: "diff-tree",
Short: "Compares the content and mode of blobs found via two tree objects",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(diff_treeCmd)
}

25
git_completer/cmd/difftool_generated.go Normal file
View File

@ -0,0 +1,25 @@
package cmd
import (
"github.com/spf13/cobra"
)
var difftoolCmd = &cobra.Command{
Use: "difftool",
Short: "Show changes using common diff tools",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
difftoolCmd.Flags().BoolP("dir-diff", "d", false, "perform a full-directory diff")
difftoolCmd.Flags().BoolP("gui", "g", false, "use `diff.guitool` instead of `diff.tool`")
difftoolCmd.Flags().Bool("no-index", false, "passed to `diff`")
difftoolCmd.Flags().Bool("symlinks", false, "use symlinks in dir-diff mode")
difftoolCmd.Flags().Bool("tool-help", false, "print a list of diff tools that may be used with `--tool`")
difftoolCmd.Flags().Bool("trust-exit-code", false, "make 'git-difftool' exit when an invoked diff tool returns a non - zero exit code")
difftoolCmd.Flags().BoolP("tool", "t", false, "<tool> use the specified diff tool")
difftoolCmd.Flags().BoolP("extcmd", "x", false, "<command> specify a custom command for viewing diffs")
difftoolCmd.Flags().BoolP("no-prompt", "y", false, "do not prompt before launching a diff tool")
rootCmd.AddCommand(difftoolCmd)
}

32
git_completer/cmd/fast_export_generated.go Normal file
View File

@ -0,0 +1,32 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fast_exportCmd = &cobra.Command{
Use: "fast-export",
Short: "Git data exporter",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
fast_exportCmd.Flags().Bool("anonymize", false, "anonymize output")
fast_exportCmd.Flags().String("export-marks", "", "Dump marks to this file")
fast_exportCmd.Flags().Bool("fake-missing-tagger", false, "Fake a tagger when tags lack one")
fast_exportCmd.Flags().Bool("full-tree", false, "Output full tree for each commit")
fast_exportCmd.Flags().String("import-marks", "", "Import marks from this file")
fast_exportCmd.Flags().String("import-marks-if-exists", "", "Import marks from this file if it exists")
fast_exportCmd.Flags().Bool("mark-tags", false, "Label tags with mark ids")
fast_exportCmd.Flags().Bool("no-data", false, "Skip output of blob data")
fast_exportCmd.Flags().String("progress", "", "show progress after <n> objects")
fast_exportCmd.Flags().String("reencode", "", "select handling of commit messages in an alternate encoding")
fast_exportCmd.Flags().Bool("reference-excluded-parents", false, "Reference parents which are not in fast-export stream by object id")
fast_exportCmd.Flags().String("refspec", "", "Apply refspec to exported refs")
fast_exportCmd.Flags().Bool("show-original-ids", false, "Show original object ids of blobs/commits")
fast_exportCmd.Flags().String("signed-tags", "", "select handling of signed tags")
fast_exportCmd.Flags().String("tag-of-filtered-object", "", "select handling of tags that tag filtered objects")
fast_exportCmd.Flags().Bool("use-done-feature", false, "Use the done feature to terminate the stream")
rootCmd.AddCommand(fast_exportCmd)
}

17
git_completer/cmd/fast_import_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fast_importCmd = &cobra.Command{
Use: "fast-import",
Short: "Backend for fast Git data importers",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(fast_importCmd)
}

49
git_completer/cmd/fetch_generated.go Normal file
View File

@ -0,0 +1,49 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fetchCmd = &cobra.Command{
Use: "fetch",
Short: "Download objects and refs from another repository",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
fetchCmd.Flags().BoolP("ipv4", "4", false, "use IPv4 addresses only")
fetchCmd.Flags().BoolP("ipv6", "6", false, "use IPv6 addresses only")
fetchCmd.Flags().BoolP("append", "a", false, "append to .git/FETCH_HEAD instead of overwriting")
fetchCmd.Flags().Bool("all", false, "fetch from all remotes")
fetchCmd.Flags().Bool("auto-gc", false, "run 'gc --auto' after fetching")
fetchCmd.Flags().String("deepen", "", "deepen history of shallow clone")
fetchCmd.Flags().String("depth", "", "deepen history of shallow clone")
fetchCmd.Flags().Bool("dry-run", false, "dry run")
fetchCmd.Flags().BoolP("force", "f", false, "force overwrite of local reference")
fetchCmd.Flags().String("filter", "", "object filtering")
fetchCmd.Flags().BoolP("jobs", "j", false, "<n> number of submodules fetched in parallel")
fetchCmd.Flags().BoolP("keep", "k", false, "keep downloaded pack")
fetchCmd.Flags().BoolP("multiple", "m", false, "fetch from multiple remotes")
fetchCmd.Flags().BoolP("n", "n", false, "do not fetch all tags (--no-tags)")
fetchCmd.Flags().String("negotiation-tip", "", "report that we have only objects reachable from this object")
fetchCmd.Flags().BoolP("server-option", "o", false, "<server-specific> option to transmit")
fetchCmd.Flags().BoolP("prune", "p", false, "prune remote-tracking branches no longer on remote")
fetchCmd.Flags().BoolP("prune-tags", "P", false, "prune local tags no longer on remote and clobber changed tags")
fetchCmd.Flags().Bool("progress", false, "force progress reporting")
fetchCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
fetchCmd.Flags().String("recurse-submodules", "", "control recursive fetching of submodules")
fetchCmd.Flags().String("refmap", "", "specify fetch refmap")
fetchCmd.Flags().Bool("set-upstream", false, "set upstream for git pull/fetch")
fetchCmd.Flags().String("shallow-exclude", "", "deepen history of shallow clone, excluding rev")
fetchCmd.Flags().String("shallow-since", "", "deepen history of shallow repository based on time")
fetchCmd.Flags().Bool("show-forced-updates", false, "check for forced-updates on all updated branches")
fetchCmd.Flags().BoolP("tags", "t", false, "fetch all tags and associated objects")
fetchCmd.Flags().Bool("unshallow", false, "convert to a complete repository")
fetchCmd.Flags().Bool("update-shallow", false, "accept refs that update .git/shallow")
fetchCmd.Flags().String("upload-pack", "", "path to upload pack on remote end")
fetchCmd.Flags().BoolP("update-head-ok", "u", false, "allow updating of HEAD ref")
fetchCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
fetchCmd.Flags().Bool("write-commit-graph", false, "write the commit-graph after fetching")
rootCmd.AddCommand(fetchCmd)
}

17
git_completer/cmd/fetch_pack_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fetch_packCmd = &cobra.Command{
Use: "fetch-pack",
Short: "Receive missing objects from another repository",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(fetch_packCmd)
}

17
git_completer/cmd/filter_branch_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var filter_branchCmd = &cobra.Command{
Use: "filter-branch",
Short: "Rewrite branches",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(filter_branchCmd)
}

19
git_completer/cmd/fmt_merge_msg_generated.go Normal file
View File

@ -0,0 +1,19 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fmt_merge_msgCmd = &cobra.Command{
Use: "fmt-merge-msg",
Short: "Produce a merge commit message",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
fmt_merge_msgCmd.Flags().BoolP("file", "F", false, "<file> file to read from")
fmt_merge_msgCmd.Flags().String("log", "", "populate log with at most <n> entries from shortlog")
fmt_merge_msgCmd.Flags().BoolP("message", "m", false, "<text> use <text> as start of message")
rootCmd.AddCommand(fmt_merge_msgCmd)
}

30
git_completer/cmd/for_each_ref_generated.go Normal file
View File

@ -0,0 +1,30 @@
package cmd
import (
"github.com/spf13/cobra"
)
var for_each_refCmd = &cobra.Command{
Use: "for-each-ref",
Short: "Output information on each ref",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
for_each_refCmd.Flags().String("color", "", "respect format colors")
for_each_refCmd.Flags().String("contains", "", "print only refs which contain the commit")
for_each_refCmd.Flags().String("count", "", "show only <n> matched refs")
for_each_refCmd.Flags().String("format", "", "format to use for the output")
for_each_refCmd.Flags().Bool("ignore-case", false, "sorting and filtering are case insensitive")
for_each_refCmd.Flags().String("merged", "", "print only refs that are merged")
for_each_refCmd.Flags().String("no-contains", "", "print only refs which don't contain the commit")
for_each_refCmd.Flags().String("no-merged", "", "print only refs that are not merged")
for_each_refCmd.Flags().String("points-at", "", "print only refs which points at the given object")
for_each_refCmd.Flags().BoolP("perl", "p", false, "quote placeholders suitably for perl")
for_each_refCmd.Flags().Bool("python", false, "quote placeholders suitably for python")
for_each_refCmd.Flags().String("sort", "", "field name to sort on")
for_each_refCmd.Flags().BoolP("shell", "s", false, "quote placeholders suitably for shells")
for_each_refCmd.Flags().Bool("tcl", false, "quote placeholders suitably for Tcl")
rootCmd.AddCommand(for_each_refCmd)
}

50
git_completer/cmd/format_patch_generated.go Normal file
View File

@ -0,0 +1,50 @@
package cmd
import (
"github.com/spf13/cobra"
)
var format_patchCmd = &cobra.Command{
Use: "format-patch",
Short: "Prepare patches for e-mail submission",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
format_patchCmd.Flags().String("add-header", "", "add email header")
format_patchCmd.Flags().String("attach", "", "attach the patch")
format_patchCmd.Flags().String("base", "", "add prerequisite tree info to the patch series")
format_patchCmd.Flags().String("cc", "", "add Cc: header")
format_patchCmd.Flags().String("cover-from-description", "", "generate parts of a cover letter based on a branch's description")
format_patchCmd.Flags().Bool("cover-letter", false, "generate a cover letter")
format_patchCmd.Flags().String("creation-factor", "", "percentage by which creation is weighted")
format_patchCmd.Flags().String("from", "", "set From address to <ident> (or committer ident if absent)")
format_patchCmd.Flags().Bool("ignore-if-in-upstream", false, "don't include a patch matching a commit upstream")
format_patchCmd.Flags().String("inline", "", "inline the patch")
format_patchCmd.Flags().String("in-reply-to", "", "make first mail a reply to <message-id>")
format_patchCmd.Flags().String("interdiff", "", "show changes against <rev> in cover letter or single patch")
format_patchCmd.Flags().BoolP("keep-subject", "k", false, "don't strip/add [PATCH]")
format_patchCmd.Flags().BoolP("no-numbered", "N", false, "use [PATCH] even with multiple patches")
format_patchCmd.Flags().BoolP("numbered", "n", false, "use [PATCH n/m] even with a single patch")
format_patchCmd.Flags().Bool("no-binary", false, "don't output binary diffs")
format_patchCmd.Flags().Bool("numbered-files", false, "use simple number sequence for output file names")
format_patchCmd.Flags().BoolP("output-directory", "o", false, "<dir> store resulting files in <dir>")
format_patchCmd.Flags().BoolP("no-stat", "p", false, "show patch format instead of default (patch + stat)")
format_patchCmd.Flags().Bool("progress", false, "show progress while generating patches")
format_patchCmd.Flags().BoolP("quiet", "q", false, "don't print the patch filenames")
format_patchCmd.Flags().String("range-diff", "", "show changes against <refspec> in cover letter or single patch")
format_patchCmd.Flags().Bool("rfc", false, "Use [RFC PATCH] instead of [PATCH]")
format_patchCmd.Flags().String("signature-file", "", "add a signature from a file")
format_patchCmd.Flags().String("signature", "", "add a signature")
format_patchCmd.Flags().BoolP("signoff", "s", false, "add Signed-off-by:")
format_patchCmd.Flags().String("start-number", "", "start numbering patches at <n> instead of 1")
format_patchCmd.Flags().Bool("stdout", false, "print patches to standard out")
format_patchCmd.Flags().String("subject-prefix", "", "Use [<prefix>] instead of [PATCH]")
format_patchCmd.Flags().String("suffix", "", "use <sfx> instead of '.patch'")
format_patchCmd.Flags().String("thread", "", "enable message threading, styles: shallow, deep")
format_patchCmd.Flags().String("to", "", "add To: header")
format_patchCmd.Flags().BoolP("reroll-count", "v", false, "<n> mark the series as Nth re-roll")
format_patchCmd.Flags().Bool("zero-commit", false, "output all-zero hash in From header")
rootCmd.AddCommand(format_patchCmd)
}

29
git_completer/cmd/fsck_generated.go Normal file
View File

@ -0,0 +1,29 @@
package cmd
import (
"github.com/spf13/cobra"
)
var fsckCmd = &cobra.Command{
Use: "fsck",
Short: "Verifies the connectivity and validity of the objects in the database",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
fsckCmd.Flags().Bool("cache", false, "make index objects head nodes")
fsckCmd.Flags().Bool("connectivity-only", false, "check only connectivity")
fsckCmd.Flags().Bool("dangling", false, "show dangling objects")
fsckCmd.Flags().Bool("full", false, "also consider packs and alternate objects")
fsckCmd.Flags().Bool("lost-found", false, "write dangling objects in .git/lost-found")
fsckCmd.Flags().Bool("name-objects", false, "show verbose names for reachable objects")
fsckCmd.Flags().Bool("progress", false, "show progress")
fsckCmd.Flags().Bool("reflogs", false, "make reflogs head nodes (default)")
fsckCmd.Flags().Bool("root", false, "report root nodes")
fsckCmd.Flags().Bool("strict", false, "enable more strict checking")
fsckCmd.Flags().Bool("tags", false, "report tags")
fsckCmd.Flags().Bool("unreachable", false, "show unreachable objects")
fsckCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(fsckCmd)
}

22
git_completer/cmd/gc_generated.go Normal file
View File

@ -0,0 +1,22 @@
package cmd
import (
"github.com/spf13/cobra"
)
var gcCmd = &cobra.Command{
Use: "gc",
Short: "Cleanup unnecessary files and optimize the local repository",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
gcCmd.Flags().Bool("aggressive", false, "be more thorough (increased runtime)")
gcCmd.Flags().Bool("auto", false, "enable auto-gc mode")
gcCmd.Flags().Bool("force", false, "force running gc even if there may be another gc running")
gcCmd.Flags().Bool("keep-largest-pack", false, "repack all other packs except the largest pack")
gcCmd.Flags().String("prune", "", "prune unreferenced objects")
gcCmd.Flags().BoolP("quiet", "q", false, "suppress progress reporting")
rootCmd.AddCommand(gcCmd)
}

17
git_completer/cmd/get_tar_commit_id_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var get_tar_commit_idCmd = &cobra.Command{
Use: "get-tar-commit-id",
Short: "Extract commit ID from an archive created using git-archive",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(get_tar_commit_idCmd)
}

17
git_completer/cmd/gitk_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var gitkCmd = &cobra.Command{
Use: "gitk",
Short: "The Git repository browser",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(gitkCmd)
}

17
git_completer/cmd/gitweb_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var gitwebCmd = &cobra.Command{
Use: "gitweb",
Short: "Git web interface (web frontend to Git repositories)",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(gitwebCmd)
}

63
git_completer/cmd/grep_generated.go Normal file
View File

@ -0,0 +1,63 @@
package cmd
import (
"github.com/spf13/cobra"
)
var grepCmd = &cobra.Command{
Use: "grep",
Short: "Print lines matching a pattern",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
grepCmd.Flags().BoolP("after-context", "A", false, "<n> show <n> context lines after matches")
grepCmd.Flags().Bool("all-match", false, "show only matches from files that match all patterns")
grepCmd.Flags().Bool("and", false, "combine patterns specified with -e")
grepCmd.Flags().BoolP("text", "a", false, "process binary files as text")
grepCmd.Flags().BoolP("before-context", "B", false, "<n> show <n> context lines before matches")
grepCmd.Flags().Bool("break", false, "print empty line between matches from different files")
grepCmd.Flags().Bool("cached", false, "search in index instead of in the work tree")
grepCmd.Flags().BoolP("context", "C", false, "<n> show <n> context lines before and after matches")
grepCmd.Flags().BoolP("count", "c", false, "show the number of matches instead of matching lines")
grepCmd.Flags().String("color", "", "highlight matches")
grepCmd.Flags().Bool("column", false, "show column number of first match")
grepCmd.Flags().BoolP("extended-regexp", "E", false, "use extended POSIX regular expressions")
grepCmd.Flags().StringP("e", "e", "", "match <pattern>")
grepCmd.Flags().Bool("exclude-standard", false, "ignore files specified via '.gitignore'")
grepCmd.Flags().Bool("ext-grep", false, "allow calling of grep(1) (ignored by this build)")
grepCmd.Flags().StringP("f", "f", "", "read patterns from file")
grepCmd.Flags().BoolP("fixed-strings", "F", false, "interpret patterns as fixed strings")
grepCmd.Flags().Bool("full-name", false, "show filenames relative to top directory")
grepCmd.Flags().BoolP("basic-regexp", "G", false, "use basic POSIX regular expressions (default)")
grepCmd.Flags().BoolP("h", "h", false, "don't show filenames")
grepCmd.Flags().Bool("heading", false, "show filename only once above matches from same file")
grepCmd.Flags().BoolP("H", "H", false, "show filenames")
grepCmd.Flags().BoolP("I", "I", false, "don't match patterns in binary files")
grepCmd.Flags().BoolP("ignore-case", "i", false, "case insensitive matching")
grepCmd.Flags().BoolP("files-with-matches", "l", false, "show only filenames instead of matching lines")
grepCmd.Flags().BoolP("files-without-match", "L", false, "show only the names of files without match")
grepCmd.Flags().String("max-depth", "", "descend at most <depth> levels")
grepCmd.Flags().Bool("name-only", false, "synonym for --files-with-matches")
grepCmd.Flags().BoolP("line-number", "n", false, "show line numbers")
grepCmd.Flags().Bool("no-index", false, "find in contents not managed by git")
grepCmd.Flags().Bool("not", false, "")
//grepCmd.Flags().BoolP("NUM", "NUM", false, "shortcut for -C NUM")
grepCmd.Flags().BoolP("only-matching", "o", false, "show only matching parts of a line")
grepCmd.Flags().StringP("open-files-in-pager", "O", "", "show matching files in the pager")
grepCmd.Flags().Bool("or", false, "")
grepCmd.Flags().BoolP("perl-regexp", "P", false, "use Perl-compatible regular expressions")
grepCmd.Flags().BoolP("show-function", "p", false, "show a line with the function name before matches")
grepCmd.Flags().BoolP("quiet", "q", false, "indicate hit with exit status without output")
grepCmd.Flags().Bool("recurse-submodules", false, "recursively search in each submodule")
grepCmd.Flags().BoolP("recursive", "r", false, "search in subdirectories (default)")
grepCmd.Flags().Bool("textconv", false, "process binary files with textconv filters")
grepCmd.Flags().String("threads", "", "use <n> worker threads")
grepCmd.Flags().Bool("untracked", false, "search in both tracked and untracked files")
grepCmd.Flags().BoolP("invert-match", "v", false, "show non-matching lines")
grepCmd.Flags().BoolP("function-context", "W", false, "show the surrounding function")
grepCmd.Flags().BoolP("word-regexp", "w", false, "match patterns only at word boundaries")
grepCmd.Flags().BoolP("null", "z", false, "print NUL after filenames")
rootCmd.AddCommand(grepCmd)
}

17
git_completer/cmd/gui_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var guiCmd = &cobra.Command{
Use: "gui",
Short: "A portable graphical interface to Git",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(guiCmd)
}

23
git_completer/cmd/hash_object_generated.go Normal file
View File

@ -0,0 +1,23 @@
package cmd
import (
"github.com/spf13/cobra"
)
var hash_objectCmd = &cobra.Command{
Use: "hash-object",
Short: "Compute object ID and optionally creates a blob from a file",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
hash_objectCmd.Flags().Bool("literally", false, "just hash any random garbage to create corrupt objects for debugging Git")
hash_objectCmd.Flags().Bool("no-filters", false, "store file as is without filters")
hash_objectCmd.Flags().String("path", "", "process file as it were from this path")
hash_objectCmd.Flags().Bool("stdin-paths", false, "read file names from stdin")
hash_objectCmd.Flags().Bool("stdin", false, "read the object from stdin")
hash_objectCmd.Flags().StringP("t", "t", "", "object type")
hash_objectCmd.Flags().BoolP("w", "w", false, "write the object into the object database")
rootCmd.AddCommand(hash_objectCmd)
}

23
git_completer/cmd/help_generated.go Normal file
View File

@ -0,0 +1,23 @@
package cmd
import (
"github.com/spf13/cobra"
)
var helpCmd = &cobra.Command{
Use: "help",
Short: "Display help information about Git",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
helpCmd.Flags().BoolP("all", "a", false, "print all available commands")
helpCmd.Flags().BoolP("config", "c", false, "print all configuration variable names")
helpCmd.Flags().BoolP("guides", "g", false, "print list of useful guides")
helpCmd.Flags().BoolP("info", "i", false, "show info page")
helpCmd.Flags().BoolP("man", "m", false, "show man page")
helpCmd.Flags().BoolP("verbose", "v", false, "print command description")
helpCmd.Flags().BoolP("web", "w", false, "show manual in web browser")
rootCmd.AddCommand(helpCmd)
}

17
git_completer/cmd/http_backend_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var http_backendCmd = &cobra.Command{
Use: "http-backend",
Short: "Server side implementation of Git over HTTP",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(http_backendCmd)
}

19
git_completer/cmd/imap_send_generated.go Normal file
View File

@ -0,0 +1,19 @@
package cmd
import (
"github.com/spf13/cobra"
)
var imap_sendCmd = &cobra.Command{
Use: "imap-send",
Short: "Send a collection of patches from stdin to an IMAP folder",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
imap_sendCmd.Flags().Bool("curl", false, "use libcurl to communicate with the IMAP server")
imap_sendCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
imap_sendCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
rootCmd.AddCommand(imap_sendCmd)
}

17
git_completer/cmd/index_pack_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var index_packCmd = &cobra.Command{
Use: "index-pack",
Short: "Build pack index file for an existing packed archive",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(index_packCmd)
}

21
git_completer/cmd/init_generated.go Normal file
View File

@ -0,0 +1,21 @@
package cmd
import (
"github.com/spf13/cobra"
)
var initCmd = &cobra.Command{
Use: "init",
Short: "Create an empty Git repository or reinitialize an existing one",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
initCmd.Flags().Bool("bare", false, "create a bare repository")
initCmd.Flags().BoolP("quiet", "q", false, "be quiet")
initCmd.Flags().String("separate-git-dir", "", "separate git dir from working tree")
initCmd.Flags().String("shared", "", "specify that the git repository is to be shared amongst several users")
initCmd.Flags().String("template", "", "directory from which templates will be used")
rootCmd.AddCommand(initCmd)
}

24
git_completer/cmd/instaweb_generated.go Normal file
View File

@ -0,0 +1,24 @@
package cmd
import (
"github.com/spf13/cobra"
)
var instawebCmd = &cobra.Command{
Use: "instaweb",
Short: "Instantly browse your working repository in gitweb",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
instawebCmd.Flags().BoolP("browser", "b", false, "... the browser to launch")
instawebCmd.Flags().BoolP("httpd", "d", false, "... the command to launch")
instawebCmd.Flags().BoolP("local", "l", false, "only bind on 127.0.0.1")
instawebCmd.Flags().BoolP("module-path", "m", false, "... the module path (only needed for apache2)")
instawebCmd.Flags().BoolP("port", "p", false, "... the port to bind to")
instawebCmd.Flags().Bool("restart", false, "restart the web server")
instawebCmd.Flags().Bool("start", false, "start the web server")
instawebCmd.Flags().Bool("stop", false, "stop the web server")
rootCmd.AddCommand(instawebCmd)
}

27
git_completer/cmd/interpret_trailers_generated.go Normal file
View File

@ -0,0 +1,27 @@
package cmd
import (
"github.com/spf13/cobra"
)
var interpret_trailersCmd = &cobra.Command{
Use: "interpret-trailers",
Short: "Add or parse structured information in commit messages",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
interpret_trailersCmd.Flags().String("if-exists", "", "action if trailer already exists")
interpret_trailersCmd.Flags().String("if-missing", "", "action if trailer is missing")
interpret_trailersCmd.Flags().Bool("in-place", false, "edit files in place")
interpret_trailersCmd.Flags().Bool("no-divider", false, "do not treat --- specially")
interpret_trailersCmd.Flags().Bool("only-input", false, "do not apply config rules")
interpret_trailersCmd.Flags().Bool("only-trailers", false, "output only the trailers")
interpret_trailersCmd.Flags().Bool("parse", false, "set parsing options")
interpret_trailersCmd.Flags().String("trailer", "", "trailer(s) to add")
interpret_trailersCmd.Flags().Bool("trim-empty", false, "trim empty trailers")
interpret_trailersCmd.Flags().Bool("unfold", false, "join whitespace-continued values")
interpret_trailersCmd.Flags().String("where", "", "where to place the new trailer")
rootCmd.AddCommand(interpret_trailersCmd)
}

23
git_completer/cmd/log_generated.go Normal file
View File

@ -0,0 +1,23 @@
package cmd
import (
"github.com/spf13/cobra"
)
var logCmd = &cobra.Command{
Use: "log",
Short: "Show commit logs",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
logCmd.Flags().String("decorate", "", "decorate options")
logCmd.Flags().String("decorate-refs-exclude", "", "do not decorate refs that match <pattern>")
logCmd.Flags().String("decorate-refs", "", "only decorate refs that match <pattern>")
logCmd.Flags().StringP("L", "L", "", "Process line range n,m in file, counting from 1")
logCmd.Flags().BoolP("quiet", "q", false, "suppress diff output")
logCmd.Flags().Bool("source", false, "show source")
logCmd.Flags().Bool("use-mailmap", false, "Use mail map file")
rootCmd.AddCommand(logCmd)
}

42
git_completer/cmd/ls_files_generated.go Normal file
View File

@ -0,0 +1,42 @@
package cmd
import (
"github.com/spf13/cobra"
)
var ls_filesCmd = &cobra.Command{
Use: "ls-files",
Short: "Show information about files in the index and the working tree",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
ls_filesCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
ls_filesCmd.Flags().BoolP("cached", "c", false, "show cached files in the output (default)")
ls_filesCmd.Flags().BoolP("deleted", "d", false, "show deleted files in the output")
ls_filesCmd.Flags().Bool("debug", false, "show debugging data")
ls_filesCmd.Flags().Bool("directory", false, "show 'other' directories' names only")
ls_filesCmd.Flags().Bool("empty-directory", false, "don't show empty directories")
ls_filesCmd.Flags().Bool("eol", false, "show line endings of files")
ls_filesCmd.Flags().Bool("error-unmatch", false, "if any <file> is not in the index, treat this as an error")
ls_filesCmd.Flags().String("exclude-per-directory", "", "read additional per-directory exclude patterns in <file>")
ls_filesCmd.Flags().Bool("exclude-standard", false, "add the standard git exclusions")
ls_filesCmd.Flags().Bool("full-name", false, "make the output relative to the project top directory")
ls_filesCmd.Flags().BoolP("f", "f", false, "use lowercase letters for 'fsmonitor clean' files")
ls_filesCmd.Flags().BoolP("ignored", "i", false, "show ignored files in the output")
ls_filesCmd.Flags().BoolP("killed", "k", false, "show files on the filesystem that need to be removed")
ls_filesCmd.Flags().BoolP("modified", "m", false, "show modified files in the output")
ls_filesCmd.Flags().BoolP("others", "o", false, "show other files in the output")
ls_filesCmd.Flags().Bool("recurse-submodules", false, "recurse through submodules")
ls_filesCmd.Flags().Bool("resolve-undo", false, "show resolve-undo information")
ls_filesCmd.Flags().BoolP("stage", "s", false, "show staged contents' object name in the output")
ls_filesCmd.Flags().BoolP("t", "t", false, "identify the file status with tags")
ls_filesCmd.Flags().BoolP("unmerged", "u", false, "show unmerged files in the output")
ls_filesCmd.Flags().BoolP("v", "v", false, "use lowercase letters for 'assume unchanged' files")
ls_filesCmd.Flags().String("with-tree", "", "pretend that paths removed since <tree-ish> are still present")
ls_filesCmd.Flags().BoolP("exclude-from", "X", false, "<file> exclude patterns are read from <file>")
ls_filesCmd.Flags().BoolP("exclude", "x", false, "<pattern> skip files matching pattern")
ls_filesCmd.Flags().BoolP("z", "z", false, "paths are separated with NUL character")
rootCmd.AddCommand(ls_filesCmd)
}

26
git_completer/cmd/ls_remote_generated.go Normal file
View File

@ -0,0 +1,26 @@
package cmd
import (
"github.com/spf13/cobra"
)
var ls_remoteCmd = &cobra.Command{
Use: "ls-remote",
Short: "List references in a remote repository",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
ls_remoteCmd.Flags().Bool("exit-code", false, "exit with exit code 2 if no matching refs are found")
ls_remoteCmd.Flags().Bool("get-url", false, "take url.<base>.insteadOf into account")
ls_remoteCmd.Flags().BoolP("heads", "h", false, "limit to heads")
ls_remoteCmd.Flags().BoolP("server-option", "o", false, "<server-specific> option to transmit")
ls_remoteCmd.Flags().BoolP("quiet", "q", false, "do not print remote URL")
ls_remoteCmd.Flags().Bool("refs", false, "do not show peeled tags")
ls_remoteCmd.Flags().String("sort", "", "field name to sort on")
ls_remoteCmd.Flags().Bool("symref", false, "show underlying ref in addition to the object pointed by it")
ls_remoteCmd.Flags().BoolP("tags", "t", false, "limit to tags")
ls_remoteCmd.Flags().String("upload-pack", "", "path of git-upload-pack on the remote host")
rootCmd.AddCommand(ls_remoteCmd)
}

26
git_completer/cmd/ls_tree_generated.go Normal file
View File

@ -0,0 +1,26 @@
package cmd
import (
"github.com/spf13/cobra"
)
var ls_treeCmd = &cobra.Command{
Use: "ls-tree",
Short: "List the contents of a tree object",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
ls_treeCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
ls_treeCmd.Flags().BoolP("d", "d", false, "only show trees")
ls_treeCmd.Flags().Bool("full-name", false, "use full path names")
ls_treeCmd.Flags().Bool("full-tree", false, "list entire tree; not just current directory (implies --full-name)")
ls_treeCmd.Flags().BoolP("long", "l", false, "include object size")
ls_treeCmd.Flags().Bool("name-only", false, "list only filenames")
ls_treeCmd.Flags().Bool("name-status", false, "list only filenames")
ls_treeCmd.Flags().BoolP("r", "r", false, "recurse into subtrees")
ls_treeCmd.Flags().BoolP("t", "t", false, "show trees when recursing")
ls_treeCmd.Flags().BoolP("z", "z", false, "terminate entries with NUL byte")
rootCmd.AddCommand(ls_treeCmd)
}

17
git_completer/cmd/mailinfo_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mailinfoCmd = &cobra.Command{
Use: "mailinfo",
Short: "Extracts patch and authorship from a single e-mail message",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(mailinfoCmd)
}

17
git_completer/cmd/mailsplit_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mailsplitCmd = &cobra.Command{
Use: "mailsplit",
Short: "Simple UNIX mbox splitter program",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(mailsplitCmd)
}

21
git_completer/cmd/merge_base_generated.go Normal file
View File

@ -0,0 +1,21 @@
package cmd
import (
"github.com/spf13/cobra"
)
var merge_baseCmd = &cobra.Command{
Use: "merge-base",
Short: "Find as good common ancestors as possible for a merge",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
merge_baseCmd.Flags().BoolP("all", "a", false, "output all common ancestors")
merge_baseCmd.Flags().Bool("fork-point", false, "find where <commit> forked from reflog of <ref>")
merge_baseCmd.Flags().Bool("independent", false, "list revs not reachable from others")
merge_baseCmd.Flags().Bool("is-ancestor", false, "is the first one ancestor of the other?")
merge_baseCmd.Flags().Bool("octopus", false, "find ancestors for a single n-way merge")
rootCmd.AddCommand(merge_baseCmd)
}

24
git_completer/cmd/merge_file_generated.go Normal file
View File

@ -0,0 +1,24 @@
package cmd
import (
"github.com/spf13/cobra"
)
var merge_fileCmd = &cobra.Command{
Use: "merge-file",
Short: "Run a three-way file merge",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
merge_fileCmd.Flags().Bool("diff3", false, "use a diff3 based merge")
merge_fileCmd.Flags().StringP("L", "L", "", "set labels for file1/orig-file/file2")
merge_fileCmd.Flags().String("marker-size", "", "for conflicts, use this marker size")
merge_fileCmd.Flags().Bool("ours", false, "for conflicts, use our version")
merge_fileCmd.Flags().BoolP("stdout", "p", false, "send results to standard output")
merge_fileCmd.Flags().BoolP("quiet", "q", false, "do not warn about conflicts")
merge_fileCmd.Flags().Bool("theirs", false, "for conflicts, use their version")
merge_fileCmd.Flags().Bool("union", false, "for conflicts, use a union version")
rootCmd.AddCommand(merge_fileCmd)
}

43
git_completer/cmd/merge_generated.go Normal file
View File

@ -0,0 +1,43 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mergeCmd = &cobra.Command{
Use: "merge",
Short: "Join two or more development histories together",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
mergeCmd.Flags().Bool("abort", false, "abort the current in-progress merge")
mergeCmd.Flags().Bool("allow-unrelated-histories", false, "allow merging unrelated histories")
mergeCmd.Flags().String("cleanup", "", "how to strip spaces and #comments from message")
mergeCmd.Flags().Bool("commit", false, "perform a commit if the merge succeeds (default)")
mergeCmd.Flags().Bool("continue", false, "continue the current in-progress merge")
mergeCmd.Flags().BoolP("edit", "e", false, "edit message before committing")
mergeCmd.Flags().Bool("ff", false, "allow fast-forward (default)")
mergeCmd.Flags().BoolP("file", "F", false, "<path> read message from file")
mergeCmd.Flags().Bool("ff-only", false, "abort if fast-forward is not possible")
mergeCmd.Flags().String("log", "", "add (at most <n>) entries from shortlog to merge commit message")
mergeCmd.Flags().BoolP("message", "m", false, "<message> merge commit message (for a non-fast-forward merge)")
mergeCmd.Flags().BoolP("n", "n", false, "do not show a diffstat at the end of the merge")
mergeCmd.Flags().Bool("no-verify", false, "bypass pre-merge-commit and commit-msg hooks")
mergeCmd.Flags().Bool("overwrite-ignore", false, "update ignored files (default)")
mergeCmd.Flags().Bool("progress", false, "force progress reporting")
mergeCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
mergeCmd.Flags().Bool("quit", false, "--abort but leave index and working tree alone")
mergeCmd.Flags().Bool("rerere-autoupdate", false, "update the index with reused conflict resolution if possible")
mergeCmd.Flags().StringP("gpg-sign", "S", "", "GPG sign commit")
mergeCmd.Flags().Bool("signoff", false, "add Signed-off-by:")
mergeCmd.Flags().Bool("squash", false, "create a single commit instead of doing a merge")
mergeCmd.Flags().BoolP("strategy", "s", false, "<strategy> merge strategy to use")
mergeCmd.Flags().Bool("stat", false, "show a diffstat at the end of the merge")
mergeCmd.Flags().Bool("summary", false, "(synonym to --stat)")
mergeCmd.Flags().Bool("verify-signatures", false, "verify that the named commit has a valid GPG signature")
mergeCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
mergeCmd.Flags().BoolP("strategy-option", "X", false, "<option=value> option for selected merge strategy")
rootCmd.AddCommand(mergeCmd)
}

17
git_completer/cmd/merge_index_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var merge_indexCmd = &cobra.Command{
Use: "merge-index",
Short: "Run a merge for files needing merging",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(merge_indexCmd)
}

17
git_completer/cmd/merge_one_file_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var merge_one_fileCmd = &cobra.Command{
Use: "merge-one-file",
Short: "The standard helper program to use with git-merge-index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(merge_one_fileCmd)
}

17
git_completer/cmd/merge_tree_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var merge_treeCmd = &cobra.Command{
Use: "merge-tree",
Short: "Show three-way merge without touching index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(merge_treeCmd)
}

17
git_completer/cmd/mergetool_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mergetoolCmd = &cobra.Command{
Use: "mergetool",
Short: "Run merge conflict resolution tools to resolve merge conflicts",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(mergetoolCmd)
}

17
git_completer/cmd/mktag_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mktagCmd = &cobra.Command{
Use: "mktag",
Short: "Creates a tag object",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(mktagCmd)
}

19
git_completer/cmd/mktree_generated.go Normal file
View File

@ -0,0 +1,19 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mktreeCmd = &cobra.Command{
Use: "mktree",
Short: "Build a tree-object from ls-tree formatted text",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
mktreeCmd.Flags().Bool("batch", false, "allow creation of more than one tree")
mktreeCmd.Flags().Bool("missing", false, "allow missing objects")
mktreeCmd.Flags().BoolP("z", "z", false, "input is NUL terminated")
rootCmd.AddCommand(mktreeCmd)
}

19
git_completer/cmd/multi_pack_index_generated.go Normal file
View File

@ -0,0 +1,19 @@
package cmd
import (
"github.com/spf13/cobra"
)
var multi_pack_indexCmd = &cobra.Command{
Use: "multi-pack-index",
Short: "Write and verify multi-pack-indexes",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
multi_pack_indexCmd.Flags().String("batch-size", "", "during repack, collect pack-files of smaller size into a batch that is larger than this size")
multi_pack_indexCmd.Flags().String("object-dir", "", "object directory containing set of packfile and pack-index pairs")
multi_pack_indexCmd.Flags().Bool("progress", false, "force progress reporting")
rootCmd.AddCommand(multi_pack_indexCmd)
}

20
git_completer/cmd/mv_generated.go Normal file
View File

@ -0,0 +1,20 @@
package cmd
import (
"github.com/spf13/cobra"
)
var mvCmd = &cobra.Command{
Use: "mv",
Short: "Move or rename a file, a directory, or a symlink",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
mvCmd.Flags().BoolP("force", "f", false, "force move/rename even if target exists")
mvCmd.Flags().BoolP("k", "k", false, "skip move/rename errors")
mvCmd.Flags().BoolP("dry-run", "n", false, "dry run")
mvCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(mvCmd)
}

24
git_completer/cmd/name_rev_generated.go Normal file
View File

@ -0,0 +1,24 @@
package cmd
import (
"github.com/spf13/cobra"
)
var name_revCmd = &cobra.Command{
Use: "name-rev",
Short: "Find symbolic names for given revs",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
name_revCmd.Flags().Bool("all", false, "list all commits reachable from all refs")
name_revCmd.Flags().Bool("always", false, "show abbreviated commit object as fallback")
name_revCmd.Flags().String("exclude", "", "ignore refs matching <pattern>")
name_revCmd.Flags().Bool("name-only", false, "print only names (no SHA-1)")
name_revCmd.Flags().String("refs", "", "only use refs matching <pattern>")
name_revCmd.Flags().Bool("stdin", false, "read from stdin")
name_revCmd.Flags().Bool("tags", false, "only use tags to name the commits")
name_revCmd.Flags().Bool("undefined", false, "allow to print `undefined` names (default)")
rootCmd.AddCommand(name_revCmd)
}

17
git_completer/cmd/notes_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var notesCmd = &cobra.Command{
Use: "notes",
Short: "Add or inspect object notes",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
notesCmd.Flags().String("ref", "", "use notes from <notes-ref>")
rootCmd.AddCommand(notesCmd)
}

17
git_completer/cmd/p4_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var p4Cmd = &cobra.Command{
Use: "p4",
Short: "Import from and submit to Perforce repositories",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(p4Cmd)
}

55
git_completer/cmd/pack_objects_generated.go Normal file
View File

@ -0,0 +1,55 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pack_objectsCmd = &cobra.Command{
Use: "pack-objects",
Short: "Create a packed archive of objects",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
pack_objectsCmd.Flags().Bool("all", false, "include objects reachable from any reference")
pack_objectsCmd.Flags().Bool("all-progress-implied", false, "similar to --all-progress when progress meter is shown")
pack_objectsCmd.Flags().Bool("all-progress", false, "show progress meter during object writing phase")
pack_objectsCmd.Flags().String("compression", "", "pack compression level")
pack_objectsCmd.Flags().Bool("delta-base-offset", false, "use OFS_DELTA objects")
pack_objectsCmd.Flags().Bool("delta-islands", false, "respect islands during delta compression")
pack_objectsCmd.Flags().String("depth", "", "maximum length of delta chain allowed in the resulting pack")
pack_objectsCmd.Flags().Bool("exclude-promisor-objects", false, "do not pack objects in promisor packfiles")
pack_objectsCmd.Flags().String("filter", "", "object filtering")
pack_objectsCmd.Flags().Bool("honor-pack-keep", false, "ignore packs that have companion .keep file")
pack_objectsCmd.Flags().Bool("include-tag", false, "include tag objects that refer to objects to be packed")
pack_objectsCmd.Flags().Bool("incremental", false, "ignore packed objects")
pack_objectsCmd.Flags().Bool("indexed-objects", false, "include objects referred to by the index")
pack_objectsCmd.Flags().String("index-version", "", "write the pack index file in the specified idx format version")
pack_objectsCmd.Flags().String("keep-pack", "", "ignore this pack")
pack_objectsCmd.Flags().Bool("keep-true-parents", false, "do not hide commits by grafts")
pack_objectsCmd.Flags().Bool("keep-unreachable", false, "keep unreachable objects")
pack_objectsCmd.Flags().Bool("local", false, "ignore borrowed objects from alternate object store")
pack_objectsCmd.Flags().String("max-pack-size", "", "maximum size of each output pack file")
pack_objectsCmd.Flags().String("missing", "", "handling for missing objects")
pack_objectsCmd.Flags().Bool("non-empty", false, "do not create an empty pack output")
pack_objectsCmd.Flags().Bool("pack-loose-unreachable", false, "pack loose unreachable objects")
pack_objectsCmd.Flags().Bool("progress", false, "show progress meter")
pack_objectsCmd.Flags().BoolP("quiet", "q", false, "do not show progress meter")
pack_objectsCmd.Flags().Bool("reflog", false, "include objects referred by reflog entries")
pack_objectsCmd.Flags().Bool("reuse-delta", false, "reuse existing deltas")
pack_objectsCmd.Flags().Bool("reuse-object", false, "reuse existing objects")
pack_objectsCmd.Flags().Bool("revs", false, "read revision arguments from standard input")
pack_objectsCmd.Flags().Bool("shallow", false, "create packs suitable for shallow fetches")
pack_objectsCmd.Flags().Bool("sparse", false, "use the sparse reachability algorithm")
pack_objectsCmd.Flags().Bool("stdout", false, "output pack to stdout")
pack_objectsCmd.Flags().Bool("thin", false, "create thin packs")
pack_objectsCmd.Flags().String("threads", "", "use threads when searching for best delta matches")
pack_objectsCmd.Flags().Bool("unpacked", false, "limit the objects to those that are not yet packed")
pack_objectsCmd.Flags().String("unpack-unreachable", "", "unpack unreachable objects newer than <time>")
pack_objectsCmd.Flags().Bool("use-bitmap-index", false, "use a bitmap index if available to speed up counting objects")
pack_objectsCmd.Flags().String("window-memory", "", "limit pack window by memory in addition to object limit")
pack_objectsCmd.Flags().String("window", "", "limit pack window by objects")
pack_objectsCmd.Flags().Bool("write-bitmap-index", false, "write a bitmap index together with the pack index")
rootCmd.AddCommand(pack_objectsCmd)
}

17
git_completer/cmd/pack_redundant_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pack_redundantCmd = &cobra.Command{
Use: "pack-redundant",
Short: "Find redundant pack files",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(pack_redundantCmd)
}

18
git_completer/cmd/pack_refs_generated.go Normal file
View File

@ -0,0 +1,18 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pack_refsCmd = &cobra.Command{
Use: "pack-refs",
Short: "Pack heads and tags for efficient repository access",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
pack_refsCmd.Flags().Bool("all", false, "pack everything")
pack_refsCmd.Flags().Bool("prune", false, "prune loose refs (default)")
rootCmd.AddCommand(pack_refsCmd)
}

17
git_completer/cmd/patch_id_generated.go Normal file
View File

@ -0,0 +1,17 @@
package cmd
import (
"github.com/spf13/cobra"
)
var patch_idCmd = &cobra.Command{
Use: "patch-id",
Short: "Compute unique ID for a patch",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
rootCmd.AddCommand(patch_idCmd)
}

21
git_completer/cmd/prune_generated.go Normal file
View File

@ -0,0 +1,21 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pruneCmd = &cobra.Command{
Use: "prune",
Short: "Prune all unreachable objects from the object database",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
pruneCmd.Flags().Bool("exclude-promisor-objects", false, "limit traversal to objects outside promisor packfiles")
pruneCmd.Flags().String("expire", "", "expire objects older than <time>")
pruneCmd.Flags().BoolP("dry-run", "n", false, "do not remove, show only")
pruneCmd.Flags().Bool("progress", false, "show progress")
pruneCmd.Flags().BoolP("verbose", "v", false, "report pruned objects")
rootCmd.AddCommand(pruneCmd)
}

18
git_completer/cmd/prune_packed_generated.go Normal file
View File

@ -0,0 +1,18 @@
package cmd
import (
"github.com/spf13/cobra"
)
var prune_packedCmd = &cobra.Command{
Use: "prune-packed",
Short: "Remove extra objects that are already in pack files",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
prune_packedCmd.Flags().BoolP("dry-run", "n", false, "dry run")
prune_packedCmd.Flags().BoolP("quiet", "q", false, "be quiet")
rootCmd.AddCommand(prune_packedCmd)
}

54
git_completer/cmd/pull_generated.go Normal file
View File

@ -0,0 +1,54 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pullCmd = &cobra.Command{
Use: "pull",
Short: "Fetch from and integrate with another repository or a local branch",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
pullCmd.Flags().BoolP("ipv4", "4", false, "use IPv4 addresses only")
pullCmd.Flags().BoolP("ipv6", "6", false, "use IPv6 addresses only")
pullCmd.Flags().BoolP("append", "a", false, "append to .git/FETCH_HEAD instead of overwriting")
pullCmd.Flags().Bool("all", false, "fetch from all remotes")
pullCmd.Flags().Bool("allow-unrelated-histories", false, "allow merging unrelated histories")
pullCmd.Flags().Bool("autostash", false, "automatically stash/stash pop before and after rebase")
pullCmd.Flags().String("cleanup", "", "how to strip spaces and #comments from message")
pullCmd.Flags().Bool("commit", false, "perform a commit if the merge succeeds (default)")
pullCmd.Flags().String("depth", "", "deepen history of shallow clone")
pullCmd.Flags().Bool("dry-run", false, "dry run")
pullCmd.Flags().Bool("edit", false, "edit message before committing")
pullCmd.Flags().Bool("ff", false, "allow fast-forward")
pullCmd.Flags().Bool("ff-only", false, "abort if fast-forward is not possible")
pullCmd.Flags().BoolP("force", "f", false, "force overwrite of local branch")
pullCmd.Flags().StringP("jobs", "j", "", "number of submodules pulled in parallel")
pullCmd.Flags().BoolP("keep", "k", false, "keep downloaded pack")
pullCmd.Flags().String("log", "", "add (at most <n>) entries from shortlog to merge commit message")
pullCmd.Flags().BoolP("n", "n", false, "do not show a diffstat at the end of the merge")
pullCmd.Flags().BoolP("prune", "p", false, "prune remote-tracking branches no longer on remote")
pullCmd.Flags().Bool("progress", false, "force progress reporting")
pullCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
pullCmd.Flags().String("recurse-submodules", "", "control for recursive fetching of submodules")
pullCmd.Flags().String("refmap", "", "specify fetch refmap")
pullCmd.Flags().StringP("rebase", "r", "", "incorporate changes by rebasing rather than merging")
pullCmd.Flags().Bool("set-upstream", false, "set upstream for git pull/fetch")
pullCmd.Flags().StringP("gpg-sign", "S", "", "GPG sign commit")
pullCmd.Flags().Bool("show-forced-updates", false, "check for forced-updates on all updated branches")
pullCmd.Flags().String("signoff", "", "add Signed-off-by:")
pullCmd.Flags().Bool("squash", false, "create a single commit instead of doing a merge")
pullCmd.Flags().BoolP("strategy", "s", false, "<strategy> merge strategy to use")
pullCmd.Flags().Bool("stat", false, "show a diffstat at the end of the merge")
pullCmd.Flags().BoolP("tags", "t", false, "fetch all tags and associated objects")
pullCmd.Flags().Bool("unshallow", false, "convert to a complete repository")
pullCmd.Flags().Bool("update-shallow", false, "accept refs that update .git/shallow")
pullCmd.Flags().String("upload-pack", "", "path to upload pack on remote end")
pullCmd.Flags().Bool("verify-signatures", false, "verify that the named commit has a valid GPG signature")
pullCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
pullCmd.Flags().BoolP("strategy-option", "X", false, "<option=value> option for selected merge strategy")
rootCmd.AddCommand(pullCmd)
}

41
git_completer/cmd/push_generated.go Normal file
View File

@ -0,0 +1,41 @@
package cmd
import (
"github.com/spf13/cobra"
)
var pushCmd = &cobra.Command{
Use: "push",
Short: "Update remote refs along with associated objects",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
pushCmd.Flags().BoolP("ipv4", "4", false, "use IPv4 addresses only")
pushCmd.Flags().BoolP("ipv6", "6", false, "use IPv6 addresses only")
pushCmd.Flags().Bool("all", false, "push all refs")
pushCmd.Flags().Bool("atomic", false, "request atomic transaction on remote side")
pushCmd.Flags().BoolP("delete", "d", false, "delete refs")
pushCmd.Flags().String("exec", "", "receive pack program")
pushCmd.Flags().BoolP("force", "f", false, "force updates")
pushCmd.Flags().Bool("follow-tags", false, "push missing but relevant tags")
pushCmd.Flags().String("force-with-lease", "", "require old value of ref to be at this value")
pushCmd.Flags().Bool("mirror", false, "mirror all refs")
pushCmd.Flags().BoolP("dry-run", "n", false, "dry run")
pushCmd.Flags().Bool("no-verify", false, "bypass pre-push hook")
pushCmd.Flags().BoolP("push-option", "o", false, "<server-specific> option to transmit")
pushCmd.Flags().Bool("porcelain", false, "machine-readable output")
pushCmd.Flags().Bool("progress", false, "force progress reporting")
pushCmd.Flags().Bool("prune", false, "prune locally removed refs")
pushCmd.Flags().BoolP("quiet", "q", false, "be more quiet")
pushCmd.Flags().String("receive-pack", "", "receive pack program")
pushCmd.Flags().String("recurse-submodules", "", "control recursive pushing of submodules")
pushCmd.Flags().String("repo", "", "repository")
pushCmd.Flags().String("signed", "", "GPG sign the push")
pushCmd.Flags().Bool("tags", false, "push tags (can't be used with --all or --mirror)")
pushCmd.Flags().Bool("thin", false, "use thin pack")
pushCmd.Flags().BoolP("set-upstream", "u", false, "set upstream for git pull/status")
pushCmd.Flags().BoolP("verbose", "v", false, "be more verbose")
rootCmd.AddCommand(pushCmd)
}

21
git_completer/cmd/quiltimport_generated.go Normal file
View File

@ -0,0 +1,21 @@
package cmd
import (
"github.com/spf13/cobra"
)
var quiltimportCmd = &cobra.Command{
Use: "quiltimport",
Short: "Applies a quilt patchset onto the current branch",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
quiltimportCmd.Flags().String("author", "", "author name and email address for patches without any")
quiltimportCmd.Flags().Bool("keep-non-patch", false, "Pass -b to git mailinfo")
quiltimportCmd.Flags().BoolP("dry-run", "n", false, "dry run")
quiltimportCmd.Flags().String("patches", "", "path to the quilt patches")
quiltimportCmd.Flags().String("series", "", "path to the quilt series file")
rootCmd.AddCommand(quiltimportCmd)
}

100
git_completer/cmd/range_diff_generated.go Normal file
View File

@ -0,0 +1,100 @@
package cmd
import (
"github.com/spf13/cobra"
)
var range_diffCmd = &cobra.Command{
Use: "range-diff",
Short: "Compare two commit ranges (e.g. two versions of a branch)",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
range_diffCmd.Flags().String("abbrev", "", "use <n> digits to display SHA-1s")
range_diffCmd.Flags().String("anchored", "", "generate diff using the \"anchored diff\" algorithm")
range_diffCmd.Flags().BoolP("text", "a", false, "treat all files as text")
range_diffCmd.Flags().StringP("break-rewrites", "B", "", "break complete rewrite changes into pairs of delete and create")
range_diffCmd.Flags().BoolP("ignore-space-change", "b", false, "ignore changes in amount of whitespace")
range_diffCmd.Flags().Bool("binary", false, "output a binary diff that can be applied")
range_diffCmd.Flags().StringP("find-copies", "C", "", "detect copies")
range_diffCmd.Flags().Bool("check", false, "warn if changes introduce conflict markers or whitespace errors")
range_diffCmd.Flags().String("color-moved", "", "moved lines of code are colored differently")
range_diffCmd.Flags().String("color-moved-ws", "", "how white spaces are ignored in --color-moved")
range_diffCmd.Flags().String("color", "", "show colored diff")
range_diffCmd.Flags().String("color-words", "", "equivalent to --word-diff=color --word-diff-regex=<regex>")
range_diffCmd.Flags().Bool("compact-summary", false, "generate compact summary in diffstat")
range_diffCmd.Flags().String("creation-factor", "", "Percentage by which creation is weighted")
range_diffCmd.Flags().Bool("cumulative", false, "synonym for --dirstat=cumulative")
range_diffCmd.Flags().String("diff-algorithm", "", "choose a diff algorithm")
range_diffCmd.Flags().String("diff-filter", "", "select files by diff type")
range_diffCmd.Flags().BoolP("irreversible-delete", "D", false, "omit the preimage for deletes")
range_diffCmd.Flags().String("dirstat-by-file", "", "synonym for --dirstat=files,param1,param2...")
range_diffCmd.Flags().String("dst-prefix", "", "show the given destination prefix instead of \"b/\"")
range_diffCmd.Flags().Bool("exit-code", false, "exit with 1 if there were differences, 0 otherwise")
range_diffCmd.Flags().Bool("ext-diff", false, "allow an external diff helper to be executed")
range_diffCmd.Flags().Bool("find-copies-harder", false, "use unmodified files as source to find copies")
range_diffCmd.Flags().String("find-object", "", "look for differences that change the number of occurrences of the specified object")
range_diffCmd.Flags().Bool("follow", false, "continue listing the history of a file beyond renames")
range_diffCmd.Flags().Bool("full-index", false, "show full pre- and post-image object names on the \"index\" lines")
range_diffCmd.Flags().StringP("G", "G", "", "look for differences that change the number of occurrences of the specified regex")
range_diffCmd.Flags().Bool("histogram", false, "generate diff using the \"histogram diff\" algorithm")
range_diffCmd.Flags().Bool("ignore-blank-lines", false, "ignore changes whose lines are all blank")
range_diffCmd.Flags().Bool("ignore-cr-at-eol", false, "ignore carrier-return at the end of line")
range_diffCmd.Flags().Bool("ignore-space-at-eol", false, "ignore changes in whitespace at EOL")
range_diffCmd.Flags().String("ignore-submodules", "", "ignore changes to submodules in the diff generation")
range_diffCmd.Flags().Bool("indent-heuristic", false, "heuristic to shift diff hunk boundaries for easy reading")
range_diffCmd.Flags().String("inter-hunk-context", "", "show context between diff hunks up to the specified number of lines")
range_diffCmd.Flags().Bool("ita-invisible-in-index", false, "hide 'git add -N' entries from the index")
range_diffCmd.Flags().Bool("ita-visible-in-index", false, "treat 'git add -N' entries as real in the index")
range_diffCmd.Flags().String("line-prefix", "", "prepend an additional prefix to every line of output")
range_diffCmd.Flags().StringP("l", "l", "", "prevent rename/copy detection if the number of rename/copy targets exceeds given limit")
range_diffCmd.Flags().StringP("find-renames", "M", "", "detect renames")
range_diffCmd.Flags().Bool("minimal", false, "produce the smallest possible diff")
range_diffCmd.Flags().Bool("name-only", false, "show only names of changed files")
range_diffCmd.Flags().Bool("name-status", false, "show only names and status of changed files")
range_diffCmd.Flags().Bool("no-dual-color", false, "use simple diff colors")
range_diffCmd.Flags().Bool("no-prefix", false, "do not show any source or destination prefix")
range_diffCmd.Flags().Bool("no-renames", false, "disable rename detection")
range_diffCmd.Flags().String("notes", "", "passed to 'git log'")
range_diffCmd.Flags().Bool("numstat", false, "machine friendly --stat")
range_diffCmd.Flags().StringP("O", "O", "", "control the order in which files appear in the output")
range_diffCmd.Flags().String("output", "", "Output to a specific file")
range_diffCmd.Flags().String("output-indicator-context", "", "specify the character to indicate a context instead of ' '")
range_diffCmd.Flags().String("output-indicator-new", "", "specify the character to indicate a new line instead of '+'")
range_diffCmd.Flags().String("output-indicator-old", "", "specify the character to indicate an old line instead of '-'")
range_diffCmd.Flags().Bool("patch-with-raw", false, "synonym for '-p --raw'")
range_diffCmd.Flags().Bool("patch-with-stat", false, "synonym for '-p --stat'")
range_diffCmd.Flags().Bool("patience", false, "generate diff using the \"patience diff\" algorithm")
range_diffCmd.Flags().Bool("pickaxe-all", false, "show all changes in the changeset with -S or -G")
range_diffCmd.Flags().Bool("pickaxe-regex", false, "treat <string> in -S as extended POSIX regular expression")
range_diffCmd.Flags().BoolP("patch", "p", false, "generate patch")
range_diffCmd.Flags().Bool("quiet", false, "disable all output of the program")
range_diffCmd.Flags().Bool("raw", false, "generate the diff in raw format")
range_diffCmd.Flags().String("relative", "", "when run from subdir, exclude changes outside and show relative paths")
range_diffCmd.Flags().Bool("rename-empty", false, "use empty blobs as rename source")
range_diffCmd.Flags().BoolP("R", "R", false, "swap two inputs, reverse the diff")
range_diffCmd.Flags().Bool("shortstat", false, "output only the last line of --stat")
range_diffCmd.Flags().BoolP("no-patch", "s", false, "suppress diff output")
range_diffCmd.Flags().String("src-prefix", "", "show the given source prefix instead of \"a/\"")
range_diffCmd.Flags().StringP("S", "S", "", "look for differences that change the number of occurrences of the specified string")
range_diffCmd.Flags().String("stat-count", "", "generate diffstat with limited lines")
range_diffCmd.Flags().String("stat-graph-width", "", "generate diffstat with a given graph width")
range_diffCmd.Flags().String("stat-name-width", "", "generate diffstat with a given name width")
range_diffCmd.Flags().String("stat", "", "generate diffstat")
range_diffCmd.Flags().String("stat-width", "", "generate diffstat with a given width")
range_diffCmd.Flags().String("submodule", "", "specify how differences in submodules are shown")
range_diffCmd.Flags().Bool("summary", false, "condensed summary such as creations, renames and mode changes")
range_diffCmd.Flags().Bool("textconv", false, "run external text conversion filters when comparing binary files")
range_diffCmd.Flags().BoolP("u", "u", false, "generate patch")
range_diffCmd.Flags().StringP("unified", "U", "", "generate diffs with <n> lines context")
range_diffCmd.Flags().BoolP("function-context", "W", false, "generate diffs with <n> lines context")
range_diffCmd.Flags().BoolP("ignore-all-space", "w", false, "ignore whitespace when comparing lines")
range_diffCmd.Flags().String("word-diff", "", "show word diff, using <mode> to delimit changed words")
range_diffCmd.Flags().String("word-diff-regex", "", "use <regex> to decide what a word is")
range_diffCmd.Flags().String("ws-error-highlight", "", "highlight whitespace errors in the 'context', 'old' or 'new' lines in the diff")
range_diffCmd.Flags().StringP("dirstat", "X", "", "output the distribution of relative amount of changes for each sub-directory")
range_diffCmd.Flags().BoolP("z", "z", false, "do not munge pathnames and use NULs as output field terminators in --raw or --numstat")
rootCmd.AddCommand(range_diffCmd)
}

32
git_completer/cmd/read_tree_generated.go Normal file
View File

@ -0,0 +1,32 @@
package cmd
import (
"github.com/spf13/cobra"
)
var read_treeCmd = &cobra.Command{
Use: "read-tree",
Short: "Reads tree information into the index",
Run: func(cmd *cobra.Command, args []string) {
},
}
func init() {
read_treeCmd.Flags().Bool("aggressive", false, "3-way merge in presence of adds and removes")
read_treeCmd.Flags().Bool("debug-unpack", false, "debug unpack-trees")
read_treeCmd.Flags().Bool("empty", false, "only empty the index")
read_treeCmd.Flags().String("exclude-per-directory", "", "allow explicitly ignored files to be overwritten")
read_treeCmd.Flags().BoolP("i", "i", false, "don't check the working tree after merging")
read_treeCmd.Flags().String("index-output", "", "write resulting index to <file>")
read_treeCmd.Flags().BoolP("m", "m", false, "perform a merge in addition to a read")
read_treeCmd.Flags().BoolP("dry-run", "n", false, "don't update the index or the work tree")
read_treeCmd.Flags().Bool("no-sparse-checkout", false, "skip applying sparse checkout filter")
read_treeCmd.Flags().String("prefix", "", "read the tree into the index under <subdirectory>/")
read_treeCmd.Flags().BoolP("quiet", "q", false, "suppress feedback messages")
read_treeCmd.Flags().String("recurse-submodules", "", "control recursive updating of submodules")
read_treeCmd.Flags().Bool("reset", false, "same as -m, but discard unmerged entries")
read_treeCmd.Flags().Bool("trivial", false, "3-way merge if no file level merging required")
read_treeCmd.Flags().BoolP("u", "u", false, "update working tree with merge result")
read_treeCmd.Flags().BoolP("verbose", "v", false, "be verbose")
rootCmd.AddCommand(read_treeCmd)
}

Some files were not shown because too many files have changed in this diff Show More