scss-lint 0.29.0 → 0.30.0

data/lib/scss_lint/rake_task.rb

@@ -27,6 +27,7 @@ module SCSSLint
     def run_task
       # Lazy load so task doesn't impact load time of Rakefile
       require 'scss_lint'
+      require 'scss_lint/cli'
 
       CLI.new([]).tap do |cli|
         cli.parse_arguments

data/lib/scss_lint/runner.rb

@@ -48,7 +48,8 @@ module SCSSLint
         end
       end
     rescue Sass::SyntaxError => ex
-      @lints << Lint.new(nil, ex.sass_filename, Location.new(ex.sass_line), ex.to_s, :error)
+      @lints << Lint.new(nil, ex.sass_filename, Location.new(ex.sass_line),
+                         "Syntax Error: #{ex}", :error)
     rescue FileEncodingError => ex
       @lints << Lint.new(nil, file, Location.new, ex.to_s, :error)
     end

data/lib/scss_lint/sass/script.rb

@@ -6,6 +6,8 @@ module Sass::Script
   # Define the `node_name` and `visit_method` class methods for each Sass Script
   # parse tree node type so that our custom visitor can seamless traverse the
   # tree.
+  # Define the `invalid_child_method_name` and `invalid_parent_method_name`
+  # class methods to make errors understandable.
   #
   # This would be easier if we could just define an `inherited` callback, but
   # that won't work since the Sass library will have already been loaded before
@@ -29,6 +31,14 @@ module Sass::Script
           def self.visit_method
             :visit_script_#{node_name}
           end
+
+          def self.invalid_child_method_name
+            :"invalid_#{node_name}_child?"
+          end
+
+          def self.invalid_parent_method_name
+            :"invalid_#{node_name}_parent?"
+          end
         end
       DECL
     end

data/lib/scss_lint/version.rb

@@ -1,4 +1,4 @@
 # Defines the gem version.
 module SCSSLint
-  VERSION = '0.29.0'
+  VERSION = '0.30.0'
 end

data/spec/scss_lint/cli_spec.rb

@@ -93,7 +93,39 @@ describe SCSSLint::CLI do
 
       it 'includes all linters except the excluded one' do
         safe_parse
-        subject.config.enabled_linters.should == [SCSSLint::Linter::FakeTestLinter2]
+        subject.config.enabled_linters.should == \
+          [SCSSLint::Linter::FakeTestLinter2]
+      end
+    end
+
+    context 'when the require flag is set' do
+      let(:flags) { %w[--require uri] }
+
+      it 'requires the specified file and constants are accessible' do
+        safe_parse
+        expect { subject.instance_eval %{ URI } }.to_not raise_error
+      end
+    end
+
+    context 'when neither format nor out flag is set' do
+      let(:flags) { %w[] }
+
+      it 'sets the default reporter to output to stdout' do
+        safe_parse
+        subject.options[:reporters].should \
+          include([SCSSLint::Reporter::DefaultReporter, :stdout])
+      end
+    end
+
+    context 'when the out flag is set' do
+      context 'and the path is valid' do
+        let(:flags) { %w[--out foo.txt] }
+
+        it 'sets the default :output to the given path' do
+          safe_parse
+          subject.options[:reporters].should \
+            include([SCSSLint::Reporter::DefaultReporter, 'foo.txt'])
+        end
       end
     end
 
@@ -103,7 +135,18 @@ describe SCSSLint::CLI do
 
         it 'sets the :reporter option to the correct reporter' do
           safe_parse
-          subject.options[:reporter].should == SCSSLint::Reporter::XMLReporter
+          subject.options[:reporters].should \
+            include([SCSSLint::Reporter::XMLReporter, :stdout])
+        end
+      end
+
+      context 'and an out path is specified' do
+        let(:flags) { %w[--format XML --out foo.txt] }
+
+        it 'sets the specified reporter :output to the given path' do
+          safe_parse
+          subject.options[:reporters].should \
+            include([SCSSLint::Reporter::XMLReporter, 'foo.txt'])
         end
       end
 

