scss-lint 0.33.0 → 0.34.0

data/spec/scss_lint/linter/space_between_parens_spec.rb

@@ -2,111 +2,111 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::SpaceBetweenParens do
   context 'when the opening parens is followed by a space' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: ( value);
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when the closing parens is preceded by a space' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: (value );
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when both parens are space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: ( value );
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2, count: 2 }
   end
 
   context 'when neither parens are space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: (value);
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when parens are multi-line' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: (
           value
         );
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when parens are multi-line with tabs' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
 \t\t\tp {
 \t\t\t\tproperty: (
 \t\t\t\t\tvalue
 \t\t\t\t);
 \t\t\t}
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when outer parens are space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: fn( fn2(val1, val2) );
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2, count: 2 }
   end
 
   context 'when inner parens are space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: fn(fn2( val1, val2 ));
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2, count: 2 }
   end
 
   context 'when both parens are not space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: fn(fn2(val1, val2));
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when both parens are space padded' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: fn( fn2( val1, val2 ) );
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2, count: 4 }
   end
 
   context 'when multi level parens are multi-line' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         property: fn(
           fn2(
@@ -114,27 +114,27 @@ describe SCSSLint::Linter::SpaceBetweenParens do
           )
         );
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when parens exist in a silent comment' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0; // Some comment ( with parens )
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when parens exist in an outputted comment' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0; /* Some comment ( with parens ) */
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
@@ -143,111 +143,111 @@ describe SCSSLint::Linter::SpaceBetweenParens do
     let(:linter_config) { { 'spaces' => 1 } }
 
     context 'when the opening parens is followed by a space' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: ( value);
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'when the closing parens is preceded by a space' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: (value );
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'when neither parens are space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: (value);
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2, count: 2 }
     end
 
     context 'when both parens are space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: ( value );
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when parens are multi-line' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: (
             value
           );
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when parens are multi-line with tabs' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
 \t\t\t\tp {
 \t\t\t\t\tproperty: (
 \t\t\t\t\t\tvalue
 \t\t\t\t\t);
 \t\t\t\t}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when outer parens are space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: fn( fn2(val1, val2) );
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2, count: 2 }
     end
 
     context 'when inner parens are space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: fn(fn2( val1, val2 ));
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2, count: 2 }
     end
 
     context 'when both parens are not space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: fn(fn2(val1, val2));
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2, count: 4 }
     end
 
     context 'when both parens are space padded' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: fn( fn2( val1, val2 ) );
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when multi level parens are multi-line' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           property: fn(
             fn2(
@@ -255,7 +255,7 @@ describe SCSSLint::Linter::SpaceBetweenParens do
             )
           );
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end

data/spec/scss_lint/linter/string_quotes_spec.rb

@@ -2,320 +2,332 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::StringQuotes do
   context 'when string is written with single quotes' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         content: 'hello';
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
 
     context 'and contains escaped single quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: 'hello \\'world\\'';
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and contains single quotes escaped as hex' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: 'hello \\27world\\27';
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and contains double quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: 'hello "world"';
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and contains interpolation' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: 'hello \#{$world}';
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
   end
 
   context 'when @import uses single quotes' do
-    let(:css) { "@import 'file';" }
+    let(:scss) { "@import 'file';" }
 
     it { should_not report_lint }
 
     context 'and has no trailing semicolon' do
-      let(:css) { "@import 'file'\n" }
+      let(:scss) { "@import 'file'\n" }
 
       it { should_not report_lint }
     end
   end
 
   context 'when @charset uses single quotes' do
-    let(:css) { "@charset 'UTF-8';" }
+    let(:scss) { "@charset 'UTF-8';" }
 
     it { should_not report_lint }
   end
 
   context 'when string is written with double quotes' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         content: "hello";
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
 
     context 'and contains escaped double quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: "hello \\"world\\"";
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and contains double quotes escaped as hex' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: "hello \\22world\\22";
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and contains single quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: "hello 'world'";
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and contains interpolation' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: "hello \#{$world}"
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
   end
 
   context 'when @import uses double quotes' do
-    let(:css) { '@import "file";' }
+    let(:scss) { '@import "file";' }
 
     it { should report_lint }
 
     context 'and has no trailing semicolon' do
-      let(:css) { '@import "file"' }
+      let(:scss) { '@import "file"' }
 
       it { should report_lint }
     end
   end
 
   context 'when @charset uses double quotes' do
-    let(:css) { '@charset "UTF-8";' }
+    let(:scss) { '@charset "UTF-8";' }
 
     it { should report_lint }
   end
 
   context 'when property has a literal identifier' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         display: none;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when property is a URL with single quotes' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         background: url('image.png');
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when property is a URL with double quotes' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         background: url("image.png");
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
+  context 'when Sass script is written in a non-silent comment' do
+    let(:scss) { <<-SCSS }
+      /**
+       * .thing-\#{$key} {
+       *   color: \#{value}
+       * }
+       */
+    SCSS
+
+    it { should_not report_lint }
+  end
+
   context 'when the configuration has been set to prefer double quotes' do
     let(:linter_config) { { 'style' => 'double_quotes' } }
 
     context 'and string is written with single quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: 'hello';
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
 
       context 'and contains escaped single quotes' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: 'hello \\'world\\'';
           }
-        CSS
+        SCSS
 
         it { should report_lint line: 2 }
       end
 
       context 'and contains single quotes escaped as hex' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: 'hello \\27world\\27';
           }
-        CSS
+        SCSS
 
         it { should report_lint line: 2 }
       end
 
       context 'and contains double quotes' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: 'hello "world"';
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and contains interpolation' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: 'hello \#{$world}';
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and contains interpolation inside a substring with single quotes' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "<svg width='\#{$something}'>";
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and contains a single-quoted string inside interpolation' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "<svg width='\#{func('hello')}'>";
           }
-        CSS
+        SCSS
 
         it { should report_lint }
       end
     end
 
     context 'and string is written with double quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           content: "hello";
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
 
       context 'and contains escaped double quotes' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "hello \\"world\\"";
           }
-        CSS
+        SCSS
 
         it { should report_lint line: 2 }
       end
 
       context 'and contains double quotes escaped as hex' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "hello \\22world\\22";
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and contains single quotes' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "hello 'world'";
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and contains interpolation' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           p {
             content: "hello \#{$world}";
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
     end
 
     context 'when property has a literal identifier' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           display: none;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when property is a URL with single quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           background: url('image.png');
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'when property is a URL with double quotes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           background: url("image.png");
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end