/// <summary>
        /// Merges the specified assets.
        /// </summary>
        /// <param name="contentType">Type of the content.</param>
        /// <param name="assetHandlerPath">The asset handler path.</param>
        /// <param name="isSecured">if set to <c>true</c> [is secure].</param>
        /// <param name="canCompress">if set to <c>true</c> [can compress].</param>
        /// <param name="assets">The assets.</param>
        /// <returns></returns>
        public IList<string> Merge(string contentType, string assetHandlerPath, bool isSecured, bool canCompress, WebAssetItemCollection assets)
        {
            Guard.IsNotNullOrEmpty(contentType, "contentType");
            Guard.IsNotNullOrEmpty(assetHandlerPath, "assetHandlerPath");
            Guard.IsNotNull(assets, "assets");

            IList<string> mergedList = new List<string>();

            foreach (IWebAssetItem asset in assets)
            {
                WebAssetItem item = asset as WebAssetItem;
                WebAssetItemGroup itemGroup = asset as WebAssetItemGroup;

                if (item != null)
                {
                    mergedList.Add(Resolve(item.Source, null));
                }
                else if (itemGroup != null)
                {
                    IList<string> groupResult = MergeGroup(contentType, assetHandlerPath, isSecured, canCompress, itemGroup);

                    if (groupResult != null)
                        mergedList.AddRange(groupResult);
                }
            }

            return mergedList.ToList();
        }
Exemplo n.º 2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ScriptRegistrar"/> class.
        /// </summary>
        /// <param name="scripts">The scripts.</param>
        /// <param name="scriptableComponents">The scriptable components.</param>
        /// <param name="viewContext">The view context.</param>
        /// <param name="assetItemMerger">The asset merger.</param>
        /// <param name="scriptWrapper">The script wrapper.</param>
        public ScriptRegistrar(WebAssetItemCollection scripts, IList<IScriptableComponent> scriptableComponents, ViewContext viewContext, IWebAssetItemMerger assetItemMerger, ScriptWrapperBase scriptWrapper)
        {
            Guard.IsNotNull(scripts, "scripts");
            Guard.IsNotNull(scriptableComponents, "scriptableComponents");
            Guard.IsNotNull(viewContext, "viewContext");
            Guard.IsNotNull(assetItemMerger, "assetItemMerger");
            Guard.IsNotNull(scriptWrapper, "scriptWrapper");

            if (viewContext.HttpContext.Items[Key] != null)
            {
                throw new InvalidOperationException(Resources.TextResource.OnlyOneScriptRegistrarIsAllowedInASingleRequest);
            }

            viewContext.HttpContext.Items[Key] = this;

            DefaultGroup = new WebAssetItemGroup("default") { DefaultPath = FrameworkScriptPath };
            Scripts = scripts;
            this.scriptableComponents = scriptableComponents;
            ViewContext = viewContext;
            AssetMerger = assetItemMerger;
            ScriptWrapper = scriptWrapper;
            AssetHandlerPath = WebAssetHttpHandler.DefaultPath;

            OnDocumentReadyActions = new List<Action>();
            OnWindowUnloadActions = new List<Action>();
        }
        public void Should_be_able_to_merge()
        {
            WebAssetItemCollection assets = new WebAssetItemCollection(WebAssetDefaultSettings.ScriptFilesPath)
                                             {
                                                 new WebAssetItem("~/Scripts/script1.js"),
                                                 new WebAssetItemGroup("group1") { DefaultPath = WebAssetDefaultSettings.ScriptFilesPath },
                                                 new WebAssetItemGroup("group2") { DefaultPath = WebAssetDefaultSettings.ScriptFilesPath },
                                                 new WebAssetItemGroup("group3") { DefaultPath = WebAssetDefaultSettings.ScriptFilesPath }
                                             };

            WebAssetItemGroup group1 = assets.FindGroupByName("group1");
            group1.ContentDeliveryNetworkUrl = "http://cdn.com";

            WebAssetItemGroup group2 = assets.FindGroupByName("group2");
            group2.Items.AddRange(new[] { new WebAssetItem("~/Scripts/script2.js"), new WebAssetItem("~/Scripts/script3.js") });

            WebAssetItemGroup group3 = assets.FindGroupByName("group3");
            group3.Items.AddRange(new[] { new WebAssetItem("~/Scripts/script4.js"), new WebAssetItem("~/Scripts/script5.js") });
            group3.Combined = true;

            _httpServer.Setup(s => s.UrlEncode(It.IsAny<string>())).Returns((string u) => u);
            _assetRegistry.Setup(r => r.Locate(It.IsAny<string>())).Returns((string p) => p);
            _assetRegistry.Setup(r => r.Store(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<float>(), It.IsAny<IList<string>>())).Returns("123");

            _urlResolver.Setup(resolver => resolver.Resolve(It.IsAny<string>())).Returns((string p) => p.Substring(1));

            IList<string> items = _assetItemMerger.Merge("application/x-javascript", WebAssetHttpHandler.DefaultPath, assets);

            Assert.Equal("/Scripts/script1.js", items[0]);
            Assert.Equal("http://cdn.com", items[1]);
            Assert.Equal("/Scripts/script2.js", items[2]);
            Assert.Equal("/Scripts/script3.js", items[3]);
            Assert.Equal("/asset.axd?id=123", items[4]);
        }
        /// <summary>
        /// Merges the specified assets.
        /// </summary>
        /// <param name="contentType">Type of the content.</param>
        /// <param name="assetHandlerPath">The asset handler path.</param>
        /// <param name="assets">The assets.</param>
        /// <returns></returns>
        public IList<string> Merge(string contentType, string assetHandlerPath, WebAssetItemCollection assets)
        {
            Guard.IsNotNullOrEmpty(contentType, "contentType");
            Guard.IsNotNullOrEmpty(assetHandlerPath, "assetHandlerPath");
            Guard.IsNotNull(assets, "assets");

            IList<string> mergedList = new List<string>();

            Func<string, string> getRelativePath = source => urlResolver.Resolve(assetRegistry.Locate(source));

            if (!assets.IsEmpty())
            {
                foreach (IWebAssetItem asset in assets)
                {
                    WebAssetItem item = asset as WebAssetItem;
                    WebAssetItemGroup itemGroup = asset as WebAssetItemGroup;

                    if (item != null)
                    {
                        mergedList.Add(getRelativePath(item.Source));
                    }
                    else if (itemGroup != null)
                    {
                        if (!itemGroup.Disabled)
                        {
                            if (!string.IsNullOrEmpty(itemGroup.ContentDeliveryNetworkUrl))
                            {
                                mergedList.Add(itemGroup.ContentDeliveryNetworkUrl);
                            }
                            else
                            {
                                if (itemGroup.Combined)
                                {
                                    string id = assetRegistry.Store(contentType, itemGroup.Version, itemGroup.Compress, itemGroup.CacheDurationInDays, itemGroup.Items.Select(i => i.Source).ToList());
                                    string virtualPath = "{0}?{1}={2}".FormatWith(assetHandlerPath, httpServer.UrlEncode(WebAssetHttpHandler.IdParameterName), httpServer.UrlEncode(id));
                                    string relativePath = urlResolver.Resolve(virtualPath);

                                    if (!mergedList.Contains(relativePath, StringComparer.OrdinalIgnoreCase))
                                    {
                                        mergedList.Add(relativePath);
                                    }
                                }
                                else
                                {
                                    itemGroup.Items.Each(i =>
                                                          {
                                                              if (!mergedList.Contains(i.Source, StringComparer.OrdinalIgnoreCase))
                                                              {
                                                                  mergedList.Add(getRelativePath(i.Source));
                                                              }
                                                          });
                                }
                            }
                        }
                    }
                }
            }

            return mergedList.ToList();
        }
