예제 #1
0
 public ConsoleColoredString Validate()
 {
     if (FromPath.Length != ToPath.Length)
     {
         return(CommandLineParser.Colorize(RhoML.Parse("The number of {option}--from{} arguments must match the number of {option}--to{} arguments.")));
     }
     for (int i = 0; i < FromPath.Length; i++)
     {
         FromPath[i] = Path.GetFullPath(FromPath[i]).WithSlash();
         ToPath[i]   = Path.GetFullPath(ToPath[i]).WithSlash();
     }
     for (int i = 0; i < IgnorePath.Length; i++)
     {
         IgnorePath[i] = Path.GetFullPath(IgnorePath[i]).WithSlash();
     }
     foreach (var path in FromPath.Concat(ToPath))
     {
         if (!Directory.Exists(path))
         {
             return(CommandLineParser.Colorize(RhoML.Parse($"Directory not found: {{h}}{path}{{}}.")));
         }
     }
     if (SettingsPath != null && !Directory.Exists(Path.GetDirectoryName(SettingsPath)))
     {
         return(CommandLineParser.Colorize(RhoML.Parse($"The {{option}}--settings{{}} file does not exist and will not be created because this directory does not exist: {{h}}{Path.GetDirectoryName(SettingsPath)}{{}}.")));
     }
     return(null);
 }
예제 #2
0
        public ConsoleColoredString Validate()
        {
            if (CommandToRun.Length == 0)
            {
                return("You must specify the command to be executed (CommandToRun).");
            }

            if (WorkingDir != null)
            {
                try { Directory.SetCurrentDirectory(WorkingDir); }
                catch { return("Cannot set working directory - check that the directory exists and that the path is valid. \"{0}\"".Fmt(WorkingDir)); }
            }

            if (LogFilename == null)
            {
                LogFilename = Path.GetFileName(CommandToRun[0]).Replace(".", "_") + "--{}.log";
            }
            LogFilename = Path.GetFullPath(LogFilename.Replace("{}", DateTime.Now.ToString("yyyy-MM-dd")));

            if (SuccessCodes != null && FailureCodes != null)
            {
                return(CommandLineParser.Colorize(RhoML.Parse("The options {option}--success-codes{} and {option}--failure-codes{} are mutually exclusive and cannot be specified together.")));
            }

            // Parse the success/failure codes list
            var codes = SuccessCodes ?? FailureCodes;

            if (codes != null)
            {
                var result = new List <Tuple <int, int> >();
                foreach (var part in codes.Split(','))
                {
                    var match = Regex.Match(part, @"^\s*(?<fr>-?\d+)\s*(-\s*(?<to>-?\d+\s*))?$");
                    if (!match.Success)
                    {
                        return(CommandLineParser.Colorize(RhoML.Parse("Could not parse the exit code list for {option}{0}{}: cannot parse segment \"{h}{1}{}\".".Fmt(SuccessCodes != null ? "--success-codes" : "--failure-codes", part))));
                    }
                    var fr = int.Parse(match.Groups["fr"].Value);
                    if (!match.Groups["to"].Success)
                    {
                        result.Add(Tuple.Create(fr, fr));
                    }
                    else
                    {
                        var to = int.Parse(match.Groups["to"].Value);
                        result.Add(Tuple.Create(Math.Min(fr, to), Math.Max(fr, to)));
                    }
                }
                if (SuccessCodes != null)
                {
                    SuccessCodesParsed = result;
                }
                else
                {
                    FailureCodesParsed = result;
                }
            }

            return(null);
        }
예제 #3
0
        public ConsoleColoredString Validate()
        {
            ConfigPath = Path.GetFullPath(ConfigPath);
            if (!File.Exists(ConfigPath))
            {
                var cfg = new Config {
                    Domain = "example.com", NotifyEmail = "*****@*****.**", PfxPassword = "******", CountryName = "GB", Locality = "London", State = "London"
                };
                File.WriteAllText(ConfigPath, JsonConvert.SerializeObject(cfg, Formatting.Indented));
                return(CommandLineParser.Colorize(RhoML.Parse($"Config file not found: {{h}}{ConfigPath}{{}}\r\n\r\nA template file has been created at the above path.")));
            }

            try { Config = JsonConvert.DeserializeObject <Config>(File.ReadAllText(ConfigPath)); }
            catch { return(CommandLineParser.Colorize(RhoML.Parse($"Could not parse config file: {{h}}{ConfigPath}{{}}"))); }

            return(null);
        }
예제 #4
0
파일: Logmeon.cs 프로젝트: rstarkov/LogMeOn
 /// <summary>
 ///     Outputs text to the console, parsing and colorizing where required. For syntax, see
 ///     https://docs.timwi.de/M:RT.Util.CommandLine.CommandLineParser.Colorize(RT.Util.RhoElement) and
 ///     https://docs.timwi.de/T:RT.Util.RhoML. Example: "Normal text {red}Red text{} normal text."</summary>
 public static void WriteLineColored(string str)
 {
     ConsoleUtil.WriteLine(CommandLineParser.Colorize(RhoML.Parse(str)));
 }
