ruby_css_lint 0.0.1

data/csslint/tests/all-rules.js

@@ -0,0 +1,64 @@
+/*
+ * This file contains generic tests that are run against every rule. Early on,
+ * we found some common rule patterns that would cause errors under certain
+ * conditions. Instead of tracking them down individually, this file runs
+ * the same tests on every defined rule to track down these patterns.
+ *
+ * When run in addition to the other tests, this causes the Rhino CLI test
+ * to fail due to Java stack overflow. This must be run separate from other tests.
+ */
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert,
+        suite   = new YUITest.TestSuite("General Tests for all Rules"),
+        rules   = CSSLint.getRules(),
+        i, len;
+
+    for (i=0, len=25; i < len; i++){
+
+        (function(i, rules){
+
+            suite.add(new YUITest.TestCase({
+
+                name: "General Tests for " + rules[i].id,
+
+                setUp: function(){
+                    this.options = {};
+                    this.options[rules[i].id] = 1;
+                },
+
+                "Using @keyframes should not result in an error": function(){
+                    var result = CSSLint.verify("@keyframes resize { 0% {padding: 0;} 50% {padding: 0;} 100% {padding: 0;}}", this.options);
+                    Assert.areEqual(0, result.messages.length);
+                },
+
+                "Using @font-face should not result in an error": function(){
+                    var result = CSSLint.verify("@font-face { src: local(foo); }", this.options);
+                    Assert.areEqual(0, result.messages.length);
+                },
+
+                "Using @page should not result in an error": function(){
+                    var result = CSSLint.verify("@page { width: 100px; }", this.options);
+                    Assert.areEqual(0, result.messages.length);
+                },
+
+                "Using @page @top-left should not result in an error": function(){
+                    var result = CSSLint.verify("@page { @top-left { content: ''; } }", this.options);
+                    Assert.areEqual(0, result.messages.length);
+                },
+
+                "Using a regular rule should not result in an error": function(){
+                    var result = CSSLint.verify("body { margin: 0; }", this.options);
+                    Assert.areEqual(0, result.messages.length);
+                }
+
+            }));
+
+        })(i, rules);
+
+    }
+
+    YUITest.TestRunner.add(suite);
+
+})();

data/csslint/tests/core/CSSLint.js

