Merge pull request #485 from tkouba/develop

Localized demo

demo/ReadText.LocalizedDemo/.cr/personal/Navigation/RecentFilesHistory.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Root Type="DevExpress.CodeRush.Foundation.Navigation.QuickFileNav.SolutionFileInfosContainer">
+  <Options Language="Neutral">
+    <Items>
+      <Item Id="{62fa45be-9e28-4fdc-b57e-974ea27ae9a4}">
+        <Filename>LocalizableAttributeProperty.cs</Filename>
+        <FilePath>d:\work\arci\commandline\src\commandline\infrastructure\localizableattributeproperty.cs</FilePath>
+        <Folders>
+          <Item>Infrastructure</Item>
+        </Folders>
+        <ProjectFileName>d:\WORK\ARCI\commandline\src\CommandLine\CommandLine.csproj</ProjectFileName>
+        <ProjectName>CommandLine</ProjectName>
+      </Item>
+    </Items>
+  </Options>
+</Root>

demo/ReadText.LocalizedDemo/LocalizableSentenceBuilder.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CommandLine;
+using CommandLine.Text;
+
+namespace ReadText.LocalizedDemo
+{
+    public class LocalizableSentenceBuilder : SentenceBuilder
+    {
+        public override Func<string> RequiredWord
+        {
+            get { return () => Properties.Resources.SentenceRequiredWord; }
+        }
+
+        public override Func<string> ErrorsHeadingText
+        {
+            // Cannot be pluralized
+            get { return () => Properties.Resources.SentenceErrorsHeadingText; }
+        }
+
+        public override Func<string> UsageHeadingText
+        {
+            get { return () => Properties.Resources.SentenceUsageHeadingText; }
+        }
+
+        public override Func<bool, string> HelpCommandText
+        {
+            get
+            {
+                return isOption => isOption
+                    ? Properties.Resources.SentenceHelpCommandTextOption
+                    : Properties.Resources.SentenceHelpCommandTextVerb;
+            }
+        }
+
+        public override Func<bool, string> VersionCommandText
+        {
+            get { return _ => Properties.Resources.SentenceVersionCommandText; }
+        }
+
+        public override Func<Error, string> FormatError
+        {
+            get
+            {
+                return error =>
+                {
+                    switch (error.Tag)
+                    {
+                        case ErrorType.BadFormatTokenError:
+                            return String.Format(Properties.Resources.SentenceBadFormatTokenError, ((BadFormatTokenError)error).Token);
+                        case ErrorType.MissingValueOptionError:
+                            return String.Format(Properties.Resources.SentenceMissingValueOptionError, ((MissingValueOptionError)error).NameInfo.NameText);
+                        case ErrorType.UnknownOptionError:
+                            return String.Format(Properties.Resources.SentenceUnknownOptionError, ((UnknownOptionError)error).Token);
+                        case ErrorType.MissingRequiredOptionError:
+                            var errMisssing = ((MissingRequiredOptionError)error);
+                            return errMisssing.NameInfo.Equals(NameInfo.EmptyName)
+                                       ? Properties.Resources.SentenceMissingRequiredOptionError
+                                       : String.Format(Properties.Resources.SentenceMissingRequiredOptionError, errMisssing.NameInfo.NameText);
+                        case ErrorType.BadFormatConversionError:
+                            var badFormat = ((BadFormatConversionError)error);
+                            return badFormat.NameInfo.Equals(NameInfo.EmptyName)
+                                       ? Properties.Resources.SentenceBadFormatConversionErrorValue
+                                       : String.Format(Properties.Resources.SentenceBadFormatConversionErrorOption, badFormat.NameInfo.NameText);
+                        case ErrorType.SequenceOutOfRangeError:
+                            var seqOutRange = ((SequenceOutOfRangeError)error);
+                            return seqOutRange.NameInfo.Equals(NameInfo.EmptyName)
+                                       ? Properties.Resources.SentenceSequenceOutOfRangeErrorValue
+                                       : String.Format(Properties.Resources.SentenceSequenceOutOfRangeErrorOption, 
+                                            seqOutRange.NameInfo.NameText);
+                        case ErrorType.BadVerbSelectedError:
+                            return String.Format(Properties.Resources.SentenceBadVerbSelectedError, ((BadVerbSelectedError)error).Token);
+                        case ErrorType.NoVerbSelectedError:
+                            return Properties.Resources.SentenceNoVerbSelectedError;
+                        case ErrorType.RepeatedOptionError:
+                            return String.Format(Properties.Resources.SentenceRepeatedOptionError, ((RepeatedOptionError)error).NameInfo.NameText);
+                        case ErrorType.SetValueExceptionError:
+                            var setValueError = (SetValueExceptionError)error;
+                            return String.Format(Properties.Resources.SentenceSetValueExceptionError, setValueError.NameInfo.NameText, setValueError.Exception.Message);
+                    }
+                    throw new InvalidOperationException();
+                };
+            }
+        }
+
+        public override Func<IEnumerable<MutuallyExclusiveSetError>, string> FormatMutuallyExclusiveSetErrors
+        {
+            get
+            {
+                return errors =>
+                {
+                    var bySet = from e in errors
+                                group e by e.SetName into g
+                                select new { SetName = g.Key, Errors = g.ToList() };
+
+                    var msgs = bySet.Select(
+                        set =>
+                        {
+                            var names = String.Join(
+                                String.Empty,
+                                (from e in set.Errors select String.Format("'{0}', ", e.NameInfo.NameText)).ToArray());
+                            var namesCount = set.Errors.Count();
+
+                            var incompat = String.Join(
+                                String.Empty,
+                                (from x in
+                                     (from s in bySet where !s.SetName.Equals(set.SetName) from e in s.Errors select e)
+                                    .Distinct()
+                                 select String.Format("'{0}', ", x.NameInfo.NameText)).ToArray());
+                            //TODO: Pluralize by namesCount
+                            return
+                                String.Format(Properties.Resources.SentenceMutuallyExclusiveSetErrors,
+                                    names.Substring(0, names.Length - 2), incompat.Substring(0, incompat.Length - 2));
+                        }).ToArray();
+                    return string.Join(Environment.NewLine, msgs);
+                };
+            }
+        }
+    }
+}

