コード例 #1
0
        public YaclopsDumpTreeCommand(CommandNode start)
        {
            _start = start;

            _entries.Add(new TypeEntry { Type = typeof(CommandRoot), Code = "R", HasChildren = true });
            _entries.Add(new TypeEntry { Type = typeof(CommandGroup), Code = "G", HasChildren = true });
            _entries.Add(new TypeEntry { Type = typeof(Command), Code = "C", HasChildren = false });
        }
コード例 #2
0
        private void DumpNode(CommandNode node, int indent)
        {
            TypeEntry entry = _entries.FirstOrDefault(x => x.Type.IsInstanceOfType(node));
            if (entry == null)
            {
                throw new ArgumentException("Node is of an unknown type: " + node.GetType().Name, "node");
            }

            var shortNames = node.NamedParameters.SelectMany(x => x.ShortNames, (x, l) => l).OrderBy(x => x).ToList();
            var longNames = node.NamedParameters.SelectMany(x => x.LongNames, (x, l) => l).OrderBy(x => x).ToList();

            var chars = new string('.', indent);
            var spaces = new string(' ', indent + 7);
            Console.WriteLine("{0}[{1}]: {2}", chars, entry.Code, node.Verb);

            if (shortNames.Any())
            {
                Console.WriteLine("{0}SN: {1}", spaces, string.Join("|", shortNames));
            }

            if (longNames.Any())
            {
                Console.WriteLine("{0}LN: {1}", spaces, string.Join("|", longNames));
            }

            if (node.PositionalParameters.Any())
            {
                Console.WriteLine("{0}PP: {1}", spaces, string.Join("|", node.PositionalParameters.Select(x => x.PropertyName + (x.IsRequired ? "(r)" : string.Empty))));
            }

            if (entry.HasChildren)
            {
                var group = (CommandGroup) node;
                foreach (var child in group.Nodes.OrderBy(x => x.Verb))
                {
                    DumpNode(child, indent + 2);
                }
            }
        }
コード例 #3
0
ファイル: ParserState.cs プロジェクト: cj525/yaclops
        public ParserState(CommandNode startNode, Lexer lexer, IEnumerable<string> helpFlags, string helpVerb)
        {
            NamedParameters = new List<ParserNamedParameterResult>();
            PositionalParameters = new List<ParserPositionalParameterResult>();
            CurrentNode = startNode;
            ExtractParameters(CurrentNode);

            foreach (var flag in helpFlags)
            {
                if (flag.StartsWith("--"))
                {
                    _longHelpFlags.Add(flag.Substring(2));
                }
                else if (flag.StartsWith("-"))
                {
                    _shortHelpFlags.Add(flag.Substring(1));
                }
            }

            _lexer = lexer;
            _helpVerb = helpVerb;
            CurrentToken = _lexer.Pop();
        }
コード例 #4
0
ファイル: InternalCommand.cs プロジェクト: cj525/yaclops
 public InternalCommand(CommandNode parent, string verb, Action<CommandRoot, CommandNode> worker)
     : base(parent, verb)
 {
     Worker = worker;
 }
コード例 #5
0
ファイル: CommandNode.cs プロジェクト: cj525/yaclops
 protected CommandNode(CommandNode parent, string verb)
 {
     Parent = parent;
     Verb = verb;
 }
コード例 #6
0
ファイル: ExternalCommand.cs プロジェクト: cj525/yaclops
 protected ExternalCommand(CommandNode parent, string verb)
     : base(parent, verb)
 {
 }
コード例 #7
0
ファイル: ParserState.cs プロジェクト: cj525/yaclops
        private void ExtractParameters(CommandNode node)
        {
            foreach (var p in node.NamedParameters)
            {
                foreach (var name in p.LongNames)
                {
                    _longNames[name] = p;
                }

                foreach (var name in p.ShortNames)
                {
                    _shortNames[name] = p;
                }
            }

            foreach (var p in node.PositionalParameters)
            {
                _positionalParameters.Enqueue(p);

                if (p.IsRequired)
                {
                    _pendingRequired.Add(p.PropertyName);
                }
            }
        }
コード例 #8
0
ファイル: HelpCommand.cs プロジェクト: cj525/yaclops
 public static HelpCommand Make(CommandNode start, GlobalParserSettings settings)
 {
     return new HelpCommand(start, settings);
 }
コード例 #9
0
ファイル: HelpCommand.cs プロジェクト: cj525/yaclops
 public CommandChildEntry(CommandNode node, int depth)
 {
     Node = node;
     Depth = depth;
 }
コード例 #10
0
ファイル: HelpCommand.cs プロジェクト: cj525/yaclops
        // TODO - include options of ancestor groups?
        private string VerbPath(CommandNode node, int maxDepth = int.MaxValue)
        {
            StringBuilder builder = new StringBuilder();

            if ((node.Parent != null) && (maxDepth > 0))
            {
                builder.Append(VerbPath(node.Parent, maxDepth - 1));
            }

            if (builder.Length > 0)
            {
                builder.Append(" ");
            }

            builder.Append(node.HelpVerb);

            return builder.ToString();
        }
コード例 #11
0
ファイル: HelpCommand.cs プロジェクト: cj525/yaclops
 public HelpCommand(CommandNode start, GlobalParserSettings settings)
 {
     _start = start;
     _settings = settings;
 }
コード例 #12
0
ファイル: HelpCommand.cs プロジェクト: cj525/yaclops
        private int CountChildCommands(CommandNode node, bool includeHidden)
        {
            int count = 0;

            Command command = node as Command;
            if (command != null)
            {
                count += 1;
            }
            else
            {
                CommandGroup group = node as CommandGroup;
                if ((group != null) && (includeHidden || !group.Hidden))
                {
                    count += group.Nodes.Sum(child => CountChildCommands(child, includeHidden));
                }
            }

            return count;
        }