Inact 0.2.3

Inact

Inact is a framework for creating interactive terminal environments. There are two classes, which are used to specify the environment, namely the Inact class and the MethodConstruct class. Both classes contain options to customize the environment.

The Inact class

This class represents the environment being created. It has the following options:

The MethodConstruct class

This class represtens methods that can be executed from the environment. It has the following options:

How to specify an environment

There are two ways of specifying an Inact environment.

Method-based specification

For this, an Inact object must be instantiated. It is then possible to specify the environment, using method calls on the object.

An example:

var env = new Inact();

env.SetMarkFunc(() => "My environment >> ")

env.SetSetup(
    new MethodConstruct("SETUP") {
        Params_info = "Takes nothing",
        Params_check = ps => true,
        Method = ps => {
            return new Succes("Environment ready!");
        }
    }
);

env.AddMethod(
    new MethodConstruct("echo") {
        Shorthand = "e",
        Description = "Prints its parameter",
        Params_info = "Takes 1 parameter",
        Params_check = ps => ps.Length == 1,
        Method = ps => {
            return new Succes(ps[0]);
        }
    }
);

env.Run();

Object-based specification

For this, a class is created, and then, using attributes, the environment is specified. An instance of the class, is given to the InactFactory to construct the Inact object. Three imporant point with using this method of specification is:

• The name of methods with the InactMethod attribute, will be used as the MethodConstruct Name
• The Params_check can only check that there where given a valid number of arguments

An example:

public class EnvSpec
{
    [InactMark]
    public string mark()
    {
        return "My environment >> ";
    }

    public EnvSpec() 
    {
        Console.WriteLine("Environment ready!");
    }

    [InactMethod]
    [Shorthand("e")]
    [Description("Prints its parameter")]
    [Params_info("Takes 1 parameter")]
    [Params_check(1)]
    public MethodResult echo(string[] ps)
    {
        return new Succes(ps[0]);
    }
}

var env = InactFactory.CreateFrom(new EnvSpec());

env.Run();

How to use an environment

When an environment is running, you will interact with it by given it commands to execute. Commands build out of the following expressions:

Rules

1. Commands must start with a Value expression, with a value that is either the Name or Shorthand of a MethodConstruct in the environment.
2. All following expression, will be resolved, and the results used as arguments.
3. If the result of resolving any expression in a command is Failure, it will immediatly be the result of the entire command.
4. To use a call to a method as an argument to another, the call must be surronded by parentheses.
5. To save the result of a method in a variable, an arrow followed by a word is used. This must be the final part of a call.

Examples of well formed commands

Examples of ill formed commands

Example usage of an environment

C:\Program\Interactive> dotnet run
Environment ready!
My environment >> h
[help | h] Prints a definition of all Methods
[quit | q] Terminates this interactive environment
[echo | e] Takes 1 parameter and Prints its parameter

My environment >> echo hello world
Failure: [echo | e] Takes 1 parameter and Prints its parameter
My environment >> echo "hello world"
hello world
My environment >> q

C:\Program\Interactive>