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;
});
}
