scss-lint 0.33.0 → 0.34.0

data/spec/scss_lint/linter/important_rule_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::ImportantRule do
+  context 'when !important is not used' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important is used' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000 !important;
+      }
+    SCSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when !important is used in property containing Sass script' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: \#{$my-var} !important;
+      }
+    SCSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when property contains a list literal with an empty list' do
+    let(:scss) { <<-SCSS }
+      p {
+        content: 0 ();
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+end

data/spec/scss_lint/linter/indentation_spec.rb

@@ -2,33 +2,33 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::Indentation do
   context 'when a line at the root level is indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       $var: 5px;
         $other: 10px;
-    CSS
+    SCSS
 
     it { should_not report_lint line: 1 }
     it { should report_lint line: 2 }
   end
 
   context 'when a line in a rule set is properly indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when lines in a rule set are not properly indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       margin: 0;
         padding: 1em;
       opacity: 0.5;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
     it { should_not report_lint line: 3 }
@@ -36,13 +36,13 @@ describe SCSSLint::Linter::Indentation do
   end
 
   context 'when selector of a nested rule set is not properly indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       em {
         font-style: italic;
       }
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
     it { should_not report_lint line: 3 }
@@ -50,7 +50,7 @@ describe SCSSLint::Linter::Indentation do
   end
 
   context 'when multi-line selector of a nested rule set is not properly indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       b,
       em,
@@ -58,7 +58,7 @@ describe SCSSLint::Linter::Indentation do
         font-style: italic;
       }
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
     it { should_not report_lint line: 3 }
@@ -67,28 +67,28 @@ describe SCSSLint::Linter::Indentation do
   end
 
   context 'when a property is on the same line as its rule selector' do
-    let(:css) { 'h1 { margin: 5px; }' }
+    let(:scss) { 'h1 { margin: 5px; }' }
     it { should_not report_lint }
   end
 
   context 'when an argument list spans multiple lines' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @include mixin(one,
                      two,
                      three);
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when an argument list of an improperly indented script spans multiple lines' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       @include mixin(one,
                      two,
                      three);
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
     it { should_not report_lint line: 3 }
@@ -96,59 +96,59 @@ describe SCSSLint::Linter::Indentation do
   end
 
   context 'when an if statement is incorrectly indented' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       $condition: true;
         @if $condition {
         padding: 0;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when an if statement is accompanied by a correctly indented else statement' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @if $condition {
         padding: 0;
       } @else {
         margin: 0;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @at-root directive contains correctly indented children' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .block {
         @at-root {
           .something {}
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @at-root directive with an inline selector contains correctly indented children' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .block {
         @at-root .something {
           .something-else {}
         }
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when @at-root directive with no inline selector contains comment' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @at-root {
         // A comment that causes a crash
         .something-else {}
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
@@ -156,63 +156,63 @@ describe SCSSLint::Linter::Indentation do
   context 'when the indentation width has been explicitly set' do
     let(:linter_config) { { 'width' => 3 } }
 
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0;
          padding: 5px;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
     it { should_not report_lint line: 3 }
   end
 
   context 'when there are selectors across multiple lines' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .class1,
       .class2 {
         margin: 0;
         padding: 5px;
       }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when there are selectors across multiple lines with a single line block' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       .class1,
       .class2 { margin: 0; }
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a comment node precedes a node' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       // A comment
       $var: 1;
-    CSS
+    SCSS
 
     it { should_not report_lint }
   end
 
   context 'when a line is indented with tabs' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       \tmargin: 0;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a line contains a mix of tabs and spaces' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         \tmargin: 0;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
@@ -221,31 +221,91 @@ describe SCSSLint::Linter::Indentation do
     let(:linter_config) { { 'character' => 'tab', 'width' => 1 } }
 
     context 'and the line is indented correctly' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
         \tmargin: 0;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'and the line is incorrectly indented' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
         \t\tmargin: 0;
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'and the line is indented with spaces' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           margin: 0;
         }
-      CSS
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+  end
+
+  context 'when indentation in non-nested code is allowed' do
+    let(:linter_config) do
+      { 'allow_non_nested_indentation' => true,
+        'character' => 'space',
+        'width' => 2,
+      }
+    end
+
+    context 'and non-nested code is indented' do
+      let(:scss) { <<-SCSS }
+        .component {}
+          .component__image {}
+          .component__text {}
+            .component-subblock {}
+            .component-subblock__text {}
+          .component-category {}
+            .component-other {}
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and nested code is indented too much' do
+      let(:scss) { <<-SCSS }
+        .component {
+          .component__image {}
+          .component__text {}
+            .component-subblock {}
+        }
+      SCSS
+
+      it { should_not report_lint line: 2 }
+      it { should_not report_lint line: 3 }
+      it { should report_lint line: 4 }
+    end
+
+    context 'and nested code is indented too little' do
+      let(:scss) { <<-SCSS }
+        .component {
+          .component__image {}
+          .component__text {}
+        .component-subblock {}
+        }
+      SCSS
+
+      it { should_not report_lint line: 2 }
+      it { should_not report_lint line: 3 }
+      it { should report_lint line: 4 }
+    end
+
+    context 'and a non-nested non-ruleset is incorrectly indented' do
+      let(:scss) { <<-SCSS }
+        p {}
+          $var: one;
+      SCSS
 
       it { should report_lint line: 2 }
     end

data/spec/scss_lint/linter/leading_zero_spec.rb

@@ -2,177 +2,177 @@ require 'spec_helper'
 
 describe SCSSLint::Linter::LeadingZero do
   context 'when no values exist' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
       }
