Ejemplo n.º 1
0
        /// <summary>
        /// Remove and get framework group.
        /// </summary>
        /// <param name="itemGroup">The web asset to remove.</param>
        /// <returns>The web asset item group</returns>
        private static WebAssetItemGroup RemoveAndGetFrameworkGroup(WebAssetItemGroup itemGroup)
        {
            WebAssetItemGroup frameworkGroup =
                new WebAssetItemGroup("framework", false)
            {
                Combined            = itemGroup.Combined,
                Compress            = itemGroup.Compress,
                CacheDurationInDays = itemGroup.CacheDurationInDays,
                DefaultPath         = itemGroup.DefaultPath,
                Version             = itemGroup.Version
            };

            for (int i = itemGroup.Items.Count - 1; i >= 0; i--)
            {
                WebAssetItem item     = itemGroup.Items[i];
                string       fileName = Path.GetFileName(item.Source);

                if ((!fileName.Equals(ScriptRegistrar.jQuery, StringComparison.OrdinalIgnoreCase)) &&
                    (ScriptRegistrar.FrameworkScriptFileNames.Contains(fileName, StringComparer.OrdinalIgnoreCase)))
                {
                    frameworkGroup.Items.Add(new WebAssetItem(item.Source));
                    itemGroup.Items.RemoveAt(i);
                }
            }

            frameworkGroup.Items.Reverse();
            return(frameworkGroup);
        }
