scss-lint 0.33.0 → 0.34.0

data/spec/scss_lint/linter/property_spelling_spec.rb

@@ -2,31 +2,31 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::PropertySpelling do
   context 'with a regular property' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 5px;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'with a property containing interpolation' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         \#{$property-name}: 5px;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'with a non-existent property' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         peanut-butter: jelly-time;
       }
-    CSS
+    SCSS
 
     it { should report_lint }
   end
@@ -35,48 +35,48 @@ describe SCSSLint::Linter::PropertySpelling do
     let(:linter_config) { { 'extra_properties' => ['made-up-property'] } }
 
     context 'with a non-existent property' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           peanut-butter: jelly-time;
         }
-      CSS
+      SCSS
 
       it { should report_lint }
     end
 
     context 'with a property listed as an extra property' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           made-up-property: value;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
   end
 
   context 'with valid nested properties' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         text: {
           align: center;
           transform: uppercase;
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'with invalid nested properties' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         text: {
           aligned: center;
           transformed: uppercase;
         }
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 3 }
     it { should report_lint line: 4 }

data/spec/scss_lint/linter/qualifying_element_spec.rb

@@ -2,84 +2,84 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::QualifyingElement do
   context 'when selector does not include an element' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {}
       #bar {}
       [foobar] {}
       .foo .bar {}
       #bar > .foo {}
       [foobar] #bar .foo {}
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when selector includes an element' do
     context 'and element does not qualify' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         ul {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and element qualifies class' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         ul.list {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and element qualifies attribute' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         a[href] {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and element qualifies id' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         ul#list {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and selector is in a group' do
       context 'and element does not qualify' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .list li,
           .item > span {}
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and element qualifies class' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .item span,
           ul > li.item {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end
 
       context 'and element qualifies attribute' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .item + span,
           li a[href] {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end
 
       context 'and element qualifies id' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           #foo,
           li#item + li {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end
@@ -87,36 +87,36 @@ describe SCSSLint::Linter::QualifyingElement do
 
     context 'and selector involves a combinator' do
       context 'and element does not qualify' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .list li {}
           .list > li {}
           .item + li {}
           .item ~ li {}
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
 
       context 'and element qualifies class' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           ul > li.item {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end
 
       context 'and element qualifies attribute' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           li a[href] {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end
 
       context 'and element qualifies id' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           li#item + li {}
-        CSS
+        SCSS
 
         it { should report_lint line: 1 }
       end

data/spec/scss_lint/linter/selector_depth_spec.rb

@@ -2,30 +2,30 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::SelectorDepth do
   context 'when sequence has a depth of one' do
-    let(:css) { 'p {}' }
+    let(:scss) { 'p {}' }
 
     it { should_not report_lint }
   end
 
   context 'when sequence has a depth of three' do
-    let(:css) { 'body article p {}' }
+    let(:scss) { 'body article p {}' }
 
     it { should_not report_lint }
 
     context 'and contains a nested selector' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         body article p {
           i {
             font-style: italic;
           }
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and contains multiple nested selectors' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         body article p {
           b {
             font-weight: bold;
@@ -34,7 +34,7 @@ describe SCSSLint::Linter::SelectorDepth do
             font-style: italic;
           }
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
       it { should report_lint line: 5 }
@@ -42,99 +42,99 @@ describe SCSSLint::Linter::SelectorDepth do
   end
 
   context 'when sequence has a depth of four' do
-    let(:css) { 'body article p i {}' }
+    let(:scss) { 'body article p i {}' }
 
     it { should report_lint line: 1 }
   end
 
   context 'when sequence is made up of adjacent sibling combinators' do
-    let(:css) { '.one + .two + .three + .four {}' }
+    let(:scss) { '.one + .two + .three + .four {}' }
 
     it { should_not report_lint }
   end
 
   context 'when sequence is made up of general sibling combinators' do
-    let(:css) { '.one .two ~ .three ~ .four {}' }
+    let(:scss) { '.one .two ~ .three ~ .four {}' }
 
     it { should_not report_lint }
   end
 
   context 'when sequence contains interpolation' do
-    let(:css) { '.one #{$interpolated-string} .two .three {}' }
+    let(:scss) { '.one #{$interpolated-string} .two .three {}' }
 
     it { should_not report_lint }
   end
 
   context 'when comma sequence contains no sequences exceeding depth limit' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p,
       .one .two .three,
       ul > li {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
 
     context 'and a nested selector causes one of the sequences to exceed the limit' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p,
         .one .two .three,
         ul > li {
           .four {}
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 4 }
     end
   end
 
   context 'when comma sequence contains a sequence exceeding the depth limit' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p,
       .one .two .three .four,
       ul > li {
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when sequence contains a nested selector with a parent selector' do
     context 'which does not exceed the depth limit' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .one .two  {
           .three & {}
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
 
       context 'and the parent selector is chained' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .one .two .three {
             &.chained {}
           }
-        CSS
+        SCSS
 
         it { should_not report_lint }
       end
     end
 
     context 'which does exceed the depth limit' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .one .two {
           .three & & .four {}
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
 
       context 'and the parent selector is chained' do
-        let(:css) { <<-CSS }
+        let(:scss) { <<-SCSS }
           .one .two .three > .four {
             &.chained {}
           }
-        CSS
+        SCSS
 
         it { should report_lint line: 2 }
       end
@@ -142,7 +142,7 @@ describe SCSSLint::Linter::SelectorDepth do
   end
 
   context 'when sequence contains a @keyframe' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @keyframe my-keyframe {
         0% {
           background: #000;
@@ -152,7 +152,7 @@ describe SCSSLint::Linter::SelectorDepth do
           background: #fff;
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end

data/spec/scss_lint/linter/selector_format_spec.rb

@@ -2,82 +2,82 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::SelectorFormat do
   context 'when class has alphanumeric chars and is separated by hyphens' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo-bar-77 {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when id has alphanumeric chars and is separated by hyphens' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       #foo-bar-77 {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when element has alphanumeric chars and is separated by hyphens' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       foo-bar-77 {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when placeholder has alphanumeric chars and is separated by hyphens' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       %foo-bar-77 {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when selector has alphanumeric chars and is separated by underscores' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo_bar {
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
-  context 'when selector has is in camelCase' do
-    let(:css) { <<-CSS }
+  context 'when selector is camelCase' do
+    let(:scss) { <<-SCSS }
       fooBar77 {
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when placeholder has alphanumeric chars and is separated by underscores' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       %foo_bar {
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when attribute has alphanumeric chars and is separated by underscores' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       [data_text] {
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when attribute selector has alphanumeric chars and is separated by underscores' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       [data-text=some_text] {
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
@@ -86,28 +86,28 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'convention' => 'snake_case' } }
 
     context 'when selector has alphanumeric chars and is separated by underscores' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .foo_bar_77 {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when selector has alphanumeric chars and is separated by hyphens' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .foo-bar-77 {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'when selector is in camelCase' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .fooBar77 {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
@@ -116,38 +116,38 @@ describe SCSSLint::Linter::SelectorFormat do
   context 'when convention is set to camel_case' do
     let(:linter_config) { { 'convention' => 'camel_case' } }
 
-    context 'when selector has is in camelCase' do
-      let(:css) { <<-CSS }
+    context 'when selector is camelCase' do
+      let(:scss) { <<-SCSS }
         .fooBar77 {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when selector capitalizes first word' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .FooBar77 {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'when selector has alphanumeric chars and is separated by underscores' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .foo_bar_77 {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'when selector has alphanumeric chars and is separated by hyphens' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .foo-bar-77 {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
@@ -157,19 +157,19 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'convention' => /^[0-9]*$/ } }
 
     context 'when selector uses regex properly' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .1337 {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when selector does not use regex properly' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .leet {
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
@@ -179,10 +179,10 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'ignored_names' => ['fooBar'] } }
 
     context 'it ignores exact string matches' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         fooBar {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
@@ -192,10 +192,10 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'ignored_types' => ['class'] } }
 
     context 'it ignores all invalid classes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .fooBar {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
@@ -207,37 +207,37 @@ describe SCSSLint::Linter::SelectorFormat do
     end
 
     context 'it ignores all invalid ids' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         #fooBar {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'it ignores all invalid elements' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         fooBar {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'it ignores all invalid placeholders' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         %fooBar {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'it ignores all invalid attributes' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         [fooBar=fooBar] {
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
@@ -247,28 +247,28 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'id_convention' => 'snake_case' } }
 
     context 'and actual id is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         #snake_case {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and actual id is incorrect' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and something else uses the `id_convention`' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .snake_case {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
@@ -278,28 +278,28 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'class_convention' => 'camel_case' } }
 
     context 'and actual class is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .camelCase {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and actual class is incorrect' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and something else uses the `class_convention`' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         #camelCase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
@@ -309,28 +309,28 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'placeholder_convention' => 'snake_case' } }
 
     context 'and actual placeholder is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         %snake_case {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and actual placeholder is incorrect' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .hyphenated-lowercase {}
         %hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and something else uses the `placeholder_convention`' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         .snake_case {}
         %snake_case {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
@@ -345,28 +345,28 @@ describe SCSSLint::Linter::SelectorFormat do
     end
 
     context 'and actual element is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         hyphenated-lowercase {}
         #camelCase {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and actual element is incorrect' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         camelCase {}
         #camelCase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and something else uses the `element_convention`' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         hyphenated-lowercase {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
@@ -381,28 +381,28 @@ describe SCSSLint::Linter::SelectorFormat do
     end
 
     context 'and actual attribute is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         [hyphenated-lowercase] {}
         #camelCase {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and actual attribute is incorrect' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         [camelCase] {}
         #camelCase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
     end
 
     context 'and something else uses the `attribute_convention`' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         [hyphenated-lowercase] {}
         #hyphenated-lowercase {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
@@ -419,35 +419,35 @@ describe SCSSLint::Linter::SelectorFormat do
     end
 
     context 'and everything is correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         #camelCase {}
         hyphenated-lowercase {}
         [snake_case] {}
         .foo--bar {}
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'some things are not correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         #camelCase {}
         camelCase {}
         [snake_case] {}
         .fooBar {}
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
       it { should report_lint line: 4 }
     end
 
     context 'other things are not correct' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         #snake_case {}
         hyphenated-lowercase {}
         [camelCase] {}
         .foo--bar {}
-      CSS
+      SCSS
 
       it { should report_lint line: 1 }
       it { should report_lint line: 3 }
@@ -458,79 +458,79 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'convention' => 'BEM' } }
 
     context 'when a name contains no underscores or hyphens' do
-      let(:css) { '.block {}' }
+      let(:scss) { '.block {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains single hyphen' do
-      let(:css) { '.b-block {}' }
+      let(:scss) { '.b-block {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains multiple hyphens' do
-      let(:css) { '.b-block-name {}' }
+      let(:scss) { '.b-block-name {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains multiple hyphens in a row' do
-      let(:css) { '.b-block--modifier {}' }
+      let(:scss) { '.b-block--modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when a name contains a single underscore' do
-      let(:css) { '.block_modifier {}' }
+      let(:scss) { '.block_modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when a block has name-value modifier' do
-      let(:css) { '.block_modifier_value {}' }
+      let(:scss) { '.block_modifier_value {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a block has name-value modifier with lots of hyphens' do
-      let(:css) { '.b-block-name_modifier-name-here_value-name-here {}' }
+      let(:scss) { '.b-block-name_modifier-name-here_value-name-here {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name has double underscores' do
-      let(:css) { '.b-block__element {}' }
+      let(:scss) { '.b-block__element {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element goes after block with modifier' do
-      let(:css) { '.block_modifier_value__element {}' }
+      let(:scss) { '.block_modifier_value__element {}' }
 
       it { should report_lint }
     end
 
     context 'when element has modifier' do
-      let(:css) { '.block__element_modifier_value {}' }
+      let(:scss) { '.block__element_modifier_value {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element has not paired modifier' do
-      let(:css) { '.block__element_modifier {}' }
+      let(:scss) { '.block__element_modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when element has hypenated modifier' do
-      let(:css) { '.block__element--modifier {}' }
+      let(:scss) { '.block__element--modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when element has hypenated paired modifier' do
-      let(:css) { '.block__element--modifier_value {}' }
+      let(:scss) { '.block__element--modifier_value {}' }
 
       it { should report_lint }
     end
@@ -540,91 +540,91 @@ describe SCSSLint::Linter::SelectorFormat do
     let(:linter_config) { { 'convention' => 'hyphenated_BEM' } }
 
     context 'when a name contains no underscores or hyphens' do
-      let(:css) { '.block {}' }
+      let(:scss) { '.block {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains single hyphen' do
-      let(:css) { '.b-block {}' }
+      let(:scss) { '.b-block {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains multiple hyphens' do
-      let(:css) { '.b-block-name {}' }
+      let(:scss) { '.b-block-name {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains multiple hyphens in a row' do
-      let(:css) { '.b-block--modifier {}' }
+      let(:scss) { '.b-block--modifier {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name contains a single underscore' do
-      let(:css) { '.block_modifier {}' }
+      let(:scss) { '.block_modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when a block has name-value modifier' do
-      let(:css) { '.block--modifier-value {}' }
+      let(:scss) { '.block--modifier-value {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a block has name-value modifier with lots of hyphens' do
-      let(:css) { '.b-block-name--modifier-name-here-value-name-here {}' }
+      let(:scss) { '.b-block-name--modifier-name-here-value-name-here {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a name has double underscores' do
-      let(:css) { '.b-block__element {}' }
+      let(:scss) { '.b-block__element {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element goes after block with modifier' do
-      let(:css) { '.block--modifier-value__element {}' }
+      let(:scss) { '.block--modifier-value__element {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element has modifier' do
-      let(:css) { '.block__element--modifier-value {}' }
+      let(:scss) { '.block__element--modifier-value {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element has hypenated modifier' do
-      let(:css) { '.block__element--modifier {}' }
+      let(:scss) { '.block__element--modifier {}' }
 
       it { should_not report_lint }
     end
 
     context 'when element has hypenated paired modifier' do
-      let(:css) { '.block__element--modifier-value {}' }
+      let(:scss) { '.block__element--modifier-value {}' }
 
       it { should_not report_lint }
     end
 
     context 'when a block contains an underscore' do
-      let(:css) { '.a_block__element--modifier {}' }
+      let(:scss) { '.a_block__element--modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when an element contains an underscore' do
-      let(:css) { '.block__an_element--modifier {}' }
+      let(:scss) { '.block__an_element--modifier {}' }
 
       it { should report_lint }
     end
 
     context 'when a modifier contains an underscore' do
-      let(:css) { '.block__element--a_modifier {}' }
+      let(:scss) { '.block__element--a_modifier {}' }
 
       it { should report_lint }
     end