Beispiel #1
0
        public static void ProtectDirectory(this FsPath directory, ILog log)
        {
            var           outp = directory.Combine("index.html");
            StringBuilder sb   = new StringBuilder(4096);

            for (int i = 0; i < 256; i++)
            {
                sb.Append("                ");
            }
            outp.WriteFile(log, sb.ToString());
        }
        private void ValidateBuildConfig(FsPath WorkDirectory, BuildConfig target)
        {
            if (target == null)
            {
                AddError(Resources.MissingSection);
                return;
            }

            if (!string.IsNullOrEmpty(target.TemplateFile) &&
                !WorkDirectory.Combine(target.TemplateFile).IsExisting)
            {
                AddError(Resources.MissingTemplateFile, target.TemplateFile);
            }

            if (target.TemplateAssets == null)
            {
                AddError(Resources.MissingAssets);
            }
            else
            {
                foreach (var asset in target.TemplateAssets)
                {
                    var source = WorkDirectory.Combine(asset.Source);

                    if (!source.IsExisting)
                    {
                        AddError(Resources.MissingAsset, source.ToString());
                    }
                }
            }

            if (target.StyleClasses == null)
            {
                AddError(Resources.MissingStyleClasses);
            }

            ValidateImageOptions(target.ImageOptions);
        }
Beispiel #3
0
        public override void Validate()
        {
            if (!_toc.Chapters.Any())
            {
                AddError(Resources.TOCNoChapters);
            }

            foreach (var file in _toc.Files)
            {
                var source = _workdir.Combine(file);
                if (!source.IsExisting)
                {
                    AddError(Resources.TOCFileNotExists, file);
                }

                if (!IsValidFileName(file))
                {
                    AddError(Resources.TOCInvalidFilePathChars, file);
                }
            }
        }
        public override void Validate()
        {
            if (Errors.Count > 0)
            {
                Errors.Clear();
            }

            var WorkDirectory = new FsPath(_workdir);

            switch (ValidationLevel)
            {
            case ValidateFor.Epub:
                ValidateBuildConfig(WorkDirectory, _config.TargetEpub);
                break;

            case ValidateFor.Print:
                ValidateBuildConfig(WorkDirectory, _config.TargetPrint);
                break;

            case ValidateFor.Web:
                ValidateBuildConfig(WorkDirectory, _config.TargetWeb);
                break;

            case ValidateFor.All:
                ValidateBuildConfig(WorkDirectory, _config.TargetEpub);
                ValidateBuildConfig(WorkDirectory, _config.TargetPrint);
                ValidateBuildConfig(WorkDirectory, _config.TargetWeb);
                break;
            }

            if (!string.IsNullOrEmpty(_config.ImageDir) && !WorkDirectory.Combine(_config.ImageDir).IsExisting)
            {
                AddError(Resources.MissingImageDir, _config.ImageDir);
            }

            if (!WorkDirectory.Combine(_config.TOCFile).IsExisting)
            {
                AddError(Resources.MissingTocFile, _config.TOCFile);
            }

            if (string.IsNullOrEmpty(_config.HostName))
            {
                AddError(Resources.MissingHostName);
            }
            else if (!_config.HostName.EndsWith("/"))
            {
                AddError(Resources.MissingTrailingSlash);
            }

            if (string.IsNullOrEmpty(_config.Index))
            {
                AddError(Resources.MissingIndex);
            }

            if (_config.Translations == null)
            {
                AddError(Resources.MissingTranslations);
            }
            if (_config.Metadata == null)
            {
                AddError(Resources.MissingMetadata);
            }
        }