public SolutionGraph(IEnumerable<Solution> solutions)
{
_allNugets = new Lazy<IEnumerable<NugetSpec>>(() => _solutions.SelectMany(x => x.PublishedNugets).ToList());
solutions.Each(s => _solutions[s.Name] = s);
solutions.Each(s => s.DetermineDependencies(FindNugetSpec));
_orderedSolutions = new Lazy<IList<Solution>>(() =>
{
var graph = new DependencyGraph<Solution>(s => s.Name, s => s.SolutionDependencies().Select(x => x.Name));
solutions.Each(graph.RegisterItem);
return graph.Ordered().ToList();
});
}
public SerializationContext Create(IEnumerable <DataRepository> dataRepositories = null, IEnumerable <IWithId> externalReferences = null)
{
var projectRetriever = _container.Resolve <IPKSimProjectRetriever>();
var project = projectRetriever.Current;
//do not use the pksim repository since we need to register the deserialized object afterwards
//this repository is only used to resolve the references
var withIdRepository = new WithIdRepository();
externalReferences?.Each(withIdRepository.Register);
var allRepositories = new List <DataRepository>();
if (project != null)
{
allRepositories.AddRange(project.All <IndividualSimulation>()
.Where(s => s.HasResults)
.Select(s => s.DataRepository)
.Union(project.AllObservedData));
}
if (dataRepositories != null)
{
allRepositories.AddRange(dataRepositories);
}
allRepositories.Each(withIdRepository.Register);
return(SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, withIdRepository, _cloneManagerForModel, allRepositories));
}
public static FileInclusionPolicy CreateInclusionPolicy(IEnumerable<string> excludes = null, IEnumerable<string> includes = null)
{
var policy = new FileInclusionPolicy();
if (excludes != null) excludes.Each(policy.AddExclude);
if(includes != null) includes.Each(policy.AddInclude);
return policy;
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
ReadScriptConfig(FubuMvcPackageFacility.GetApplicationPath(), log);
packages.Each(p => p.ForFolder(BottleFiles.WebContentFolder, folder => ReadScriptConfig(folder, log)));
_assets.CompileDependencies(log);
}
public static Type GenerateType(Type baseType, IEnumerable<Type> interfaceTypes)
{
var newType = dynamicModule.DefineType(
Prefix + "." + baseType.GetName(),
TypeAttributes.AutoLayout | TypeAttributes.Public | TypeAttributes.Class,
baseType);
interfaceTypes.Each(interfaceType =>
{
newType.AddInterfaceImplementation(interfaceType);
interfaceType.GetMethods().Each(method =>
{
ImplementInterfaceMethod(newType, method);
});
});
baseType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Each(constructor =>
{
switch (constructor.Attributes & MethodAttributes.MemberAccessMask)
{
case MethodAttributes.Family:
case MethodAttributes.Public:
case MethodAttributes.FamORAssem:
ImplementConstructor(newType, constructor);
break;
}
});
return newType.CreateType();
}
public FubuMvcContext(IFubuMvcSystem system)
{
_system = system;
_contextualProviders = system.ContextualProviders ?? new IContextualInfoProvider[0];
_contextualProviders.Each(x => x.Reset());
}
public void EachWithFunc( IEnumerable<object> sut )
{
var copy = sut.ToList();
Func<object, bool> action = copy.Remove;
var results = sut.Each( action );
Assert.All( results, b => b.IsFalse( () => { throw new InvalidOperationException( "was not true." ); } ) );
}
public IEnumerable<IActivator> Bootstrap(IPackageLog log)
{
_services = _inner.Bootstrap(log).Select(x => new BottleService(x, log));
_services.Each(x => x.Start());
return new IActivator[0];
}
public ThreadSafeLocaleCache(CultureInfo culture, IEnumerable<LocalString> strings)
{
_data = new Dictionary<LocalizationKey, string>();
strings.Each(s => _data.Add(new LocalizationKey(s.value), s.display));
_culture = culture;
}
public void Report(IEnumerable<SuiteRunResult> executed)
{
var totalPasses = executed.Sum(x => x.Passes);
var totalFailures = executed.Sum(x => x.Failures);
var total = totalPasses + totalFailures;
_output.WriteLine("Loaded: {0}".FormatWith(executed.Select(s => s.Name).Join(", ")));
_output.WriteLine(" {0} {1} loaded.".FormatWith(
total,
"test".Pluralize(total)));
_output.WriteLine(" {0}/{1} {2} passed ({3} {4}).".FormatWith(
totalPasses,
total,
"test".Pluralize(total),
totalFailures,
"failure".Pluralize(totalFailures)));
if (totalFailures > 0)
_output.WriteLine("Failures: ");
executed.Each(suiteResult => suiteResult
.Results
.Where(containerResult => containerResult.Results.Any(r => !r.Pass))
.Each(f =>
{
_output.WriteLine(" {0}.{1} contained {2} failures.".FormatWith(suiteResult.Name, f.Name, f.Failures));
f.Results.Where(r => !r.Pass).Each(r => _output.WriteLine(" {0} failed. [{1}]".FormatWith(r.Name, r.Message)));
}));
_output.Flush();
}
public void Each( IEnumerable<object> sut )
{
var count = 0;
Action<object> action = o => count++;
sut.Each( action );
Assert.Equal( sut.Count(), count );
}
public AggregateResult(IEnumerable<GameResult> results)
{
_playerToScoreMap = new Dictionary<BotPlayer, int>();
results.SelectMany(x => x.Players).Each(x => _playerToScoreMap[x] = 0);
results.Each(result =>
{
if (result.IsTie)
{
result.Players.Each(player =>
{
_playerToScoreMap[player]++;
});
}
else
{
_playerToScoreMap[result.Winner] += 3;
}
});
var winners = _playerToScoreMap.GroupBy(x => x.Value).OrderByDescending(x => x.Key).First();
if (winners.Count() == _playerToScoreMap.Count)
{
IsTie = true;
}
else
{
Winner = winners.First().Key;
}
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
var provider = new FileSystemVirtualPathProvider();
HostingEnvironment.RegisterVirtualPathProvider(provider);
packages.Each(x => x.ForFolder(FubuMvcPackages.WebContentFolder, provider.RegisterContentDirectory));
}
public void Discard(IEnumerable<Card> cards)
{
cards.Each(card =>
{
RemoveCardFromDeck(card);
Player.AddToDiscard(card);
});
}
public void Draw(IEnumerable<Card> cards)
{
cards.Each(card =>
{
RemoveCardFromDeck(card);
Player.AddCardToHand(card);
});
}
protected override void applyBufferingToChildSectionLines(IEnumerable<Line> sectionLines, int index)
{
if (isSubsequentLine(index))
{
var buffer = (Convert.ToChar(9475).ToString() + " ").PadLeft(_tabWidth);
sectionLines.Each(x => x.Prepend(buffer));
}
}
public void RunAssemblies(IEnumerable<Assembly> assemblies)
{
var map = new Dictionary<Assembly, IEnumerable<Context>>();
assemblies.Each(assembly => map.Add(assembly, _explorer.FindContextsIn(assembly)));
StartRun(map);
}
public void RunAssemblies(IEnumerable<Assembly> assemblies)
{
_internalListener.OnRunStart();
assemblies.Each(x => InternalRunAssembly(x));
_internalListener.OnRunEnd();
}
public static string Visualize(this IFubuPage page, IEnumerable<BehaviorNode> nodes)
{
var builder = new StringBuilder();
nodes.Each(x => builder.Append(page.Visualize(x)));
return builder.ToString();
}
public FubuMvcContext(IApplicationUnderTest application, BindingRegistry binding, IEnumerable<IContextualInfoProvider> contextualProviders )
{
_application = application;
_binding = binding;
_contextualProviders = contextualProviders ?? new IContextualInfoProvider[0];
_contextualProviders.Each(x => x.Reset());
}
public ServiceGroupTag(string title, IEnumerable<Description> descriptions) : base(Guid.NewGuid().ToString(), title)
{
descriptions.Each(x =>
{
var titleTag = new HtmlTag("div").AddClass("service-title").Text(x.Title);
AppendContent(titleTag);
AppendContent(new DescriptionBodyTag(x));
});
}
public void Refill(IEnumerable<ScreenAction> actions)
{
ContextMenu.Items.Clear();
actions.Each(x =>
{
var item = CommandMenuItem.Build(x);
ContextMenu.Items.Add(item);
});
}
public void SendOutgoingMessages(Envelope original, IEnumerable<object> cascadingMessages)
{
if (original.AckRequested)
{
sendAcknowledgement(original);
}
cascadingMessages.Each(o => SendOutgoingMessage(original, o));
}
public static ExecutionResult Merge(this ExecutionResult executionResult, IEnumerable<ValidationFailure> validationFailures, MessageCategory withMessageCategory = MessageCategory.BrokenBusinessRule)
{
if (executionResult != null)
{
validationFailures.Each(
x => executionResult.Add(MessageCategory.BrokenBusinessRule, x.ErrorMessage, x.PropertyName));
}
return executionResult;
}
public void Create(Guid identity, Guid metadataDefinitionGroupIdentity, string name, IEnumerable<ValueSet> values)
{
var aggregate = new Entity(identity,metadataDefinitionGroupIdentity, new EntityName(name));
if(values != null && values.Any())
values.Each(x => aggregate.AddMetadataDefinitionValue(x.MetadataDefinitionIdentity, new MetadataDefinitionName(x.Name), DataTypeBuilder.Create(x.DataType), x.Regex, GetValue(x.Values)));
_repository.Save(aggregate.ToMaybe());
}
public void StartWatching(string physicalPath, IEnumerable<string> folders)
{
cleanUpWatchers();
Console.WriteLine("Listening for file changes at");
addDirectory(physicalPath);
folders.Each(addDirectory);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(FubuMvcPackages.WebContentFolder, topFolder =>
{
var contentFolder = FileSystem.Combine(topFolder, "content");
log.Trace("Added folder '{0}' to the package folder list", contentFolder);
_contents.RegisterDirectory(contentFolder);
}));
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(FubuMvcPackages.WebContentFolder, topFolder =>
{
var imagesFolder = Path.Combine(topFolder, "content\\images");
log.Trace("Added folder '{0}' to the PackagedImageUrl list", imagesFolder);
_resolver.RegisterDirectory(imagesFolder);
}));
}
static void ExecuteCommands(IEnumerable<Command> commands)
{
int count = 0;
commands.Each(command =>
{
command.Execute();
count++;
});
_log.Debug(x => x.Write("{0} command{1} executed", count, (count > 0 ? "s" : "")));
}
public void LogBootstrapperRun(IBootstrapper bootstrapper, IEnumerable<IActivator> activators)
{
var provenance = "Loaded by Bootstrapper: " + bootstrapper;
var bootstrapperLog = LogFor(bootstrapper);
activators.Each(a =>
{
LogObject(a, provenance);
bootstrapperLog.AddChild(a);
});
}
public Transformer(IEnumerable<ITransformHandler> handlers)
{
handlers.Each(x => _handlers[x.Key] = x);
_handlers["inner"] = new InnerTransformHandler(this);
_handlers.OnMissing = key =>
{
throw new ArgumentOutOfRangeException(nameof(key), key,
"No transformation handler is available for '" + key + "'");
};
}
public void Set(IEnumerable <IContent> set)
{
try
{
var redis = redisManager.GetClient();
var redisMovie = redis.As <IContent>();
set?.Each(x => redisMovie.SetValue(x.ID, x));
return;
}
catch
{
}
}
public SerializationContext(IDimensionFactory dimensionFactory, IObjectBaseFactory objectFactory,
IWithIdRepository withIdRepository, IEnumerable <DataRepository> dataRepositories, ICloneManagerForModel cloneManagerForModel, IContainer container)
{
Container = container;
StringMap = new Cache <string, int>();
IdStringMap = new Cache <int, string>();
IdRepository = withIdRepository;
DimensionFactory = dimensionFactory;
ObjectFactory = objectFactory;
Formulas = new FormulaCache();
_modelReferenceCache = new ModelReferenceCache(withIdRepository, cloneManagerForModel);
_dataReferenceCache = new DataReferenceCache(withIdRepository);
_dataRepositories = new List <DataRepository>();
dataRepositories?.Each(AddRepository);
}
public void AddNodes(IEnumerable <ITreeNode> nodesToAdd)
{
removeHandlers();
_treeGroups.DoWithinBatchUpdate(() => nodesToAdd.Each(_treeGroups.AddNode));
addHandlers();
}
public void RemoveNodes(IEnumerable <ITreeNode> nodesToDelete)
{
removeHandlers();
_treeGroups.DoWithinBatchUpdate(() => nodesToDelete.Each(RemoveNode));
addHandlers();
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(BottleFiles.WebContentFolder, folder => ReadSparkConfig(p.Name, folder, log)));
ReadSparkConfig(FubuSparkConstants.HostOrigin, FubuMvcPackageFacility.GetApplicationPath(), log);
}
public void AppendRange(IEnumerable <TValue> values)
{
values.Each(x => Append(x));
}
public static JsonObject CreateJwtPayload(
IAuthSession session, string issuer, TimeSpan expireIn,
string audience = null,
IEnumerable <string> roles = null,
IEnumerable <string> permissions = null)
{
var now = DateTime.UtcNow;
var jwtPayload = new JsonObject
{
{ "iss", issuer },
{ "sub", session.UserAuthId },
{ "iat", now.ToUnixTime().ToString() },
{ "exp", now.Add(expireIn).ToUnixTime().ToString() },
};
if (audience != null)
{
jwtPayload["aud"] = audience;
}
if (!string.IsNullOrEmpty(session.Email))
{
jwtPayload["email"] = session.Email;
}
if (!string.IsNullOrEmpty(session.FirstName))
{
jwtPayload["given_name"] = session.FirstName;
}
if (!string.IsNullOrEmpty(session.LastName))
{
jwtPayload["family_name"] = session.LastName;
}
if (!string.IsNullOrEmpty(session.DisplayName))
{
jwtPayload["name"] = session.DisplayName;
}
if (!string.IsNullOrEmpty(session.UserName))
{
jwtPayload["preferred_username"] = session.UserName;
}
else if (!string.IsNullOrEmpty(session.UserAuthName) && !session.UserAuthName.Contains("@"))
{
jwtPayload["preferred_username"] = session.UserAuthName;
}
var profileUrl = session.GetProfileUrl();
if (profileUrl != null && profileUrl != AuthMetadataProvider.DefaultNoProfileImgUrl)
{
jwtPayload["picture"] = profileUrl;
}
var combinedRoles = new List <string>(session.Roles.Safe());
var combinedPerms = new List <string>(session.Permissions.Safe());
roles.Each(x => combinedRoles.AddIfNotExists(x));
permissions.Each(x => combinedPerms.AddIfNotExists(x));
if (combinedRoles.Count > 0)
{
jwtPayload["roles"] = combinedRoles.ToJson();
}
if (combinedPerms.Count > 0)
{
jwtPayload["perms"] = combinedPerms.ToJson();
}
return(jwtPayload);
}
public void AddRange(IEnumerable <IBusinessRule> rulesToAdd)
{
rulesToAdd.Each(Add);
}
/// <summary>
/// to initialize the serialization FormulaCache of a building block with its FormulaCache (which may contain unused
/// formulas)
/// </summary>
public void AddFormulasToCache(IEnumerable <IFormula> formulas)
{
formulas?.Each(f => AddFormulaToCache(f));
}
/// <summary>
/// Force Marten to create document mappings for all the given document types
/// </summary>
/// <param name="documentTypes"></param>
public void RegisterDocumentTypes(IEnumerable <Type> documentTypes)
{
documentTypes.Each(RegisterDocumentType);
}
/// <summary>
/// Appends a sequence of items to an existing list
/// </summary>
/// <typeparam name="T">The type of the items in the list</typeparam>
/// <param name="list">The list to modify</param>
/// <param name="items">The sequence of items to add to the list</param>
/// <returns></returns>
public static IList <T> AddRange <T>(this IList <T> list, IEnumerable <T> items)
{
items.Each(list.Add);
return(list);
}
public void AddRange(IEnumerable <ObjectDef> items)
{
items.Each(Add);
}
/// <summary>
/// Writes a sequence of fields to the CSV file. This will
/// ignore any need to quote and ignore the
/// <see cref="CsvConfiguration.QuoteAllFields"/>
/// and just quote based on the shouldQuote
/// parameter.
/// When all fields are written for a row,
/// <see cref="CsvWriter.NextRow" /> must be called
/// to complete writing of the current row.
/// </summary>
/// <param name="fields">The fields to write.</param>
/// <param name="shouldQuote">True to quote the fields, otherwise false.</param>
public virtual void WriteFields(IEnumerable <string> fields, bool shouldQuote)
{
Guard.NotNull(fields, nameof(fields));
fields.Each(x => WriteField(x, shouldQuote));
}
public virtual void AddObserverSetMappings(IEnumerable <ObserverSetMapping> observerSetMappings) => observerSetMappings.Each(AddObserverSetMapping);
public void RemoveOwnershipFromThisNode(IEnumerable <Uri> subjects)
{
_persistence.Alter(_graph.NodeId, node => subjects.Each(node.RemoveOwnership));
}
/* ----------------------------------------------------------------- */ /// /// Add /// /// <summary> /// Adds the Page object to be rendered. /// </summary> /// /// <param name="items">Page collection.</param> /// /* ----------------------------------------------------------------- */ public void Add(IEnumerable <Page> items) => items.Each(e => _inner.Add(this.NewItem(Count, e)));
public void RemoveOwnershipFromNode(string nodeId, IEnumerable <Uri> subjects)
{
_persistence.Alter(nodeId, node => subjects.Each(node.RemoveOwnership));
}
public TaskHealthAssignmentPlanner(IEnumerable <Uri> permanentTasks)
{
_permanentTasks = permanentTasks;
_permanentTasks.Each(x => _status.FillDefault(x));
}
public InterceptorChainBuilder Use(IEnumerable <Type> interceptorTypes)
{
interceptorTypes.Each((type, index) => this.Use(type, index));
return(this);
}
public void AppendRange(IEnumerable <TValue> values, Func <TValue, object> idSelector)
{
Guard.NotNull(idSelector, nameof(idSelector));
values.Each(x => Append(x, idSelector(x)));
}
public void AddRoutes(IEnumerable <string> paths)
{
paths.Each(x => _matches.Add(x.Substring(1), x));
_routes.Add(new Route("{controller}", new StubRouteHandler()));
}
public void AddEventTypes(IEnumerable <Type> types)
{
types.Each(AddEventType);
}
static void InvokeAll(this IEnumerable <Action> actions)
{
actions.Each(x => x());
}
public virtual void Delete(IEnumerable <object> key)
{
key.Each(u => Delete(u));
}
private void RecalculateNemesis(IEnumerable <int> playerIdsThatNeedNewNemesis, ApplicationUser currentUser)
{
playerIdsThatNeedNewNemesis.Each(x => _nemesisRecalculator.RecalculateNemesis(x, currentUser, _dataContext));
}
private void RecalculateChampions(IEnumerable <int> gameDefinitionIds, ApplicationUser currentUser)
{
gameDefinitionIds.Each(x => _championRecalculator.RecalculateChampion(x, currentUser, _dataContext));
}
public void AddDataRepositories(IEnumerable <ModelDataRepository> dataRepositories)
{
dataRepositories?.Each(AddDataRepository);
}
/// <summary>
/// Writes a sequence of fields to the CSV file. The fields
/// may get quotes added to it.
/// When all fields are written for a row,
/// <see cref="CsvWriter.NextRow" /> must be called
/// to complete writing of the current row.
/// </summary>
/// <param name="fields">The fields to write.</param>
public virtual void WriteFields(IEnumerable <string> fields)
{
Guard.NotNull(fields, nameof(fields));
fields.Each(x => WriteField(x));
}
public PathCache <TEntity> For(IEnumerable <TEntity> entities)
{
entities?.Each(Add);
return(this);
}
