public void CheckThrowNamedParamsOrder(ComplexParam param)
{
int lastNamedParamIndex = -1;
int lastNonNamedParamIndex = -1;
int i = 0;
foreach (var subparam in param.SubParams)
{
if (String.IsNullOrWhiteSpace(subparam.Name))
{
lastNonNamedParamIndex = i;
}
else
{
lastNamedParamIndex = i;
}
i++;
}
if ((lastNamedParamIndex > -1 && lastNonNamedParamIndex > -1) &&
lastNonNamedParamIndex > lastNamedParamIndex)
{
throw new MisplacedNamedParamException(param);
}
}
protected void CheckThrowParamNumber(ComplexParam param, ParameterDefinition[] paramsDef)
{
int requiredParams = paramsDef.Count(cmdi => cmdi.Options?.IsRequired ?? false);
if (param.SubParams.Length < requiredParams ||
param.SubParams.Length > paramsDef.Length)
{
throw new ArgumentNumberException(param);
}
}
public void Checks(ComplexParam param, Type target, ParameterDefinition[] paramsDef)
{
CheckThrowParameterNameCollisions(target, paramsDef);
CheckThrowArgumentNameCollisions(param);
CheckThrowParamNumber(param, paramsDef);
CheckThrowNamedParamsExist(param, target, paramsDef);
CheckThrowNamedParamsOrder(param);
//CheckThrowParamsTypeOrder (if cp provided and sp is expected number is still ok but should throw)
}
private void CheckThrowArgumentNameCollisions(ComplexParam param)
{
//anonymous params (empty name) are not a problem
var groups = param.SubParams.Where(p => !String.IsNullOrEmpty(p.Name))
.GroupBy(p => p.Name.ToLower());
foreach (var item in groups)
{
if (item.Count() > 1)
{
throw new DuplicateArgumentException(item.Key);
}
}
}
/// <summary>
/// Check and throw if any unsupported namedparam is provided
/// (can be a mispelling of a named param)
/// </summary>
protected void CheckThrowNamedParamsExist(ComplexParam param, Type target, ParameterDefinition[] paramsDef)
{
var longNames = paramsDef.Where(l => !String.IsNullOrWhiteSpace(l.Name))
.Select(l => l.Name.ToLower());
var availableParamNames = longNames
.Where(i => !String.IsNullOrWhiteSpace(i));
var providedParams = param.SubParams.Where(l => !String.IsNullOrWhiteSpace(l.Name))
.Select(p => p.Name.ToLower());
foreach (var providedParam in providedParams)
{
var isCorrectParam = availableParamNames.Contains(providedParam);
if (!isCorrectParam)
{
throw new UndefinedParameterException(target, providedParam);
}
}
}
public void ComplexParamNoReturn(ComplexParam complex)
{
}
public IEnumerable <ParsedCommand> Parse(string commandLine)
{
if (String.IsNullOrWhiteSpace(commandLine))
{
throw new ArgumentNullException(nameof(commandLine), "Null or empty command");
}
var commands = commandLine.SplitKeepDelimiter(COMMAND_IDENTIFIER).ToArray();
if (commands.Length == 0)
{
//try implicit notation
{
var match = BalancedParenthesesRegex.Match(commandLine);
if (!match.Success)
{
throw new SyntaxErrorException();
}
var parsedParams = match.Groups["params"]
.Captures.Cast <Capture>()
.Select(c => c.Value);
}
throw new SyntaxErrorException();
}
int paramIndex = 0;
foreach (var command in commands)
{
var match = CommandRegex.Match(command);
if (!match.Success)
{
throw new SyntaxErrorException();
}
var cmdName = match.Groups["command"].Value;
var parsedParams = match.Groups["params"]
.Captures.Cast <Capture>()
.Select(c => c.Value);
var parameters = GetCommandParams(parsedParams).ToList();
IParsedParam theparam = null;
if (parameters.Count > 1)
{
theparam = new ComplexParam()
{
//Name = cmdName,
Index = paramIndex,
SubParams = parameters.ToArray()
};
}
else
{
var p = parameters.FirstOrDefault();
if (p == null)
{
theparam = null;
}
else
{
p.Index = paramIndex;
theparam = p;
}
}
yield return(new ParsedCommand()
{
Name = cmdName,
Param = theparam
});
paramIndex++;
}
}
public void ComplexParamRecursion()
{
var mapper = new Mapper();
mapper.Config.Mappers.AddBefore <ReferenceMapper>(new IMappingExpressionBuilder[]
{
new SimpleParamExpressionBuilder(mapper.Config),
new ComplexParamExpressionBuilder(mapper.Config)
});
var complexParam = new ComplexParam()
{
Index = 4,
Name = "asdf",
SubParams = new IParsedParam[]
{
new SimpleParam()
{
Name = nameof(Commands.PropertyA),
Index = 0,
Value = "A"
},
new SimpleParam()
{
Name = nameof(Commands.PropertyB),
Index = 1,
Value = "1"
},
new ComplexParam()
{
Name = nameof(Commands.SomeCommand),
Index = 2,
SubParams = new IParsedParam[]
{
new SimpleParam()
{
Name = nameof(Commands.SomeCommand.A),
Index = 0,
Value = "SomeCommand.A"
},
new SimpleParam()
{
Name = nameof(Commands.SomeCommand.B),
Index = 1,
Value = "SomeCommand.B"
},
new ComplexParam()
{
Name = nameof(Commands.SomeCommand.SubLevel2),
Index = 2,
SubParams = new IParsedParam[]
{
new SimpleParam()
{
Name = nameof(Commands.SomeCommand.SubLevel2.D),
Index = 0,
Value = "SomeCommand.SubLevel2.D"
},
new SimpleParam()
{
Name = nameof(Commands.SomeCommand.SubLevel2.E),
Index = 1,
Value = "SomeCommand.SubLevel2.E"
}
}
}
}
}
}
};
var target = mapper.Map <Commands>(complexParam);
Assert.IsTrue(target.PropertyA == "A");
Assert.IsTrue(target.PropertyB == 1);
Assert.IsTrue(target.SomeCommand.A == "SomeCommand.A");
Assert.IsTrue(target.SomeCommand.B == "SomeCommand.B");
Assert.IsTrue(target.SomeCommand.SubLevel2.D == "SomeCommand.SubLevel2.D");
Assert.IsTrue(target.SomeCommand.SubLevel2.E == "SomeCommand.SubLevel2.E");
}
private IParsedParam Internal(IParsedParam param, ParameterDefinition def)
{
if (param == null)
{
return(null);
}
switch (param)
{
case ArrayParam _: return(param);
case SimpleParam sp:
if (def.Type?.IsBuiltIn(true) == true)
{
return(sp);
}
return(new ComplexParam()
{
Name = def.Name,
Index = 0,
SubParams = new[] { sp }
});
case ComplexParam cp:
{
var subParamsDef = def.SubParams;
if (subParamsDef.All(s => s.Type.IsBuiltIn(true)))
{
_complexParamChecks.Checks(cp, def.Type, def.SubParams);
return(cp);
}
IEnumerable <IParsedParam> getSubparams(ComplexParam localcp)
{
for (int i = 0; i < localcp.SubParams.Length; i++)
{
var item = localcp.SubParams[i];
var defSub = def.SubParams.FirstOrDefault(k => k.Name.ToLower() == item.Name.ToLower());
if (defSub == null)
{
defSub = def.SubParams.FirstOrDefault(k => k.Options.Order == item.Index);
}
var newitem = Internal(item, defSub);
yield return(newitem);
}
};
if (def.SubParams.Length == 1)
{
//nesting just to check properly
var temp = new ComplexParam()
{
Name = "",
SubParams = new[] { cp }
};
_complexParamChecks.Checks(temp, def.Type, def.SubParams);
var subparams = getSubparams(temp).ToArray();
return(subparams.First());
}
else
{
_complexParamChecks.Checks(cp, def.Type, def.SubParams);
var subparams = getSubparams(cp).ToArray();
return(new ComplexParam()
{
Name = def.Name,
Index = 0,
SubParams = subparams
});
}
}
}
throw new NotSupportedException();
}
