private IEnumerable<IRenderingJob> CreateRenderingJobs(FileSystemInfo inputPath,
                                                           IBatchRenderingOptions inputOutputInfo,
                                                           RenderingMode? mode)
        {
            IEnumerable<IRenderingJob> output;

              if(inputPath != null && (inputPath is FileInfo))
              {
            output = new [] { CreateRenderingJob((FileInfo) inputPath, mode, inputPath.GetParentDirectory()) };
              }
              else if(inputPath != null && (inputPath is DirectoryInfo))
              {
            var dir = (DirectoryInfo) inputPath;

            output = (from file in dir.GetFiles(inputOutputInfo.InputSearchPattern, SearchOption.AllDirectories)
                  where  !inputOutputInfo.IgnoredPaths.Any(x => file.IsChildOf(x))
                  select CreateRenderingJob(file, mode, dir));
              }
              else
              {
            output = new IRenderingJob[0];
              }

              return output;
        }
        /// <summary>
        /// Validate the given options.
        /// </summary>
        /// <param name="options">The options to validate.</param>
        public void Validate(IBatchRenderingOptions options)
        {
            if(options == null)
              {
            throw new ArgumentNullException(nameof(options));
              }

              if(options.InputStream == null && !options.InputPaths.Any())
              {
            string message = Resources.ExceptionMessages.BatchOptionsMustHaveInputStreamOrPaths;
            throw new InvalidBatchRenderingOptionsException(message, BatchRenderingFatalErrorType.NoInputsSpecified);
              }
              else if(options.InputStream != null && options.InputPaths.Any())
              {
            string message = Resources.ExceptionMessages.BatchOptionsMustNotHaveBothInputStreamAndPaths;
            throw new InvalidBatchRenderingOptionsException(message, BatchRenderingFatalErrorType.InputCannotBeBothStreamAndPaths);
              }

              if(options.OutputStream == null && options.OutputPath == null)
              {
            string message = Resources.ExceptionMessages.BatchOptionsMustHaveOutputStreamOrPath;
            throw new InvalidBatchRenderingOptionsException(message, BatchRenderingFatalErrorType.NoOutputsSpecified);
              }
              else if(options.OutputStream != null && options.OutputPath != null)
              {
            string message = Resources.ExceptionMessages.BatchOptionsMustNotHaveBothOutputStreamAndPath;
            throw new InvalidBatchRenderingOptionsException(message, BatchRenderingFatalErrorType.OutputCannotBeBothStreamAndPaths);
              }
        }
        /// <summary>
        /// Gets the rendering jobs from the batch rendering options.
        /// </summary>
        /// <returns>The rendering jobs.</returns>
        /// <param name="inputOutputInfo">Input output info.</param>
        /// <param name="mode">Mode.</param>
        public IEnumerable<IRenderingJob> GetRenderingJobs(IBatchRenderingOptions inputOutputInfo,
                                                       RenderingMode? mode)
        {
            IEnumerable<IRenderingJob> output;

              if(inputOutputInfo.InputStream != null)
              {
            output = ReadFromStream(inputOutputInfo.InputStream, mode);
              }
              else
              {
            output = ReadFromInputPaths(inputOutputInfo, mode);
              }

              return output;
        }
Exemple #4
0
        /// <summary>
        /// Parse and render the documents found using the given batch rendering options.
        /// </summary>
        /// <param name="settings">Rendering settings.</param>
        /// <param name="batchOptions">Batch rendering options, indicating the source and destination files.</param>
        public virtual IBatchRenderingResponse Render(IBatchRenderingOptions batchOptions,
                                                  IRenderingSettings settings)
        {
            ValidateBatchOptions(batchOptions);

              var jobs = GetRenderingJobs(batchOptions, batchOptions.RenderingMode);

              List<IBatchRenderingDocumentResponse> documents = new List<IBatchRenderingDocumentResponse>();

              foreach(var job in jobs)
              {
            var contextConfigurator = GetContextConfigurator(job);

            var docResponse = Render(job, settings, batchOptions, contextConfigurator);
            documents.Add(docResponse);
              }

              return new BatchRenderingResponse(documents);
        }
Exemple #5
0
        public Stream GetOutputStream(IBatchRenderingOptions batchOptions)
        {
            if(batchOptions == null)
              {
            throw new ArgumentNullException(nameof(batchOptions));
              }

              Stream output;

              if(batchOptions.OutputStream != null)
              {
            output = batchOptions.OutputStream;
              }
              else
              {
            var outputFile = GetOutputFile(batchOptions);
            output = GetOutputStream(outputFile);
              }

              return output;
        }
