private static void HandleDeclaration(ParseItem item, ICssCheckerContext context)
        {
            Declaration dec = (Declaration)item;

            if (dec == null || dec.PropertyName == null)
                return;

            if (dec.IsVendorSpecific())
            {
                string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C property", dec.PropertyName.Text);
                context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }

            foreach (var value in dec.Values)
            {
                string text = value.Text;
                if (!(value is NumericalValue) && text.StartsWith("-", StringComparison.Ordinal))
                {
                    int index = text.IndexOf('(');

                    if (index > -1)
                    {
                        text = text.Substring(0, index);
                    }

                    string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C value", text);
                    context.AddError(new SimpleErrorTag(value, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                }
            }
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            UrlItem url = (UrlItem)item;

            if (!WESettings.GetBoolean(WESettings.Keys.ValidateEmbedImages) || !url.IsValid || url.UrlString.Text.Contains("base64,") || context == null)
                return ItemCheckResult.Continue;

            string fileName = ImageQuickInfo.GetFullUrl(url.UrlString.Text, EditorExtensionsPackage.DTE.ActiveDocument.FullName);
            if (string.IsNullOrEmpty(fileName) || fileName.Contains("://"))
                return ItemCheckResult.Continue;

            FileInfo file = new FileInfo(fileName);

            if (file.Exists && file.Length < (1024 * 3))
            {
                Declaration dec = url.FindType<Declaration>();
                if (dec != null && dec.PropertyName != null && dec.PropertyName.Text[0] != '*' && dec.PropertyName.Text[0] != '_')
                {
                    string error = string.Format(Resources.PerformanceEmbedImageAsDataUri, file.Length);
                    context.AddError(new SimpleErrorTag(url.UrlString, error));
                }
            }

            return ItemCheckResult.Continue;
        }
Example #3
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateVendorSpecifics)
            {
                return(ItemCheckResult.Continue);
            }

            AtDirective directive = (AtDirective)item;

            if (!directive.IsValid || directive.IsVendorSpecific() || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            ICssSchemaInstance schema = CssEditorChecker.GetSchemaForItem(context, item);
            var missingEntries        = directive.GetMissingVendorSpecifics(schema);

            if (missingEntries.Any())
            {
                string    error = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeAddMissingVendorSpecificDirective, directive.Keyword.Text, string.Join(", ", missingEntries));
                ICssError tag   = new SimpleErrorTag(directive.Keyword, error);
                context.AddError(tag);
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            RuleBlock rule = (RuleBlock)item;

            if (!rule.IsValid || context == null)
                return ItemCheckResult.Continue;

            IEnumerable<string> properties = from d in rule.Declarations
                                             where d.PropertyName != null && d.Values.Count < 2
                                             select d.PropertyName.Text;


            foreach (string shorthand in _cache.Keys)
            {
                if (_cache[shorthand].All(p => properties.Contains(p)))
                {
                    Declaration dec = rule.Declarations.First(p => p.PropertyName != null && _cache[shorthand].Contains(p.PropertyName.Text));
                    string message = string.Format(CultureInfo.CurrentCulture, Resources.PerformanceUseShorthand, string.Join(", ", _cache[shorthand]), shorthand);

                    context.AddError(new SimpleErrorTag(dec, message));
                }
            }

            return ItemCheckResult.Continue;
        }
Example #5
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            RuleBlock rule = (RuleBlock)item;

            if (!rule.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            bool isInline = rule.Declarations.Any(d => d.PropertyName != null && d.PropertyName.Text == "display" && d.Values.Any(v => v.Text == "inline"));

            if (!isInline)
            {
                return(ItemCheckResult.Continue);
            }

            IEnumerable <Declaration> invalids = rule.Declarations.Where(d => invalidProperties.Contains(d.PropertyName.Text));

            foreach (Declaration invalid in invalids)
            {
                string error = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeInlineIncompat, invalid.PropertyName.Text);
                context.AddError(new SimpleErrorTag(invalid.PropertyName, error));
            }

            return(ItemCheckResult.Continue);
        }
