public void Map_with_multi_instance_sequence()
{
var tokenPartitions = new[]
{
new KeyValuePair <string, IEnumerable <string> >("i", new [] { "1", "2" }),
new KeyValuePair <string, IEnumerable <string> >("i", new [] { "3" }),
new KeyValuePair <string, IEnumerable <string> >("i", new [] { "4", "5" }),
};
var specProps = new[]
{
SpecificationProperty.Create(
new OptionSpecification("i", string.Empty, false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '\0', Maybe.Nothing <object>(), string.Empty, string.Empty, new List <string>(), typeof(IEnumerable <int>), TargetType.Sequence, string.Empty),
typeof(Simple_Options).GetProperties().Single(p => p.Name.Equals(nameof(Simple_Options.IntSequence), StringComparison.Ordinal)),
Maybe.Nothing <object>())
};
var result = OptionMapper.MapValues(
specProps.Where(pt => pt.Specification.IsOption()),
tokenPartitions,
(vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, CultureInfo.InvariantCulture, false),
StringComparer.Ordinal);
var property = result.SucceededWith().Single();
Assert.True(property.Specification.IsOption());
Assert.True(property.Value.MatchJust(out var sequence));
var expected = tokenPartitions.Aggregate(Enumerable.Empty <int>(), (prev, part) => prev.Concat(part.Value.Select(i => int.Parse(i))));
Assert.Equal(expected, sequence);
}
public void Map_boolean_switch_creates_boolean_value()
{
// Fixture setup
var tokenPartitions = new[]
{
new KeyValuePair <string, IEnumerable <string> >("x", new [] { "true" })
};
var specProps = new[]
{
SpecificationProperty.Create(
new OptionSpecification("x", string.Empty, false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '\0', Maybe.Nothing <object>(), string.Empty, string.Empty, new List <string>(), typeof(bool), TargetType.Switch, string.Empty),
typeof(Simple_Options).GetProperties().Single(p => p.Name.Equals("BoolValue", StringComparison.Ordinal)),
Maybe.Nothing <object>())
};
// Exercize system
var result = OptionMapper.MapValues(
specProps.Where(pt => pt.Specification.IsOption()),
tokenPartitions,
(vals, type, isScalar) => TypeConverter.ChangeType(vals, type, isScalar, CultureInfo.InvariantCulture, false),
StringComparer.Ordinal
);
// Verify outcome
Assert.NotNull(((Ok <IEnumerable <SpecificationProperty>, Error>)result).Success.Single(
a => a.Specification.IsOption() &&
((OptionSpecification)a.Specification).ShortName.Equals("x") &&
(bool)((Just <object>)a.Value).Value));
// Teardown
}
private ParserResult ParseOptions(IEnumerable <string> arguments, Type targetType)
{
var optionProperties = targetType.GetOptionProperties();
if (optionProperties == null || !optionProperties.Any())
{
throw new InvalidOperationException(
$"The specified type {targetType.Name} does not have any properties marked with {nameof(OptionAttribute)}.");
}
var tokens = Tokenizer.Tokenize(arguments);
if (tokens == null || !tokens.Any())
{
PrintHelpForTypes(new[] { targetType });
return(new NotParsedResult());
}
var pairs = TokenPartitioner.Partition(tokens);
try
{
var newObj = Activator.CreateInstance(targetType);
OptionMapper.Map(optionProperties, pairs, newObj);
return(new ParsedResult(newObj));
}
catch (InvalidOperationException)
{
PrintHelpForTypes(new[] { targetType });
}
return(new NotParsedResult());
}
public void Map_with_multi_instance_scalar()
{
var tokenPartitions = new[]
{
new KeyValuePair <string, IEnumerable <string> >("s", new[] { "string1" }),
new KeyValuePair <string, IEnumerable <string> >("shortandlong", new[] { "string2" }),
new KeyValuePair <string, IEnumerable <string> >("shortandlong", new[] { "string3" }),
new KeyValuePair <string, IEnumerable <string> >("s", new[] { "string4" }),
};
var specProps = new[]
{
SpecificationProperty.Create(
new OptionSpecification("s", "shortandlong", false, string.Empty, Maybe.Nothing <int>(), Maybe.Nothing <int>(), '\0', Maybe.Nothing <object>(), string.Empty, string.Empty, new List <string>(), typeof(string), TargetType.Scalar, string.Empty),
typeof(Simple_Options).GetProperties().Single(p => p.Name.Equals(nameof(Simple_Options.ShortAndLong), StringComparison.Ordinal)),
Maybe.Nothing <object>()),
};
var result = OptionMapper.MapValues(
specProps.Where(pt => pt.Specification.IsOption()),
tokenPartitions,
(vals, type, isScalar, isFlag) => TypeConverter.ChangeType(vals, type, isScalar, isFlag, CultureInfo.InvariantCulture, false),
StringComparer.Ordinal);
var property = result.SucceededWith().Single();
Assert.True(property.Specification.IsOption());
Assert.True(property.Value.MatchJust(out var stringVal));
Assert.Equal(tokenPartitions.Last().Value.Last(), stringVal);
}
public IHttpActionResult GetBodies()
{
var bodies = Connector.GetAllBodies();
var dto = new List <OptionDTO>();
bodies.ForEach(body =>
{
var uri = Url.Link("getBodyImageById", new { id = body.Id });
dto.Add(OptionMapper.optionToDto(body, uri));
});
return(Ok(dto));
}
public IHttpActionResult GetWings()
{
var wings = Connector.GetAllWings();
var dto = new List <OptionDTO>();
wings.ForEach(wing =>
{
var uri = Url.Link("getWingsImageById", new { id = wing.Id });
dto.Add(OptionMapper.optionToDto(wing, uri));
});
return(Ok(dto));
}
public IHttpActionResult GetHats()
{
var hats = Connector.GetAllHats();
var dto = new List <OptionDTO>();
hats.ForEach(hat =>
{
var uri = Url.Link("getHatImageById", new { id = hat.Id });
dto.Add(OptionMapper.optionToDto(hat, uri));
});
return(Ok(dto));
}
public IHttpActionResult GetShoes()
{
var shoes = Connector.GetAllShoes();
var dto = new List <OptionDTO>();
shoes.ForEach(shoe =>
{
var uri = Url.Link("getShoesImageById", new { id = shoe.Id });
dto.Add(OptionMapper.optionToDto(shoe, uri));
});
return(Ok(dto));
}
public void ArePropertiesMappedCorrectly()
{
var optionProperties = typeof(TestClassValid).GetOptionProperties();
var tokens = Tokenizer.Tokenize(TestClassValidArgs);
var keyValuePairs = TokenPartitioner.Partition(tokens);
var obj = new TestClassValid();
OptionMapper.Map(optionProperties, keyValuePairs, obj);
Assert.AreEqual("value1", obj.Option1);
Assert.AreEqual("value2", obj.Option2);
}
public void MapThrowsNullExceptionOnObject()
{
OptionMapper.Map(new List <OptionProperty>(), new List <KeyValuePair <string, string> >(), null);
}
public void MapThrowsNullExceptionOnOptionProperties()
{
OptionMapper.Map(null, new List <KeyValuePair <string, string> >(), new object());
}
/// <summary>
/// Разместить опции
/// </summary>
/// <param name="Base"></param>
/// <param name="Actions"></param>
/// <param name="M"></param>
/// <returns></returns>
public static OptionViewer[] PlaceOptions(Control Base, Options.Option[] Options, OptionMapper M, Action <Options.Option> OnChange)
{
var Opts = new List <OptionViewer>();
M.Reset();
foreach (var O in Options)
{
if (O.GetType() != typeof(OptionHidden))
{
var OV = M.CreateNextControl("", O) as OptionViewer;
OV.Option = O;
// if(O.GetType() == typeof(OptionList))
OV.OnChange += new EventHandler(delegate(Object o, EventArgs a)
{
var Option = (o as OptionViewer).Option;
OnChange(Option);
});
Opts.Add(OV);
Base.Controls.Add(OV);
}
}
return(Opts.ToArray());
}
public VoteServiceImpl(VoteMapper voteMapper, OptionMapper optionMapper, PollMapper pollMapper)
{
this._voteMapper = voteMapper;
this._optionMapper = optionMapper;
this._pollMapper = pollMapper;
}