demo/ReadText.LocalizedDemo/Options.cs

@@ -0,0 +1,69 @@
+using CommandLine;
+using CommandLine.Text;
+using System.Collections.Generic;
+
+namespace ReadText.LocalizedDemo
+{
+    interface IOptions
+    {
+        [Option('n', "lines",
+            Default = 5U,
+            SetName = "bylines",
+            HelpText = "HelpTextLines",
+            ResourceType = typeof(Properties.Resources))]
+        uint? Lines { get; set; }
+
+        [Option('c', "bytes",
+            SetName = "bybytes",
+            HelpText = "HelpTextBytes",
+            ResourceType = typeof(Properties.Resources))]
+        uint? Bytes { get; set; }
+
+        [Option('q', "quiet",
+            HelpText = "HelpTextQuiet",
+            ResourceType = typeof(Properties.Resources))]
+        bool Quiet { get; set; }
+
+        [Value(0, MetaName = "input file",
+            HelpText = "HelpTextFileName",
+            Required = true,
+            ResourceType = typeof(Properties.Resources))]
+        string FileName { get; set; }
+    }
+
+    [Verb("head", HelpText = "HelpTextVerbHead", ResourceType = typeof(Properties.Resources))]
+    class HeadOptions : IOptions
+    {
+        public uint? Lines { get; set; }
+
+        public uint? Bytes { get; set; }
+
+        public bool Quiet { get; set; }
+
+        public string FileName { get; set; }
+
+        [Usage(ApplicationAlias = "ReadText.LocalizedDemo.exe")]
+        public static IEnumerable<Example> Examples
+        {
+            get
+            {
+                yield return new Example(Properties.Resources.ExamplesNormalScenario, new HeadOptions { FileName = "file.bin"});
+                yield return new Example(Properties.Resources.ExamplesSpecifyBytes, new HeadOptions { FileName = "file.bin", Bytes=100 });
+                yield return new Example(Properties.Resources.ExamplesSuppressSummary, UnParserSettings.WithGroupSwitchesOnly(), new HeadOptions { FileName = "file.bin", Quiet = true });
+                yield return new Example(Properties.Resources.ExamplesReadMoreLines, new[] { UnParserSettings.WithGroupSwitchesOnly(), UnParserSettings.WithUseEqualTokenOnly() }, new HeadOptions { FileName = "file.bin", Lines = 10 });
+            }
+        }
+    }
+
+    [Verb("tail", HelpText = "HelpTextVerbTail", ResourceType = typeof(Properties.Resources))]
+    class TailOptions : IOptions
+    {
+        public uint? Lines { get; set; }
+
+        public uint? Bytes { get; set; }
+
+        public bool Quiet { get; set; }
+
+        public string FileName { get; set; }
+    }
+}

