Beispiel #1
0
        public override INode CreateNode(PseudoList item)
        {
            var car = item.GetCarSymbolName().ToLowerInvariant();

            if (car == "worker")
            {
                INode workerNode;

                var workerName = item.GetSingleKeywordArgument <Symbol>(":worker-name", true)?.Name;
                if (workerName == null)
                {
                    throw new CliException("Worker name is null.");
                }
                else
                {
                    workerNode = new MultiTextNode(
                        item
                        .GetAllKeywordArguments(":verbs")
                        .Cast <StringAtom>()
                        .Select(x => x.Value)
                        .ToList(),
                        new ITextClass[]
                    {
                        TermTextClass.Instance,
                    },
                        true,
                        WorkerAction,
                        this.NodeFamily,
                        $"Worker Node. Name: [{workerName}]");

                    workerNode.Properties["worker-name"] = workerName;
                }

                return(workerNode);
            }

            var node = base.CreateNode(item);

            if (node is FallbackNode)
            {
                return(node);
            }

            if (!(node is ActionNode))
            {
                throw new CliException("ActionNode was expected to be created.");
            }

            var actionNode = (ActionNode)base.CreateNode(item);

            if (actionNode == null)
            {
                throw new CliException($"Could not build node for item '{car}'.");
            }

            var    action = item.GetSingleKeywordArgument <Symbol>(":action", true)?.Name?.ToLowerInvariant();
            string alias;

            switch (action)
            {
            case "key":
                actionNode.Action = KeyAction;
                alias             = item.GetSingleKeywordArgument <Symbol>(":alias").Name;
                actionNode.Properties["alias"] = alias;
                break;

            case "value":
                actionNode.Action = ValueAction;
                break;

            case "option":
                actionNode.Action = OptionAction;
                break;

            case "argument":
                actionNode.Action = ArgumentAction;
                alias             = item.GetSingleKeywordArgument <Symbol>(":alias").Name;
                actionNode.Properties["alias"] = alias;
                break;

            default:
                throw new CliException($"Keyword ':action' is missing for item '{car}'.");
            }

            return(actionNode);
        }
Beispiel #2
0
        public virtual INode CreateNode(PseudoList item)
        {
            if (item == null)
            {
                throw new ArgumentNullException(nameof(item));
            }

            try
            {
                var   car = item.GetCarSymbolName();
                INode node;

                switch (car)
                {
                case "EXACT-TEXT":
                    node = new ExactTextNode(
                        item.GetSingleKeywordArgument <StringAtom>(":value").Value,
                        this.ParseTextClasses(item.GetAllKeywordArguments(":classes")),
                        _isCaseSensitive,
                        null,
                        this.NodeFamily,
                        item.GetItemName());
                    break;

                case "SOME-TEXT":
                    node = new TextNode(
                        this.ParseTextClasses(item.GetAllKeywordArguments(":classes")),
                        null,
                        this.NodeFamily,
                        item.GetItemName());
                    break;

                case "MULTI-TEXT":
                    node = new MultiTextNode(
                        item.GetAllKeywordArguments(":values").Cast <StringAtom>().Select(x => x.Value),
                        this.ParseTextClasses(item.GetAllKeywordArguments(":classes")),
                        _isCaseSensitive,
                        null,
                        this.NodeFamily,
                        item.GetItemName());
                    break;

                case "EXACT-PUNCTUATION":
                    node = new ExactPunctuationNode(
                        item.GetSingleKeywordArgument <StringAtom>(":value").Value.Single(),
                        null,
                        this.NodeFamily,
                        item.GetItemName());
                    break;

// todo: some-number?
                case "SOME-INTEGER":
                    node = new IntegerNode(
                        null,
                        this.NodeFamily,
                        item.GetItemName());
                    break;

                case "FALLBACK":
                    var name = item.GetItemName();
                    if (name == null)
                    {
                        throw new BuildingException("Fallback node must have a name.");
                    }

                    node = new FallbackNode(
                        this.CreateFallbackPredicate(name),
                        this.NodeFamily,
                        name);

                    break;

                default:
                    return(null);
                }

                return(node);
            }
            catch (Exception ex)
            {
                throw new BuildingException($"Could not build a node from item {item}.", ex);
            }
        }
Beispiel #3
0
        public override INode CreateNode(PseudoList item)
        {
            var car = item.GetCarSymbolName().ToLowerInvariant();

            if (car == "executor")
            {
                INode executorNode;

                var executorName = item.GetSingleKeywordArgument <Symbol>(":executor-name", true)?.Name;
                if (executorName == null)
                {
                    executorNode = new IdleNode(this.NodeFamily, $"Root node for unnamed executor of type {this.GetType().FullName}");
                }
                else
                {
                    executorNode = new MultiTextNode(
                        new string[] { item.GetSingleKeywordArgument <StringAtom>(":verb").Value },
                        new ITextClass[]
                    {
                        TermTextClass.Instance,
                    },
                        true,
                        ExecutorAction,
                        this.NodeFamily,
                        $"Executor Node. Name: [{executorName}]");

                    executorNode.Properties["executor-name"] = executorName;
                }

                return(executorNode);
            }

            var node = base.CreateNode(item);

            if (node == null)
            {
                throw new CliException($"Could not build node for item '{car}'.");
            }

            if (node is FallbackNode)
            {
                return(node);
            }

            if (!(node is ActionNode))
            {
                throw new CliException($"'{typeof(ActionNode).Name}' instance was expected to be created.");
            }

            var baseResult = (ActionNode)node;

            var    action = item.GetSingleKeywordArgument <Symbol>(":action", true)?.Name?.ToLowerInvariant();
            string alias;

            switch (action)
            {
            case "key":
                baseResult.Action = KeyAction;
                alias             = item.GetSingleKeywordArgument <Symbol>(":alias").Name;
                baseResult.Properties["alias"] = alias;
                break;

            case "value":
                baseResult.Action = ValueAction;
                break;

            case "option":
                baseResult.Action = OptionAction;
                alias             = item.GetSingleKeywordArgument <Symbol>(":alias").Name;
                baseResult.Properties["alias"] = alias;
                break;

            case "argument":
                baseResult.Action = ArgumentAction;
                alias             = item.GetSingleKeywordArgument <Symbol>(":alias").Name;
                baseResult.Properties["alias"] = alias;
                break;


            default:
                throw new CliException($"Keyword ':action' is missing or invalid for item '{car}'.");
            }

            return(baseResult);
        }