scss_lint 0.38.0

data/spec/scss_lint/linter/property_spelling_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::PropertySpelling do
+  context 'with a regular property' do
+    let(:scss) { <<-SCSS }
+      p {
+        margin: 5px;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a property containing interpolation' do
+    let(:scss) { <<-SCSS }
+      p {
+        \#{$property-name}: 5px;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a non-existent property' do
+    let(:scss) { <<-SCSS }
+      p {
+        peanut-butter: jelly-time;
+      }
+    SCSS
+
+    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(:scss) { <<-SCSS }
+        p {
+          peanut-butter: jelly-time;
+        }
+      SCSS
+
+      it { should report_lint }
+    end
+
+    context 'with a property listed as an extra property' do
+      let(:scss) { <<-SCSS }
+        p {
+          made-up-property: value;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+  end
+
+  context 'with valid nested properties' do
+    let(:scss) { <<-SCSS }
+      p {
+        text: {
+          align: center;
+          transform: uppercase;
+        }
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with invalid nested properties' do
+    let(:scss) { <<-SCSS }
+      p {
+        text: {
+          aligned: center;
+          transformed: uppercase;
+        }
+      }
+    SCSS
+
+    it { should report_lint line: 3 }
+    it { should report_lint line: 4 }
+  end
+end

data/spec/scss_lint/linter/property_units_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::PropertyUnits do
+  context 'when global units are set and local are not set' do
+    let(:linter_config) { { 'global' => ['rem'], 'properties' => {} } }
+
+    context 'when unit is allowed' do
+      let(:scss) { <<-SCSS }
+        p {
+          font-size: 1.54rem;
+          margin: 1rem;
+          padding: .1rem;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when unit is not allowed' do
+      let(:scss) { <<-SCSS }
+        p {
+          font-size: 16.54px;
+          margin: 1px;
+          padding: .1px;
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+      it { should report_lint line: 3 }
+      it { should report_lint line: 4 }
+    end
+
+    context 'when using a shorthand property' do
+      context 'and the unit is allowed' do
+        let(:scss) { <<-SCSS }
+          p {
+            font: italic 1rem Serif;
+          }
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'and the unit is not allowed' do
+        let(:scss) { <<-SCSS }
+          p {
+            font: italic 16px Serif;
+          }
+        SCSS
+
+        it { should report_lint line: 2 }
+      end
+    end
+  end
+
+  context 'when global and local units are set' do
+    let(:linter_config) { { 'global' => ['rem'], 'properties' => { 'font-size' => ['px'] } } }
+
+    context 'when unit is allowed locally not globally' do
+      let(:scss) { <<-SCSS }
+        p {
+          font-size: 16px;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when unit is allowed globally not locally' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 1rem;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when unit is not allowed globally nor locally' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 1vh;
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+  end
+
+  context 'when local units are set and global are not set' do
+    let(:linter_config) { { 'global' => [], 'properties' => { 'margin' => ['rem'] } } }
+
+    context 'when unit is allowed locally not globally' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 1rem;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when unit is not allowed locally nor globally' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 10px;
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+  end
+
+  context 'when multiple units are set on a property' do
+    let(:linter_config) { { 'global' => [], 'properties' => { 'margin' => %w[rem em] } } }
+
+    context 'when one of multiple units is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 1rem;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when another of multiple units is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 1em;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'when a not allowed unit is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          margin: 10px;
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+  end
+
+  context 'when no local units are allowed' do
+    let(:linter_config) { { 'global' => ['px'], 'properties' => { 'line-height' => [] } } }
+
+    context 'when a disallowed unit is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          line-height: 10px;
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+
+    context 'when no unit is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          line-height: 1;
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+  end
+
+  context 'when nested properties are used' do
+    let(:linter_config) { { 'global' => ['rem'], 'properties' => { 'font-size' => ['em'] } } }
+
+    context 'and an allowed unit is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          font: {
+            size: 1em;
+          }
+        }
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and a disallowed unit is used' do
+      let(:scss) { <<-SCSS }
+        p {
+          font: {
+            size: 16px;
+          }
+        }
+      SCSS
+
+      it { should report_lint line: 3 }
+    end
+  end
+
+  context 'when property contains a function call' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: my-special-color(5);
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when property contains a unicode sequence' do
+    let(:scss) { <<-SCSS }
+      p {
+        content: "\\25be";
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when property contains a string in quotes that looks like a value' do
+    let(:scss) { <<-SCSS }
+      p {
+        content: "This is 12px";
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+end

data/spec/scss_lint/linter/qualifying_element_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::QualifyingElement do
+  context 'when selector does not include an element' do
+    let(:scss) { <<-SCSS }
+      .foo {}
+      #bar {}
+      [foobar] {}
+      .foo .bar {}
+      #bar > .foo {}
+      [foobar] #bar .foo {}
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when selector includes an element' do
+    context 'and element does not qualify' do
+      let(:scss) { <<-SCSS }
+        ul {}
+      SCSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and element qualifies class' do
+      let(:scss) { <<-SCSS }
+        ul.list {}
+      SCSS
+
+      it { should report_lint line: 1 }
+    end
+
+    context 'and element qualifies attribute' do
+      let(:scss) { <<-SCSS }
+        a[href] {}
+      SCSS
+
+      it { should report_lint line: 1 }
+    end
+
+    context 'and element qualifies id' do
+      let(:scss) { <<-SCSS }
+        ul#list {}
+      SCSS
+
+      it { should report_lint line: 1 }
+    end
+
+    context 'and selector is in a group' do
+      context 'and element does not qualify' do
+        let(:scss) { <<-SCSS }
+          .list li,
+          .item > span {}
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'and element qualifies class' do
+        let(:scss) { <<-SCSS }
+          .item span,
+          ul > li.item {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+
+      context 'and element qualifies attribute' do
+        let(:scss) { <<-SCSS }
+          .item + span,
+          li a[href] {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+
+      context 'and element qualifies id' do
+        let(:scss) { <<-SCSS }
+          #foo,
+          li#item + li {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+    end
+
+    context 'and selector involves a combinator' do
+      context 'and element does not qualify' do
+        let(:scss) { <<-SCSS }
+          .list li {}
+          .list > li {}
+          .item + li {}
+          .item ~ li {}
+        SCSS
+
+        it { should_not report_lint }
+      end
+
+      context 'and element qualifies class' do
+        let(:scss) { <<-SCSS }
+          ul > li.item {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+
+      context 'and element qualifies attribute' do
+        let(:scss) { <<-SCSS }
+          li a[href] {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+
+      context 'and element qualifies id' do
+        let(:scss) { <<-SCSS }
+          li#item + li {}
+        SCSS
+
+        it { should report_lint line: 1 }
+      end
+    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(:scss) { 'p {}' }
+
+    it { should_not report_lint }
+  end
+
+  context 'when sequence has a depth of three' do
+    let(:scss) { 'body article p {}' }
+
+    it { should_not report_lint }
+
+    context 'and contains a nested selector' do
+      let(:scss) { <<-SCSS }
+        body article p {
+          i {
+            font-style: italic;
+          }
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+    end
+
+    context 'and contains multiple nested selectors' do
+      let(:scss) { <<-SCSS }
+        body article p {
+          b {
+            font-weight: bold;
+          }
+          i {
+            font-style: italic;
+          }
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+      it { should report_lint line: 5 }
+    end
+  end
+
+  context 'when sequence has a depth of four' do
+    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(:scss) { '.one + .two + .three + .four {}' }
+
+    it { should_not report_lint }
+  end
+
+  context 'when sequence is made up of general sibling combinators' do
+    let(:scss) { '.one .two ~ .three ~ .four {}' }
+
+    it { should_not report_lint }
+  end
+
+  context 'when sequence contains interpolation' do
+    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(:scss) { <<-SCSS }
+      p,
+      .one .two .three,
+      ul > li {
+      }
+    SCSS
+
+    it { should_not report_lint }
+
+    context 'and a nested selector causes one of the sequences to exceed the limit' do
+      let(:scss) { <<-SCSS }
+        p,
+        .one .two .three,
+        ul > li {
+          .four {}
+        }
+      SCSS
+
+      it { should report_lint line: 4 }
+    end
+  end
+
+  context 'when comma sequence contains a sequence exceeding the depth limit' do
+    let(:scss) { <<-SCSS }
+      p,
+      .one .two .three .four,
+      ul > li {
+      }
+    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(:scss) { <<-SCSS }
+        .one .two  {
+          .three & {}
+        }
+      SCSS
+
+      it { should_not report_lint }
+
+      context 'and the parent selector is chained' do
+        let(:scss) { <<-SCSS }
+          .one .two .three {
+            &.chained {}
+          }
+        SCSS
+
+        it { should_not report_lint }
+      end
+    end
+
+    context 'which does exceed the depth limit' do
+      let(:scss) { <<-SCSS }
+        .one .two {
+          .three & & .four {}
+        }
+      SCSS
+
+      it { should report_lint line: 2 }
+
+      context 'and the parent selector is chained' do
+        let(:scss) { <<-SCSS }
+          .one .two .three > .four {
+            &.chained {}
+          }
+        SCSS
+
+        it { should report_lint line: 2 }
+      end
+    end
+  end
+
+  context 'when sequence contains a @keyframe' do
+    let(:scss) { <<-SCSS }
+      @keyframe my-keyframe {
+        0% {
+          background: #000;
+        }
+
+        50% {
+          background: #fff;
+        }
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+end