@@ -0,0 +1,22 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "CSSLint object tests",
+        
+        "Adjoining classes should not cause an error": function(){
+            var result = CSSLint.verify(".foo.bar{}", { });
+            Assert.areEqual(0, result.messages.length);
+        },
+        
+        "@media (max-width:400px) should not cause an error": function(){
+            var result = CSSLint.verify("@media (max-width:400px) {}", { });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();

data/csslint/tests/core/Reporter.js

@@ -0,0 +1,36 @@
+(function(){
+
+    /*global YUITest, CSSLint, Reporter*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Reporter Object Tests",
+        
+        "Report should cause a warning": function(){
+            var reporter = new CSSLint._Reporter([], { "fake-rule": 1});
+            reporter.report("Foo", 1, 1, { id: "fake-rule" });
+            
+            Assert.areEqual(1, reporter.messages.length);
+            Assert.areEqual("warning", reporter.messages[0].type);
+        },
+        
+        "Report should cause an error": function(){
+            var reporter = new CSSLint._Reporter([], { "fake-rule": 2});
+            reporter.report("Foo", 1, 1, { id: "fake-rule" });
+            
+            Assert.areEqual(1, reporter.messages.length);
+            Assert.areEqual("error", reporter.messages[0].type);
+        },
+        
+        "Calling error() should cause an error": function(){
+            var reporter = new CSSLint._Reporter([], { "fake-rule": 1});
+            reporter.error("Foo", 1, 1, { id: "fake-rule" });
+            
+            Assert.areEqual(1, reporter.messages.length);
+            Assert.areEqual("error", reporter.messages[0].type);
+        }
+
+    }));
+
+})();

data/csslint/tests/css/width-100.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>Untitled Document</title>
+<style type="text/css">
+.parent {padding: 100px;background-color:#999999}
+.child {width:100%;background-color: #CCCCCC; border-collapse:collapse;}
+td{border: 15px solid red;}
+</style>
+
+</head>
+
+<body>
+<div class="parent">
+	<div class="child">
+  	width 100% child in a parent with padding.
+  </div>
+</div>
+
+<div class="parent">
+	<table class="child">
+  <tr>
+    <th scope="col">filler</th>
+    <th scope="col">filler</th>
+    <th scope="col">filler</th>
+    <th scope="col">filler</th>
+    <th scope="col">filler</th>
+    <th scope="col">filler</th>
+  </tr>
+  <tr>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+  </tr>
+  <tr>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+  </tr>
+  <tr>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+  </tr>
+  <tr>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+  </tr>
+  <tr>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+    <td>filler</td>
+  </tr>
+</table>
+
+</div>
+
+</body>
+</html>

data/csslint/tests/formatters/checkstyle-xml.js

@@ -0,0 +1,44 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Checkstyle XML formatter test",
+
+        "File with no problems should say so": function(){
+            var result = { messages: [], stats: [] },
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle></checkstyle>";
+            Assert.areEqual(expected, CSSLint.format(result, "FILE", "checkstyle-xml"));
+        },
+
+        "File with problems should list them": function(){
+            var result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: { name: "A Rule"} },
+                     { type: "error", line: 2, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: { name: "Some Other Rule"} }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<error line=\"1\" column=\"1\" severity=\"warning\" message=\"BOGUS\" source=\"net.csslint.ARule\"/>",
+                error2 = "<error line=\"2\" column=\"1\" severity=\"error\" message=\"BOGUS\" source=\"net.csslint.SomeOtherRule\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle>" + file + error1 + error2 + "</file></checkstyle>",
+                actual = CSSLint.format(result, "FILE", "checkstyle-xml");
+            Assert.areEqual(expected, actual);
+        },
+
+        "Formatter should escape special characters": function() {
+            var specialCharsSting = 'sneaky, "sneaky", <sneaky>, sneak & sneaky',
+                result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: specialCharsSting, evidence: "ALSO BOGUS", rule: [] },
+                     { type: "error", line: 2, col: 1, message: specialCharsSting, evidence: "ALSO BOGUS", rule: [] }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<error line=\"1\" column=\"1\" severity=\"warning\" message=\"sneaky, &quot;sneaky&quot;, &lt;sneaky&gt;, sneak &amp; sneaky\" source=\"\"/>",
+                error2 = "<error line=\"2\" column=\"1\" severity=\"error\" message=\"sneaky, &quot;sneaky&quot;, &lt;sneaky&gt;, sneak &amp; sneaky\" source=\"\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><checkstyle>" + file + error1 + error2 + "</file></checkstyle>",
+                actual = CSSLint.format(result, "FILE", "checkstyle-xml");
+            Assert.areEqual(expected, actual);
+        }
+
+    }));
+})();

data/csslint/tests/formatters/compact.js

@@ -0,0 +1,47 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+        name: "Compact formatter",
+
+        "File with no problems should say so": function() {
+            var result = { messages: [], stats: [] },
+                actual = CSSLint.getFormatter("compact").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE"});
+            Assert.areEqual("path/to/FILE: Lint Free!", actual);
+        },
+
+        "Should have no output when quiet option is specified and no errors": function() {
+            var result = { messages: [], stats: [] },
+                actual = CSSLint.getFormatter("compact").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE", quiet: "true"});
+            Assert.areEqual("", actual);
+        },
+
+        "File with problems should list them": function() {
+            var result = { messages: [ 
+                     { type: 'error', line: 2, col: 1, message: 'BOGUS ERROR', evidence: 'BOGUS', rule: [] },
+                     { type: 'warning', line: 1, col: 1, message: 'BOGUS WARNING', evidence: 'BOGUS', rule: [] }
+                ], stats: [] },
+                err = "path/to/FILE: line 2, col 1, Error - BOGUS ERROR\n",
+                warning = "path/to/FILE: line 1, col 1, Warning - BOGUS WARNING\n",
+                expected = err + warning,
+                actual = CSSLint.getFormatter("compact").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE"});
+            Assert.areEqual(expected, actual);
+        },
+
+        "Should output relative file paths": function() {
+            var result = { messages: [ 
+                    { type: 'error', line: 2, col: 1, message: 'BOGUS ERROR', evidence: 'BOGUS', rule: [] },
+                    { type: 'warning', line: 1, col: 1, message: 'BOGUS WARNING', evidence: 'BOGUS', rule: [] }
+                ], stats: [] },
+                err = "path/to/FILE: line 2, col 1, Error - BOGUS ERROR\n",
+                warning = "path/to/FILE: line 1, col 1, Warning - BOGUS WARNING\n",
+                expected = err + warning,
+                actual = CSSLint.getFormatter("compact").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE"});
+            Assert.areEqual(expected, actual);
+        }
+
+    }));
+
+})();

data/csslint/tests/formatters/csslint-xml.js

@@ -0,0 +1,42 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+        name: "CSSLint XML formatter test",
+        
+        "File with no problems should say so": function(){
+            var result = { messages: [], stats: [] },
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><csslint></csslint>";
+            Assert.areEqual(expected, CSSLint.format(result, "FILE", "csslint-xml"));
+        },
+
+        "File with problems should list them": function(){
+            var result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: [] },
+                     { type: "error", line: 2, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: [] }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<issue line=\"1\" char=\"1\" severity=\"warning\" reason=\"BOGUS\" evidence=\"ALSO BOGUS\"/>",
+                error2 = "<issue line=\"2\" char=\"1\" severity=\"error\" reason=\"BOGUS\" evidence=\"ALSO BOGUS\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><csslint>" + file + error1 + error2 + "</file></csslint>",
+                actual = CSSLint.format(result, "FILE", "csslint-xml");
+            Assert.areEqual(expected, actual);
+        },
+
+        "Formatter should escape double quotes": function() {
+            var doubleQuotedEvidence = 'sneaky, "sneaky", <sneaky>, sneak & sneaky',
+                result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: "BOGUS", evidence: doubleQuotedEvidence, rule: [] },
+                     { type: "error", line: 2, col: 1, message: "BOGUS", evidence: doubleQuotedEvidence, rule: [] }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<issue line=\"1\" char=\"1\" severity=\"warning\" reason=\"BOGUS\" evidence=\"sneaky, 'sneaky', &lt;sneaky&gt;, sneak &amp; sneaky\"/>",
+                error2 = "<issue line=\"2\" char=\"1\" severity=\"error\" reason=\"BOGUS\" evidence=\"sneaky, 'sneaky', &lt;sneaky&gt;, sneak &amp; sneaky\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><csslint>" + file + error1 + error2 + "</file></csslint>",
+                actual = CSSLint.format(result, "FILE", "csslint-xml");
+            Assert.areEqual(expected, actual);
+        }
+    }));
+})();

data/csslint/tests/formatters/lint-xml.js

@@ -0,0 +1,43 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Lint XML formatter test",
+        
+        "File with no problems should say so": function(){
+            var result = { messages: [], stats: [] },
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><lint></lint>";
+            Assert.areEqual(expected, CSSLint.format(result, "FILE", "lint-xml"));
+        },
+
+        "File with problems should list them": function(){
+            var result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: [] },
+                     { type: "error", line: 2, col: 1, message: "BOGUS", evidence: "ALSO BOGUS", rule: [] }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<issue line=\"1\" char=\"1\" severity=\"warning\" reason=\"BOGUS\" evidence=\"ALSO BOGUS\"/>",
+                error2 = "<issue line=\"2\" char=\"1\" severity=\"error\" reason=\"BOGUS\" evidence=\"ALSO BOGUS\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><lint>" + file + error1 + error2 + "</file></lint>",
+                actual = CSSLint.format(result, "FILE", "lint-xml");
+            Assert.areEqual(expected, actual);
+        },
+
+        "Formatter should escape double quotes": function() {
+            var doubleQuotedEvidence = 'sneaky, "sneaky", <sneaky>, sneak & sneaky',
+                result = { messages: [
+                     { type: "warning", line: 1, col: 1, message: "BOGUS", evidence: doubleQuotedEvidence, rule: [] },
+                     { type: "error", line: 2, col: 1, message: "BOGUS", evidence: doubleQuotedEvidence, rule: [] }
+                ], stats: [] },
+                file = "<file name=\"FILE\">",
+                error1 = "<issue line=\"1\" char=\"1\" severity=\"warning\" reason=\"BOGUS\" evidence=\"sneaky, 'sneaky', &lt;sneaky&gt;, sneak &amp; sneaky\"/>",
+                error2 = "<issue line=\"2\" char=\"1\" severity=\"error\" reason=\"BOGUS\" evidence=\"sneaky, 'sneaky', &lt;sneaky&gt;, sneak &amp; sneaky\"/>",
+                expected = "<?xml version=\"1.0\" encoding=\"utf-8\"?><lint>" + file + error1 + error2 + "</file></lint>",
+                actual = CSSLint.format(result, "FILE", "lint-xml");
+            Assert.areEqual(expected, actual);
+        }
+    }));
+})();

data/csslint/tests/formatters/text.js

@@ -0,0 +1,36 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Text formatter",
+        
+        "File with no problems should say so": function() {
+            var result = { messages: [], stats: [] },
+                actual = CSSLint.getFormatter("text").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE"});
+            Assert.areEqual("\n\ncsslint: No errors in path/to/FILE.", actual);
+        },
+
+        "Should have no output when quiet option is specified and no errors": function() {
+            var result = { messages: [], stats: [] },
+                actual = CSSLint.getFormatter("text").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE", quiet: "true"});
+            Assert.areEqual("", actual);
+        },
+
+        "File with problems should list them": function() {
+            var result = { messages: [ 
+                     { type: 'warning', line: 1, col: 1, message: 'BOGUS', evidence: 'ALSO BOGUS', rule: [] },
+                     { type: 'error', line: 2, col: 1, message: 'BOGUS', evidence: 'ALSO BOGUS', rule: [] }
+                ], stats: [] },
+                error1 = "\n1: warning at line 1, col 1\nBOGUS\nALSO BOGUS",
+                error2 = "\n2: error at line 2, col 1\nBOGUS\nALSO BOGUS",
+                expected = "\n\ncsslint: There are 2 problems in path/to/FILE.\n\nFILE" + error1 + "\n\nFILE" + error2,
+                actual = CSSLint.getFormatter("text").formatResults(result, "path/to/FILE", {fullPath: "/absolute/path/to/FILE"});
+            Assert.areEqual(expected, actual);
+        }
+
+    }));
+
+})();

data/csslint/tests/rules/adjoining-classes.js

@@ -0,0 +1,31 @@
+(function(){
+
+    /*global YUITest, CSSLint*/
+    var Assert = YUITest.Assert;
+
+    YUITest.TestRunner.add(new YUITest.TestCase({
+
+        name: "Adjoining Selector Rule Errors",
+        
+        "Adjoining classes should result in a warning": function(){
+            var result = CSSLint.verify(".foo.bar { }", { "adjoining-classes": 1 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("warning", result.messages[0].type);
+            Assert.areEqual("Don't use adjoining classes.", result.messages[0].message);
+        },
+
+        "Adjoining classes should result in an error": function(){
+            var result = CSSLint.verify(".foo.bar { }", { "adjoining-classes": 2 });
+            Assert.areEqual(1, result.messages.length);
+            Assert.areEqual("error", result.messages[0].type);
+            Assert.areEqual("Don't use adjoining classes.", result.messages[0].message);
+        },
+
+        "Descendant selector with classes should not result in a warning": function(){
+            var result = CSSLint.verify(".foo .bar { }", { "adjoining-classes": 1 });
+            Assert.areEqual(0, result.messages.length);
+        }
+
+    }));
+
+})();