Beispiel #1
0
        public void AddLink(string type, string path, string url = null)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            if (!UPath.TryParse(path, out _))
            {
                throw new ArgumentException($"Invalid path [{path}]", nameof(path));
            }

            if (url != null)
            {
                if (!UPath.TryParse(url, out _))
                {
                    throw new ArgumentException($"Invalid url [{url}]", nameof(url));
                }
            }

            if (path.Contains("*") && (url == null || !url.EndsWith("/")))
            {
                throw new ArgumentException($"Invalid url [{path}]. Must end with a `/` if the path contains a wildcard.", nameof(url));
            }

            var link = new BundleLink(this, type, path, url);

            Links.Add(link);
        }
        private static void RemoveSourceMaps(BundleLink link)
        {
            var content = link.Content;

            if (content == null)
            {
                return;
            }
            content      = RegexSourceMapSimple.Replace(content, string.Empty);
            content      = RegexSourceMapMulti.Replace(content, string.Empty);
            link.Content = content;
            link.ContentObject.Content = content;
        }
Beispiel #3
0
        private static void Minify(IContentMinifier minifier, BundleLink link, string minifyExtension)
        {
            var contentObject = link.ContentObject;

            // Don't try to minify content that is already minified
            if (contentObject != null && !link.Path.EndsWith($".min.{link.Type}"))
            {
                var minifiedResult = minifier.Minify(link.Type, link.Content, link.Path);
                contentObject.Content = minifiedResult;
                link.Content          = minifiedResult;

                var minExtension = (minifyExtension ?? string.Empty) + "." + link.Type;
                if (!contentObject.Url.EndsWith(minExtension))
                {
                    var url = Path.ChangeExtension(contentObject.Url, minExtension);
                    contentObject.Url = url;
                }
            }
        }
