scss-lint 0.33.0 → 0.34.0

data/spec/scss_lint/linter/trailing_semicolon_spec.rb

@@ -4,88 +4,88 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::TrailingSemicolon do
   context 'when a property does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a property ends with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a property ends with a space followed by a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0 ;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a property ends with a semicolon and is followed by a comment' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0;  // This is a comment
         padding: 0; /* This is another comment */
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a property contains nested properties' do
     context 'and there is a value on the namespace' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           font: 2px/3px {
             style: italic;
             weight: bold;
           }
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and there is no value on the namespace' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           font: {
             style: italic;
             weight: bold;
           }
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
   end
 
   context 'when a nested property does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         font: {
           weight: bold
         }
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 3 }
   end
 
   context 'when a multi-line property ends with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         background:
           top repeat-x url('top-image.jpg'),
@@ -93,13 +93,13 @@ describe SCSSLint::Linter::TrailingSemicolon do
           bottom repeat-x url('bottom-image.jpg'),
           left repeat-y url('left-image.jpg');
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a multi-line property does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         background:
           top repeat-x url('top-image.jpg'),
@@ -107,71 +107,71 @@ describe SCSSLint::Linter::TrailingSemicolon do
           bottom repeat-x url('bottom-image.jpg'),
           left repeat-y url('left-image.jpg')
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a oneline rule does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo { border: 0 }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when a oneline rule has a space before a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo { border: 0 ; }
-    CSS
+    SCSS
 
     it { should report_lint line: 1 }
   end
 
   context 'when @extend does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @extend %bar
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when @extend ends with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @extend %bar;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @include does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @include bar
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when @include takes a block' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @include bar {
           border: 0;
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @include takes a block with nested props' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @include bar {
           .bar {
@@ -179,13 +179,13 @@ describe SCSSLint::Linter::TrailingSemicolon do
           }
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @include takes a block with an if-node' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @include bar {
           @if $var {
@@ -193,112 +193,111 @@ describe SCSSLint::Linter::TrailingSemicolon do
           }
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @include ends with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         @include bar;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @import ends with a semicolon' do
-    let(:css) { '@import "something";' }
+    let(:scss) { '@import "something";' }
 
     it { should_not report_lint }
   end
 
   context 'when @import does not end with a semicolon' do
-    let(:css) { '@import "something"' }
+    let(:scss) { '@import "something"' }
 
     it { should report_lint line: 1 }
   end
 
   context 'when @import has a space before a semicolon' do
-    let(:css) { '@import "something" ;' }
+    let(:scss) { '@import "something" ;' }
 
     it { should report_lint line: 1 }
   end
 
   context 'when an import directive is split over multiple lines' do
     context 'and is missing the trailing semicolon' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         @import 'functions/strip-units',
                 'functions/pc'
-      CSS
+      SCSS
 
       it { should report_lint }
     end
 
     context 'and is not missing the trailing semicolon' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         @import 'functions/strip-units',
                 'functions/pc';
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
   end
 
   context 'when variable declaration does not end with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         $bar: 1
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when variable declaration ends with a semicolon' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         $bar: 1;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when variable declaration ends with multiple semicolons' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .foo {
         $bar: 1;;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when interpolation within single quotes is followed by property' do
     context 'and property has a trailing semicolon' do
-      let(:css) { "[class~='\#{$test}'] { width: 100%; }" }
+      let(:scss) { "[class~='\#{$test}'] { width: 100%; }" }
 
       it { should_not report_lint }
     end
 
     context 'and property does not have a trailing semicolon' do
-      let(:css) { "[class~='\#{$test}'] { width : 100% }" }
+      let(:scss) { "[class~='\#{$test}'] { width : 100% }" }
 
       it { should report_lint }
     end
   end
 
   context 'when triggering a bug based on Windows IBM437 encoding' do
-    CSS = <<-CSS
+    let(:scss) { <<-SCSS.force_encoding('IBM437') }
       @charset "UTF-8";
 
       .foo:before {
         content: '▼';
       }
-    CSS
-    let(:css) { CSS.force_encoding('IBM437') }
+    SCSS
 
     it { should_not report_lint }
   end

data/spec/scss_lint/linter/trailing_zero_spec.rb

@@ -2,174 +2,174 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::TrailingZero do
   context 'when no values exist' do
-    let(:css) { 'p {}' }
+    let(:scss) { 'p {}' }
 
     it { should_not report_lint }
   end
 
   context 'when a zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when an integer value exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: 2;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when an integer value with units exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 5px;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a unitless fractional value with no trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: .5;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a negative unitless fractional value with no trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: -.5;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a fractional value with units and no trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: .5em;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a negative fractional value with units and no trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: -.5em;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a fractional value with a trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: .50;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a fractional value with units and a trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: .50em;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a negative fractional value with units and a trailing zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: -.50em;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a fractional value with a mantissa ending in zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: 10.5;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when multiple fractional values with trailing zeros exist' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0.50em .50 0.10px .90pt;
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 4, line: 2 }
   end
 
   context 'when trailing zeros appear in function arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: some-function(.50em, 0.40 0.30 .2);
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 3, line: 2 }
   end
 
   context 'when trailing zeros appear in mixin arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         @include some-mixin(0.50em, 0.40 0.30 .2);
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 3, line: 2 }
   end
 
   context 'when trailiing zeros appear in variable declarations' do
-    let(:css) { '$some-var: .50em;' }
+    let(:scss) { '$some-var: .50em;' }
 
     it { should report_lint line: 1 }
   end
 
   context 'when trailing zeros appear in named arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         @include line-clamp($line-height: .90, $line-count: 2);
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when trailing zeros appear in parameter defaults' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @mixin my-mixin($bad-value: .50, $good-value: .9, $string-value: ".90") {
         margin: $some-value;
         padding: $some-other-value;
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 1, line: 1 }
   end