Ejemplo n.º 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="contentType"></param>
        /// <param name="assetGroup"></param>
        /// <returns></returns>
        private static MergedAsset CreateMergedAssetWith(string contentType, WebAssetItemGroup assetGroup)
        {
            Func <string, string> getDirectory = path => path.Substring(2, path.LastIndexOf("/", StringComparison.Ordinal) - 2);
            Func <string, string> getFile      = path => path.Substring(path.LastIndexOf("/", StringComparison.Ordinal) + 1);

            MergedAsset asset = new MergedAsset
            {
                ContentType         = contentType,
                Version             = assetGroup.Version,
                Compress            = assetGroup.Compress,
                CacheDurationInDays = assetGroup.CacheDurationInDays
            };

            IEnumerable <string> directories = assetGroup.Items.Select(item => getDirectory(item.Source)).Distinct(StringComparer.OrdinalIgnoreCase);

            directories.Each(directory => asset.Directories.Add(new MergedAssetDirectory {
                Path = directory
            }));

            for (int i = 0; i < assetGroup.Items.Count; i++)
            {
                string item      = assetGroup.Items[i].Source;
                string directory = getDirectory(item);
                string file      = getFile(item);

                MergedAssetDirectory assetDirectory = asset.Directories.Single(d => d.Path.IsCaseInsensitiveEqual(directory));

                assetDirectory.Files.Add(new MergedAssetFile {
                    Order = i, Name = file
                });
            }

            return(asset);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Stores the specified asset group.
        /// </summary>
        /// <param name="contentType">Type of the content.</param>
        /// <param name="assetGroup">The asset group.</param>
        /// <returns></returns>
        public string Store(string contentType, WebAssetItemGroup assetGroup)
        {
            MergedAsset mergedAsset = CreateMergedAssetWith(contentType, assetGroup);
            string      id          = assetGroup.IsShared ? assetGroup.Name : CreateIdFrom(mergedAsset);

            EnsureAsset(mergedAsset, id);

            return(id);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Inserts the specified source as <see cref="WebAssetItem"/> at the specified index in the specified <see cref="WebAssetItemGroup"/>.
        /// </summary>
        /// <param name="index">The index.</param>
        /// <param name="groupName">Name of the group.</param>
        /// <param name="itemSource">The item source.</param>
        public virtual void Insert(int index, string groupName, string itemSource)
        {
            WebAssetItemGroup itemGroup = FindGroupByName(groupName);

            if (itemGroup == null)
            {
                itemGroup = CreateGroup(groupName);
                Insert(index, itemGroup);
            }

            itemGroup.Items.Add(CreateItem(itemSource));
        }
Ejemplo n.º 5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private static MergedAsset CreateMergedAssetFromConfiguration(string id)
        {
            WebAssetItemGroup assetGroup  = SharedGroup.FindScriptGroup(id);
            string            contentType = "application/x-javascript";

            if (assetGroup == null)
            {
                assetGroup  = SharedGroup.FindStyleSheetGroup(id);
                contentType = "text/css";
            }

            return((assetGroup != null) ? CreateMergedAssetWith(contentType, assetGroup) : null);
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Does the web asset already exist.
        /// </summary>
        /// <param name="item">The item to test.</param>
        /// <returns>True if it exists else false.</returns>
        private bool AlreadyExists(IWebAssetItem item)
        {
            WebAssetItem      assetItem      = item as WebAssetItem;
            WebAssetItemGroup assetItemGroup = item as WebAssetItemGroup;

            if (assetItem != null)
            {
                return(AssetItems.Any(i => i != item && i.Source.IsCaseInsensitiveEqual(assetItem.Source)));
            }

            if (assetItemGroup != null)
            {
                return(AssetGroups.Any(i => i != item && i.Name.IsCaseInsensitiveEqual(assetItemGroup.Name)));
            }

            return(false);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Remove and get native files.
        /// </summary>
        /// <param name="itemGroup">The native web asset to remove</param>
        /// <returns>The new list of paths.</returns>
        private static IList <string> RemoveAndGetNativeFiles(WebAssetItemGroup itemGroup)
        {
            List <string> nativeFiles = new List <string>();

            for (int i = itemGroup.Items.Count - 1; i >= 0; i--)
            {
                WebAssetItem item = itemGroup.Items[i];

                if (IsNativeFile(item))
                {
                    nativeFiles.Add(Path.GetFileName(item.Source));
                    itemGroup.Items.RemoveAt(i);
                }
            }

            nativeFiles.Reverse();
            return(nativeFiles);
        }
        /// <summary>
        /// Executes the provided delegate that is used to configure the group fluently.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="configureAction">The configure action.</param>
        public virtual WebAssetItemCollectionBuilder GetGroup(string name, Action <WebAssetItemGroupBuilder> configureAction)
        {
            WebAssetItemGroup itemGroup = _assets.FindGroupByName(name);

            if (itemGroup == null)
            {
                throw new ArgumentException("Group with specified name does not exist please make sure you have specified a correct name", "name");
            }

            if (itemGroup.IsShared)
            {
                throw new InvalidOperationException("You cannot configure a shared web asset group");
            }

            WebAssetItemGroupBuilder builder = new WebAssetItemGroupBuilder(itemGroup);

            configureAction(builder);
            return(this);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Adds the group.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="configureAction">The configure action.</param>
        /// <returns>The shared asset builder.</returns>
        public virtual SharedGroupBuilder AddGroup(string name, Action <WebAssetItemGroupBuilder> configureAction)
        {
            WebAssetItemGroup group;

            if (_assets.TryGetValue(name, out group))
            {
                throw new ArgumentException("Group with specified name already exists please specify a different name", "name");
            }

            group = new WebAssetItemGroup(name, true)
            {
                DefaultPath = _defaultPath
            };
            _assets.Add(name, group);

            WebAssetItemGroupBuilder builder = new WebAssetItemGroupBuilder(group);

            configureAction(builder);
            return(this);
        }
        /// <summary>
        /// Adds a new web asset group.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="configureAction">The configure action.</param>
        /// <example>
        /// <code lang="CS">
        /// &lt;%= Html.NequeoUI().ScriptRegistrar()
        ///            .Scripts(scripts => scripts.AddGroup("Group1", group =>
        ///                 {
        ///                     group.Add("script1.js");
        ///                 }
        ///            ))
        /// %&gt;
        /// </code>
        /// </example>
        public virtual WebAssetItemCollectionBuilder AddGroup(string name, Action <WebAssetItemGroupBuilder> configureAction)
        {
            WebAssetItemGroup itemGroup = _assets.FindGroupByName(name);

            if (itemGroup != null)
            {
                throw new ArgumentException("Group with specified name already exists please specify a different name", "name");
            }

            itemGroup = new WebAssetItemGroup(name)
            {
                DefaultPath = _assets.DefaultPath
            };
            _assets.Add(itemGroup);

            WebAssetItemGroupBuilder builder = new WebAssetItemGroupBuilder(itemGroup);

            configureAction(builder);

            return(this);
        }
        /// <summary>
        /// Adds the specified shared group.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <example>
        /// <code lang="CS">
        /// &lt;%= Html.NequeoUI().ScriptRegistrar()
        ///            .Scripts(scripts => scripts.AddShareGroup("SharedGroup1"))
        /// %&gt;
        /// </code>
        /// </example>
        public virtual WebAssetItemCollectionBuilder AddSharedGroup(string name)
        {
            WebAssetItemGroup group = (_assetType == WebAssetType.StyleSheet) ?
                                      SharedGroup.FindStyleSheetGroup(name) :
                                      SharedGroup.FindScriptGroup(name);

            if (group == null)
            {
                throw new ArgumentException("GroupWithSpecifiedNameDoesNotExistInAssetTypeOfSharedWebAssets", "name");
            }

            if (_assets.FindGroupByName(name) == null)
            {
                // People might have the same group reference in multiple place.
                // So we will skip it once it is added.

                // throw new ArgumentException(TextResource.LocalGroupWithSpecifiedNameAlreadyExists.FormatWith(name));

                // Add a copy of the shared asset
                WebAssetItemGroup localGroup = new WebAssetItemGroup(group.Name, true)
                {
                    DefaultPath         = group.DefaultPath,
                    Version             = group.Version,
                    Compress            = group.Compress,
                    CacheDurationInDays = group.CacheDurationInDays,
                    Combined            = group.Combined
                };

                foreach (WebAssetItem item in group.Items)
                {
                    localGroup.Items.Add(new WebAssetItem(item.Source));
                }

                _assets.Add(localGroup);
            }

            return(this);
        }
Ejemplo n.º 12
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="assetItemGroup">The current web asset item group to add the item to.</param>
 public WebAssetItemGroupBuilder(WebAssetItemGroup assetItemGroup)
 {
     _assetItemGroup = assetItemGroup;
 }
Ejemplo n.º 13
0
        /// <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>The collection of web asset paths.</returns>
        public IList <string> Merge(string contentType, string assetHandlerPath, bool isSecured, bool canCompress, WebAssetItemCollection assets)
        {
            // If the instance object is null.
            if (contentType == null)
            {
                throw new System.ArgumentNullException("contentType");
            }
            if (assetHandlerPath == null)
            {
                throw new System.ArgumentNullException("assetHandlerPath");
            }
            if (assets == null)
            {
                throw new System.ArgumentNullException("assets");
            }

            IList <string> mergedList = new List <string>();
            Func <string, string, string> getRelativePath = (source, version) => _urlResolver.Resolve(_assetRegistry.Locate(source, version));

            Action <WebAssetItemGroup> processGroup = group =>
            {
                if (group.Combined)
                {
                    string id           = _assetRegistry.Store(contentType, group);
                    string virtualPath  = "{0}?{1}={2}".FormatWith(assetHandlerPath, _urlEncoder.Encode(WebAssetHttpHandler.IdParameterName), _urlEncoder.Encode(id));
                    string relativePath = _urlResolver.Resolve(virtualPath);

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

            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, null));
                    }
                    else if (itemGroup != null)
                    {
                        WebAssetItemGroup frameworkGroup = null;

                        if ((frameworkGroup != null) && !frameworkGroup.Items.IsEmpty())
                        {
                            processGroup(frameworkGroup);
                        }

                        if (!itemGroup.Items.IsEmpty())
                        {
                            processGroup(itemGroup);
                        }
                    }
                }
            }

            // Return the list.
            return(mergedList.ToList());
        }