Abstract command which can be invoked from the command line. Commands are configured with a single "current" repository and then the execute(String[]) method is invoked with the arguments that appear after the subcommand. Command constructors should perform as little work as possible as they may be invoked very early during process loading, and the command may not execute even though it was constructed.
Esempio n. 1
0
 public CommandRef(TextBuiltin clazz, String cn)
 {
     impl = (TextBuiltin)clazz;
     name = cn;
     Command cmd = impl.GetCommand();
     if (cmd != null)
     {
         common = cmd.common;
         complete = cmd.complete;
         usage = cmd.usage;
         cmdHelp = clazz.getCommandHelp();
     }
 }
Esempio n. 2
0
        public CommandRef(TextBuiltin clazz, String cn)
        {
            impl = (TextBuiltin)clazz;
            name = cn;
            Command cmd = impl.GetCommand();

            if (cmd != null)
            {
                common   = cmd.common;
                complete = cmd.complete;
                usage    = cmd.usage;
                cmdHelp  = clazz.getCommandHelp();
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Returns a new instance of the command implementation.
        /// </summary>
        /// <returns></returns>
        public TextBuiltin Create()
        {
            TextBuiltin c = Activator.CreateInstance(Type.GetType(impl.ToString())) as TextBuiltin;

            if (c != null)
            {
                c.setCommandHelp(cmdHelp);
                return(c);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Execute the command line
        /// </summary>
        /// <param name="argv"></param>
        private static void execute(string[] argv)
        {
            if (argv.Count() == 0)
            {
                ShowHelp();
            }
            else if (!argv[0].StartsWith("--") && !argv[0].StartsWith("-"))
            {
                CommandCatalog catalog    = new CommandCatalog();
                CommandRef     subcommand = catalog.Get(argv[0]);
                string         gitdir     = null;

                if (subcommand != null)
                {
                    TextBuiltin         cmd  = subcommand.Create();
                    List <String>       args = argv.ToList();
                    GitSharp.Repository repo = null;

                    try
                    {
                        for (int x = 0; x < args.Count; x++)
                        {
                            if (args[x].IndexOf("--git-dir=") > -1)
                            {
                                if (args[x].Length > 10)
                                {
                                    gitdir = args[x].Substring(10);
                                    args.RemoveAt(x);
                                    break;
                                }
                            }
                        }
                    }
                    catch (ArgumentException)
                    {
                        if (Git.DefaultOutputStream != null)
                        {
                            Git.DefaultOutputStream.WriteLine("error: can't find git directory");
                            Git.DefaultOutputStream.Flush();
                        }
                        Exit(1);
                    }

                    if (cmd.RequiresRepository)
                    {
                        if (gitdir == null)
                        {
                            gitdir = Commands.AbstractCommand.FindGitDirectory(null, true, false);
                            if (gitdir == null)
                            {
                                Console.Error.WriteLine("fatal: Not a git repository (or any of the parent directories): .git");
                                Exit(0);
                            }
                        }

                        repo = new GitSharp.Repository(gitdir);
                        cmd.Init(repo, gitdir);
                    }
                    else
                    {
                        cmd.Init(null, gitdir);
                    }

                    try
                    {
                        // Remove the subcommand from the command line
                        args.RemoveAt(0);
                        cmd.Execute(args.ToArray());
                    }
                    finally
                    {
                        if (Git.DefaultOutputStream != null)
                        {
                            Git.DefaultOutputStream.Flush();
                        }

                        if (repo != null)
                        {
                            repo.Close();
                        }
                    }
                }
                else
                {
                    // List all available commands starting with argv[0] if the command
                    // specified does not exist.
                    // If no commands exist starting with argv[0], show the help screen.
                    if (!ShowCommandMatches(argv[0]))
                    {
                        ShowHelp();
                    }
                }
            }
            else
            {
                // If the first argument in the command line is an option (denoted by starting with - or --),
                // no subcommand has been specified in the command line.
                try
                {
                    options.Parse(argv, out arguments);
                }
                catch (OptionException err)
                {
                    if (arguments.Count > 0)
                    {
                        Console.Error.WriteLine("fatal: " + err.Message);
                        Exit(1);
                    }
                }
            }
            Exit(0);
        }
Esempio n. 5
0
 public CommandRef(TextBuiltin clazz)
     : this(clazz, clazz.getCommandName())
 {
 }
Esempio n. 6
0
        public CommandRef(TextBuiltin clazz)
            : this(clazz, clazz.getCommandName())
        {

        }