public void ReadsCorrectValue()
{
var parser = new TagParser();
var tag = parser.Parse("GENRE=this");
Assert.Equal("GENRE", tag.TagName);
Assert.Equal("this", tag.Value);
}
public void ShouldThrow_WhenCurrentCharIsIncorrect()
{
//Move cursor on char 't' after the /.
stream.Next();
TagParser parser = new TagParser(stream);
Assert.Catch <InvalidOperationException>(() => parser.Parse());
}
public void SetUp()
{
_strategy = A.Fake <ITagParserStrategy>();
A.CallTo(() => _strategy.Tag).Returns(TagName);
_parser = new TagParser(new List <ITagParserStrategy> {
_strategy
});
}
public void AcceptsEmptyValue()
{
var parser = new TagParser();
var tag = parser.Parse("GENRE=");
Assert.Equal("GENRE", tag.TagName);
Assert.Equal("", tag.Value);
}
public override void Execute(FreneticScript.CommandSystem.CommandQueue queue, CommandEntry entry)
{
try
{
LocationTag loc = LocationTag.For(entry.GetArgument(queue, 1));
if (loc == null)
{
queue.HandleError(entry, "Invalid location!");
return;
}
EntityTag entity = EntityTag.For(entry.GetArgumentObject(queue, 0));
if (entity == null)
{
queue.HandleError(entry, "Invalid entity!");
return;
}
PlayerTag player;
if (entity.TryGetPlayer(out player))
{
player.Internal.player.gameObject.AddComponent <LaunchComponent>().LaunchPlayer(loc.ToVector3());
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully launched player " + TagParser.Escape(player.ToString()) + " to " + TagParser.Escape(loc.ToString()) + "!");
}
return;
}
ZombieTag zombie;
if (entity.TryGetZombie(out zombie))
{
zombie.Internal.gameObject.AddComponent <LaunchComponent>().Launch(loc.ToVector3());
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully launched zombie " + TagParser.Escape(zombie.ToString()) + " to " + TagParser.Escape(loc.ToString()) + "!");
}
return;
}
AnimalTag animal;
if (entity.TryGetAnimal(out animal))
{
animal.Internal.gameObject.AddComponent <LaunchComponent>().Launch(loc.ToVector3());
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully launched animal " + TagParser.Escape(animal.ToString()) + " to " + TagParser.Escape(loc.ToString()) + "!");
}
return;
}
ItemEntityTag item;
if (entity.TryGetItem(out item))
{
// TODO: Find some way to teleport items, barricades, etc without voiding the InstanceID?
}
queue.HandleError(entry, "That entity can't be launched!");
}
catch (Exception ex) // TODO: Necessity?
{
queue.HandleError(entry, "Failed to launch entity: " + ex.ToString());
}
}
public override void Execute(FreneticScript.CommandSystem.CommandQueue queue, CommandEntry entry)
{
PlayerTag player = PlayerTag.For(entry.GetArgument(queue, 0));
if (player == null)
{
queue.HandleError(entry, "Invalid player!");
return;
}
ItemAssetTag item = ItemAssetTag.For(entry.GetArgument(queue, 1));
if (item == null)
{
queue.HandleError(entry, "Invalid item!");
return;
}
byte amount = 1;
if (entry.Arguments.Count > 2)
{
amount = (byte)Utilities.StringToUInt(entry.GetArgument(queue, 2));
}
PlayerInventory inventory = player.Internal.player.inventory;
byte remainingAmount = amount;
InventorySearch search;
while (remainingAmount > 0 && (search = inventory.has(item.Internal.id)) != null) // TODO: Less awkward code!?
{
if (search.jar.item.amount <= remainingAmount)
{
inventory.removeItem(search.page, inventory.getIndex(search.page, search.jar.x, search.jar.y));
remainingAmount -= search.jar.item.amount;
}
else
{
inventory.sendUpdateAmount(search.page, search.jar.x, search.jar.y, (byte)(search.jar.item.amount - remainingAmount));
remainingAmount = 0;
}
}
if (remainingAmount == 0)
{
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully took " + amount + " " + TagParser.Escape(item.Internal.name) + "!");
}
}
else if (remainingAmount < amount)
{
if (entry.ShouldShowGood(queue))
{
entry.Good(queue, "Successfully took " + (amount - remainingAmount) + " " + TagParser.Escape(item.Internal.name) + "! (" + remainingAmount + " more not found!)");
}
}
else
{
queue.HandleError(entry, "Failed to take item (does the inventory contain any?)!");
}
}
public static async Task <string> FetchLyrics(Mediafile file, string lyricSource)
{
var mediaFile = new Mediafile();
mediaFile.Title = TagParser.ParseTitle(file.Title.ToString());
if (mediaFile.Title == null)
{
return(null);
}
var cleanedArtist = TagParser.ParseTitle(file.LeadArtist.ToString());
List <string> parsedArtists = TagParser.ParseArtists(cleanedArtist);
if (string.IsNullOrEmpty(cleanedArtist))
{
cleanedArtist = file.Title;
parsedArtists = TagParser.ParseArtists(cleanedArtist);
parsedArtists.RemoveAt(0);
}
mediaFile.LeadArtist = !parsedArtists.Any() ? file.LeadArtist : TagParser.ParseTitle(parsedArtists[0]);
if (mediaFile.LeadArtist == null || mediaFile.LeadArtist.Equals("Unknown Artist", System.StringComparison.CurrentCultureIgnoreCase))
{
return(null);
}
string Lyrics = "";
switch (lyricSource)
{
case "Auto":
for (int i = 0; i < Sources.Length; i++)
{
var lrc = await Sources[i].FetchLyrics(mediaFile).ConfigureAwait(false);
if (LrcParser.IsLrc(lrc))
{
Lyrics = lrc;
break;
}
}
break;
case "Musixmatch":
Lyrics = await Sources[0].FetchLyrics(mediaFile).ConfigureAwait(false);
break;
case "Netease":
Lyrics = await Sources[1].FetchLyrics(mediaFile).ConfigureAwait(false);
break;
case "Baidu":
Lyrics = await Sources[3].FetchLyrics(mediaFile).ConfigureAwait(false);
break;
case "Xiami":
Lyrics = await Sources[2].FetchLyrics(mediaFile).ConfigureAwait(false);
break;
}
return(Lyrics);
}
public void TryParseDbUShortWithoutLength()
{
Assert.True(TagParser.TryParseTag("DB1.10000,w", out var result));
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(10000, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(ushort), result.ResultType);
Assert.Equal(typeof(ushort), result.VarType);
}
public void TryParseDbBitWithLength()
{
Assert.True(TagParser.TryParseTag("DB1.10000,x0,1", out var result));
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(80000, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(bool), result.ResultType);
Assert.Equal(typeof(bool), result.VarType);
}
public void TryParseDbCharWithSpecificLength()
{
Assert.True(TagParser.TryParseTag("DB1.10000,c,10", out var result));
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(10000, result.Offset);
Assert.Equal(10, result.Length);
Assert.Equal(typeof(char[]), result.ResultType);
Assert.Equal(typeof(char), result.VarType);
}
public void TokenShouldHaveHaveStartIndexHasIndex()
{
TagParser parser = new TagParser(stream);
TokenIndex startIndex = parser.Index;
TagToken token = parser.Parse();
Assert.AreEqual(startIndex.Index, token.Index.Index);
}
public void TryParseInputBitWithoutLength()
{
Assert.True(TagParser.TryParseTag("I.1910,x3", out var result));
Assert.Equal(PlcArea.IB, result.Area);
Assert.Equal(15283, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(bool), result.ResultType);
Assert.Equal(typeof(bool), result.VarType);
}
public override void Execute(CommandQueue queue, CommandEntry entry)
{
if (entry.Arguments.Count < 1)
{
ShowUsage(queue, entry);
return;
}
entry.Good(queue, "'<{color.emphasis}>" + TagParser.Escape(entry.GetArgument(queue, 0)) + "<{color.base}>' to you as well from " + ThePlugin.Name + "!");
}
public async Task <PagedQueryResult <ImageAssetSummary> > ExecuteAsync(SearchImageAssetSummariesQuery query, IExecutionContext executionContext)
{
IQueryable <ImageAsset> dbQuery = _dbContext
.ImageAssets
.AsNoTracking()
.Include(i => i.Creator)
.Include(i => i.Updater)
.Include(i => i.ImageAssetTags)
.ThenInclude(i => i.Tag);
// Filter by tags
if (!string.IsNullOrEmpty(query.Tags))
{
var tags = TagParser.Split(query.Tags).ToList();
foreach (string tag in tags)
{
// See http://stackoverflow.com/a/7288269/486434 for why this is copied into a new variable
string localTag = tag;
dbQuery = dbQuery.Where(p => p.ImageAssetTags
.Select(t => t.Tag.TagText)
.Contains(localTag)
);
}
}
// Filter Dimensions
if (query.Height > 0)
{
dbQuery = dbQuery.Where(p => p.HeightInPixels == query.Height);
}
else if (query.MinHeight > 0)
{
dbQuery = dbQuery.Where(p => p.HeightInPixels >= query.MinHeight);
}
if (query.Width > 0)
{
dbQuery = dbQuery.Where(p => p.WidthInPixels == query.Width);
}
else if (query.MinWidth > 0)
{
dbQuery = dbQuery.Where(p => p.WidthInPixels >= query.MinWidth);
}
var dbPagedResults = await dbQuery
.OrderByDescending(p => p.CreateDate)
.ToPagedResultAsync(query);
var mappedResults = dbPagedResults
.Items
.Select(_imageAssetSummaryMapper.Map)
.ToList();
return(dbPagedResults.ChangeType(mappedResults));
}
private static void ExtractStepInfo(Guide aGuide, Step aStep, string aFileContents, string aStepDirectory)
{
aStep.IsValid = true;
bool validTitleFound = false;
bool validStepNumberFound = false;
bool wasNewLine = true;
for (int index = 0; index < aFileContents.Length; index++)
{
var character = aFileContents[index];
if (wasNewLine && character == '#')
{
continue;
}
wasNewLine = character == '\r' || character == '\n';
if (TagParser.ParseTag(aFileContents, ref index, out var tag, out var tagContent, out var attributes, isIncrementIndex: true))
{
if (SimpleTags.IsTag(SimpleTags.Tag.Title, tag))
{
aStep.Title = SimpleTags.GetContent <string>(tagContent);
validTitleFound = !string.IsNullOrEmpty(aStep.Title);
}
else if (SimpleTags.IsTag(SimpleTags.Tag.Image, tag))
{
ClassEnum classEnum = ClassEnum.All;
if (attributes.ContainsKey("class")) //TODO make hard reference
{
classEnum = SimpleTags.GetContent <ClassEnum>(attributes["class"]);
}
aStep.ImageSources[classEnum] = Path.Combine(aStepDirectory, SimpleTags.GetContent <string>(tagContent));
}
else if (SimpleTags.IsTag(SimpleTags.Tag.StepNumber, tag))
{
aStep.StepNumber = SimpleTags.GetContent <int>(tagContent);
validStepNumberFound = true;
}
else if (SimpleTags.IsTag(SimpleTags.Tag.SubStep, tag))
{
SubStep subStep = SubStep.Parse(aGuide, aStep, attributes, tagContent);
if (subStep.IsValid)
{
aStep.SubSteps.Add(subStep);
}
}
}
}
aStep.ValidateImageSources();
if (!validTitleFound || !validStepNumberFound)
{
aStep.IsValid = false;
}
}
public void FrameParsing()
{
var parser = new TagParser("<ar><ti>");
var expect = new List <FrameType>()
{
FrameType.Artist, FrameType.Title
};
CollectionAssert.AreEquivalent(expect, parser.GetTags());
}
public void ShouldReturnFalseWhenCallingCanParseAndTheNextTokenIsNotADotHashOrWord()
{
var tokens = new Mock <TokenStream>(Enumerable.Empty <StringToken>());
tokens.Setup(t => t.Current).Returns(new StringToken(TokenType.QuotedString, 1, 1, 1));
var tagParser = new TagParser();
Assert.IsFalse(tagParser.CanParse(tokens.Object));
}
public void ShouldReturnTrueWhenCallingCanParseAndAWordIsTheNextToken()
{
var tokens = new Mock <TokenStream>(Enumerable.Empty <StringToken>());
tokens.Setup(t => t.Current).Returns(new StringToken(TokenType.Word, 1, 1, 1));
var tagParser = new TagParser();
Assert.IsTrue(tagParser.CanParse(tokens.Object));
}
protected override void OnNewIntent(Intent intent)
{
base.OnNewIntent(intent);
var alert = new AlertDialog.Builder(this).Create();
string tagId = TagParser.GetTagId(intent);
alert.SetMessage("Tag Id: " + tagId);
alert.SetTitle("NFC");
alert.Show();
}
public void ParseDbBitWithLength()
{
var result = TagParser.ParseTag("DB1.10000,x0,1");
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(80000, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(bool), result.ResultType);
Assert.Equal(typeof(bool), result.VarType);
}
public void ShouldThrowError_WhenTheSecondCharIsNot_Letter()
{
ParseStream parseStream = new ParseStream("/1ab");
TagParser parser = new TagParser(parseStream);
UnexpectedTokenException ex = Assert.Throws <UnexpectedTokenException>(() => parser.Parse());
Assert.AreEqual(1, ex.TokenIndex.Index);
Assert.AreEqual('1', ex.Character);
}
public void ParseDbShortWithoutLength()
{
var result = TagParser.ParseTag("DB1.10000,i");
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(10000, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(short), result.ResultType);
Assert.Equal(typeof(short), result.VarType);
}
public void ParseDbUIntWithLength()
{
var result = TagParser.ParseTag("DB1.10000,dw,1");
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(10000, result.Offset);
Assert.Equal(1, result.Length);
Assert.Equal(typeof(uint), result.ResultType);
Assert.Equal(typeof(uint), result.VarType);
}
public void ParseDbIntWithSpecificLength()
{
var result = TagParser.ParseTag("DB1.10000,di,10");
Assert.Equal(PlcArea.DB, result.Area);
Assert.Equal(10000, result.Offset);
Assert.Equal(10, result.Length);
Assert.Equal(typeof(int[]), result.ResultType);
Assert.Equal(typeof(int), result.VarType);
}
public void OneTagValueParsing()
{
var expect = "artist";
var parser = new TagParser("<ar>");
var frames = parser.GetTagsValue(expect);
Assert.AreEqual(1, frames.Count);
Assert.AreEqual(expect, frames[FrameType.Artist]);
}
public void Create(string codeText, string value, string tagName, int index)
{
ParseStream parseStream = new ParseStream(codeText);
TagParser parser = new TagParser(parseStream);
TagToken token = parser.Parse();
Assert.AreEqual(value, token.Value);
Assert.AreEqual(tagName, token.TagName);
Assert.AreEqual(index, parseStream.Index.Index);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(TextBox.Text))
{
return;
}
Node rootNode = TagParser.Parse(TextBox.Text);
Tree.ItemsSource = ConverToViewModels(rootNode);
}
public void ShouldUseTheWordAsTheTagWhenCallingParseAndTheFirstTokenIsAWord()
{
var tokens = new Mock <TokenLine>((IEnumerable <StringToken>) new[] { new StringToken(TokenType.Word, 1, 1, 1, "hello") });
tokens.CallBase = true;
var tagParser = new TagParser();
var tag = tagParser.Parse(tokens.Object) as JTag;
Assert.AreEqual("hello", tag.Tag);
}
/// <summary>
/// Initializes a new instance of the <see cref="TemplateParser"/> class
/// </summary>
/// <param name="p">The <see cref="TagParser"/>.</param>
/// <param name="ts">The collection of tokens.</param>
public TemplateParser(TagParser p, Token[] ts)
: base()
{
if (ts == null)
{
throw new ArgumentNullException("\"ts\" cannot be null.");
}
this.tagParser = p;
this.tokens = ts;
Reset();
}
public string ComponentString()
{
StringBuilder sb = new StringBuilder();
sb.Append("{");
foreach (ItemStackBase itb in Components)
{
sb.Append(TagParser.Escape(itb.ToString()) + ";");
}
sb.Append("}");
return(sb.ToString());
}
private void Dispose(bool bDisposing)
{
if(!bDisposed)
{
bDisposed=true;
if(oChunk!=null)
{
oChunk.Dispose();
oChunk=null;
}
if(sText!=null)
{
sText.Dispose();
sText=null;
}
bHTML=null;
if(oE!=null)
{
oE.Dispose();
oE=null;
}
if(oTP!=null)
{
oTP.Dispose();
oTP=null;
}
}
}