Exemplo n.º 5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="StyleSheetRegistrar"/> class.
        /// </summary>
        /// <param name="styleSheets">The style sheets.</param>
        /// <param name="viewContext">The view context.</param>
        /// <param name="assetItemMerger">The asset merger.</param>
        public StyleSheetRegistrar(WebAssetItemCollection styleSheets, ViewContext viewContext, IWebAssetItemMerger assetItemMerger)
        {
            // If the instance object is null.
            if (styleSheets == null)
            {
                throw new System.ArgumentNullException("styleSheets");
            }
            if (viewContext == null)
            {
                throw new System.ArgumentNullException("viewContext");
            }
            if (assetItemMerger == null)
            {
                throw new System.ArgumentNullException("assetItemMerger");
            }

            if (viewContext.HttpContext.Items[Key] != null)
            {
                throw new InvalidOperationException("Only one style sheet registrar is allowed in a single request");
            }

            viewContext.HttpContext.Items[Key] = this;

            DefaultGroup = new WebAssetItemGroup("default", false)
            {
                DefaultPath = WebAssetDefaultSettings.StyleSheetFilesPath
            };
            StyleSheets = styleSheets;
            ViewContext = viewContext;
            AssetMerger = assetItemMerger;

            AssetHandlerPath = WebAssetHttpHandler.DefaultPath;
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="WebAssetItemCollectionBuilder"/> class.
        /// </summary>
        /// <param name="assetType">Type of the asset.</param>
        /// <param name="assets">The assets.</param>
        public WebAssetItemCollectionBuilder(WebAssetType assetType, WebAssetItemCollection assets)
        {
            if (assetType == WebAssetType.None)
            {
                throw new ArgumentException(TextResource.NoneIsOnlyUsedForInternalPurpose, "assetType");
            }

            Guard.IsNotNull(assets, "assets");

            this.assetType = assetType;
            this.assets = assets;
        }
Exemplo n.º 7
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ScriptRegistrar"/> class.
        /// </summary>
        /// <param name="scripts">The scripts.</param>
        /// <param name="scriptableComponents">The scriptable components.</param>
        /// <param name="viewContext">The view context.</param>
        /// <param name="assetItemMerger">The asset merger.</param>
        /// <param name="scriptWrapper">The script wrapper.</param>
        public ScriptRegistrar(WebAssetItemCollection scripts, IList <IScriptableComponent> scriptableComponents,
                               ViewContext viewContext, IWebAssetItemMerger assetItemMerger, ScriptWrapperBase scriptWrapper)
        {
            // If the instance object is null.
            if (scripts == null)
            {
                throw new System.ArgumentNullException("scripts");
            }
            if (scriptableComponents == null)
            {
                throw new System.ArgumentNullException("scriptableComponents");
            }
            if (viewContext == null)
            {
                throw new System.ArgumentNullException("viewContext");
            }
            if (assetItemMerger == null)
            {
                throw new System.ArgumentNullException("assetItemMerger");
            }
            if (scriptWrapper == null)
            {
                throw new System.ArgumentNullException("scriptWrapper");
            }

            if (viewContext.HttpContext.Items[Key] != null)
            {
                throw new InvalidOperationException("Only one script registrar is allowed in a single request");
            }

            viewContext.HttpContext.Items[Key] = this;

            DefaultGroup = new WebAssetItemGroup("default", false)
            {
                DefaultPath = WebAssetDefaultSettings.ScriptFilesPath
            };
            Scripts = scripts;
            Scripts.Insert(0, DefaultGroup);

            this.scriptableComponents = scriptableComponents;
            ViewContext      = viewContext;
            AssetMerger      = assetItemMerger;
            ScriptWrapper    = scriptWrapper;
            AssetHandlerPath = WebAssetHttpHandler.DefaultPath;

            OnDocumentReadyActions    = new List <Action>();
            OnDocumentReadyStatements = new List <string>();
            OnWindowUnloadActions     = new List <Action>();
            OnWindowUnloadStatements  = new List <string>();
        }
        public StyleSheetRegistrarTests()
        {
            _httpContext = TestHelper.CreateMockedHttpContext();
            _styleSheets = new WebAssetItemCollection(WebAssetDefaultSettings.StyleSheetFilesPath);
            _styleableComponents = new List<IStyleableComponent>();
            _assetMerger = new Mock<IWebAssetItemMerger>();

            _viewContext = new ViewContext
                               {
                                   HttpContext = _httpContext.Object,
                                   ViewData = new ViewDataDictionary()
                               };

            _styleSheetRegistrar = new StyleSheetRegistrar(_styleSheets, _styleableComponents, _viewContext, _assetMerger.Object);
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="StyleSheetRegistrar"/> class.
        /// </summary>
        /// <param name="styleSheets">The style sheets.</param>
        /// <param name="viewContext">The view context.</param>
        /// <param name="assetItemMerger">The asset merger.</param>
        public StyleSheetRegistrar(WebAssetItemCollection styleSheets, ViewContext viewContext, IWebAssetItemMerger assetItemMerger)
        {
            Guard.IsNotNull(styleSheets, "styleSheets");
            Guard.IsNotNull(viewContext, "viewContext");
            Guard.IsNotNull(assetItemMerger, "assetItemMerger");

            if (viewContext.HttpContext.Items[Key] != null)
            {
                throw new InvalidOperationException(Resources.TextResource.OnlyOneStyleSheetRegistrarIsAllowedInASingleRequest);
            }

            viewContext.HttpContext.Items[Key] = this;

            DefaultGroup = new WebAssetItemGroup("default", false) { DefaultPath = WebAssetDefaultSettings.StyleSheetFilesPath };
            StyleSheets = styleSheets;
            styleSheets.Insert(0, DefaultGroup);

            ViewContext = viewContext;
            AssetMerger = assetItemMerger;

            AssetHandlerPath = WebAssetHttpHandler.DefaultPath;
        }
 public WebAssetItemCollectionBuilderTests()
 {
     _collection = new WebAssetItemCollection(WebAssetDefaultSettings.ScriptFilesPath);
     _builder = new WebAssetItemCollectionBuilder(_collection);
 }
        /// <summary>
        /// Initializes a new instance of the <see cref="WebAssetItemCollectionBuilder"/> class.
        /// </summary>
        /// <param name="assets">The assets.</param>
        public WebAssetItemCollectionBuilder(WebAssetItemCollection assets)
        {
            Guard.IsNotNull(assets, "assets");

            this.assets = assets;
        }
 public WebAssetItemCollectionTests()
 {
     _collection = new WebAssetItemCollection(WebAssetDefaultSettings.ScriptFilesPath);
 }