예제 #5
0
        public ConsoleColoredString Validate()
        {
            if (SvgPath == null && (Filename == null || Id == null))
            {
                return(CommandLineParser.Colorize(RhoML.Parse("If {option}-p{} is not used, {option}-f{} and {option}-i{} must both be present.")));
            }
            if (SvgPath != null && (Filename != null || Id != null))
            {
                return(CommandLineParser.Colorize(RhoML.Parse("If {option}-p{} is used, neither {option}-f{} nor {option}-i{} must be present.")));
            }

            Matrix matrix = new Matrix();

            if (Filename != null)
            {
                if (!File.Exists(Filename))
                {
                    return(CommandLineParser.Colorize(RhoML.Parse("The specified file, {{h}}{0}{{}}, does not exist.".Fmt(Filename))));
                }
                var xml     = XDocument.Parse(File.ReadAllText(Filename));
                var element = xml.Descendants().FirstOrDefault(el => el.AttributeI("id").NullOr(id => id.Value == Id) == true);
                if (element == null)
                {
                    return(CommandLineParser.Colorize(RhoML.Parse("An XML element with the specified ID, {{h}}{0}{{}}, does not exist in the specified file.".Fmt(Id))));
                }
                SvgPath = element.AttributeI("d")?.Value;
                if (SvgPath == null)
                {
                    return(CommandLineParser.Colorize(RhoML.Parse("The XML element with the specified ID, {{h}}{0}{{}}, does not have the {{h}}d{{}} attribute.".Fmt(Id))));
                }

                var   tr = element.AttributeI("transform")?.Value;
                Match m;
                if (tr != null && (m = Regex.Match(tr, @"^\s*matrix\s*\(\s*(-?\d*(?:\d|\.\d+)),\s*(-?\d*(?:\d|\.\d+)),\s*(-?\d*(?:\d|\.\d+)),\s*(-?\d*(?:\d|\.\d+)),\s*(-?\d*(?:\d|\.\d+)),\s*(-?\d*(?:\d|\.\d+))\s*\)\s*$")).Success)
                {
                    matrix = new Matrix(float.Parse(m.Groups[1].Value), float.Parse(m.Groups[2].Value), float.Parse(m.Groups[3].Value), float.Parse(m.Groups[4].Value), float.Parse(m.Groups[5].Value), float.Parse(m.Groups[6].Value));
                    System.Console.WriteLine("Using matrix!");
                }
            }

            PointF?prev   = null;
            bool   figure = false;

            SvgPath = SvgPath.Trim();
            var num = @"-?\d*(?:\d|\.\d+)(?=$|\s|,)";

            ParsedPath = new GraphicsPath(UseWindingFill ? FillMode.Winding : FillMode.Alternate);
            var  index       = 0;
            char?prevCommand = null;
            var  commands    = "MLCZz";

            while (index < SvgPath.Length)
            {
                var match = Regex.Match(SvgPath.Substring(index), @"^(?:
                    [ML]{1}(?:\s|,)*({0})(?:\s|,)+({0})(?:\s|,)*|
                    [C]{2}(?:\s|,)*({0})(?:\s|,)+({0})(?:\s|,)+({0})(?:\s|,)+({0})(?:\s|,)+({0})(?:\s|,)+({0})(?:\s|,)*|
                    [Zz](?:\s|,)*
                )".Fmt(
                                            /* {0} */ num,
                                            /* {1} */ prevCommand == 'M' || prevCommand == 'L' ? "?" : "",
                                            /* {2} */ prevCommand == 'C' ? "?" : ""
                                            ), RegexOptions.IgnorePatternWhitespace);
                if (!match.Success)
                {
                    return("The specified path data does not conform to the expected syntax at index {0}.".Fmt(index));
                }
                index += match.Length;
                if (match.Value[0] != 'M' && prev.Value == null)
                {
                    return("The path data cannot start with any command other than M.");
                }
                if (commands.Contains(match.Value[0]))
                {
                    prevCommand = match.Value[0];
                }
                switch (prevCommand)
                {
                case 'M':
                    if (figure)
                    {
                        ParsedPath.CloseFigure();
                    }
                    prev = new PointF(float.Parse(match.Groups[1].Value), float.Parse(match.Groups[2].Value));
                    break;

                case 'L':
                    var p = new PointF(float.Parse(match.Groups[1].Value), float.Parse(match.Groups[2].Value));
                    ParsedPath.AddLine(prev.Value, p);
                    prev   = p;
                    figure = true;
                    break;

                case 'C':
                    var p1 = new PointF(float.Parse(match.Groups[3].Value), float.Parse(match.Groups[4].Value));
                    var p2 = new PointF(float.Parse(match.Groups[5].Value), float.Parse(match.Groups[6].Value));
                    var p3 = new PointF(float.Parse(match.Groups[7].Value), float.Parse(match.Groups[8].Value));
                    ParsedPath.AddBezier(prev.Value, p1, p2, p3);
                    prev   = p3;
                    figure = true;
                    break;

                case 'Z':
                case 'z':
                    if (figure)
                    {
                        ParsedPath.CloseFigure();
                        figure = false;
                    }
                    break;

                default:
                    return("The specified path data does not conform to the expected syntax. (2)");
                }
            }
            if (figure)
            {
                ParsedPath.CloseFigure();
            }
            ParsedPath.Transform(matrix);
            return(null);
        }