scss-lint 0.25.1 → 0.26.0

data/spec/scss_lint/linter/placeholder_in_extend_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::PlaceholderInExtend do
+  context 'when extending with a class' do
+    let(:css) { <<-CSS }
+      p {
+        @extend .error;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when extending with a type' do
+    let(:css) { <<-CSS }
+      p {
+        @extend span;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when extending with an id' do
+    let(:css) { <<-CSS }
+      p {
+        @extend #some-identifer;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when extending with a placeholder' do
+    let(:css) { <<-CSS }
+      p {
+        @extend %placeholder;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when extending with a selector whose prefix is not a placeholder' do
+    let(:css) { <<-CSS }
+      p {
+        @extend .blah-\#{$dynamically_generated_name};
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when extending with a selector whose prefix is dynamic' do
+    let(:css) { <<-CSS }
+      p {
+        @extend \#{$dynamically_generated_placeholder_name};
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+end

data/spec/scss_lint/linter/property_sort_order_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::PropertySortOrder do
+  context 'when rule is empty' do
+    let(:css) { <<-CSS }
+      p {
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when rule contains properties in sorted order' do
+    let(:css) { <<-CSS }
+      p {
+        background: #000;
+        display: none;
+        margin: 5px;
+        padding: 10px;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when rule contains mixins followed by properties in sorted order' do
+    let(:css) { <<-CSS }
+      p {
+        @include border-radius(5px);
+        background: #000;
+        display: none;
+        margin: 5px;
+        padding: 10px;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when rule contains nested rules after sorted properties' do
+    let(:css) { <<-CSS }
+      p {
+        background: #000;
+        display: none;
+        margin: 5px;
+        padding: 10px;
+        a {
+          color: #555;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when rule contains properties in random order' do
+    let(:css) { <<-CSS }
+      p {
+        padding: 5px;
+        display: block;
+        margin: 10px;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when there are multiple rules with out of order properties' do
+    let(:css) { <<-CSS }
+      p {
+        display: block;
+        background: #fff;
+      }
+      a {
+        margin: 5px;
+        color: #444;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+    it { should report_lint line: 6 }
+  end
+
+  context 'when there are nested rules with out of order properties' do
+    let(:css) { <<-CSS }
+      p {
+        display: block;
+        background: #fff;
+        a {
+          margin: 5px;
+          color: #444;
+        }
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+    it { should report_lint line: 5 }
+  end
+
+  context 'when out-of-order property is the second last in the list of sorted properties' do
+    let(:css) { <<-CSS }
+      p {
+        border: 0;
+        border-radius: 3px;
+        float: left;
+        display: block;
+      }
+    CSS
+
+    it { should report_lint line: 4 }
+  end
+
+  context 'when vendor-prefixed properties are ordered after the non-prefixed property' do
+    let(:css) { <<-CSS }
+      p {
+        border-radius: 3px;
+        -moz-border-radius: 3px;
+        -o-border-radius: 3px;
+        -webkit-border-radius: 3px;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when vendor-prefixed properties are ordered before the non-prefixed property' do
+    let(:css) { <<-CSS }
+      p {
+        -moz-border-radius: 3px;
+        -o-border-radius: 3px;
+        -webkit-border-radius: 3px;
+        border-radius: 3px;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when using -moz-osx vendor-prefixed property' do
+    let(:css) { <<-CSS }
+      p {
+        -moz-osx-font-smoothing: grayscale;
+        -webkit-font-smoothing: antialiased;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when vendor properties are ordered out-of-order before the non-prefixed property' do
+    let(:css) { <<-CSS }
+      p {
+        -moz-border-radius: 3px;
+        -webkit-border-radius: 3px;
+        -o-border-radius: 3px;
+        border-radius: 3px;
+      }
+    CSS
+
+    it { should report_lint line: 3 }
+  end
+
+  context 'when the order has been explicitly set' do
+    let(:linter_config) { { 'order' => %w[position display padding margin width] } }
+
+    context 'and the properties match the specified order' do
+      let(:css) { <<-CSS }
+        p {
+          display: block;
+          padding: 5px;
+          margin: 10px;
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and the properties do not match the specified order' do
+      let(:css) { <<-CSS }
+        p {
+          padding: 5px;
+          display: block;
+          margin: 10px;
+        }
+      CSS
+
+      it { should report_lint line: 2 }
+    end
+
+    context 'and there are properties that are not specified in the explicit ordering' do
+      let(:css) { <<-CSS }
+        p {
+          display: block;
+          padding: 5px;
+          font-weight: bold; // Unspecified
+          margin: 10px;
+          border: 0;         // Unspecified
+          background: red;   // Unspecified
+          width: 100%;
+        }
+      CSS
+
+      context 'and the ignored_omitted option is enabled' do
+        let(:linter_config) { super().merge('ignored_unspecified' => true) }
+
+        it { should_not report_lint }
+      end
+
+      context 'and the ignored_omitted option is disabled' do
+        let(:linter_config) { super().merge('ignored_unspecified' => false) }
+
+        it { should report_lint }
+      end
+    end
+  end
+
+  context 'when sort order is set to a preset order' do
+    let(:linter_config) { { 'order' => 'concentric' } }
+
+    context 'and the properties match the order' do
+      let(:css) { <<-CSS }
+        p {
+          display: block;
+          position: absolute;
+          float: left;
+          clear: both;
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and the properties do not match the order' do
+      let(:css) { <<-CSS }
+        p {
+          clear: both;
+          display: block;
+          float: left;
+          position: absolute;
+        }
+      CSS
+
+      it { should report_lint }
+    end
+  end
+end

data/spec/scss_lint/linter/property_spelling_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::PropertySpelling do
+  context 'with a regular property' do
+    let(:css) { <<-CSS }
+      p {
+        margin: 5px;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a property containing interpolation' do
+    let(:css) { <<-CSS }
+      p {
+        \#{$property-name}: 5px;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a non-existent property' do
+    let(:css) { <<-CSS }
+      p {
+        peanut-butter: jelly-time;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when extra properties are specified' do
+    let(:linter_config) { { 'extra_properties' => ['made-up-property'] } }
+
+    context 'with a non-existent property' do
+      let(:css) { <<-CSS }
+        p {
+          peanut-butter: jelly-time;
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'with a property listed as an extra property' do
+      let(:css) { <<-CSS }
+        p {
+          made-up-property: value;
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+  end
+end

data/spec/scss_lint/linter/selector_depth_spec.rb

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