Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/naaando/console-command


https://github.com/naaando/console-command

Last synced: 8 days ago
JSON representation

Awesome Lists containing this project

README 

        
# Console commands



Library to route command-line arguments to a Command pattern object, current implementation covers extension by inheritance or using closures.



**Note**: I wanted to create a reflection based approach to register the commands automatically so we can just trigger the execution from the cli arguments, but Vala register objects derivated classes dynamically(we can't introspect types before them being called with new Object () or Type.class_ref ()), so instantiating the class type would be necessary somewhere.



## Basic usage



Subclass BaseCommand class



```cs

public class MyCommand : Console.BaseCommand {

    public override string get_name () {

        return "My command";

    }



    public override async void execute () {

        print (@"Aha!\n");

    }

}

```



Use Commands service to store your commands and parse arguments on main

```cs

public static int main(string[] args) {

    var commands = new Console.Commands ();

    commands["something"] = new MyCommand ();

    commands.execute_with_args (args);

    return 0;

}

```



## Requests

Console requests parse arguments to *Actions*, *modifiers* and *targets*

#### Actions

Actions are the intent to do something

Like delete, copy, help, create



They are the first argument after program name, the later are targets or modifiers.

If a command should nest an action like *help create* then create would be the target



#### Modifiers (Parameters)

Parameters act modifying the behavior of an action

Short form: -f -s -t ...   

Long form: --force --track --no-git ...



#### Targets

Files usually but could be urls, git addresses, or names too.



## Commands



#### Command Interface

```cs

public interface Console.Command : Object {

    public abstract string get_name ();

    public abstract async void execute ();

    public abstract void execute_sync ();

    public abstract void show_description ();

    public abstract void show_help ();

}

```



#### BaseCommand class

Is an abstract class that handles all the fuzz to create a basic class

you should only override execute and get_name methods and you're ready to go



```cs

public class TestCommand : Console.BaseCommand {

    public override string get_name () {

        return "Test";

    }



    public override async void execute () {

        print (@"Aha!\n");

    }

}



```



#### ClousureCommand

If your command is simple you can use just a closure using ClosureCommand (nameOfCommand, closure) and it's possible to append details with with_description (string dsc) method

```cs

commands["quick"] = new Console.ClosureCommand ("quick",

        (request) => print (@"Testing closure command\n"))

        .with_description ("Tests a closure based Command");

```



### Commands service

Commands service is a container that holds a list of commands and executes commands



#### Adding commands

```cs

var commands = new Console.Commands ();

// You can use add method

commands.add ("hello", new HelloCommand ());

// Or the container accessor

commands["hello"] = new HelloCommand ();

```



#### Removing commands

```cs

commands.remove ("hello");

```



#### Parsing args and executing



You can parse the args returning a Request by

```cs

public static int main(string[] args) {

    var commands = new Console.Commands ();

    var request = commands.parse_request_from_args (args);

    return 0;

}

```

And execute requests with

```cs

commands.execute_request (request);

```

It's also possible to parse and execute in one shot with

```cs

public static int main(string[] args) {

    var commands = new Console.Commands ();

    commands.execute_with_args (args);

    return 0;

}



```