Example #6
0
        private static void HandleDeclaration(ParseItem item, ICssCheckerContext context)
        {
            Declaration dec = (Declaration)item;

            if (dec == null || dec.PropertyName == null)
            {
                return;
            }

            if (dec.IsVendorSpecific())
            {
                string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C property", dec.PropertyName.Text);
                context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }

            foreach (var value in dec.Values)
            {
                string text = value.Text;
                if (!(value is NumericalValue) && text.StartsWith("-", StringComparison.Ordinal))
                {
                    int index = text.IndexOf('(');

                    if (index > -1)
                    {
                        text = text.Substring(0, index);
                    }

                    string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C value", text);
                    context.AddError(new SimpleErrorTag(value, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                }
            }
        }
Example #7
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            UrlItem url = (UrlItem)item;

            if (!WESettings.GetBoolean(WESettings.Keys.ValidateEmbedImages) || !url.IsValid || url.UrlString.Text.Contains("base64,") || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            string fileName = ImageQuickInfo.GetFileName(url.UrlString.Text);

            if (fileName.Contains("://"))
            {
                return(ItemCheckResult.Continue);
            }

            FileInfo file = new FileInfo(fileName);

            if (file.Exists && file.Length < (1024 * 3))
            {
                Declaration dec = url.FindType <Declaration>();
                if (dec != null && dec.PropertyName != null && dec.PropertyName.Text[0] != '*' && dec.PropertyName.Text[0] != '_')
                {
                    string error = string.Format(Resources.PerformanceEmbedImageAsDataUri, file.Length);
                    context.AddError(new SimpleErrorTag(url.UrlString, error));
                }
            }

            return(ItemCheckResult.Continue);
        }
Example #8
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateZeroUnit)
            {
                return(ItemCheckResult.Continue);
            }

            NumericalValue number = (NumericalValue)item;
            UnitValue      unit   = number as UnitValue;

            if (unit == null || context == null || item.FindType <Declaration>() == null)
            {
                return(ItemCheckResult.Continue);
            }

            // The 2nd and 3rd arguments to hsl() require units even when zero
            var function = unit.Parent.Parent as FunctionColor;

            if (function != null && function.FunctionName.Text.StartsWith("hsl", StringComparison.OrdinalIgnoreCase))
            {
                var arg = unit.Parent as FunctionArgument;
                if (arg != function.Arguments[0])
                {
                    return(ItemCheckResult.Continue);
                }
            }

            if (number.Number.Text == "0" && unit.UnitType != UnitType.Unknown && unit.UnitType != UnitType.Time)
            {
                string message = string.Format(System.Globalization.CultureInfo.CurrentCulture, Resources.BestPracticeZeroUnit, unit.UnitToken.Text);
                context.AddError(new SimpleErrorTag(number, message));
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            UrlItem url = (UrlItem)item;

            if (!WESettings.Instance.Css.ValidateEmbedImages || !url.IsValid || url.UrlString == null || url.UrlString.Text.Contains("base64,") || context == null)
                return ItemCheckResult.Continue;

            string fileName = ImageQuickInfo.GetFullUrl(url.UrlString.Text, WebEssentialsPackage.DTE.ActiveDocument.FullName);
            if (string.IsNullOrEmpty(fileName) || fileName.Contains("://"))
                return ItemCheckResult.Continue;

            // Remove parameters if any; c:/temp/myfile.ext?#iefix
            fileName = fileName.Split('?', '#')[0];

            try
            {
                FileInfo file = new FileInfo(fileName);

                if (file.Exists && file.Length < (1024 * 3))
                {
                    Declaration dec = url.FindType<Declaration>();
                    if (dec != null && dec.PropertyName != null && dec.PropertyName.Text[0] != '*' && dec.PropertyName.Text[0] != '_')
                    {
                        string error = string.Format(CultureInfo.CurrentCulture, Resources.PerformanceEmbedImageAsDataUri, file.Length);
                        context.AddError(new SimpleErrorTag(url.UrlString, error));
                    }
                }
            }
            catch { /* Ignore any error here */ }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            RuleBlock rule = (RuleBlock)item;

            if (!rule.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            IEnumerable <string> properties = from d in rule.Declarations
                                              where d.PropertyName != null && d.Values.Count < 2
                                              select d.PropertyName.Text;


            foreach (string shorthand in _cache.Keys)
            {
                if (_cache[shorthand].All(p => properties.Contains(p)))
                {
                    Declaration dec     = rule.Declarations.First(p => p.PropertyName != null && _cache[shorthand].Contains(p.PropertyName.Text));
                    string      message = string.Format(Resources.PerformanceUseShorthand, string.Join(", ", _cache[shorthand]), shorthand);

                    context.AddError(new SimpleErrorTag(dec, message));
                }
            }

            return(ItemCheckResult.Continue);
        }
Example #11
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateVendorSpecifics)
            {
                return(ItemCheckResult.Continue);
            }

            Declaration dec = (Declaration)item;

            if (!dec.IsValid || dec.IsVendorSpecific() || IgnoreProperty(dec) || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            ICssSchemaInstance schema = CssEditorChecker.GetSchemaForItem(context, item);
            var missingEntries        = dec.GetMissingVendorSpecifics(schema);

            if (missingEntries.ToArray().Length > 0)
            {
                var       missingPrefixes = missingEntries.Select(e => e.Substring(0, e.IndexOf('-', 1) + 1));
                string    error           = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeAddMissingVendorSpecific, dec.PropertyName.Text, string.Join(", ", missingPrefixes));
                ICssError tag             = new SimpleErrorTag(dec.PropertyName, error);
                context.AddError(tag);
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateVendorSpecifics)
                return ItemCheckResult.Continue;

            Declaration dec = (Declaration)item;

            if (!dec.IsValid || !dec.IsVendorSpecific() || context == null)
                return ItemCheckResult.Continue;

            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, item);

            ICssCompletionListEntry prop = schema.GetProperty(dec.PropertyName.Text);

            if (prop == null)
            {
                string message = string.Format(CultureInfo.CurrentCulture, Resources.ValidationVendorDeclarations, dec.PropertyName.Text);
                context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return ItemCheckResult.CancelCurrentItem;
            }
            else
            {
                string obsolete = prop.GetAttribute("obsolete");
                if (!string.IsNullOrEmpty(obsolete))
                {
                    string message = string.Format(CultureInfo.CurrentCulture, Resources.BestPracticeRemoveObsolete, dec.PropertyName.Text, obsolete);
                    context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListMessage));
                    return ItemCheckResult.CancelCurrentItem;
                }
            }

            return ItemCheckResult.Continue;
        }
