How do I abstract a set of modules to a variable to be included in multiple pipelines? - wyam

Question

I'm trying to abstract a set of modules to use them in multiple pipelines. I have this before my first pipeline.
IModule[] textReplacement = new IModule[] {
Replace(" -- ", "—"),
Replace("--", "—"),
Trace("Text replacement performed...")
};
Then, in a pipeline:
Pipelines.Add("Pages",
ReadFiles("*.md"),
Concat(textReplacement),
WriteFiles("*.html)
);
When I execute, Text replacement performed... is written to the console, so the execution flow is working through those two modules. However --
Text replacement does not actually occur. (Or, if it does, it's not persisted in the documents that continue down the pipeline.)
An empty document is added to document set.
The documentation for Concat clearly states:
The specified modules are executed with an empty initial document and then outputs the original input documents without modification concatenated with the results from the specified module sequence.
I just can't figure out why this is, why it would be needed or helpful, or how to get rid of it. I can't have am empty document floating around in my document set, or else is causes errors in subsequent pipelines.

Answer 1

The trick here is to use the LINQ .Concat() method to form a single array consisting of the modules specific to each pipeline combined with the common module array that's declared before the pipelines (textReplacement in the example). This works because IPipelineCollection.Add() accepts a params IModule[] array.
IModule[] textReplacement = new IModule[] {
Replace(" -- ", "—"),
Replace("--", "—"),
Trace("Text replacement performed...")
};
Pipelines.Add("Pages",
new[]
{
// Modules before the common set
ReadFiles("*.md")
}
.Concat(textReplacement) // The common set
.Concat(new[]
{
// Modules after the common set
WriteFiles("*.html)
})
.ToArray()
);
Granted, this is pretty awkward. Of course there are other ways to create a single array to feed to IPipelineCollection.Add() besides using .Concat(). For example, you could create a List<IModule> before each pipeline using List<T>.Add() and List<T>.AddRange() to create the aggregate sequence of modules and then just convert it to an array when creating the pipeline. You could also write an extension method that knows how to concatenate multiple sequences into a single array.
In the future this will become much easier with the introduction of a special module named Modules designed specifically for this purpose that acts as a container of child modules (https://github.com/Wyamio/Wyam/issues/197):
Modules textReplacement = Modules(
Replace(" -- ", "—"),
Replace("--", "—"),
Trace("Text replacement performed...")
);
Pipelines.Add("Pages",
ReadFiles("*.md"),
textReplacement,
WriteFiles("*.html)
);