demo/ReadText.LocalizedDemo/Program.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using CommandLine;
+using CommandLine.Text;
+
+namespace ReadText.LocalizedDemo
+{
+    class Program
+    {
+        public static int Main(string[] args)
+        {
+            // Set sentence builder to localizable
+            SentenceBuilder.Factory = () => new LocalizableSentenceBuilder();
+
+            Func<IOptions, string> reader = opts =>
+                {
+                    var fromTop = opts.GetType() == typeof(HeadOptions);
+                    return opts.Lines.HasValue
+                        ? ReadLines(opts.FileName, fromTop, (int)opts.Lines)
+                        : ReadBytes(opts.FileName, fromTop, (int)opts.Bytes);
+                };
+            Func<IOptions, string> header = opts =>
+                {
+                    if (opts.Quiet)
+                    {
+                        return string.Empty;
+                    }
+                    var fromTop = opts.GetType() == typeof(HeadOptions);
+                    var builder = new StringBuilder(Properties.Resources.Reading);
+                    builder = opts.Lines.HasValue
+                        ? builder.Append(opts.Lines).Append(Properties.Resources.Lines)
+                        : builder.Append(opts.Bytes).Append(Properties.Resources.Bytes);
+                    builder = fromTop ? builder.Append(Properties.Resources.FromTop) : builder.Append(Properties.Resources.FromBottom);
+                    return builder.ToString();
+                };
+            Action<string> printIfNotEmpty = text =>
+                {
+                    if (text.Length == 0) { return; }
+                    Console.WriteLine(text);
+                };
+
+            var result = Parser.Default.ParseArguments<HeadOptions, TailOptions>(args);
+            var texts = result
+                .MapResult(
+                    (HeadOptions opts) => Tuple.Create(header(opts), reader(opts)),
+                    (TailOptions opts) => Tuple.Create(header(opts), reader(opts)),
+                    _ => MakeError());
+
+            printIfNotEmpty(texts.Item1);
+            printIfNotEmpty(texts.Item2);
+
+            return texts.Equals(MakeError()) ? 1 : 0;
+        }
+
+        private static string ReadLines(string fileName, bool fromTop, int count)
+        {
+            var lines = File.ReadAllLines(fileName);
+            if (fromTop)
+            {
+                return string.Join(Environment.NewLine, lines.Take(count));
+            }
+            return string.Join(Environment.NewLine, lines.Reverse().Take(count));
+        }
+
+        private static string ReadBytes(string fileName, bool fromTop, int count)
+        {
+            var bytes = File.ReadAllBytes(fileName);
+            if (fromTop)
+            {
+                return Encoding.UTF8.GetString(bytes, 0, count);
+            }
+            return Encoding.UTF8.GetString(bytes, bytes.Length - count, count);
+        }
+
+        private static Tuple<string, string> MakeError()
+        {
+            return Tuple.Create("\0", "\0");
+        }
+    }
+}

demo/ReadText.LocalizedDemo/Properties/AssemblyInfo.cs

@@ -0,0 +1,11 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle("ReadText.Demo")]
+[assembly: AssemblyDescription("ReadText.Demo for Command Line Parser Library")]
+[assembly: AssemblyTrademark("")]
+#if DEBUG
+[assembly: AssemblyConfiguration("Debug")]
+#else
+[assembly: AssemblyConfiguration("Release")]
+#endif