Exemple #6
0
        public string GetOutputInfo(IBatchRenderingOptions batchOptions)
        {
            if(batchOptions == null)
              {
            throw new ArgumentNullException(nameof(batchOptions));
              }

              string output;

              if(batchOptions.OutputStream != null)
              {
            output = "STDOUT";
              }
              else
              {
            var outputFile = GetOutputFile(batchOptions);
            output = outputFile.FullName;
              }

              return output;
        }
Exemple #7
0
 /// <summary>
 /// Parse and render the documents found using the given batch rendering options.
 /// </summary>
 /// <param name="options">Rendering options.</param>
 /// <param name="batchOptions">Batch rendering options, indicating the source and destination files.</param>
 /// <returns>
 /// An object instance indicating the outcome of the rendering.
 /// </returns>
 public virtual IBatchRenderingResponse Render(IBatchRenderingOptions batchOptions,
                                           IRenderingOptions options = null)
 {
     return this.Render(batchOptions, _settingsFactory.CreateSettings(options));
 }
Exemple #8
0
 /// <summary>
 /// Validates the batch rendering options.
 /// </summary>
 /// <param name="options">Options.</param>
 protected virtual void ValidateBatchOptions(IBatchRenderingOptions options)
 {
     _optionsValidator.Validate(options);
 }
Exemple #9
0
        /// <summary>
        /// Renders a single rendering job and returns a response.
        /// </summary>
        /// <param name="job">The job to render.</param>
        /// <param name="options">Rendering options.</param>
        /// <param name="batchOptions">Batch rendering options.</param>
        /// <param name="contextConfigurator">Context configurator.</param>
        protected virtual IBatchRenderingDocumentResponse Render(IRenderingJob job,
                                                             IRenderingSettings options,
                                                             IBatchRenderingOptions batchOptions,
                                                             Action<IModelValueContainer> contextConfigurator)
        {
            var doc = GetDocument(job);
              var outputInfo = GetOutputInfo(job, batchOptions);

              using(var outputStream = GetOutputStream(job, batchOptions))
              {
            return Render(doc, outputStream, options, contextConfigurator, outputInfo);
              }
        }
Exemple #10
0
 /// <summary>
 /// Gets the rendering jobs from the rendering job factory.
 /// </summary>
 /// <returns>The rendering jobs.</returns>
 /// <param name="options">Batch rendering options.</param>
 /// <param name="mode">An optional rendering mode override.</param>
 protected virtual IEnumerable<IRenderingJob> GetRenderingJobs(IBatchRenderingOptions options, RenderingMode? mode)
 {
     return _jobFactory.GetRenderingJobs(options, mode);
 }
Exemple #11
0
 /// <summary>
 /// Gets the output stream for a given rendering job.
 /// </summary>
 /// <returns>The output stream.</returns>
 /// <param name="job">Job.</param>
 /// <param name="batchOptions">Batch options.</param>
 protected virtual Stream GetOutputStream(IRenderingJob job, IBatchRenderingOptions batchOptions)
 {
     return job.GetOutputStream(batchOptions);
 }
Exemple #12
0
 /// <summary>
 /// Gets the output info for a given rendering job.
 /// </summary>
 /// <returns>The output info.</returns>
 /// <param name="job">Job.</param>
 /// <param name="batchOptions">Batch options.</param>
 protected virtual string GetOutputInfo(IRenderingJob job, IBatchRenderingOptions batchOptions)
 {
     return job.GetOutputInfo(batchOptions);
 }
 private void ExerciseSut()
 {
     _result = _sut.GetBatchOptions(_options);
 }
Exemple #14
0
        private FileInfo GetOutputFile(IBatchRenderingOptions batchOptions)
        {
            FileInfo output;

              if(batchOptions.OutputPath is FileInfo)
              {
            output = (FileInfo) batchOptions.OutputPath;
              }
              else if(batchOptions.OutputPath is DirectoryInfo)
              {
            output = GetOutputFile((DirectoryInfo) batchOptions.OutputPath, batchOptions.OutputExtensionOverride);
              }
              else
              {
            throw new BatchRenderingException(Resources.ExceptionMessages.InvalidBatchRenderingOutputPath);
              }

              return output;
        }
 private IEnumerable<IRenderingJob> ReadFromInputPaths(IBatchRenderingOptions inputOutputInfo,
                                                   RenderingMode? mode)
 {
     return inputOutputInfo.InputPaths.SelectMany(x => CreateRenderingJobs(x, inputOutputInfo, mode));
 }