public void Process(SyntaxNode node)
{
IMetricsDataStore storage = dataProvider.GetDataStore();
var nodeKind = node.Kind();
if (AssignmentSyntax.Contains(nodeKind))
{
IncrementOccurenceCount(AssignmentCount);
}
if (nodeKind == SyntaxKind.EqualsValueClause &&
(node.Parent.IsKind(SyntaxKind.VariableDeclarator) || node.Parent.IsKind(SyntaxKind.PropertyDeclaration))
)
{
IncrementOccurenceCount(AssignmentCount);
}
if (BranchingSyntax.Contains(nodeKind))
{
IncrementOccurenceCount(BranchingCount);
}
if (CallSyntax.Contains(nodeKind))
{
IncrementOccurenceCount(CallCount);
}
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^I go by ([\w/]+)\.?$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var pronouns = await _dataStoreProvider.GetDataStore("Pronouns");
var key = match.Groups[1].Value.ToLowerInvariant();
var pronoun = await pronouns.GetSingle(key);
if (pronoun == null)
{
return(message.Respond($"Sorry, {message.From.Mention}, but I don't know that pronoun yet."));
}
var preferences = await _dataStoreProvider.GetDataStore("PronounPreferences");
await preferences.Add(message.From.Id, pronoun.Key);
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <string> GetValue(string variable, Message context)
{
var variableTypes = await _dataStoreProvider.GetDataStore("VariableTypes");
var match = Regex.Match(variable, @"(.+)(?:(s)|(ed)|(en)|(ing))$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
variable = match.Groups[1].Value;
var type = await variableTypes.GetSingle(variable);
if (type == null)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Variables");
if (match.Groups[2].Success && type.Value == "noun")
{
var noun = await dataStore.GetRandom(variable);
if (noun == null)
{
return(null);
}
return(await _conjugator.Plural(noun.Value));
}
var verb = await dataStore.GetRandom(variable);
if (verb == null)
{
return(null);
}
if (match.Groups[2].Success && type.Value == "verb")
{
return(await _conjugator.ThirdPerson(verb.Value));
}
if (match.Groups[3].Success && type.Value == "verb")
{
return(await _conjugator.Past(verb.Value));
}
if (match.Groups[4].Success && type.Value == "verb")
{
return(await _conjugator.Participle(verb.Value));
}
if (match.Groups[5].Success && type.Value == "verb")
{
return(await _conjugator.Gerund(verb.Value));
}
return(null);
}
public async Task <Response> Respond(Message message)
{
var triggerLength = Int32.Parse(await _config.Get("FactoidTriggerLength", "6"));
if (!message.Addressed && message.Text.Length < triggerLength)
{
return(null);
}
var trigger = message.Text;
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var historyStore = await _dataStoreProvider.GetDataStore("FactoidHistory");
var aliases = new HashSet <string>();
while (true)
{
var reply = await dataStore.GetRandom(trigger);
if (reply == null)
{
return(null);
}
var factoid = ParseFactoid(trigger, reply.Value);
if (factoid.Verb == "alias")
{
if (!aliases.Add(trigger))
{
return(message.Respond("Oh no! There's a factoid that resolves to a circular reference!"));
}
trigger = factoid.Response;
continue;
}
await historyStore.SetSingle(message.Channel, $"(#{reply.Id}) \"{factoid.ToString()}\"");
if (_random.Next(100) > factoid.ChanceToTrigger)
{
return(null);
}
if (factoid.Verb == "reply")
{
return(message.Respond(factoid.Response));
}
if (factoid.Verb == "action")
{
return(message.Respond(factoid.Response, true));
}
return(message.Respond($"{trigger} {factoid.Verb} {factoid.Response}"));
}
}
public void Process(SyntaxNode node)
{
IMetricsDataStore storage = dataProvider.GetDataStore();
if (linesToCount.Contains(node.Kind()))
{
int currentComplexity;
storage.TryGetDataItem <int>(CyclomaticComplexityeData, out currentComplexity);
storage.SetDataItem <int>(CyclomaticComplexityeData, ++currentComplexity);
}
}
public async Task <string> Get(string key, string defaultValue = null)
{
_log.Trace($"Getting config value for {key}");
var dataStore = await _dataStoreProvider.GetDataStore("Config");
var value = (await dataStore.GetAll(key)).FirstOrDefault();
if (value == null)
{
_log.Debug($"No config value set for {key}, defaulting to {defaultValue ?? "null"}");
return(defaultValue);
}
_log.Trace($"Successfully got config value \"{value.Value}\" for {key}");
return(value.Value);
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^delete var ([a-z][a-z0-9_-]*)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Variables");
var variable = match.Groups[1].Value.ToLowerInvariant();
var values = await dataStore.RemoveAll(variable);
if (values == 0)
{
return(message.Respond($"There's no such variable, {message.From.Mention}!"));
}
if (values == 1)
{
return(message.Respond($"Ok, {message.From.Mention}, deleted variable \"{variable}\" and its value."));
}
return(message.Respond($"Ok, {message.From.Mention}, deleted variable \"{variable}\" and its {values} values."));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^add value ([a-z][a-z0-9_-]*) (.+)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Variables");
var variable = match.Groups[1].Value.ToLowerInvariant();
var value = match.Groups[2].Value;
var added = await dataStore.Add(variable, value);
if (!added)
{
return(message.Respond($"I already had it that way, {message.From.Mention}!"));
}
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <string> Dump(string dataStore, string key)
{
var store = await _dataStoreProvider.GetDataStore(dataStore);
var data = await store.GetAll(key);
var subdirName = GetSlug(dataStore);
var directory = Path.Combine(_dataDumpDirectory, subdirName);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var filename = GetSlug(key);
if (String.IsNullOrWhiteSpace(filename))
{
filename = "_";
}
filename = $"{filename}.txt";
var dumpfile = Path.Combine(directory, filename);
await File.WriteAllLinesAsync(dumpfile, data.Select(dsv => dsv.ToFullString()), Encoding.UTF8);
var url = await _config.Get("DataDumpUrl", "http://example.com");
var relative = $"{subdirName}/{filename}";
return(new Uri(new Uri(url), relative).ToString());
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^(.+) (<[^!@>]+>) (.+)$");
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var trigger = match.Groups[1].Value.ToLowerInvariant();
var verb = match.Groups[2].Value.ToLowerInvariant();
var response = match.Groups[3].Value;
if (verb == "alias" && String.Compare(trigger, response, true) == 0)
{
return(message.Respond($"Sorry, {message.From.Mention}, but you can't alias {trigger} to itself."));
}
var added = await dataStore.Add(trigger, $"{verb} {response}");
if (!added)
{
return(message.Respond($"I already knew that, {message.From.Mention}!"));
}
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^literal (.+)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var trigger = match.Groups[1].Value;
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var values = await dataStore.GetAll(trigger);
if (!values.Any())
{
return(message.Respond($"Sorry, {message.From.Mention}, but I don't know about \"{trigger}.\""));
}
if (values.Count() > 10 || values.Sum(x => x.Value.Length) > 500)
{
var url = await _dataDumper.Dump("Factoids", trigger);
return(message.Respond($"{trigger}: {url}"));
}
var result = String.Join(", ", values.Select(x => $"(#{x.Id}) {x.Value}"));
return(message.Respond($"{trigger}: {result}"));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^list var ([a-z][a-z0-9_-]*)", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Variables");
var variable = match.Groups[1].Value.ToLowerInvariant();
var values = await dataStore.GetAll(variable);
if (!values.Any())
{
return(message.Respond($"There's no such variable, {message.From.Mention}!"));
}
if (values.Count() > 10 || values.Sum(x => x.Value.Length) > 500)
{
var url = await _dataDumper.Dump("Variables", variable);
return(message.Respond($"${variable}: {url}"));
}
var list = String.Join(", ", values.Select(v => $"(#{v.Id}) {v.Value}"));
return(message.Respond($"{variable}: {list}"));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^remove value (?:([a-z][a-z0-9_-]*) (.+)|#([0-9]+))$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Variables");
var removed = false;
if (match.Groups[1].Success && match.Groups[2].Success)
{
removed = await dataStore.Remove(match.Groups[1].Value.ToLowerInvariant(), match.Groups[2].Value);
}
else
{
removed = await dataStore.Remove(Int32.Parse(match.Groups[3].Value));
}
if (!removed)
{
return(message.Respond($"There's no such value, {message.From.Mention}!"));
}
return(message.Respond($"Ok, {message.From.Mention}"));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, "^irregular (stem|present|past|participle|gerund|plural) ([a-z][a-z0-9_-]*) (?:=>)?(.+)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var form = match.Groups[1].Value.ToLowerInvariant();
var word = match.Groups[2].Value.ToLowerInvariant();
var conjugation = match.Groups[3].Value.ToLowerInvariant();
var key = $"{word}.{form}";
var dataStore = await _dataStoreProvider.GetDataStore("Irregulars");
var success = await dataStore.SetSingle(key, conjugation);
if (!success)
{
return(message.Respond($"Sorry, {message.From.Mention}, something went wrong."));
}
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <Response> Handle(Message message)
{
var match = _commandRegex.Match(message.Text);
if (!match.Success)
{
return(null);
}
var inventory = await _dataStoreProvider.GetDataStore("Inventory");
var items = (await inventory.GetAll("CurrentInventory"))
.Select(item => item.Value)
.ToList();
if (items.Count == 0)
{
return(message.Respond("I have nothing."));
}
if (items.Count == 1)
{
return(message.Respond($"I have {items.Single()}."));
}
if (items.Count == 2)
{
return(message.Respond($"I have {items.First()} and {items.Last()}."));
}
return(message.Respond(
$"I have {string.Join(", ", items.Take(items.Count - 1))}, and {items.Last()}."
));
}
public async Task Listen(Message message)
{
var chance = Int32.Parse(await _config.Get("PercentChanceOfPassiveFactoid", "10"));
if (_random.Next(100) > chance)
{
return;
}
var match = Regex.Match(message.Text, @"^(.{0,42})\s+(is(?: also)?|are)\s+([^?]+)", RegexOptions.IgnoreCase);
if (!match.Success)
{
return;
}
_log.Debug("Someone said a factoid!");
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var trigger = match.Groups[1].Value;
var verb = match.Groups[2].Value;
var tidbit = match.Groups[3].Value;
await dataStore.Add(trigger, $"<{verb}> {tidbit}");
}
private async Task <string> GetPronoun(PartOfSpeech partOfSpeech, Message context)
{
var history = await _dataStoreProvider.GetDataStore("PersonHistory");
var lastKnown = (await history.GetAll(context.Channel)).FirstOrDefault()?.Value;
var preferences = await _dataStoreProvider.GetDataStore("PronounPreferences");
var pronouns = await _dataStoreProvider.GetDataStore("Pronouns");
var gender = lastKnown != null ? (await preferences.GetRandom(lastKnown))?.Value ?? "they" : "they";
var list = (await pronouns.GetSingle(gender))?.Value ?? "they;them;their;theirs;themself";
return(list.Split(';') [(int)partOfSpeech]);
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^what was that\??$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("FactoidHistory");
var lastFactoid = (await dataStore.GetAll(message.Channel)).FirstOrDefault();
if (lastFactoid == null)
{
return(message.Respond("¯\\_(ツ)_/¯"));
}
return(message.Respond($"{message.From.Mention}, that was {lastFactoid.Value}"));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^add pronoun ([a-z\/]+): ((?:\w+(?:[;,\s\/]+\b|$)){5})$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Pronouns");
var identifier = match.Groups[1].Value.ToLowerInvariant();
if ((await dataStore.GetSingle(identifier)) != null)
{
return(message.Respond($"I'm sorry, {message.From.Mention}, but I already know some pronouns for {identifier}."));
}
var pronouns = Regex.Split(match.Groups[2].Value.ToLowerInvariant(), @"[;,\s\/]+");
await dataStore.SetSingle(identifier, String.Join(";", pronouns));
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^var ([a-z][a-z0-9_-]*) (?:(?:is (?:a|type))|type) (var|verb|noun)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var variable = match.Groups[1].Value.ToLowerInvariant();
var type = match.Groups[2].Value.ToLowerInvariant();
var dataStore = await _dataStoreProvider.GetDataStore("VariableTypes");
var success = await dataStore.SetSingle(variable, type);
if (!success)
{
return(message.Respond($"Sorry, {message.From}, I'm afraid I can't do that."));
}
return(message.Respond($"Ok, {message.From}."));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^quote (\S+)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var target = match.Groups[1].Value;
var person = await _personProvider.GetPersonByName(message.Channel, target);
if (person == null)
{
return(message.Respond($"Sorry, {message.From.Mention}, I don't know anyone named \"{target}.\""));
}
var quoteStore = await _dataStoreProvider.GetDataStore("Quotes");
var quote = await quoteStore.GetRandom(person.Id);
if (quote == null)
{
return(message.Respond($"Sorry, {person.Name} has not said anything quote-worthy yet."));
}
return(message.Respond($"<{person.Name}> {quote.Value}"));
}
public async Task <string> GetValue(string variable, Message context)
{
var match = Regex.Match(variable, @"(?:band|tla)", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("BandNames");
return((await dataStore.GetRandom())?.Value);
}
public async Task <string> GetValue(string variable, Message context)
{
var match = Regex.Match(variable, @"(?:(who)|(to)|(someone))", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("PersonHistory");
if (match.Groups[1].Success)
{
await dataStore.SetSingle(context.Channel, context.From.Id);
return(context.From.Name);
}
if (match.Groups[2].Success)
{
// We need to handle this differently since the message might be
// addressed to something or someone that isn't a known person.
Person to = null;
if (context.To != null)
{
to = await _personProvider.GetPersonByName(context.Channel, context.To);
if (to == null)
{
await dataStore.SetSingle(context.Channel, context.To);
return(context.To);
}
}
to = to ?? await GetSomeone(context.Channel) ?? context.From;
await dataStore.SetSingle(context.Channel, to.Id);
return(to.Name);
}
if (match.Groups[3].Success)
{
var someone = await GetSomeone(context.Channel) ?? context.From;
await dataStore.SetSingle(context.Channel, someone.Id);
return(someone.Name);
}
return(null);
}
public override async Task Initialize()
{
var dataStore = await _dataStoreProvider.GetDataStore("Pronouns");
var keys = await dataStore.GetAllKeys();
if (keys.Any())
{
return;
}
// Seed data
await Task.WhenAll(_seedData.Select(kvp => dataStore.Add(kvp.Key, kvp.Value)));
}
public async Task <Response> Respond(Message message)
{
var match = Regex.Match(message.Text, @"^([a-z]\w*)\s+([a-z]\w*)\s+([a-z]\w*)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var bandChance = Int32.Parse(await _config.Get("PercentChanceOfBandName", "5"));
if (_random.Next(0, 100) > bandChance)
{
return(null);
}
var bandNameDataStore = await _dataStoreProvider.GetDataStore("BandNames");
var words = new [] { match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value };
var expanded = String.Join(" ", words);
var tla = String.Concat(words.Select(x => x.First())).ToUpperInvariant();
if (!await bandNameDataStore.Add(tla, expanded))
{
return(null);
}
var factoids = await _dataStoreProvider.GetDataStore("Factoids");
var reply = (await factoids.GetRandom("band name reply"))?.Value ?? "\"$band\" would be a cool name for a band.";
reply = reply.Replace("<reply> ", "");
reply = Regex.Replace(reply, @"\$(?:band|tla)", expanded, RegexOptions.IgnoreCase);
return(message.Respond(reply));
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^(.+) (<[^!@>]+>) (.+)$");
if (!match.Success)
{
return(null);
}
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var trigger = match.Groups[1].Value.ToLowerInvariant();
var verb = match.Groups[2].Value.ToLowerInvariant();
var percentMatch = Regex.Match(verb, @"\|(?!.*\|)(.*?)%>$");
if (percentMatch.Success)
{
decimal chanceToTrigger;
if (!Decimal.TryParse(percentMatch.Groups[1].Value, out chanceToTrigger))
{
return(message.Respond($"Sorry, {message.From.Mention}, but {verb} is not properly formatted."));
}
if (chanceToTrigger <= 0 || chanceToTrigger > 100)
{
return(message.Respond($"Sorry, {message.From.Mention}, but {verb} does not contain a valid percentage."));
}
}
var response = match.Groups[3].Value;
if (verb == "<alias>" && String.Compare(trigger, response, true) == 0)
{
return(message.Respond($"Sorry, {message.From.Mention}, but you can't alias {trigger} to itself."));
}
var added = await dataStore.Add(trigger, $"{verb} {response}");
if (!added)
{
return(message.Respond($"I already knew that, {message.From.Mention}!"));
}
return(message.Respond($"Ok, {message.From.Mention}."));
}
public async Task <Response> Respond(Message message)
{
var item = GetItem(message);
if (item == null)
{
return(null);
}
var inventory = await _dataStoreProvider.GetDataStore("Inventory");
var items = (await inventory.GetAll("CurrentInventory")).ToList();
if (await inventory.Contains("CurrentInventory", item))
{
// already exists
return(await FactoidResponse(message, "duplicate item", "I already have $item.", ("item", item)));
}
Response response = null;
var limit = Int32.Parse(await _config.Get("InventoryLimit", "10"));
if (await inventory.GetCount("CurrentInventory") >= limit)
{
// drop something
var dropped = await inventory.GetRandom("CurrentInventory");
if (dropped != null) // beware race conditions
{
await inventory.Remove(dropped.Id);
response = await FactoidResponse(message, "drops item", "I take $newitem and drop $giveitem.", ("newitem", item), ("giveitem", dropped.Value));
}
}
await inventory.Add("CurrentInventory", item);
if (!await inventory.Contains("History", item))
{
await inventory.Add("History", item);
}
if (response == null)
{
response = await FactoidResponse(message, "takes item", "I now have $item.", ("item", item));
}
return(response);
}
public async Task Listen(Message message)
{
var match = Regex.Match(message.Text, @"^(.{0,42})\s+(is(?: also)?|are)\s+(.+)", RegexOptions.IgnoreCase);
if (!match.Success)
{
return;
}
var dataStore = await _dataStoreProvider.GetDataStore("Factoids");
var trigger = match.Groups[1].Value;
var verb = match.Groups[2].Value;
var tidbit = match.Groups[3].Value;
await dataStore.Add(trigger, $"<{verb}> {tidbit}");
}
public override async Task Initialize()
{
var bandNameChance = await _config.Get("PercentChanceOfBandName");
if (bandNameChance == null)
{
await _config.Set("PercentChanceOfBandName", "5");
}
var factoids = await _dataStoreProvider.GetDataStore("Factoids");
var values = await factoids.GetAll("band name reply");
if (!values.Any())
{
await factoids.Add("band name reply", "<reply> \"$band\" would be a cool name for a band.");
}
}
public async Task <Response> Handle(Message message)
{
if (!message.Addressed)
{
return(null);
}
var match = Regex.Match(message.Text, @"^remember (\S+) (.+)$", RegexOptions.IgnoreCase);
if (!match.Success)
{
return(null);
}
var target = match.Groups[1].Value;
var search = match.Groups[2].Value;
var person = await _personProvider.GetPersonByName(message.Channel, target);
if (person == null)
{
return(message.Respond($"Sorry, {message.From.Mention}, I don't know anyone named \"{target}.\""));
}
if (person.Id == message.From.Id)
{
return(message.Respond($"Sorry, {message.From.Mention}, but you can't quote yourself."));
}
var history = await message.Messenger.GetMessageHistory(message.Channel);
var matchingMessage = history.Where(x => x.From.Id == person.Id && x.Text.IndexOf(search, 0) > -1).FirstOrDefault();
if (matchingMessage == null)
{
return(message.Respond($"Sorry, {message.From.Mention}, I don't remember what {target} said about \"{search}.\""));
}
var quoteStore = await _dataStoreProvider.GetDataStore("Quotes");
await quoteStore.Add(person.Id, matchingMessage.Text);
return(message.Respond($"You got it, {message.From.Mention}."));
}
