internal void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
foreach (ValueItem vi in _parts)
{
vi.PostPrepare(batchDefinition, batchItem);
}
}
internal override object GetValue <TKey>(TagBatchDefinition <TKey> definition, TagBatchInstance <TKey> instance)
{
string s = base.ApplyItems(instance);
//throw new NotImplementedException();
return(CreateValue(s));
}
internal virtual void PrePrepare(TagBatchDefinition batchDefinition)
{
if (_preparedFor != batchDefinition)
{
batchDefinition.Prepared = false;
_preparedFor = null;
}
}
public void CreateBatch()
{
TagEnvironment env = CreateEnvironment();
Assert.That(env, Is.Not.Null);
TagBatchDefinition <string> tbd = new TagBatchDefinition <string>();
tbd.Add("src", "@(ProjectOutput);static1", typeof(ITagItem[]));
tbd.Add("src2", "@(ProjectOutput)", typeof(string[]));
tbd.Add("to", "@(ProjectOutput->'%(FullPath)')", typeof(string));
tbd.Add("info", "%(FileOrigin)", typeof(string));
tbd.AddCondition("if", "'%(FileOrigin)' == 'c:\\work\\app\\bin\\debug'");
int n = 0;
foreach (TagBatchInstance <string> r in env.RunBatch(tbd, false))
{
Assert.That(r, Is.Not.Null);
Assert.That(r["src"], Is.TypeOf(typeof(ITagItem[])));
Assert.That(r["to"], Is.TypeOf(typeof(string)));
Assert.That(r["info"], Is.TypeOf(typeof(string)));
Assert.That(r["if"], Is.TypeOf(typeof(bool)));
switch (n++)
{
case 0:
Assert.That(r["src2"], Has.Some.EqualTo("assembly.dll"));
Assert.That(r["src2"], Has.Some.EqualTo("assembly.pdb"));
Assert.That(r["src2"], Has.Some.EqualTo("en\\assembly.resources.dll"));
Assert.That(r["info"], Is.EqualTo("c:\\work\\app\\bin\\debug"));
Assert.That(r.ConditionResult("if"), "'if' condition true");
Assert.That(r.ConditionResult(), "All conditions true");
foreach (ITagItem ii in (IEnumerable)r["src"])
{
if (ii.ItemSpec == "static1")
{
Assert.That(ii.MetadataCount, Is.EqualTo(0));
}
else
{
Assert.That(ii.MetadataCount, Is.GreaterThan(0));
Assert.That(ii.KeyNames, Has.Some.EqualTo("FileOrigin"));
}
}
break;
case 1:
Assert.That(r["info"], Is.EqualTo("c:\\work\\app"));
Assert.That(r["src2"], Has.All.EqualTo("res.txt"));
Assert.That(r.ConditionResult("if"), Is.False, "If condition false");
Assert.That(r.ConditionResult(), Is.False, "'if' conditions false");
break;
}
}
Assert.That(n, Is.EqualTo(2));
}
internal override void PrePrepare(TagBatchDefinition batchDefinition)
{
base.PrePrepare(batchDefinition);
if (_expression == null)
{
_expression = QQn.TurtleUtils.Tags.ExpressionParser.Parser.Parse(Definition, ConditionArgs);
}
}
public override void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
base.PostPrepare(batchDefinition, batchItem);
foreach (ValueItem vi in _items)
{
vi.PostPrepare(batchDefinition, batchItem);
}
}
internal override void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
base.PostPrepare(batchDefinition, batchItem);
if (Key != null)
{
_parts = batchItem.PrepareString(batchDefinition, Key, _mode);
}
}
protected internal override void PostPrepare(TagBatchDefinition batchDefinition)
{
base.PostPrepare(batchDefinition);
foreach (ValuePart vp in _parts)
{
vp.PostPrepare(batchDefinition, this);
}
}
internal override void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
base.PostPrepare(batchDefinition, batchItem);
if (IsConstraint)
{
batchDefinition.AddConstraint(Item, Key);
}
}
/// <summary>
/// Posts the prepare.
/// </summary>
protected virtual internal void PostPrepare(TagBatchDefinition batchDefinition)
{
if (_items != null)
{
foreach (ValueItem tv in _items)
{
tv.PostPrepare(batchDefinition, this);
}
}
}
internal override object GetValue <TKey>(TagBatchDefinition <TKey> definition, TagBatchInstance <TKey> instance)
{
List <ITagItem> items = new List <ITagItem>();
foreach (ValuePart vp in _parts)
{
vp.ApplyTo(items, instance);
}
return(CreateValue(items));
}
protected internal override void PostPrepare(TagBatchDefinition batchDefinition)
{
base.PostPrepare(batchDefinition);
foreach (TagExpression te in _expression.GetAllLeaveExpressions())
{
DynamicStringExpression dse = te as DynamicStringExpression;
if (dse != null)
{
dse.PostPrepare(batchDefinition, this);
}
}
}
protected internal ValueItem[] PrepareString(TagBatchDefinition batchDefinition, string definition, PrepareMode mode)
{
int lastOffset = 0;
int offset = 0;
List <ValueItem> list = new List <ValueItem>();
List <string> freeConstraints = new List <string>();
string flat = TagExpander.ItemKeyOrPropertyRegex.Replace(definition, delegate(Match match)
{
if (offset > lastOffset)
{
list.Add(new StringValueItem(definition.Substring(lastOffset, offset - lastOffset)));
}
int ofs = match.Index - offset;
offset = match.Index + match.Length;
lastOffset = offset;
Group g, gp, gs;
if (null != (g = match.Groups[TagExpander.RegexGroupItem]) && g.Success)
{
gp = match.Groups[TagExpander.RegexGroupTransform];
gs = match.Groups[TagExpander.RegexGroupSeparator];
batchDefinition.AddUsedItem(this, g.Value);
list.Add(new ItemValueItem(g.Value, gp.Success ? gp.Value : null, gs.Success ? gs.Value : null, mode));
}
else if (null != (g = match.Groups[TagExpander.RegexGroupKey]) && g.Success)
{
gp = match.Groups[TagExpander.RegexGroupItemPrefix];
list.Add(new TagValueItem(gp.Success ? gp.Value : null, g.Value));
}
else if (null != (g = match.Groups[TagExpander.RegexGroupProperty]) && g.Success)
{
list.Add(new PropertyValueItem(g.Value));
}
return("");
});
offset = definition.Length;
if (offset > lastOffset)
{
list.Add(new StringValueItem(definition.Substring(lastOffset, offset - lastOffset)));
}
return(list.ToArray());
}
protected virtual object CreateValue(string value)
{
if (_itemType.IsAssignableFrom(typeof(string)))
{
return(value);
}
else if (_itemType == typeof(ITagItem))
{
return(new StubItem(value));
}
else if (_itemType == TagBatchDefinition.ITaskItemTypeUnsafe)
{
return(TagBatchDefinition.CreateTaskItem("", value));
}
throw new InvalidOperationException();
}
public void PropertyTests()
{
TagPropertyCollection tpc = new TagPropertyCollection();
tpc.LoadEnvironmentVariables();
Assert.That(tpc, Is.All.Not.Null);
Assert.That(tpc["PATH"], Is.Not.Null);
Assert.That(tpc.ExpandProperties("$(Path)"), Is.EqualTo(Environment.GetEnvironmentVariable("PATH")));
Assert.That(TagBatchDefinition.IsTagItemType(typeof(Microsoft.Build.Framework.ITaskItem)), Is.True);
Assert.That(TagBatchDefinition.IsTagItemType(typeof(string)), Is.True);
Assert.That(TagBatchDefinition.IsTagItemType(typeof(ITagItem)), Is.True);
Assert.That(TagBatchDefinition.IsTagItemType(typeof(int)), Is.False);
}
protected internal override void Prepare(TagBatchDefinition batchDefinition, int offset)
{
InitPreparation(batchDefinition, offset);
List <ValuePart> parts = new List <ValuePart>();
foreach (string item in TagExpander.SplitItemList(Definition))
{
ValueItem[] vi = PrepareString(batchDefinition, item, PrepareMode.List);
if (vi.Length == 1)
{
ValueItem v = vi[0];
ItemValueItem ivi;
StringValueItem svi;
if (null != (ivi = v as ItemValueItem))
{
if (string.IsNullOrEmpty(ivi.Separator) || ivi.Separator.Trim() == ";")
{
parts.Add(new ItemValuePart(ivi));
continue;
}
}
else if (null != (svi = v as StringValueItem))
{
// TODO: Shortcut single string value
parts.Add(new ConstantValuePart(svi.Value));
continue;
}
}
parts.Add(new DynamicValuePart(vi));
}
_parts = parts.ToArray();
}
public virtual void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
}
public override void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
base.PostPrepare(batchDefinition, batchItem);
_item.PostPrepare(batchDefinition, batchItem);
}
/// <summary>
/// Prepares the specified batch definition.
/// </summary>
/// <param name="batchDefinition">The batch definition.</param>
/// <param name="offset">The offset.</param>
protected internal virtual void Prepare(TagBatchDefinition batchDefinition, int offset)
{
InitPreparation(batchDefinition, offset);
_items = PrepareString(batchDefinition, Definition, ProvidesList ? PrepareMode.List : PrepareMode.String);
}
internal override object GetValue <TKey>(TagBatchDefinition <TKey> definition, TagBatchInstance <TKey> instance)
{
return(EvaluateCondition(instance));
}
internal virtual void PostPrepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
//throw new NotImplementedException();
}
internal void Prepare(TagBatchDefinition batchDefinition, TagBatchItem batchItem)
{
_parts = batchItem.PrepareString(batchDefinition, Value, PrepareMode.Condition);
}
internal override void PrePrepare(TagBatchDefinition batchDefinition)
{
base.PrePrepare(batchDefinition);
}
internal abstract object GetValue <TKey>(TagBatchDefinition <TKey> definition, TagBatchInstance <TKey> instance)
where TKey : class;
protected void InitPreparation(TagBatchDefinition batchDefinition, int offset)
{
_preparedFor = batchDefinition;
_offset = offset;
}