How to use Main method of Gherkin.Specs.CLI.Program class

1using System;
2using System.Collections.Generic;
3using System.Linq;
4using Gherkin.CucumberMessages;
5using Gherkin.Specs.EventStubs;
6using Gherkin.Specs.Tokens;
7using Utf8Json.Resolvers;
8
9namespace Gherkin.Specs.CLI
10{
11    class Program
12    {
13        static int Main(string[] argv)
14        {
15            if (argv.Length == 0)
16            {
17                ShowUsage();
18                return 100;
19            }
20
21            switch (argv[0].ToLowerInvariant())
22            {
23                case "tokens":
24                    return PrintTokens(argv.Skip(1));
25                case "events":
26                    var printEventArgs = GetPrintEventsArgs(argv.Skip(1));
27                    return PrintEvents(printEventArgs);
28                default:
29                    ShowUsage();
30                    return 110;
31            }
32        }
33
34        private static void ShowUsage()
35        {
36            Console.WriteLine(@"Usage: 
37    dotnet Gherkin.Specs events [--no-source] [--no-ast] [--no-pickles] feature-file.feature
38    - or -
39    dotnet Gherkin.Specs tokens feature-file.feature
40");
41        }
42
43        class PrintEventsArgs
44        {
45            public bool PrintSource { get; set; } = true;
46            public bool PrintAst { get; set; } = true;
47            public bool PrintPickles { get; set; } = true;
48            public List<string> Paths { get; } = new();
49        }
50
51        private static PrintEventsArgs GetPrintEventsArgs(IEnumerable<string> args)
52        {
53            var result = new PrintEventsArgs();
54
55            foreach (string arg in args)
56            {
57                switch (arg)
58                {
59                    case "--no-source":
60                        result.PrintSource = false;
61                        break;
62                    case "--no-ast":
63                        result.PrintAst = false;
64                        break;
65                    case "--no-pickles":
66                        result.PrintPickles = false;
67                        break;
68                    default:
69                        result.Paths.Add(arg);
70                        break;
71                }
72            }
73
74            return result;
75        }
76
77        private static int PrintTokens(IEnumerable<string> paths)
78        {
79            foreach (var featureFilePath in paths)
80            {
81                try
82                {
83                    var tokensText = TokensGenerator.GenerateTokens(featureFilePath);
84                    Console.WriteLine(tokensText);
85                }
86                catch (Exception ex)
87                {
88                    Console.Error.WriteLine(ex.Message);
89                    return 1;
90                }
91            }
92
93            return 0;
94        }
95
96        private static int PrintEvents(PrintEventsArgs args)
97        {
98            var sourceProvider = new SourceProvider();
99            var sources = sourceProvider.GetSources(args.Paths);
100            var gherkinEventsProvider = new GherkinEventsProvider(args.PrintSource, args.PrintAst, args.PrintPickles, new IncrementingIdGenerator());
101            foreach (var sourceEventEvent in sources)
102            {
103                foreach (var evt in gherkinEventsProvider.GetEvents(sourceEventEvent))
104                {
105                    var jsonString = Utf8Json.JsonSerializer.ToJsonString((object)evt, StandardResolver.ExcludeNullCamelCase);
106                    Console.WriteLine(jsonString);
107                }
108            }
109            return 0;
110        }
111    }
112}
113

Source: Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Gherkin.CucumberMessages;
using Gherkin.Specs.EventStubs;
using Gherkin.Specs.Tokens;
using Utf8Json.Resolvers;

namespace Gherkin.Specs.CLI
{
    class Program
    {
        static int Main(string[] argv)
        {
            if (argv.Length == 0)
            {
                ShowUsage();
                return 100;
            }

            switch (argv[0].ToLowerInvariant())
            {
                case "tokens":
                    return PrintTokens(argv.Skip(1));
                case "events":
                    var printEventArgs = GetPrintEventsArgs(argv.Skip(1));
                    return PrintEvents(printEventArgs);
                default:
                    ShowUsage();
                    return 110;
            }
        }

        private static void ShowUsage()
        {
            Console.WriteLine(@"Usage: 
    dotnet Gherkin.Specs events [--no-source] [--no-ast] [--no-pickles] feature-file.feature
    - or -
    dotnet Gherkin.Specs tokens feature-file.feature
");
        }

        class PrintEventsArgs
        {
            public bool PrintSource { get; set; } = true;
            public bool PrintAst { get; set; } = true;
            public bool PrintPickles { get; set; } = true;
            public List<string> Paths { get; } = new();
        }

        private static PrintEventsArgs GetPrintEventsArgs(IEnumerable<string> args)
        {
            var result = new PrintEventsArgs();

            foreach (string arg in args)
            {
                switch (arg)
                {
                    case "--no-source":
                        result.PrintSource = false;
                        break;
                    case "--no-ast":
                        result.PrintAst = false;
                        break;
                    case "--no-pickles":
                        result.PrintPickles = false;
                        break;
                    default:
                        result.Paths.Add(arg);
                        break;
                }
            }

            return result;
        }

        private static int PrintTokens(IEnumerable<string> paths)
        {
            foreach (var featureFilePath in paths)
            {
                try
                {
                    var tokensText = TokensGenerator.GenerateTokens(featureFilePath);
                    Console.WriteLine(tokensText);
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine(ex.Message);
                    return 1;
                }
            }

            return 0;
        }

        private static int PrintEvents(PrintEventsArgs args)
        {
            var sourceProvider = new SourceProvider();
            var sources = sourceProvider.GetSources(args.Paths);
            var gherkinEventsProvider = new GherkinEventsProvider(args.PrintSource, args.PrintAst, args.PrintPickles, new IncrementingIdGenerator());
            foreach (var sourceEventEvent in sources)
            {
                foreach (var evt in gherkinEventsProvider.GetEvents(sourceEventEvent))
                {
                    var jsonString = Utf8Json.JsonSerializer.ToJsonString((object)evt, StandardResolver.ExcludeNullCamelCase);
                    Console.WriteLine(jsonString);
                }
            }
            return 0;
        }
    }
}