Example #13
0
        public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
        {
            if (errors == null || context == null)
            {
                return;
            }

            for (int i = errors.Count - 1; i > -1; i--)
            {
                ICssError error = errors[i];

                if (error.Item == null || error.Item.StyleSheet == null || string.IsNullOrEmpty(error.Item.Text) || !(error.Item.StyleSheet is LessStyleSheet))
                {
                    continue;
                }

                // Remove errors from using the :extend pseudo class
                if (error.Item.Text.Contains(":extend("))
                {
                    errors.RemoveAt(i);
                }

                // Remove errors from using partial selectors
                else if (error.Item.PreviousSibling != null && error.Item.PreviousSibling.Text == "&")
                {
                    errors.RemoveAt(i);
                }
            }
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateVendorSpecifics)
                return ItemCheckResult.Continue;

            if (!item.IsValid || context == null)
                return ItemCheckResult.Continue;

            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, item);

            string normalized = item.Text.Trim(':');
            ICssCompletionListEntry pseudo = schema.GetPseudo(item.Text);

            if (normalized.Length > 0 && normalized[0] == '-' && pseudo == null)
            {
                string message = string.Format(CultureInfo.CurrentCulture, Resources.ValidationVendorPseudo, item.Text);
                context.AddError(new SimpleErrorTag(item, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return ItemCheckResult.CancelCurrentItem;
            }
            else if (pseudo != null)
            {
                string obsolete = pseudo.GetAttribute("obsolete");
                if (!string.IsNullOrEmpty(obsolete))
                {
                    string message = string.Format(CultureInfo.CurrentCulture, Resources.BestPracticeRemoveObsolete, normalized, obsolete);
                    context.AddError(new SimpleErrorTag(item, message, CssErrorFlags.TaskListMessage));
                    return ItemCheckResult.CancelCurrentItem;
                }
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            UrlItem url = (UrlItem)item;

            if (!WESettings.Instance.Css.ValidateEmbedImages || !url.IsValid || url.UrlString == null || url.UrlString.Text.Contains("base64,") || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            string fileName = ImageQuickInfo.GetFullUrl(url.UrlString.Text, EditorExtensionsPackage.DTE.ActiveDocument.FullName);

            if (string.IsNullOrEmpty(fileName) || fileName.Contains("://"))
            {
                return(ItemCheckResult.Continue);
            }

            FileInfo file = new FileInfo(fileName);

            if (file.Exists && file.Length < (1024 * 3))
            {
                Declaration dec = url.FindType <Declaration>();
                if (dec != null && dec.PropertyName != null && dec.PropertyName.Text[0] != '*' && dec.PropertyName.Text[0] != '_')
                {
                    string error = string.Format(CultureInfo.CurrentCulture, Resources.PerformanceEmbedImageAsDataUri, file.Length);
                    context.AddError(new SimpleErrorTag(url.UrlString, error));
                }
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (item.Text.TrimStart(':').StartsWith("-"))
                return ItemCheckResult.Continue;

            ParseItem next = item.NextSibling;
            //ParseItem prev = item.PreviousSibling;
            SimpleSelector sel = item.FindType<SimpleSelector>();

            //if (item.Text == ":hover" && prev != null && _invalids.Contains(prev.Text))
            //{
            //    string error = string.Format(Resources.ValidationHoverOrder, prev.Text);
            //    context.AddError(new SimpleErrorTag(item, error, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed));
            //}

            if (next != null)
            {
                if (next.Text.StartsWith(":") && item.IsPseudoElement() && !next.IsPseudoElement())
                {
                    string error = string.Format(Resources.ValidationPseudoOrder, item.Text, next.Text);
                    context.AddError(new SimpleErrorTag(item, error, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed));
                }

                else if (!next.Text.StartsWith(":") && item.AfterEnd == next.Start)
                {
                    string error = string.Format(Resources.BestPracticePseudosAfterOtherSelectors, next.Text);
                    context.AddError(new SimpleErrorTag(next, error));
                }
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (item.Text.TrimStart(':').StartsWith("-"))
            {
                return(ItemCheckResult.Continue);
            }

            ParseItem next = item.NextSibling;
            //ParseItem prev = item.PreviousSibling;
            SimpleSelector sel = item.FindType <SimpleSelector>();

            //if (item.Text == ":hover" && prev != null && _invalids.Contains(prev.Text))
            //{
            //    string error = string.Format(Resources.ValidationHoverOrder, prev.Text);
            //    context.AddError(new SimpleErrorTag(item, error, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed));
            //}

            if (next != null)
            {
                if (next.Text.StartsWith(":") && item.IsPseudoElement() && !next.IsPseudoElement())
                {
                    string error = string.Format(Resources.ValidationPseudoOrder, item.Text, next.Text);
                    context.AddError(new SimpleErrorTag(item, error, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed));
                }

                else if (!next.Text.StartsWith(":") && item.AfterEnd == next.Start)
                {
                    string error = string.Format(Resources.BestPracticePseudosAfterOtherSelectors, next.Text);
                    context.AddError(new SimpleErrorTag(next, error));
                }
            }

            return(ItemCheckResult.Continue);
        }
Example #18
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.GetBoolean(WESettings.Keys.ValidateVendorSpecifics))
            {
                return(ItemCheckResult.Continue);
            }

            AtDirective dir = item as AtDirective;

            if (!dir.IsValid || !dir.IsVendorSpecific() || context == null)
            {
                return(ItemCheckResult.Continue);
            }


            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema     = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, dir);

            if (schema.GetAtDirective("@" + dir.Keyword.Text) == null)
            {
                string message = string.Format(Resources.ValidationVendorDirective, dir.Keyword.Text);
                context.AddError(new SimpleErrorTag(dir.Keyword, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
Example #19
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (item.Text.TrimStart(':').StartsWith("-", StringComparison.Ordinal))
            {
                return(ItemCheckResult.Continue);
            }

            ParseItem next = item.NextSibling;

            if (next != null)
            {
                if (next.Text.StartsWith(":", StringComparison.Ordinal) && item.IsPseudoElement() && !next.IsPseudoElement())
                {
                    string error = string.Format(CultureInfo.CurrentCulture, Resources.ValidationPseudoOrder, item.Text, next.Text);
                    context.AddError(new SimpleErrorTag(item, error, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed));
                }
                else if (!next.Text.StartsWith(":", StringComparison.Ordinal) && item.AfterEnd == next.Start)
                {
                    string error = string.Format(CultureInfo.CurrentCulture, Resources.BestPracticePseudosAfterOtherSelectors, next.Text);
                    context.AddError(new SimpleErrorTag(next, error));
                }
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateVendorSpecifics)
                return ItemCheckResult.Continue;

            AtDirective directive = (AtDirective)item;

            if (context == null || !directive.IsValid || !directive.IsVendorSpecific())
                return ItemCheckResult.Continue;

            ICssCompletionListEntry entry = VendorHelpers.GetMatchingStandardEntry(directive, context);

            if (entry != null)
            {
                var visitor = new CssItemCollector<AtDirective>();
                directive.Parent.Accept(visitor);

                if (!visitor.Items.Any(a => a != null && a.Keyword != null && "@" + a.Keyword.Text == entry.DisplayText))
                {
                    string message = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeAddMissingStandardDirective, entry.DisplayText);
                    context.AddError(new SimpleErrorTag(directive.Keyword, message));
                    return ItemCheckResult.CancelCurrentItem;
                }
            }

            return ItemCheckResult.Continue;
        }
        //private HashSet<string> _deprecated = new HashSet<string>()
        //{
        //    "-moz-opacity",
        //    "-moz-outline",
        //    "-moz-outline-style",
        //};
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.GetBoolean(WESettings.Keys.ValidateVendorSpecifics))
                return ItemCheckResult.Continue;

            Declaration dec = (Declaration)item;

            if (!dec.IsValid || !dec.IsVendorSpecific() || context == null)
                return ItemCheckResult.Continue;

            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, item);

            //if (_deprecated.Contains(dec.PropertyName.Text))
            //{
            //    string message = string.Format(Resources.ValidationDeprecatedVendorDeclaration, dec.PropertyName.Text);
            //    context.AddError(new SimpleErrorTag(dec.PropertyName, message));
            //    return ItemCheckResult.CancelCurrentItem;
            //}
             if (schema.GetProperty(dec.PropertyName.Text) == null)
            {
                string message = string.Format(Resources.ValidationVendorDeclarations, dec.PropertyName.Text);
                context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return ItemCheckResult.CancelCurrentItem;
            }

            return ItemCheckResult.Continue;
        }
Example #22
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.GetBoolean(WESettings.Keys.ValidateVendorSpecifics))
            {
                return(ItemCheckResult.Continue);
            }

            if (!item.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema     = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, item);

            string normalized = item.Text.Trim(':');

            if (normalized.Length > 0 && normalized[0] == '-' && schema.GetPseudo(item.Text) == null)
            {
                string message = string.Format(Resources.ValidationVendorPseudo, item.Text);
                context.AddError(new SimpleErrorTag(item, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
Example #23
0
        //private HashSet<string> _deprecated = new HashSet<string>()
        //{
        //    "-moz-opacity",
        //    "-moz-outline",
        //    "-moz-outline-style",
        //};

        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.GetBoolean(WESettings.Keys.ValidateVendorSpecifics))
            {
                return(ItemCheckResult.Continue);
            }

            Declaration dec = (Declaration)item;

            if (!dec.IsValid || !dec.IsVendorSpecific() || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            ICssSchemaInstance rootSchema = CssSchemaManager.SchemaManager.GetSchemaRoot(null);
            ICssSchemaInstance schema     = CssSchemaManager.SchemaManager.GetSchemaForItem(rootSchema, item);

            //if (_deprecated.Contains(dec.PropertyName.Text))
            //{
            //    string message = string.Format(Resources.ValidationDeprecatedVendorDeclaration, dec.PropertyName.Text);
            //    context.AddError(new SimpleErrorTag(dec.PropertyName, message));
            //    return ItemCheckResult.CancelCurrentItem;
            //}
            if (schema.GetProperty(dec.PropertyName.Text) == null)
            {
                string message = string.Format(Resources.ValidationVendorDeclarations, dec.PropertyName.Text);
                context.AddError(new SimpleErrorTag(dec.PropertyName, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
Example #24
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            AtDirective directive = (AtDirective)item;

            if (context == null || !directive.IsValid || !directive.IsVendorSpecific())
            {
                return(ItemCheckResult.Continue);
            }

            ICssCompletionListEntry entry = VendorHelpers.GetMatchingStandardEntry(directive, context);

            if (entry != null)
            {
                var visitor = new CssItemCollector <AtDirective>();
                directive.Parent.Accept(visitor);
                if (!visitor.Items.Any(a => "@" + a.Keyword.Text == entry.DisplayText))
                {
                    string message = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeAddMissingStandardDirective, entry.DisplayText);
                    context.AddError(new SimpleErrorTag(directive.Keyword, message));
                    return(ItemCheckResult.CancelCurrentItem);
                }
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.GetBoolean(WESettings.Keys.ValidateZeroUnit))
                return ItemCheckResult.Continue;

            NumericalValue number = (NumericalValue)item;
            UnitValue unit = number as UnitValue;

            if (unit == null || context == null)
                return ItemCheckResult.Continue;

            // The 2nd and 3rd arguments to hsl() require units even when zero
            var function = unit.Parent.Parent as FunctionColor;
            if (function != null && function.FunctionName.Text.StartsWith("hsl", StringComparison.OrdinalIgnoreCase)) {
                var arg = unit.Parent as FunctionArgument;
                if (arg != function.Arguments[0])
                    return ItemCheckResult.Continue;
            }

            if (number.Number.Text == "0" && unit.UnitType != UnitType.Unknown && unit.UnitType != UnitType.Time)
            {
                string message = string.Format(Resources.BestPracticeZeroUnit, unit.UnitToken.Text);
                context.AddError(new SimpleErrorTag(number, message));
            }

            return ItemCheckResult.Continue;
        }
        public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
        {
            Document doc = EditorExtensionsPackage.DTE.ActiveDocument;
            if (doc == null || string.IsNullOrEmpty(doc.FullName) || !doc.FullName.EndsWith(".scss", StringComparison.OrdinalIgnoreCase))
                return;

            errors.Clear();
        }
Example #27
0
        private static void ValidateAlphaValue(ICssCheckerContext context, ParseItem argument, string text)
        {
            double value;

            if (double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value) && (value < 0 || value > 1))
            {
                context.AddError(new SimpleErrorTag(argument, "Validation: The opacity value must be between 0 and 1", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }
        }
Example #28
0
        private static void HandlePseudo(ParseItem item, ICssCheckerContext context)
        {
            string text = item.Text.TrimStart(':');

            if (text.StartsWith("-", StringComparison.Ordinal))
            {
                string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C pseudo class/element", item.Text);
                context.AddError(new SimpleErrorTag(item, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }
        }
        private static void HandlePseudo(ParseItem item, ICssCheckerContext context)
        {
            string text = item.Text.TrimStart(':');

            if (text.StartsWith("-", StringComparison.Ordinal))
            {
                string message = string.Format("Validation (W3C): \"{0}\" is not a valid W3C pseudo class/element", item.Text);
                context.AddError(new SimpleErrorTag(item, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }
        }
        private static void ValidateHsl(ICssCheckerContext context, FunctionColor function)
        {
            ParseItem argument;
            string text = "";
            string[] pair;
            int argumentCount = function.Arguments.Count;
            int value;

            if (function.FunctionName.Text.StartsWith("hsla", StringComparison.OrdinalIgnoreCase) && argumentCount < 4)
            {
                context.AddError(new SimpleErrorTag(function.Arguments[2], "Validation: HSLA expects alpha value between 0 and 1 as fourth parameter", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }

            for (int i = 0; i < argumentCount; i++)
            {
                argument = function.Arguments[i];
                text = argument.Text.Trim(',');

                if (i < 3)
                {
                    pair = text.Split('%');

                    if (pair.Length > 1 || pair[0].IsNumeric())
                    {
                        context.AddError(new SimpleErrorTag(argument, "Validation: Invalid value", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                    }

                    if (!int.TryParse(pair[0], out value))
                    {
                        context.AddError(new SimpleErrorTag(argument, "Validation: Missing value", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                    }

                    else
                    {
                        if (value < 0 || value > 100)
                        {
                            context.AddError(new SimpleErrorTag(argument, "Validation: Values must be between 0 and 100%", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                        }

                        if (i > 0 && value > 0 && pair[1] == "%")
                        {
                            context.AddError(new SimpleErrorTag(argument, "Validation: Parameter missing the % unit", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                        }
                    }
                }
                else if (function.FunctionName.Text.StartsWith("hsla", StringComparison.OrdinalIgnoreCase))
                {
                    ValidateAlphaValue(context, argument, text);
                }
                else
                {
                    context.AddError(new SimpleErrorTag(argument, "Validation: HSL cannot have fourth parameter. Are you confusing HSL with HSLA?", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                }
            }
        }
        public static ICssCompletionListEntry GetMatchingStandardEntry(AtDirective directive, ICssCheckerContext context)
        {
            string standardName;
            if (directive.TryGetStandardPropertyName(out standardName, CssEditorChecker.GetSchemaForItem(context, directive)))
            {
                ICssSchemaInstance schema = CssEditorChecker.GetSchemaForItem(context, directive);
                return schema.GetAtDirective("@" + standardName);
            }

            return null;
        }
        public static ICssCompletionListEntry GetMatchingStandardEntry(Declaration declaration, ICssCheckerContext context)
        {
            string standardName;
            if (declaration.TryGetStandardPropertyName(out standardName, CssEditorChecker.GetSchemaForItem(context, declaration)))
            {
                ICssSchemaInstance schema = CssEditorChecker.GetSchemaForItem(context, declaration);
                return schema.GetProperty(standardName);
            }

            return null;
        }
 public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError error = errors[i];
         Declaration dec = error.Item.FindType<Declaration>();
         if (dec != null && (dec.Text.Contains("var-") || dec.Text.Contains("var(")))
         {
             errors.RemoveAt(i);
         }
     }
 }
 public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError error = errors[i];
         
         if (error.Item.StyleSheet is LessStyleSheet && error.Text.Contains(":extend("))
         {
             errors.RemoveAt(i);                
         }
     }
 }
Example #35
0
 public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError   error = errors[i];
         Declaration dec   = error.Item.FindType <Declaration>();
         if (dec != null && (dec.Text.Contains("var-") || dec.Text.Contains("var(")))
         {
             errors.RemoveAt(i);
         }
     }
 }
        public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
        {
            for (int i = errors.Count - 1; i > -1; i--)
            {
                ICssError error = errors[i];

                if (error.Item.StyleSheet is LessStyleSheet && error.Text.Contains(":extend("))
                {
                    errors.RemoveAt(i);
                }
            }
        }
        public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
        {
            for (int i = errors.Count - 1; i > -1; i--)
            {
                ICssError       error = errors[i];
                LessDeclaration dec   = error.Item as LessDeclaration;

                if (dec != null && dec.Text.Contains("&"))
                {
                    errors.RemoveAt(i);
                }
            }
        }
        public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
        {
            for (int i = errors.Count - 1; i > -1; i--)
            {
                ICssError error = errors[i];
                LessDeclaration dec = error.Item as LessDeclaration;

                if (dec != null && dec.Text.Contains("&"))
                {
                    errors.RemoveAt(i);
                }
            }
        }
 public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError error = errors[i];
         Declaration dec = error.Item.FindType<Declaration>();
         if (dec != null && dec.IsValid && dec.PropertyName.Text == "-ms-filter")
         {
             errors.RemoveAt(i);
             errors.Insert(i, CreateNewError(error));
         }
     }
 }
Example #40
0
 public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError   error = errors[i];
         Declaration dec   = error.Item.FindType <Declaration>();
         if (dec != null && dec.IsValid && dec.PropertyName.Text == "-ms-filter")
         {
             errors.RemoveAt(i);
             errors.Insert(i, CreateNewError(error));
         }
     }
 }
        private static void HandleDirective(ParseItem item, ICssCheckerContext context)
        {
            AtDirective dir = (AtDirective)item;

            if (dir == null || dir.Keyword == null)
                return;

            if (dir.IsVendorSpecific())
            {
                string message = string.Format("Validation (W3C): \"@{0}\" is not a valid W3C @-directive", dir.Keyword.Text);
                context.AddError(new SimpleErrorTag(dir.Keyword, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (item.IsValid)
                return ItemCheckResult.Continue;

            if (item.Text.Contains(" or "))
            {
                ICssError tag = new SimpleErrorTag(item, _orInvalidMessage);
                context.AddError(tag);
                return ItemCheckResult.CancelCurrentItem;
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            FunctionColor function = (FunctionColor)item;
            
            if (!function.IsValid || context == null)
                return ItemCheckResult.Continue;

            if (function.FunctionName.Text.StartsWith("rgb"))
            {
                ValidateRgb(context, function);
            }

            return ItemCheckResult.Continue;
        }
Example #44
0
        private static void HandleDirective(ParseItem item, ICssCheckerContext context)
        {
            AtDirective dir = (AtDirective)item;

            if (dir == null || dir.Keyword == null)
            {
                return;
            }

            if (dir.IsVendorSpecific())
            {
                string message = string.Format("Validation (W3C): \"@{0}\" is not a valid W3C @-directive", dir.Keyword.Text);
                context.AddError(new SimpleErrorTag(dir.Keyword, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }
        }
Example #45
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (!WESettings.Instance.Css.ValidateDuplicateSelectors)
            {
                return(ItemCheckResult.Continue);
            }

            RuleSet rule = (RuleSet)item;

            if (!rule.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            List <RuleResult> cache = context.GetState(this) as List <RuleResult>;

            if (cache == null || (cache.Count > 0 && cache[0].Rule.Parent != rule.Parent))
            {
                cache = BuildCache(rule);
                context.SetState(this, cache);
            }

            string     ruleText = GetSelectorText(rule);
            int        start    = rule.Start;
            RuleResult dupe     = null;

            for (int i = 0; i < cache.Count; i++)
            {
                if (cache[i].Start >= start)
                {
                    break;
                }

                if (ruleText == cache[i].Value)
                {
                    dupe = cache[i];
                    break;
                }
            }

            if (dupe != null)
            {
                SelectorErrorTag tag = new SelectorErrorTag(rule.Selectors, "The selector " + ruleText + " is already specified earlier.  Consider combining the two rule-sets.");
                context.AddError(tag);
            }

            return(ItemCheckResult.Continue);
        }
Example #46
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            if (item.IsValid)
            {
                return(ItemCheckResult.Continue);
            }

            if (item.Text.Contains(" or "))
            {
                ICssError tag = new SimpleErrorTag(item, _orInvalidMessage);
                context.AddError(tag);
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            var directive = (ImportDirective)item;

            if (!directive.IsValid || context == null)
                return ItemCheckResult.Continue;

               if (directive.Keyword.Text == "import-once")
            {
                ICssError tag = new SimpleErrorTag(directive.Keyword, Resources.LessImportOnceDeprecated);
                context.AddError(tag);
                return ItemCheckResult.CancelCurrentItem;
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            FunctionColor function = (FunctionColor)item;

            if (!function.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            if (function.FunctionName.Text.StartsWith("rgb"))
            {
                ValidateRgb(context, function);
            }

            return(ItemCheckResult.Continue);
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            RuleSet rule = (RuleSet)item;

            if (!rule.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            List <RuleResult> cache = context.GetState(this) as List <RuleResult>;

            if (cache == null || (cache.Count > 0 && cache[0].Rule.Parent != rule.Parent))
            {
                cache = BuildCache(rule);
                context.SetState(this, cache);
            }

            string     ruleText = GetSelectorText(rule);
            int        start    = rule.Start;
            RuleResult dupe     = null;

            for (int i = 0; i < cache.Count; i++)
            {
                if (cache[i].Start >= start)
                {
                    break;
                }

                if (ruleText == cache[i].Value)
                {
                    dupe = cache[i];
                    break;
                }
            }

            if (dupe != null)
            {
                int length = GetSelectorLength(rule);
                int lineNo = FindLineNumber(dupe);

                string           errorMessage = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeDuplicateSelectors, lineNo);
                SelectorErrorTag tag          = new SelectorErrorTag(rule.Selectors, errorMessage);
                context.AddError(tag);
            }

            return(ItemCheckResult.Continue);
        }
Example #50
0
 public void FilterErrorList(IList <ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError error = errors[i];
         if (error.Item.IsValid)
         {
             AtDirective atDir = error.Item.FindType <AtDirective>();
             if (atDir != null && atDir.IsValid && atDir.Keyword.Text == "-ms-keyframes")
             {
                 errors.RemoveAt(i);
                 ICssError tag = new SimpleErrorTag(error.Item, error.Text + _message, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed);
                 errors.Insert(i, tag);
             }
         }
     }
 }
        private static void ValidateHsl(ICssCheckerContext context, FunctionColor function)
        {
            ParseItem argument;
            string    text = "";

            string[] pair;
            int      argumentCount = function.Arguments.Count;
            int      value;

            if (function.FunctionName.Text.StartsWith("hsla", StringComparison.OrdinalIgnoreCase) && argumentCount < 4)
            {
                context.AddError(new SimpleErrorTag(function.Arguments[2], "Validation: HSLA expects alpha value between 0 and 1 as fourth parameter", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }

            for (int i = 0; i < argumentCount; i++)
            {
                argument = function.Arguments[i];
                text     = argument.Text.Trim(',');

                if (i < 3)
                {
                    pair = text.Split('%');

                    if (int.TryParse(pair[0], out value))
                    {
                        if (value < 0 || value > 100 && i > 0)
                        {
                            context.AddError(new SimpleErrorTag(argument, "Validation: Values must be between 0 and 100%", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                        }

                        if (i > 0 && value > 0 && pair[1] == "%")
                        {
                            context.AddError(new SimpleErrorTag(argument, "Validation: Parameter missing the % unit", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                        }
                    }
                }
                else if (function.FunctionName.Text.StartsWith("hsla", StringComparison.OrdinalIgnoreCase))
                {
                    ValidateAlphaValue(context, argument, text);
                }
                else
                {
                    context.AddError(new SimpleErrorTag(argument, "Validation: HSL cannot have fourth parameter. Are you confusing HSL with HSLA?", CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                }
            }
        }
 public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
 {
     for (int i = errors.Count - 1; i > -1; i--)
     {
         ICssError error = errors[i];
         if (error.Item.IsValid)
         {
             AtDirective atDir = error.Item.FindType<AtDirective>();
             if (atDir != null && atDir.IsValid && atDir.Keyword.Text == "-ms-keyframes")
             {
                 errors.RemoveAt(i);
                 ICssError tag = new SimpleErrorTag(error.Item, error.Text + _message, CssErrorFlags.TaskListError | CssErrorFlags.UnderlineRed);
                 errors.Insert(i, tag);
             }
         }
     }
 }
Example #53
0
        // The rules of this error is specified here: https://github.com/stubbornella/csslint/wiki/Disallow-duplicate-properties
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            RuleBlock rule = (RuleBlock)item;

            if (!rule.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            Dictionary <string, string> dic = new Dictionary <string, string>();

            foreach (Declaration declaration in rule.Declarations)
            {
                ParseItem prop = declaration.PropertyName;
                if (prop == null || prop.Text == "filter")
                {
                    continue;
                }

                string error = null;

                if (!dic.ContainsKey(declaration.Text))
                {
                    if (dic.ContainsValue(prop.Text) && dic.Last().Value != prop.Text)
                    {
                        // The same property name is specified, but not by the immidiate previous declaration
                        error = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeDuplicatePropertyInRule, prop.Text);
                    }

                    dic.Add(declaration.Text, prop.Text);
                }
                else
                {
                    // The same property and value exist more than once in the rule. The exact declaration duplicate
                    error = string.Format(CultureInfo.InvariantCulture, Resources.BestPracticeDuplicatePropertyWithSameValueInRule, prop.Text);
                }

                if (error != null)
                {
                    context.AddError(new SimpleErrorTag(prop, error));
                }
            }

            return(ItemCheckResult.Continue);
        }
Example #54
0
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            var directive = (ImportDirective)item;

            if (!directive.IsValid || context == null)
            {
                return(ItemCheckResult.Continue);
            }

            if (directive.Keyword.Text == "import-once")
            {
                ICssError tag = new SimpleErrorTag(directive.Keyword, Resources.LessImportOnceDeprecated);
                context.AddError(tag);
                return(ItemCheckResult.CancelCurrentItem);
            }

            return(ItemCheckResult.Continue);
        }
        public void FilterErrorList(IList<ICssError> errors, ICssCheckerContext context)
        {
            for (int i = errors.Count - 1; i > -1; i--)
            {
                ICssError error = errors[i];

                if (!(error.Item.StyleSheet is LessStyleSheet))
                    continue;

                // Remove errors from using the :extend pseudo class
                if (error.Item.Text.Contains(":extend("))
                    errors.RemoveAt(i);

                // Remove errors from using partial selectors
                else if (error.Item.PreviousSibling != null && error.Item.PreviousSibling.Text == "&")
                    errors.RemoveAt(i);
            }
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            SimpleSelector sel = (SimpleSelector)item;

            if (!WESettings.GetBoolean(WESettings.Keys.ValidateStarSelector) || !sel.IsValid || context == null)
                return ItemCheckResult.Continue;

            if (sel.Text == "*")
            {
                    string errorMessage = string.Format(CultureInfo.InvariantCulture, Resources.PerformanceDontUseStarSelector);

                    SimpleErrorTag tag = new SimpleErrorTag(sel, errorMessage);

                    context.AddError(tag);
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            FunctionColor function = (FunctionColor)item;

            if (!function.IsValid || context == null)
                return ItemCheckResult.Continue;

            if (function.FunctionName.Text.StartsWith("rgb", StringComparison.OrdinalIgnoreCase))
            {
                ValidateRgb(context, function);
            }
            else if (function.FunctionName.Text.StartsWith("hsl", StringComparison.OrdinalIgnoreCase))
            {
                ValidateHsl(context, function);
            }

            return ItemCheckResult.Continue;
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            ItemName itemName = (ItemName)item;

            if (!itemName.IsValid || context == null || (item.PreviousSibling != null && item.PreviousSibling.Text == "["))
                return ItemCheckResult.Continue;

            if (!_cache.Contains(itemName.Text.ToLowerInvariant()) && itemName.Text.IndexOf('-') == -1)
            {
                string error = "Validation: \"" + itemName.Text + "\" isn't a valid HTML tag.";
                ICssError tag = new SimpleErrorTag(itemName, error);
                context.AddError(tag);

                return ItemCheckResult.CancelCurrentItem;
            }

            return ItemCheckResult.Continue;
        }
        private static void ValidateRgb(ICssCheckerContext context, FunctionColor function)
        {
            for (int i = 0; i < function.Arguments.Count; i++)
            {
                var argument = function.Arguments[i];
                string text = argument.Text.Trim(',');

                if (i < 3)
                {
                    int value;
                    if (int.TryParse(text, out value) && (value < 0 || value > 255))
                        context.AddError(new SimpleErrorTag(argument, Resources.ValidationColorValuesInRange, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
                }
                else
                {
                    ValidateAlphaValue(context, argument, text);
                }
            }
        }
        public ItemCheckResult CheckItem(ParseItem item, ICssCheckerContext context)
        {
            var media = item as MediaExpression;

            if (media == null || context == null || !IsWindowsWebApp())
                return ItemCheckResult.Continue;

            int index = media.Text.IndexOf("-ms-view-state", StringComparison.OrdinalIgnoreCase);
            
            if (index > -1)
            {
                var property = item.StyleSheet.ItemAfterPosition(media.Start + index);

                string message = "The -ms-view-state has been deprecated in Internet Explorer 11";
                context.AddError(new SimpleErrorTag(property, message, CssErrorFlags.TaskListWarning | CssErrorFlags.UnderlineRed));
            }

            return ItemCheckResult.Continue;
        }