private TflTransform Decompress(string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, !string.IsNullOrEmpty(arg), "The decompress method does not take parameters. It will return a decompressed version of whatever is currently in the field.")) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "decompress"; t.IsShortHand = true; }); }
private TflTransform Replace(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The replace method requires two parameters: an old value, and a new value. Your arguments '{0}' resolve {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var oldValue = split[0]; var newValue = split[1]; return field.GetDefaultOf<TflTransform>(t => { t.Method = "replace"; t.OldValue = oldValue; t.NewValue = newValue; t.IsShortHand = true; }); }
private TflTransform If(string arg, TflField field, TflTransform lastTransform) { var linked = new LinkedList<string>(SplitComma(arg)); if (Guard.Against(_problems, linked.Count < 2, "The if method requires at least 2 arguments. Your argument '{0}' has {1}.", arg, linked.Count)) { return _guard; } // left is required first, assign and remove var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "if"; t.Left = linked.First.Value; t.IsShortHand = true; }); linked.RemoveFirst(); // operator is second, but optional, assign and remove if present ComparisonOperator op; if (Enum.TryParse(linked.First.Value, true, out op)) { element.Operator = op.ToString(); linked.RemoveFirst(); } // right, then, and else in that order var split = linked.ToList(); for (var i = 0; i < split.Count; i++) { switch (i) { case 0: element.Right = split[i]; break; case 1: element.Then = split[i]; break; case 2: element.Else = split[i]; break; } } return element; }
private TflTransform Join(string arg, TflField field, TflTransform lastTransform) { if (string.IsNullOrEmpty(arg)) { return field.GetDefaultOf<TflTransform>(t => { t.Method = "concat"; t.IsShortHand = true; }); } var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 1, "The join method requires one parameter; the separator. To get fields for join, use the copy() method.")) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "join"; t.Separator = split[0]; t.IsShortHand = true; }); }
private TflTransform Parameters(string method, string arg, int skip, TflField f, TflTransform lastTransform) { var split = SplitComma(arg, skip); if (Guard.Against(_problems, split.Length == 0, "The {0} method requires parameters.", method)) { return _guard; } var element = f.GetDefaultOf<TflTransform>(t => { t.Method = method; t.IsShortHand = true; }); if (split.Length == 1) { element.Parameter = split[0]; } else { for (var i = 0; i < split.Length; i++) { var p = split[i]; element.Parameters.Add(f.GetDefaultOf<TflParameter>(x => x.Field = p)); } } // handle single parameter that is named parameter if (element.Parameter.Contains(":")) { var pair = Common.Split(element.Parameter, ":"); element.Parameters.Insert(0, f.GetDefaultOf<TflParameter>(x => { x.Field = string.Empty; x.Name = pair[0]; x.Value = pair[1]; })); element.Parameter = string.Empty; } // handle regular parameters foreach (var p in element.Parameters) { if (!p.Field.Contains(":")) continue; var pair = Common.Split(p.Field, ":"); p.Field = string.Empty; p.Name = pair[0]; p.Value = pair[1]; } return element; }
private TflTransform Remove(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The remove method requires start index and length. You have {0} parameter{1}.", split.Length, split.Length.Plural())) { return _guard; } int startIndex; int length; if (int.TryParse(split[0], out startIndex) && int.TryParse(split[1], out length)) { return field.GetDefaultOf<TflTransform>(t => { t.Method = "remove"; t.StartIndex = startIndex; t.Length = length; t.IsShortHand = true; }); } _problems.Add(string.Format("The remove method requires two integer parameters indicating start index and length. '{0}' doesn't represent two integers.", arg)); return _guard; }
private TflTransform InsertInterval(string arg, TflField field, TflTransform lastTransform) { //interval, value var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 2, "The insertinterval method requires two parameters: the interval (e.g. every certain number of characters), and the value to insert. '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "insertinterval"; t.IsShortHand = true; }); int interval; if (int.TryParse(split[0], out interval)) { element.Interval = interval; } else { _problems.Add(string.Format("The insertinterval method's first parameter must be an integer. {0} is not an integer.", split[0])); return _guard; } element.Value = split[1]; return element; }
private TflTransform TimeOperation(string arg, TflField field, bool past) { var split = SplitComma(arg); if (split.Length == 0) { return field.GetDefaultOf<TflTransform>(t => { t.Method = "time" + (past ? "ago" : "ahead"); t.FromTimeZone = "UTC"; t.IsShortHand = true; }); } var p = split[0]; try { TimeZoneInfo.FindSystemTimeZoneById(p); return field.GetDefaultOf<TflTransform>(t => { t.Method = "time" + (past ? "ago" : "ahead"); t.FromTimeZone = p; t.IsShortHand = true; }); } catch (Exception ex) { var message = string.Format("Time" + (past ? "Ago" : "Ahead") + " from time zone is {0} is invalid. {1}", p, ex.Message); _problems.Add(message); return _guard; } }
private TflTransform Equals(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0 && lastTransform.Method != "copy" || split.Length > 1, "The equals method requires a parameter representing a value or field that you want compared with this field's value OR should be proceeded by a copy transform that supplies multiple parameters.")) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "equals"; t.Parameter = arg; t.IsShortHand = true; }); }
private TflTransform TimeZone(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The timezone method requires at least two parameters: the from-time-zone, and the to-time-zone.")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "timezone"; t.IsShortHand = true; }); foreach (var p in split) { try { TimeZoneInfo.FindSystemTimeZoneById(p); if (string.IsNullOrEmpty(element.FromTimeZone)) { element.FromTimeZone = p; } else { element.ToTimeZone = p; } } catch (TimeZoneNotFoundException ex) { if (string.IsNullOrEmpty(element.Parameter)) { element.Parameter = p; } else { _problems.Add(string.Format("The timezone method already has a parameter of {0}, and it can't interpret {1} as a valid time-zone identifer. {2}", element.Parameter, p, ex.Message)); return _guard; } } } return element; }
private TflTransform WeekOfYear(string arg, TflField field, TflTransform lastTransform) { var split = new Queue<string>(SplitComma(arg)); var transform = field.GetDefaultOf<TflTransform>(t => { t.Method = "weekofyear"; t.IsShortHand = true; }); if (split.Count == 0) { return transform; } while (split.Count > 0) { var subject = split.Dequeue(); CalendarWeekRule calendarWeekRule; DayOfWeek dayOfWeek; if (Enum.TryParse(subject, true, out calendarWeekRule)) { transform.CalendarWeekRule = calendarWeekRule.ToString().ToLower(); } else if (Enum.TryParse(subject, true, out dayOfWeek)) { transform.DayOfWeek = dayOfWeek.ToString().ToLower(); } else { var message = string.Format("WeekOfYear argument '{0}' is invalid. You may only pass in a calendar week rule [(firstday),firstfourdayweek,firstfullweek] and/or first day of week [(sunday),monday,tuesday,wednesday,thursday,friday,saturday].", subject); _problems.Add(message); return _guard; } } return transform; }
private TflTransform Format(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 1, "format() takes one parameter: the format with {{index}} style place-holders in it. To get data for format, use the copy() method.")) { return _guard; } if (Guard.Against(_problems, !split[0].Contains("{"), "A format place-holder is required. There are not left brackets {.")) { return _guard; } if (Guard.Against(_problems, !split[0].Contains("}"), "A format place-holder is required. There are not right brackets }.")) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "format"; t.Format = split[0]; t.IsShortHand = true; }); }
private TflTransform Elipse(string arg, TflField field, TflTransform lastTransform) { var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "elipse"; t.IsShortHand = true; }); var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0, "The elipse method requires a an integer representing the number of characters allowed before the elipse.")) { return _guard; } int length; if (Guard.Against(_problems, !int.TryParse(split[0], out length), "The elipse method requires a an integer representing the number of characters allowed before the elipse. You passed in '{0}'.", split[0])) { return _guard; } element.Length = length; if (split.Length > 1) { element.Elipse = split[1]; } return element; }
private TflTransform DatePart(string arg, TflField field, TflTransform lastTransform) { var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "datepart"; t.IsShortHand = true; }); var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0 || split.Length > 1, "The datepart method requires one parameter representing a time component.")) { return _guard; } var timeComponent = split[0].ToLower(); if (Guard.Against(_problems, !DatePartOperation.Parts.ContainsKey(timeComponent), "The datepart method requires one of these time components: {0}", string.Join(", ", DatePartOperation.Parts.Select(kv => kv.Key)))) { return _guard; } element.TimeComponent = timeComponent; return element; }
private TflTransform TrimStartAppend(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1, "The trimstartappend method requires at least one parameter indicating the trim characters.")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "trimstartappend"; t.TrimChars = split[0]; t.IsShortHand = true; }); if (split.Length > 1) { element.Separator = split[1]; } if (split.Length > 2) { element.Parameter = split[2]; } return element; }
private TflTransform Append(string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, string.IsNullOrEmpty(arg), "The append method requires a single argument representing a field or a value that you want to append to this field.")) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "append"; t.Parameter = arg; t.IsShortHand = true; }); }
private TflTransform Substring(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1, "The substring method requires a start index.")) { return _guard; } int startIndex; if (int.TryParse(split[0], out startIndex)) { return field.GetDefaultOf<TflTransform>(t => { t.Method = "substring"; t.StartIndex = startIndex; int length; t.Length = split.Length > 1 && int.TryParse(split[1], out length) ? length : 0; t.IsShortHand = true; }); } _problems.Add(string.Format("The substring method requires two integers indicating start index and length. '{0}' doesn't represent two integers.", arg)); return _guard; }
private TflTransform Copy(string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, string.IsNullOrEmpty(arg), "The copy method requires one or more parameters representing fields that you want to copy to this field. A single field produces a single value, multiple fields produces an array or values.")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "copy"; t.IsShortHand = true; }); var split = SplitComma(arg); if (split.Length == 1) { element.Parameter = split[0]; return element; } foreach (var p in split) { var parameter = field.GetDefaultOf<TflParameter>(); if (p.Contains(":")) { //named values var named = p.Split(':'); parameter.Name = named[0]; parameter.Value = named[1]; } else if (p.Contains(".")) { // entity, field combinations var dotted = p.Split('.'); parameter.Entity = dotted[0]; parameter.Field = dotted[1]; } else { parameter.Field = p; // just fields } element.Parameters.Add(parameter); } return element; }
private TflTransform Slug(string arg, TflField field, TflTransform lastTransform) { var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "slug"; t.IsShortHand = true; }); var split = SplitComma(arg); if (Guard.Against(_problems, split.Length > 1, "The slug method takes 1 argument; an integer representing the maximum length of the slug. You passed in '{0}' arguments.", split.Length)) { return _guard; } int length; if (int.TryParse(split[0], out length)) { element.Length = length; } return Guard.Against(_problems, length == 0, "The slug method takes 1 argument; an integer greater than zero, representing the maximum length of the slug. You passed in '{0}'.", arg) ? _guard : element; }
private TflTransform Velocity(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1 || split.Length > 2, "The velocity method takes between 1 and 2 parameters: the template name, and a snippet (of template). Use the copy method to inject other data into the template.")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "velocity"; t.IsShortHand = true; }); foreach (var parameter in split) { if (parameter.IndexOfAny(_codeCharaters) > -1) { element.Template = parameter; } else { element.Templates = new List<TflNameReference> { new TflNameReference { Name = parameter } }; } } return element; }
private TflTransform Insert(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 2, "The insert method requires two parameters; the start index, and the value (or field reference) you'd like to insert. '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "insert"; t.IsShortHand = true; }); int startIndex; if (int.TryParse(split[0], out startIndex)) { element.StartIndex = startIndex; } else { _problems.Add(string.Format("The insert method's first parameter must be an integer. {0} is not an integer.", split[0])); return _guard; } element.Parameter = split[1]; return element; }
private TflTransform Script(string method, string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 1 || split.Length > 2, "The {0} method takes between 1 and 2 parameters: a script name and/or a snippet (e.g. a function call).", method)) { return _guard; }; var element = field.GetDefaultOf<TflTransform>(t => { t.Method = method; t.IsShortHand = true; }); foreach (var parameter in split) { if (parameter.IndexOfAny(_codeCharaters) > -1) { element.Script = parameter; } else { element.Scripts = new List<TflNameReference> { new TflNameReference { Name = parameter } }; } } return element; }
private TflTransform Add(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0, "The add method requires a * parameter, or a comma delimited list of parameters that reference numeric fields.")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "add"; t.IsShortHand = true; }); if (split.Length == 1) { element.Parameter = split[0]; } else { for (var i = 0; i < split.Length; i++) { var p = split[i]; element.Parameters.Add( p.IsNumeric() ? field.GetDefaultOf<TflParameter>(x => { x.Name = p; x.Value = p; }) : field.GetDefaultOf<TflParameter>(x => { x.Field = p; })); } } return element; }
private TflTransform Pad(string method, string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, arg.Equals(string.Empty), "The {0} method requires two pararmeters: the total width, and the padding character(s).", method)) { return _guard; } var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The {0} method requires two pararmeters: the total width, and the padding character(s). You've provided {1} parameter{2}.", method, split.Length, split.Length.Plural())) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = method; t.IsShortHand = true; }); int totalWidth; if (int.TryParse(split[0], out totalWidth)) { element.TotalWidth = totalWidth; } else { _problems.Add(string.Format("The {0} method requires the first parameter to be total width; an integer. {1} is not an integer", method, split[0])); return _guard; } element.PaddingChar = split[1][0]; if (Guard.Against(_problems, element.PaddingChar == default(char), "The {0} second parameter, the padding character, must be a character. You can't pad something with nothing.", method)) { return _guard; } if (split.Length > 2) { element.Parameter = split[2]; } return element; }
private TflTransform RegexReplace(string arg, TflField field, TflTransform lastTransform) { if (Guard.Against(_problems, arg.Equals(string.Empty), "The regexreplace requires two parameters: a regular expression pattern, and replacement text. You didn't pass in any parameters.")) { return _guard; }; var split = SplitComma(arg); if (Guard.Against(_problems, split.Length < 2, "The regexreplace method requires at least two parameters: the pattern, and the replacement text. A third parameter, count (how many to replace) is optional. The argument '{0}' has {1} parameter{2}.", arg, split.Length, split.Length.Plural())) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "regexreplace"; t.Pattern = split[0]; t.Replacement = split[1]; t.IsShortHand = true; }); if (split.Length <= 2) return element; int count; if (Guard.Against(_problems, !int.TryParse(split[2], out count), "The regexreplace's third parameter; count, must be an integer. The argument '{0}' contains '{1}'.", arg, split[2])) { return _guard; } element.Count = count; return element; }
private TflTransform Web(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length > 2, "The web method takes two optional parameters: a parameter referencing a field, and an integer representing sleep ms in between web requests. You have {0} parameter{1} in '{2}'.", split.Length, split.Length.Plural(), arg)) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "web"; t.IsShortHand = true; }); foreach (var p in split) { int sleep; if (int.TryParse(p, out sleep)) { element.Sleep = sleep; } else { element.Parameter = p; } } return element; }
private TflTransform Convert(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "convert"; t.IsShortHand = true; }); if (split.Length == 0) return element; foreach (var p in split) { if (System.Text.Encoding.GetEncodings().Any(e => e.Name.Equals(p, StringComparison.OrdinalIgnoreCase))) { element.Encoding = p; } else if (Common.TypeMap.ContainsKey(Common.ToSimpleType(p))) { element.To = Common.ToSimpleType(p); } else { element.Format = p; } } return element; }
private TflTransform Map(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length == 0, "The map method requires a map name (e.g. 'map'), or a set of parameters that represent an inline map (e.g. 'a=1,b=2,c=3').")) { return _guard; } var element = field.GetDefaultOf<TflTransform>(t => { t.Method = "map"; t.IsShortHand = true; }); if (_maps.ContainsKey(split[0])) { element.Map = split[0]; Guard.Against(_problems, split.Length > 1, "If you reference a map name in a map method, that's the only parameter you can have. It will map what is in the current field."); return element; } element.Map = string.Join(",", split); return element; }
private TflTransform Left(string arg, TflField field, TflTransform lastTransform) { int length; if (Guard.Against(_problems, !int.TryParse(arg, out length), "The left method requires a single integer representing the length, or how many left-most characters you want. You passed in '{0}'.", arg)) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "left"; t.Length = length; t.IsShortHand = true; }); }
private TflTransform DistinctWords(string arg, TflField field, TflTransform lastTransform) { var split = SplitComma(arg); if (Guard.Against(_problems, split.Length != 1, "The distinctwords method takes 1 parameter. You provided {0}.", split.Length)) { return _guard; } return field.GetDefaultOf<TflTransform>(t => { t.Method = "distinctwords"; t.Separator = split[0]; t.IsShortHand = true; }); }