ruby_css_lint 0.0.1

data/csslint/tests/rules/import.js

@@ -0,0 +1,18 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Import Rule Errors",
+        
+        "Using @import should result in a warning": function(){
+            var result = CSSLint.verify("@import url('foo.css');", { "import": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("@import prevents parallel downloads, use <link> instead.", result.messages[0].message);
+        }
+    }));
+
+})();

data/csslint/tests/rules/important.js

@@ -0,0 +1,27 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "!important; Errors",
+
+        "!important declarations should result in a warning": function(){
+            var result = CSSLint.verify("h1 { color:#fff !important; }", { "important": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Use of !important", result.messages[0].message);
+        },
+
+        "Using !important at least 10 times should result in an error": function(){
+            var css = "h1 { color:#fff !important; } h2 { color:#fff !important; } h3 { color:#fff !important; } h4 { color:#fff !important; } h5 { color:#fff !important; } h6 { color:#fff !important; } p { color:#fff !important; } ul { color:#fff !important; } ol { color:#fff !important; } li { color:#fff !important; }";
+            var result = CSSLint.verify(css, { "important": 1 });
+            Assert.areEqual(11, result.messages.length);
+            Assert.areEqual("warning", result.messages[10].type);
+            Assert.areEqual("Too many !important declarations (10), try to use less than 10 to avoid specificity issues.", result.messages[10].message);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/known-properties.js

@@ -0,0 +1,44 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Known Properties Errors",
+
+        "Using an unknown property should result in a warning": function(){
+            var result = CSSLint.verify("h1 { foo: red;}", { "known-properties": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Unknown property 'foo'.", result.messages[0].message);
+        },
+
+        "Using a known property should not result in a warning": function(){
+            var result = CSSLint.verify("h1 { color: red;}", { "known-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using a known property with the star hack should not result in a warning": function(){
+            var result = CSSLint.verify("h1 { *color: red;}", { "known-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using a known property with the underscore hack should not result in a warning": function(){
+            var result = CSSLint.verify("h1 { _color: red;}", { "known-properties": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using a vendor-prefix property should not result in a warning": function(){
+            var result = CSSLint.verify("h2 { -moz-border-radius: 5px; }", { "known-properties": 1 });
+            Assert.areEqual(0, result.messages.length);        
+        },
+        
+        "Using src in @font-face should not result in a warning": function(){
+            var result = CSSLint.verify("@font-face { src: url(foo.otf); }", { "known-properties": 1 });
+            Assert.areEqual(0, result.messages.length);    
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/outline-none.js

@@ -0,0 +1,50 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Outline:none Errors",
+
+        "Using outline: none should result in a warning": function(){
+            var result = CSSLint.verify(".foo { outline: none; }", { "outline-none": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Outlines should only be modified using :focus.", result.messages[0].message);
+        },
+
+        "Using outline: 0 should result in a warning": function(){
+            var result = CSSLint.verify(".foo { outline: 0; }", { "outline-none": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Outlines should only be modified using :focus.", result.messages[0].message);
+        },
+        
+        "Using outline: none alone with :focus should result in a warning": function(){
+            var result = CSSLint.verify(".foo:focus { outline: none; }", { "outline-none": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Outlines shouldn't be hidden unless other visual changes are made.", result.messages[0].message);
+        },
+
+        "Using outline: 0 alone with :focus should result in a warning": function(){
+            var result = CSSLint.verify(".foo:focus { outline: 0; }", { "outline-none": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Outlines shouldn't be hidden unless other visual changes are made.", result.messages[0].message);
+        },
+        
+        "Using outline: none with :focus and another property should not result in a warning": function(){
+            var result = CSSLint.verify(".foo:focus { outline: none; border: 1px solid black; }", { "outline-none": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using outline: 0 with :focus and another property should not result in a warning": function(){
+            var result = CSSLint.verify(".foo:focus { outline: 0; border: 1px solid black;}", { "outline-none": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/overqualified-elements.js

@@ -0,0 +1,41 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Overqualified Elements Errors",
+
+        "Using an ID with an element should result in one warning": function(){
+            var result = CSSLint.verify("li#foo { float: left;}", { "overqualified-elements": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Element (li#foo) is overqualified, just use #foo without element name.", result.messages[0].message);
+        },
+
+        "Using a class without an element should not result in a warning": function(){
+            var result = CSSLint.verify(".foo { float: left;}", { "overqualified-elements": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "Using a class with an element should result in one warning": function(){
+            var result = CSSLint.verify("li.foo { float: left;}", { "overqualified-elements": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Element (li.foo) is overqualified, just use .foo without element name.", result.messages[0].message);
+        },
+        
+        "Using a class with two different elements should not result in a warning": function(){
+            var result = CSSLint.verify("li.foo { float: left;} p.foo { float: right; }", { "overqualified-elements": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Using a class with an element and without should not result in a warning": function(){
+            var result = CSSLint.verify("li.foo { float: left;} .foo { float: right; }", { "overqualified-elements": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/qualified-headings.js

@@ -0,0 +1,19 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Qualified Headings Errors",
+
+        "Using a heading as a descendant should result in one warning": function(){
+            var result = CSSLint.verify("li h3{ float: left;}", { "qualified-headings": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Heading (h3) should not be qualified.", result.messages[0].message);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/regex-selectors.js

@@ -0,0 +1,52 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Regex Selectors Errors",
+
+        "Using |= in an attribute selector should result in one warning": function(){
+            var result = CSSLint.verify("li[class|=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Attribute selectors with |= are slow!", result.messages[0].message);
+        },
+
+        "Using *= in an attribute selector should result in one warning": function(){
+            var result = CSSLint.verify("li[class*=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Attribute selectors with *= are slow!", result.messages[0].message);
+        },
+
+        "Using $= in an attribute selector should result in one warning": function(){
+            var result = CSSLint.verify("li[class$=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Attribute selectors with $= are slow!", result.messages[0].message);
+        },
+
+        "Using ~= in an attribute selector should result in one warning": function(){
+            var result = CSSLint.verify("li[class~=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Attribute selectors with ~= are slow!", result.messages[0].message);
+        },
+
+        "Using ^= in an attribute selector should result in one warning": function(){
+            var result = CSSLint.verify("li[class^=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Attribute selectors with ^= are slow!", result.messages[0].message);
+        },
+
+        "Using = in an attribute selector should not result in a warning": function(){
+            var result = CSSLint.verify("li[class=foo]{ color: red; }", { "regex-selectors": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/shorthand.js

@@ -0,0 +1,36 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+    
+        name: "Shorthand Rule Errors",
+
+        "All padding properties should result in a warning": function(){
+            var result = CSSLint.verify(".foo{padding-top: 0px; padding-left: 3px; padding-right: 25px; padding-bottom: 10px;}", {"shorthand": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("The properties padding-top, padding-bottom, padding-left, padding-right can be replaced by padding.", result.messages[0].message);
+        },
+
+        "All margin properties should result in a warning": function(){
+            var result = CSSLint.verify(".foo{margin-top: 0px; margin-left: 3px; margin-right: 25px; margin-bottom: 10px;}", {"shorthand": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("The properties margin-top, margin-bottom, margin-left, margin-right can be replaced by margin.", result.messages[0].message);
+        },
+
+        "padding-left should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{ padding-left: 8px;} ", {"shorthand": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "margin-top should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{ margin-top: 8px;} ", {"shorthand": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+				
+    }));
+
+})();

data/csslint/tests/rules/star-property-hack.js

@@ -0,0 +1,24 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "star-property-hack Rule Errors",
+
+        "a property with a star prefix should result in a warning": function(){
+            var result = CSSLint.verify(".foo{*width: 100px;}", {"star-property-hack": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Property with star prefix found.", result.messages[0].message);
+        },
+
+        "a property without a star prefix should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{width: 100px;}", {"star-property-hack": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/text-indent.js

@@ -0,0 +1,55 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "text-indent Rule Errors",
+
+        "-100px text-indent should result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: -100px;}", {"text-indent": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Negative text-indent doesn't work well with RTL. If you use text-indent for image replacement explicitly set direction for that item to ltr.", result.messages[0].message);
+        },
+
+        "-99px text-indent should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: -99px;} ", {"text-indent": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "-99em text-indent should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: -99em;} ", {"text-indent": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "-100px text-indent with LTR should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: -100px; direction: ltr; }", {"text-indent": 1 });
+            Assert.areEqual(0, result.messages.length);
+            result = CSSLint.verify(".foo{direction: ltr; text-indent: -100px; }", {"text-indent": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "-100em text-indent with RTL should result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: -100em; direction: rtl; }", {"text-indent": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Negative text-indent doesn't work well with RTL. If you use text-indent for image replacement explicitly set direction for that item to ltr.", result.messages[0].message);
+        },
+
+        "5px text-indent should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{text-indent: 5px;}", {"text-indent": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "This should cause a warning, not an error": function(){
+            var result = CSSLint.verify(".top h1 a { background: url(../images/background/logo.png) no-repeat; display: block; height: 44px; position: relative; text-indent: -9999px; width: 250px; }", { "text-indent": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Negative text-indent doesn't work well with RTL. If you use text-indent for image replacement explicitly set direction for that item to ltr.", result.messages[0].message);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/underscore-property-hack.js

@@ -0,0 +1,24 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "underscore-property-hack Rule Errors",
+
+        "a property with an underscore prefix should result in a warning": function(){
+            var result = CSSLint.verify(".foo{_width: 100px;}", {"underscore-property-hack": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Property with underscore prefix found.", result.messages[0].message);
+        },
+
+        "a property without an underscore prefix should not result in a warning": function(){
+            var result = CSSLint.verify(".foo{width: 100px;}", {"underscore-property-hack": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/unique-headings.js

@@ -0,0 +1,47 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Unique Headings Errors",
+
+        "Defining two rules for h1 should result in two warnings": function(){
+            var result = CSSLint.verify("h1 { color: red;} h1 {color: blue;}", { "unique-headings": 1 });
+            Assert.areEqual(2, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Heading (h1) has already been defined.", result.messages[0].message);
+            Assert.areEqual("warning", result.messages[1].type);
+            Assert.areEqual("You have 2 h1s defined in this stylesheet.", result.messages[1].message);
+        },
+
+        "Defining two rules for h1 and h2 should result in one warning": function(){
+            var result = CSSLint.verify("h1 { color: red;} h1 {color: blue;} h2 { color: red;} h2 {color: blue;}", { "unique-headings": 1 });
+            Assert.areEqual(3, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Heading (h1) has already been defined.", result.messages[0].message);
+            Assert.areEqual("warning", result.messages[1].type);
+            Assert.areEqual("Heading (h2) has already been defined.", result.messages[1].message);
+            Assert.areEqual("warning", result.messages[2].type);
+            Assert.areEqual("You have 2 h1s, 2 h2s defined in this stylesheet.", result.messages[2].message);
+        },
+
+        "Defining one rule for h1 should not result in a warning": function(){
+            var result = CSSLint.verify("h1 { color: red;}", { "unique-headings": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Defining a rule for h1 and h1:hover should not result in a warning": function(){
+            var result = CSSLint.verify("h1 { color: red;} h1:hover { color: blue; }", { "unique-headings": 1 });
+            Assert.areEqual(0, result.messages.length);
+        },
+
+        "Defining multiple rules that contain h1 should not result in a warning": function(){
+            var result = CSSLint.verify("h2 a, h2 a:active, h2 a:hover, h2 a:visited, h2 a:link { color: red;}", { "unique-headings": 1 });
+            Assert.areEqual(0, result.messages.length);        
+        }
+
+    }));
+
+})();