Exemplo n.º 1
0
        /// <summary>The method called from the regex replace to replace the matched wgInclude() statements.</summary>
        /// <param name="match">The regex match</param>
        /// <param name="workingFolder">The working folder from which to determine relative path's in the include.</param>
        /// <param name="cacheSection">The cache Section.</param>
        /// <param name="minimalOutput">Is the goal to have the most minimal output (true skips lots of comments)</param>
        /// <returns>The contents of the file to replace, with a /* WGINCLUDE [fullFilePath] */ header on top.</returns>
        private static string ReplaceInputs(Match match, string workingFolder, ICacheSection cacheSection, bool minimalOutput)
        {
            var fileOrPath = Path.Combine(workingFolder, match.Groups["fileOrPath"].Value.Trim());
            var inputSpec  = new InputSpec {
                IsOptional = true, Path = fileOrPath
            };

            if (Directory.Exists(fileOrPath))
            {
                inputSpec.SearchPattern = match.Groups["searchPattern"].Value.Trim();
            }

            cacheSection.AddSourceDependency(inputSpec);

            var result = string.Empty;

            foreach (var file in inputSpec.GetFiles())
            {
                if (!minimalOutput)
                {
                    result += "/* WGINCLUDE: {0} */\r\n".InvariantFormat(file);
                }

                result += File.ReadAllText(file) + "\r\n";
            }

            return(result);
        }
        /// <summary>Hash the images.</summary>
        /// <param name="cssContent">The css content.</param>
        /// <param name="imageHasher">The image Hasher.</param>
        /// <param name="cacheSection">The cache section.</param>
        /// <param name="threadContext">The context.</param>
        /// <param name="sourceImages">The source Images.</param>
        /// <param name="missingImage">The missing Image.</param>
        /// <returns>The css with hashed images.</returns>
        private static Tuple <string, IEnumerable <ContentItem> > HashImages(string cssContent, FileHasherActivity imageHasher, ICacheSection cacheSection, IWebGreaseContext threadContext, IDictionary <string, string> sourceImages, string missingImage)
        {
            return(threadContext.SectionedAction(SectionIdParts.MinifyCssActivity, SectionIdParts.ImageHash).Execute(() =>
            {
                var contentImagesToHash = new HashSet <string>();
                var hashedContentItems = new List <ContentItem>();
                var hashedImages = new Dictionary <string, string>();
                cssContent = UrlHashRegexPattern.Replace(
                    cssContent,
                    match =>
                {
                    var urlToHash = match.Groups["url"].Value;
                    var extraInfo = match.Groups["extra"].Value;

                    if (ResourcesResolver.LocalizationResourceKeyRegex.IsMatch(urlToHash))
                    {
                        return match.Value;
                    }

                    var normalizedHashUrl = urlToHash.NormalizeUrl();

                    var imageContentFile = sourceImages.TryGetValue(normalizedHashUrl);
                    if (imageContentFile == null && !string.IsNullOrWhiteSpace(missingImage))
                    {
                        imageContentFile = sourceImages.TryGetValue(missingImage);
                    }

                    if (imageContentFile == null)
                    {
                        throw new BuildWorkflowException("Could not find a matching source image for url: {0}".InvariantFormat(urlToHash));
                    }

                    if (contentImagesToHash.Add(normalizedHashUrl))
                    {
                        // Add the image as end result
                        var imageContentItem = ContentItem.FromFile(imageContentFile, normalizedHashUrl);
                        imageContentItem = imageHasher.Hash(imageContentItem);
                        cacheSection.AddSourceDependency(imageContentFile);
                        hashedContentItems.Add(imageContentItem);

                        imageContentFile =
                            Path.Combine(
                                imageHasher.BasePrefixToAddToOutputPath ?? Path.AltDirectorySeparatorChar.ToString(CultureInfo.InvariantCulture),
                                imageContentItem.RelativeHashedContentPath.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));

                        hashedImages.Add(normalizedHashUrl, imageContentFile);
                    }
                    else
                    {
                        imageContentFile = hashedImages[normalizedHashUrl];
                    }

                    return "url(" + imageContentFile + extraInfo + ")";
                });

                return Tuple.Create(cssContent, (IEnumerable <ContentItem>)hashedContentItems);
            }));
        }
Exemplo n.º 3
0
        /// <summary>Sets the import source dependencies.</summary>
        /// <param name="fileContent">The file content.</param>
        /// <param name="workingFolder">The working folder.</param>
        /// <param name="cacheSection">The cache section.</param>
        private static void SetImportSourceDependencies(string fileContent, string workingFolder, ICacheSection cacheSection)
        {
            var matches = ImportPattern.Matches(fileContent);

            foreach (Match match in matches)
            {
                var path = Path.Combine(workingFolder, match.Groups["path"].Value);
                var fi   = new FileInfo(path);
                cacheSection.AddSourceDependency(path);
                if (fi.Exists)
                {
                    SetImportSourceDependencies(File.ReadAllText(fi.FullName), fi.DirectoryName, cacheSection);
                }
            }
        }
Exemplo n.º 4
0
        /// <summary>The replace imports.</summary>
        /// <param name="match">The match.</param>
        /// <param name="workingFolder">The working folder.</param>
        /// <param name="cacheSection">The cache Section.</param>
        /// <param name="minimalOutput">Is the goal to have the most minimal output (true skips lots of comments)</param>
        /// <returns>The replaced imports.</returns>
        private static string ReplaceImports(Match match, string workingFolder, ICacheSection cacheSection, bool minimalOutput)
        {
            var    path            = match.Groups["path"].Value;
            string pattern         = null;
            var    pathParts       = path.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
            var    possiblePattern = pathParts.LastOrDefault();

            if (!string.IsNullOrEmpty(possiblePattern) && possiblePattern.Contains("*"))
            {
                pattern = possiblePattern;
                pathParts.RemoveAt(pathParts.Count - 1);
            }

            var pathInfo = new DirectoryInfo(Path.Combine(workingFolder, string.Join("\\", pathParts)));

            cacheSection.AddSourceDependency(new InputSpec {
                IsOptional = true, Path = pathInfo.FullName, SearchOption = SearchOption.TopDirectoryOnly, SearchPattern = pattern
            });

            if (!pathInfo.Exists)
            {
                return(string.Empty);
            }

            var files = !string.IsNullOrWhiteSpace(pattern)
                            ? Directory.GetFiles(pathInfo.FullName, pattern)
                            : Directory.GetFiles(pathInfo.FullName);

            return
                ((minimalOutput ? string.Empty : GetImportsComment(path, string.Empty))
                 + string.Join(
                     " ",
                     files
                     .Select(file => MakeRelativePath(workingFolder, file))
                     .Select(relativeFile => "{0}\r\n@import \"{1}\";".InvariantFormat(
                                 minimalOutput ? string.Empty : "\r\n" + GetImportsComment(path, Path.GetFileName(relativeFile)),
                                 relativeFile.Replace("\\", "/")))));
        }