public void CanLoadWithAdditionalMetadata()
        {
            var dataFolder = Path.GetFullPath(@"data\additional-metadata\");
            var outputPath = Path.GetFullPath("output");

            var loadConfig = new LoadSiteConfigCommand() { ConfigPath = dataFolder + "site.json" };
            var config = loadConfig.ExecuteAsync().Result;

            var loadData = new LoadDataFilesCommand(config.DataPath, config.AdditionalMetadataForFiles, config.IgnoreFiles);
            loadData.ExecuteAsync().Wait();

            var loadDocuments = new LoadDocumentsCommand();
            loadDocuments.Author = new Author();
            loadDocuments.DocumentsPath = config.DocumentsPath;
            loadDocuments.OutputRootPath = config.OutputPath;
            loadDocuments.AdditionalMetadataForFiles = config.AdditionalMetadataForFiles;
            loadDocuments.IgnoreFiles = config.IgnoreFiles;
            loadDocuments.RenderedExtensions = new[] { "md" };
            loadDocuments.RootUrl = config.RootUrl;
            loadDocuments.ApplicationUrl = config.Url;
            loadDocuments.ExecuteAsync().Wait();

            var data = loadData.DataFiles.Single();
            var document = loadDocuments.Documents.Single();

            Assert.Equal("bar", data.Metadata.Get<string>("foo"));
            Assert.Equal("quux", document.Metadata.Get<string>("baz"));
        }
Ejemplo n.º 2
0
        private Site LoadSite(SiteConfig config, IEnumerable<LastRunDocument> lastRunState, IEnumerable<string> renderedExtensions)
        {
            Site site;

            using (var capture = Statistics.Current.Start(StatisticTiming.LoadedSite))
            {
                // Load layouts.
                LayoutFileCollection layouts;
                {
                    var load = new LoadLayoutsCommand(config.LayoutsPath, config.AdditionalMetadataForFiles, config.IgnoreFiles);
                    var loaded = load.Execute();

                    layouts = new LayoutFileCollection(loaded);
                }

                // Load data files.
                IEnumerable<DataFile> data;
                {
                    var load = new LoadDataFilesCommand(config.DataPath, config.AdditionalMetadataForFiles, config.IgnoreFiles);
                    data = load.Execute();
                }

                // Load documents.
                IEnumerable<DocumentFile> documents;
                {
                    var load = new LoadDocumentsCommand();
                    load.Author = config.Author;
                    load.OutputRootPath = config.OutputPath;
                    load.Layouts = layouts;
                    load.RenderedExtensions = renderedExtensions;
                    load.DefaultLayoutForExtension = config.DefaultLayoutForExtension;
                    load.DocumentsPath = config.DocumentsPath;
                    load.RootUrl = config.RootUrl;
                    load.ApplicationUrl = config.Url;
                    load.AdditionalMetadataForFiles = config.AdditionalMetadataForFiles;
                    load.IgnoreFiles = config.IgnoreFiles;
                    documents = load.Execute();
                }

                // Load files.
                IEnumerable<StaticFile> files;
                {
                    var load = new LoadFilesCommand();
                    load.OutputPath = config.OutputPath;
                    load.FilesPath = config.FilesPath;
                    load.RootUrl = config.RootUrl;
                    load.Url = config.Url;
                    files = load.Execute();
                }

                // Calculate unmodified state.
                {
                    var unmodified = new SetUnmodifiedCommand(config.SitePath, documents, files, this.InitialLastRunState);
                    unmodified.Execute();
                }

                site = new Site(config, data, documents, files, layouts);
            }

            Statistics.Current.SiteFiles = site.Documents.Count + site.Files.Count + site.Layouts.Count;

            return site;
        }