Beispiel #4
0
        private void ProcessBundleLinks(BundleObject bundle, Dictionary <UPath, ContentObject> staticFiles)
        {
            Dictionary <string, ConcatGroup> concatBuilders = null;

            if (bundle.Concat)
            {
                concatBuilders = new Dictionary <string, ConcatGroup>();
                foreach (var type in bundle.UrlDestination)
                {
                    if (!concatBuilders.ContainsKey(type.Key))
                    {
                        concatBuilders[type.Key] = new ConcatGroup();
                    }
                }
            }

            // Expand wildcard * links
            for (int i = 0; i < bundle.Links.Count; i++)
            {
                var link = bundle.Links[i];
                var path = link.Path;
                var url  = link.Url;
                if (!path.Contains("*"))
                {
                    continue;
                }

                // Always remove the link
                bundle.Links.RemoveAt(i);

                var upath = (UPath)path;
                foreach (var file in Site.MetaFileSystem.EnumerateFileSystemEntries(upath.GetDirectory(), upath.GetName()))
                {
                    var newLink = new BundleLink(bundle, link.Type, (string)file.Path, url + file.Path.GetName());
                    bundle.Links.Insert(i++, newLink);
                }

                // Cancel the double i++
                i--;
            }

            // Collect minifier
            IContentMinifier minifier = null;

            if (bundle.Minify)
            {
                var minifierName = bundle.Minifier;
                foreach (var min in Minifiers)
                {
                    if (minifierName == null || min.Name == minifierName)
                    {
                        minifier = min;
                        break;
                    }
                }

                if (minifier == null)
                {
                    Site.Warning($"Minify is setup for bundle [{bundle.Name}] but no minifiers are registered (Minified requested: {minifierName ?? "default"})");
                }
            }

            // Process links
            for (int i = 0; i < bundle.Links.Count; i++)
            {
                var link = bundle.Links[i];
                var path = link.Path;
                var url  = link.Url;
                if (url != null)
                {
                    if (!UPath.TryParse(url, out _))
                    {
                        Site.Error($"Invalid absolute url [{url}] in bundle [{bundle.Name}]");
                    }
                }

                if (path != null)
                {
                    path      = ((UPath)path).FullName;
                    link.Path = path;
                    var entry = new FileEntry(Site.MetaFileSystem, path);

                    ContentObject currentContent;
                    var           isExistingContent = staticFiles.TryGetValue(entry.FullName, out currentContent);

                    if (url == null)
                    {
                        var outputUrlDirectory = bundle.UrlDestination[link.Type];
                        // If the file is private or meta, we need to copy to the output
                        // bool isFilePrivateOrMeta = Site.IsFilePrivateOrMeta(entry.FullName);
                        url      = outputUrlDirectory + Path.GetFileName(path);
                        link.Url = url;
                    }

                    // Process file by existing processors
                    if (currentContent == null)
                    {
                        if (entry.Exists)
                        {
                            currentContent = new ContentObject(Site, entry);
                        }
                        else
                        {
                            Site.Error($"Unable to find content [{path}] in bundle [{bundle.Name}]");
                        }
                    }

                    if (currentContent != null)
                    {
                        currentContent.Url = url;

                        var listTemp = new PageCollection()
                        {
                            currentContent
                        };
                        Site.Content.ProcessPages(listTemp, false);
                        link.ContentObject = currentContent;

                        bool isRawContent = link.Type == BundleObjectProperties.ContentType;

                        // If we require concat and/or minify, we preload the content of the file
                        if (!isRawContent && (bundle.Concat || bundle.Minify))
                        {
                            try
                            {
                                link.Content = currentContent.Content ?? entry.ReadAllText();

                                // Minify content separately
                                if (bundle.Minify && minifier != null)
                                {
                                    Minify(minifier, link, bundle.MinifyExtension);
                                }
                            }
                            catch (Exception ex)
                            {
                                Site.Error(
                                    $"Unable to load content [{path}] while trying to concatenate for bundle [{bundle.Name}]. Reason: {ex.GetReason()}");
                            }
                        }

                        // If we are concatenating
                        if (!isRawContent && concatBuilders != null)
                        {
                            currentContent.Discard = true;

                            // Remove this link from the list of links, as we are going to squash them after
                            bundle.Links.RemoveAt(i);
                            i--;

                            concatBuilders[link.Type].Pages.Add(currentContent);
                            concatBuilders[link.Type].Builder.AppendLine(link.Content);
                        }
                        else if (!isExistingContent)
                        {
                            Site.StaticFiles.Add(currentContent);
                            staticFiles.Add(entry.FullName, currentContent);
                        }
                    }
                }
            }

            // Concatenate files if necessary
            if (concatBuilders != null)
            {
                foreach (var builderGroup in concatBuilders)
                {
                    var builder = builderGroup.Value.Builder;
                    if (builder.Length > 0)
                    {
                        var type = builderGroup.Key;
                        var outputUrlDirectory = bundle.UrlDestination[type];

                        // If the file is private or meta, we need to copy to the output
                        // bool isFilePrivateOrMeta = Site.IsFilePrivateOrMeta(entry.FullName);
                        var url           = outputUrlDirectory + bundle.Name + "." + type;
                        var newStaticFile = new ContentObject(Site)
                        {
                            Url     = url,
                            Content = builder.ToString()
                        };
                        Site.DynamicPages.Add(newStaticFile);

                        // Add file dependencies
                        foreach (var page in builderGroup.Value.Pages)
                        {
                            newStaticFile.Dependencies.Add(new PageContentDependency(page));
                        }

                        var link = new BundleLink(bundle, type, null, url)
                        {
                            Content       = newStaticFile.Content,
                            ContentObject = newStaticFile
                        };

                        bundle.Links.Add(link);
                    }
                }
            }

            foreach (var link in bundle.Links)
            {
                var contentObject = link.ContentObject;
                if (contentObject != null)
                {
                    link.Url = contentObject.Url;
                }
            }
        }