Merge pull request #4 from plainerman/development

Minor improvements and additions

Author: plainerman

TicTacTubeCore/Pipelines/BaseDataPipelineBuilder.cs

@@ -42,13 +42,9 @@ protected BaseDataPipelineBuilder()
 		public IDataPipelineBuilder Append(IDataProcessorOrBuilder dataProcessorOrBuilder)
 		{
 			if (dataProcessorOrBuilder == null)
-			{
 				throw new ArgumentNullException(nameof(dataProcessorOrBuilder));
-			}
 			if (IsLocked)
-			{
 				throw new PipelineStateException("The pipeline is locked and cannot be modified.");
-			}
 
 			InternalPipeline.Add(dataProcessorOrBuilder);
 

TicTacTubeCore/Pipelines/DataPipeline.cs

@@ -41,7 +41,7 @@ public DataPipeline(ICollection<IDataProcessor> dataProcessors)
 		public DataPipeline(IEnumerable<IDataProcessorOrBuilder> dataProcessorsOrBuilder)
 		{
 			DataProcessors = dataProcessorsOrBuilder?.Select(d => d.Build()).ToList() ??
-							throw new ArgumentNullException(nameof(dataProcessorsOrBuilder));
+			                 throw new ArgumentNullException(nameof(dataProcessorsOrBuilder));
 		}
 
 		/// <inheritdoc />

TicTacTubeCore/Processors/Filesystem/SourceCloner.cs

@@ -45,9 +45,7 @@ public override IFileSource Execute(IFileSource fileSoure)
 
 			string directory = Path.GetDirectoryName(dest);
 			if (!Directory.Exists(directory))
-			{
 				Directory.CreateDirectory(directory);
-			}
 
 			fileSoure.FileInfo.CopyTo(dest);
 

TicTacTubeCore/Processors/Filesystem/SourceMover.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using TicTacTubeCore.Processors.Definitions;
 using TicTacTubeCore.Sources.Files;
 
@@ -9,6 +10,7 @@ namespace TicTacTubeCore.Processors.Filesystem
 	/// </summary>
 	public class SourceMover : BaseDataProcessor
 	{
+		private readonly Func<IFileSource, string> _processingFunction;
 		private readonly string _destinationPath;
 		private readonly bool _keepName;
 
@@ -33,16 +35,35 @@ public SourceMover(string destinationFolder, bool keepName)
 			_keepName = true;
 		}
 
+		/// <summary>
+		///		Create a source mover that moves a source to another directory. The full
+		///		path to the new file is created by the processing function.
+		/// </summary>
+		/// <param name="processingFunction">The processing function returns for a given <see cref="IFileSource"/>
+		///		a full path to the new file.
+		/// </param>
+		public SourceMover(Func<IFileSource, string> processingFunction)
+		{
+			_processingFunction = processingFunction ?? throw new ArgumentNullException(nameof(processingFunction));
+		}
+
 		/// <inheritdoc />
 		public override IFileSource Execute(IFileSource fileSoure)
 		{
-			string dest = _keepName ? Path.Combine(_destinationPath, fileSoure.FileInfo.Name) : _destinationPath;
+			string dest = _destinationPath;
+
+			if (_processingFunction != null)
+			{
+				dest = _processingFunction(fileSoure);
+			}
+			else if (_keepName)
+			{
+				dest = Path.Combine(_destinationPath, fileSoure.FileInfo.Name);
+			}
 
 			string directory = Path.GetDirectoryName(dest);
 			if (!Directory.Exists(directory))
-			{
 				Directory.CreateDirectory(directory);
-			}
 
 			fileSoure.FileInfo.MoveTo(dest);
 

TicTacTubeCore/Processors/Logical/ConditionalProcessor.cs

@@ -27,9 +27,7 @@ public ConditionalProcessor(Func<IFileSource, bool> condition, IDataProcessorOrB
 			IDataProcessorOrBuilder dataProcessorB)
 		{
 			if (dataProcessorA == null && dataProcessorB == null)
-			{
 				throw new ArgumentNullException(nameof(dataProcessorA), "Both parameters may not be null.");
-			}
 
 			_condition = condition ?? throw new ArgumentNullException(nameof(condition));
 			_dataProcessorA = dataProcessorA;
@@ -58,16 +56,12 @@ public override IFileSource Execute(IFileSource fileSoure)
 			if (eval)
 			{
 				if (_dataProcessorA != null)
-				{
 					return _dataProcessorA.Build().Execute(fileSoure);
-				}
 			}
 			else
 			{
 				if (_dataProcessorB != null)
-				{
 					return _dataProcessorB.Build().Execute(fileSoure);
-				}
 			}
 
 			return fileSoure;

TicTacTubeCore/Processors/Logical/DebugProcessor.cs

@@ -0,0 +1,40 @@
+using System;
+using TicTacTubeCore.Processors.Definitions;
+using TicTacTubeCore.Sources.Files;
+
+namespace TicTacTubeCore.Processors.Logical
+{
+	/// <summary>
+	/// A debug processor that wraps any given processor and may make debugging easier.
+	/// </summary>
+    public class DebugProcessor : BaseDataProcessor
+    {
+		/// <summary>
+		/// The internally wrapped data processor.
+		/// </summary>
+	    public IDataProcessorOrBuilder DataProcessor { get; }
+
+	    /// <summary>
+		/// The amount of calls on execute.
+		/// </summary>
+	    public int ExecutionCount { get; protected set; }
+
+		/// <summary>
+		/// Create a new debug processor that wraps the given data processor.
+		/// </summary>
+		/// <param name="dataProcessor">The data processor that will actually be executed.</param>
+	    public DebugProcessor(IDataProcessorOrBuilder dataProcessor)
+		{
+			DataProcessor = dataProcessor ?? throw new ArgumentNullException(nameof(dataProcessor));
+		}
+
+		/// <inheritdoc/>
+	    public override IFileSource Execute(IFileSource fileSoure)
+		{
+			var newFileSource = DataProcessor.Build().Execute(fileSoure);
+			ExecutionCount++;
+
+			return newFileSource;
+		}
+    }
+}

TicTacTubeCore/Processors/Logical/MultiProcessor.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TicTacTubeCore.Processors.Definitions;
+using TicTacTubeCore.Sources.Files;
+
+namespace TicTacTubeCore.Processors.Logical
+{
+	/// <summary>
+	///     A processor that is like a nested pipeline and also aggregates the file sources.
+	/// </summary>
+	public class MultiProcessor : BaseDataProcessor
+	{
+		/// <summary>
+		///     Internally stored processors that will be executed.
+		/// </summary>
+		protected readonly IEnumerable<IDataProcessorOrBuilder> Processors;
+
+		/// <summary>
+		///     Create a new multi processor (that acts like a nested pipeline) with given processors.
+		/// </summary>
+		/// <param name="processors">The processors that will be managed and processed.</param>
+		public MultiProcessor(IEnumerable<IDataProcessorOrBuilder> processors)
+		{
+			if (processors == null) throw new ArgumentNullException(nameof(processors));
+
+			var dataProcessorOrBuilders = processors as IDataProcessorOrBuilder[] ?? processors.ToArray();
+
+			if (!dataProcessorOrBuilders.Any()) throw new ArgumentException("May not be empty.", nameof(processors));
+
+			Processors = dataProcessorOrBuilders;
+		}
+
+		/// <inheritdoc />
+		public override IFileSource Execute(IFileSource fileSoure)
+		{
+			return Processors.Aggregate(fileSoure,
+				(current, dataProcessorOrBuilder) => dataProcessorOrBuilder.Build().Execute(current));
+		}
+	}
+}

TicTacTubeCore/Processors/Logical/SourceSplitter.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using TicTacTubeCore.Processors.Definitions;
+using TicTacTubeCore.Sources.Files;
+
+namespace TicTacTubeCore.Processors.Logical
+{
+	/// <summary>
+	///     This source splitter is capable of applying multiple processors to one source.
+	/// </summary>
+	public class SourceSplitter : BaseDataProcessor
+	{
+		/// <summary>
+		///     The processors that will be executed.
+		/// </summary>
+		protected readonly IEnumerable<IDataProcessorOrBuilder> Processors;
+
+		/// <summary>
+		///     Create a new source splitter that passes the given file source (the one from execute) to multiple params.
+		///     If there is a following data processor in the pipeline, it receives an unmodified version of the filesource.
+		/// </summary>
+		/// <param name="processors">The processors that will be executed.</param>
+		public SourceSplitter(IEnumerable<IDataProcessorOrBuilder> processors)
+		{
+			Processors = processors ?? throw new ArgumentNullException(nameof(processors));
+		}
+
+		/// <inheritdoc />
+		public override IFileSource Execute(IFileSource fileSoure)
+		{
+			foreach (var dataProcessorOrBuilder in Processors)
+				dataProcessorOrBuilder.Build().Execute(fileSoure);
+
+			return fileSoure;
+		}
+	}
+}

TicTacTubeCore/Schedulers/EventFiringScheduler.cs

@@ -33,13 +33,9 @@ protected override void ExecuteStop()
 		public virtual void Fire(IFileSource fileSource)
 		{
 			if (IsRunning)
-			{
 				Execute(fileSource);
-			}
 			else
-			{
 				throw new SchedulerStateException("The scheduler is not running.");
-			}
 		}
 
 		/// <summary>

TicTacTubeCore/Schedulers/Events/SchedulerLifeCycleEventArgs.cs

@@ -29,16 +29,6 @@ public enum SchedulerLifeCycleEventType
 	/// </summary>
 	public class SchedulerLifeCycleEventArgs : SchedulerEventArgs
 	{
-		/// <summary>
-		///     The running state.Determines whether the scheduler is currently active or not.
-		/// </summary>
-		public bool IsRunning { get; }
-
-		/// <summary>
-		///     The current lifecycle type (i.e. method that caused the event).
-		/// </summary>
-		public SchedulerLifeCycleEventType EventType { get; }
-
 		/// <summary>
 		///     Create given event args with the current running state and the event type.
 		/// </summary>
@@ -47,12 +37,20 @@ public class SchedulerLifeCycleEventArgs : SchedulerEventArgs
 		public SchedulerLifeCycleEventArgs(bool isRunning, SchedulerLifeCycleEventType eventType)
 		{
 			if (!Enum.IsDefined(typeof(SchedulerLifeCycleEventType), eventType))
-			{
 				throw new InvalidEnumArgumentException(nameof(eventType), (int) eventType, typeof(SchedulerLifeCycleEventType));
-			}
 
 			IsRunning = isRunning;
 			EventType = eventType;
 		}
+
+		/// <summary>
+		///     The running state.Determines whether the scheduler is currently active or not.
+		/// </summary>
+		public bool IsRunning { get; }
+
+		/// <summary>
+		///     The current lifecycle type (i.e. method that caused the event).
+		/// </summary>
+		public SchedulerLifeCycleEventType EventType { get; }
 	}
 }