data/spec/scss_lint/linter/bang_format_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::BangFormat do
+  context 'when no bang is used' do
+    let(:css) { <<-CSS }
+      p {
+        color: #000;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important is used correctly' do
+    let(:css) { <<-CSS }
+      p {
+        color: #000 !important;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important has no space before' do
+    let(:css) { <<-CSS }
+      p {
+        color: #000!important;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when !important has a space after' do
+    let(:css) { <<-CSS }
+      p {
+        color: #000 ! important;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when !important has a space after and config allows it' do
+    let(:linter_config) { { 'space_before_bang' => true, 'space_after_bang' => true } }
+
+    let(:css) { <<-CSS }
+      p {
+        color: #000 ! important;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important has a space before but config does not allow it' do
+    let(:linter_config) { { 'space_before_bang' => false, 'space_after_bang' => true } }
+
+    let(:css) { <<-CSS }
+      p {
+        color: #000 ! important;
+      }
+    CSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when !important has no spaces around and config allows it' do
+    let(:linter_config) { { 'space_before_bang' => false, 'space_after_bang' => false } }
+
+    let(:css) { <<-CSS }
+      p {
+        color: #000!important;
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+end

data/spec/scss_lint/linter/declaration_order_spec.rb

@@ -91,4 +91,470 @@ describe SCSSLint::Linter::DeclarationOrder do
 
     it { should report_lint }
   end
+
+  context 'when nested rule set' do
+    context 'contains @extend before a property' do
+      let(:css) { <<-CSS }
+        p {
+          a {
+            @extend foo;
+            color: #f00;
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'contains @extend after a property' do
+      let(:css) { <<-CSS }
+        p {
+          a {
+            color: #f00;
+            @extend foo;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'contains @extend after nested rule set' do
+      let(:css) { <<-CSS }
+        p {
+          a {
+            span {
+              color: #000;
+            }
+            @extend foo;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+  end
+
+  context 'when @include appears' do
+    context 'before a property and rule set' do
+      let(:css) { <<-CSS }
+        .error {
+          @include warn;
+          color: #f00;
+          a {
+            color: #ccc;
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'after a property and before a rule set' do
+      let(:css) { <<-CSS }
+        .error {
+          color: #f00;
+          @include warn;
+          a {
+            color: #ccc;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+  end
+
+  context 'when @include that features @content appears' do
+    context 'before a property' do
+      let(:css) { <<-CSS }
+        .foo {
+          @include breakpoint("phone") {
+            color: #ccc;
+          }
+          color: #f00;
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'after a property' do
+      let(:css) { <<-CSS }
+        .foo {
+          color: #f00;
+          @include breakpoint("phone") {
+            color: #ccc;
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'before an @extend' do
+      let(:css) { <<-CSS }
+        .foo {
+          @include breakpoint("phone") {
+            color: #ccc;
+          }
+          @extend .bar;
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'before a rule set' do
+      let(:css) { <<-CSS }
+        .foo {
+          @include breakpoint("phone") {
+            color: #ccc;
+          }
+          a {
+            color: #fff;
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'after a rule set' do
+      let(:css) { <<-CSS }
+        .foo {
+          a {
+            color: #fff;
+          }
+          @include breakpoint("phone") {
+            color: #ccc;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'with its own nested rule set' do
+      context 'before a property' do
+        let(:css) { <<-CSS }
+          @include breakpoint("phone") {
+            a {
+              color: #000;
+            }
+            color: #ccc;
+          }
+        CSS
+
+        it { should report_lint }
+      end
+
+      context 'after a property' do
+        let(:css) { <<-CSS }
+          @include breakpoint("phone") {
+            color: #ccc;
+            a {
+              color: #000;
+            }
+          }
+        CSS
+
+        it { should_not report_lint }
+      end
+    end
+  end
+
+  context 'when the nesting is crazy deep' do
+    context 'and nothing is wrong' do
+      let(:css) { <<-CSS }
+        div {
+          ul {
+            @extend .thing;
+            li {
+              @include box-shadow(yes);
+              background: green;
+              a {
+                span {
+                  @include border-radius(5px);
+                  color: #000;
+                }
+              }
+            }
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'and something is wrong' do
+      let(:css) { <<-CSS }
+        div {
+          ul {
+            li {
+              a {
+                span {
+                  color: #000;
+                  @include border-radius(5px);
+                }
+              }
+            }
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+  end
+
+  context 'when inside a @media query and rule set' do
+    context 'contains @extend before a property' do
+      let(:css) { <<-CSS }
+        @media only screen and (max-width: 1px) {
+          a {
+            @extend foo;
+            color: #f00;
+          }
+        }
+      CSS
+
+      it { should_not report_lint }
+    end
+
+    context 'contains @extend after a property' do
+      let(:css) { <<-CSS }
+        @media only screen and (max-width: 1px) {
+          a {
+            color: #f00;
+            @extend foo;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+
+    context 'contains @extend after nested rule set' do
+      let(:css) { <<-CSS }
+        @media only screen and (max-width: 1px) {
+          a {
+            span {
+              color: #000;
+            }
+            @extend foo;
+          }
+        }
+      CSS
+
+      it { should report_lint }
+    end
+  end
+
+  context 'when a pseudo-element appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        &:hover {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a pseudo-element appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        &:focus {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a chained selector appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        &.is-active {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a chained selector appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        &.is-active {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a selector with parent reference appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        .is-active & {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a selector with parent reference appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        .is-active & {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a pseudo-element appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        &:before {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a pseudo-element appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        &:before {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a direct descendent appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        > .foo {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a direct descendent appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        > .foo {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when an adjacent sibling appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        & + .foo {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when an adjacent sibling appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        & + .foo {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a general sibling appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        & ~ .foo {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a general sibling appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        & ~ .foo {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
+
+  context 'when a descendent appears after a property' do
+    let(:css) { <<-CSS }
+      a {
+        color: #fff;
+        .foo {
+          color: #000;
+        }
+      }
+    CSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when a descendent appears before a property' do
+    let(:css) { <<-CSS }
+      a {
+        .foo {
+          color: #000;
+        }
+        color: #fff;
+      }
+    CSS
+
+    it { should report_lint }
+  end
 end