-    CSS
+    SCSS
 
     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 leading 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 leading 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 leading 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 leading 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 leading zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         line-height: 0.5;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a fractional value with units and a leading zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0.5em;
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when a negative fractional value with units and a leading zero exists' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: -0.5em;
       }
-    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 leading zeros exist' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: 0.5em 0.5 0.1px 0.9pt;
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 4, line: 2 }
   end
 
   context 'when leading zeros appear in function arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         margin: some-function(0.5em, 0.4 0.3 .2);
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 3, line: 2 }
   end
 
   context 'when leading zeros appear in mixin arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         @include some-mixin(0.5em, 0.4 0.3 .2);
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 3, line: 2 }
   end
 
   context 'when leading zeros appear in variable declarations' do
-    let(:css) { '$some-var: 0.5em;' }
+    let(:scss) { '$some-var: 0.5em;' }
 
     it { should report_lint line: 1 }
   end
 
   context 'when leading zeros appear in named arguments' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       p {
         @include line-clamp($line-height: 0.9, $line-count: 2);
       }
-    CSS
+    SCSS
 
     it { should report_lint line: 2 }
   end
 
   context 'when leading zeros appear in parameter defaults' do
-    let(:css) { <<-CSS }
+    let(:scss) { <<-SCSS }
       @mixin my-mixin($bad-value: 0.5, $good-value: .9, $string-value: "0.9") {
         margin: $some-value;
         padding: $some-other-value;
       }
-    CSS
+    SCSS
 
     it { should report_lint count: 1, line: 1 }
   end
@@ -181,51 +181,51 @@ describe SCSSLint::Linter::LeadingZero do
     let(:linter_config) { { 'style' => 'include_zero' } }
 
     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 a non-zero integer value exists' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           line-height: 2;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when a fractional value with no leading zero exists' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           padding: .5em;
         }
-      CSS
+      SCSS
 
       it { should report_lint line: 2 }
     end
 
     context 'when a fractional value with leading zero exists' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           padding: 0.5em;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end
 
     context 'when a fractional value with a mantissa ending in zero exists' do
-      let(:css) { <<-CSS }
+      let(:scss) { <<-SCSS }
         p {
           padding: 10.5em;
         }
-      CSS
+      SCSS
 
       it { should_not report_lint }
     end