scss_lint 0.38.0

data/spec/scss_lint/reporter_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe SCSSLint::Reporter do
+  class SCSSLint::Reporter::FakeReporter < SCSSLint::Reporter; end
+
+  describe '#descendants' do
+    it 'contains FakeReporter' do
+      SCSSLint::Reporter.descendants.should include(SCSSLint::Reporter::FakeReporter)
+    end
+  end
+end

data/spec/scss_lint/runner_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe SCSSLint::Runner do
+  let(:config_options) do
+    {
+      'linters' => {
+        'FakeLinter1' => { 'enabled' => true },
+        'FakeLinter2' => { 'enabled' => false },
+      },
+    }
+  end
+
+  let(:config) { SCSSLint::Config.new(config_options) }
+  let(:runner) { described_class.new(config) }
+
+  before do
+    SCSSLint::LinterRegistry.stub(:linters)
+                            .and_return([SCSSLint::Linter::FakeLinter1,
+                                         SCSSLint::Linter::FakeLinter2])
+  end
+
+  class SCSSLint::Linter::FakeLinter1 < SCSSLint::Linter; end
+  class SCSSLint::Linter::FakeLinter2 < SCSSLint::Linter; end
+
+  describe '#run' do
+    let(:files) { ['dummy1.scss', 'dummy2.scss'] }
+    subject     { runner.run(files) }
+
+    before do
+      SCSSLint::Engine.stub(:new)
+      SCSSLint::Linter.any_instance.stub(:run)
+    end
+
+    it 'searches for lints in each file' do
+      runner.should_receive(:find_lints).exactly(files.size).times
+      subject
+    end
+
+    context 'when all linters are disabled' do
+      let(:config_options) do
+        {
+          'linters' => {
+            'FakeLinter1' => { 'enabled' => false },
+            'FakeLinter2' => { 'enabled' => false },
+          },
+        }
+      end
+
+      before do
+        SCSSLint::Linter.any_instance
+                        .stub(:run)
+                        .and_raise(RuntimeError.new('Linter#run was called'))
+      end
+
+      it 'never runs a linter' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'when the engine raises a FileEncodingError' do
+      let(:error) do
+        SCSSLint::FileEncodingError.new('Some error message')
+      end
+
+      before do
+        SCSSLint::Engine.stub(:new).and_raise(error)
+      end
+
+      it 'records the error as a lint' do
+        subject.count.should == 2
+      end
+    end
+
+    context 'when files ere excluded for one linter' do
+      let(:config_options) do
+        {
+          'linters' => {
+            'FakeLinter1' => { 'enabled' => true,
+                               'exclude' => [File.expand_path('dummy1.scss'),
+                                             File.expand_path('dummy2.scss')] },
+            'FakeLinter2' => { 'enabled' => false },
+          },
+        }
+      end
+
+      before do
+        SCSSLint::Linter::FakeLinter1.any_instance
+                                     .stub(:run)
+                                     .and_raise(RuntimeError.new('FakeLinter1#run was called'))
+      end
+
+      it 'does not run the linter for the disabled files' do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context 'when a linter raises an error' do
+      let(:backtrace) { %w[file.rb:1 file.rb:2] }
+
+      let(:error) do
+        StandardError.new('Some error message').tap do |e|
+          e.set_backtrace(backtrace)
+        end
+      end
+
+      before do
+        runner.stub(:run_linter).and_raise(error)
+      end
+
+      it 'raises a LinterError' do
+        expect { subject }.to raise_error(SCSSLint::Exceptions::LinterError)
+      end
+
+      it 'has the name of the file the linter was checking' do
+        expect { subject }.to raise_error { |e| e.message.should include files.first }
+      end
+
+      it 'has the same backtrace as the original error' do
+        expect { subject }.to raise_error { |e| e.backtrace.should == backtrace }
+      end
+    end
+  end
+end

data/spec/scss_lint/selector_visitor_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+
+describe SCSSLint::SelectorVisitor do
+  describe '#visit' do
+    let(:engine) { SCSSLint::Engine.new(code: scss) }
+    before { RuleVisitor.new(visitor).run(engine) }
+
+    # Visits every rule in the given parse tree and passes the parsed selector
+    # to the given `selector_visitor`.
+    class RuleVisitor < Sass::Tree::Visitors::Base
+      def initialize(selector_visitor)
+        @selector_visitor = selector_visitor
+      end
+
+      def run(engine)
+        visit(engine.tree)
+      end
+
+      def visit_rule(node)
+        @selector_visitor.visit_selector(node.parsed_rules)
+        yield # Continue linting children
+      end
+    end
+
+    # Superclass for all the test selector visitors
+    class TrackingSelectorVisitor
+      include SCSSLint::SelectorVisitor
+
+      attr_reader :node_order
+
+      def initialize
+        @node_order = []
+      end
+    end
+
+    context 'when visitor defines visit_attribute' do
+      class TestAttributeVisitor < TrackingSelectorVisitor
+        def visit_attribute(attribute)
+          @node_order << attribute.name
+        end
+      end
+
+      let(:visitor) { TestAttributeVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        [rel="nofollow"] {}
+        a[href="http"] {}
+        .class [data-count] {}
+      SCSS
+
+      it 'visits all attribute nodes' do
+        visitor.node_order.should == %w[rel href data-count]
+      end
+    end
+
+    context 'when visitor defines visit_class' do
+      class TestClassVisitor < TrackingSelectorVisitor
+        def visit_class(klass)
+          @node_order << klass.name
+        end
+      end
+
+      let(:visitor) { TestClassVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        a.link {}
+        .menu .menu-item {}
+        .button[data-source], .overlay {}
+      SCSS
+
+      it 'visits all class nodes' do
+        visitor.node_order.should == %w[link menu menu-item button overlay]
+      end
+    end
+
+    context 'when visitor defines visit_element' do
+      class TestElementVisitor < TrackingSelectorVisitor
+        def visit_element(element)
+          @node_order << element.name
+        end
+      end
+
+      let(:visitor) { TestElementVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        a, b {}
+        .class {}
+        i + p {}
+      SCSS
+
+      it 'visits all element nodes' do
+        visitor.node_order.should == %w[a b i p]
+      end
+    end
+
+    context 'when visitor defines visit_id' do
+      class TestIdVisitor < TrackingSelectorVisitor
+        def visit_id(id)
+          @node_order << id.name
+        end
+      end
+
+      let(:visitor) { TestIdVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        #something, #thing {}
+        #object + #entity {}
+      SCSS
+
+      it 'visits all id nodes' do
+        visitor.node_order.should == %w[something thing object entity]
+      end
+    end
+
+    context 'when visitor defines visit_parent' do
+      class TestParentVisitor < TrackingSelectorVisitor
+        def visit_parent(parent)
+          @node_order << parent.line
+        end
+      end
+
+      let(:visitor) { TestParentVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        p {
+          &.class {}
+          .container & {}
+          .nothing {}
+        }
+      SCSS
+
+      it 'visits all parent nodes' do
+        visitor.node_order.should == [2, 3]
+      end
+    end
+
+    context 'when visitor defines visit_placeholder' do
+      class TestPlaceholderVisitor < TrackingSelectorVisitor
+        def visit_placeholder(placeholder)
+          @node_order << placeholder.name
+        end
+      end
+
+      let(:visitor) { TestPlaceholderVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        %placeholder, %other-placeholder {}
+        .button, %button {}
+      SCSS
+
+      it 'visits all placeholder nodes' do
+        visitor.node_order.should == %w[placeholder other-placeholder button]
+      end
+    end
+
+    context 'when visitor defines visit_pseudo' do
+      class TestPseudoVisitor < TrackingSelectorVisitor
+        def visit_pseudo(pseudo)
+          @node_order << pseudo.name
+        end
+      end
+
+      let(:visitor) { TestPseudoVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        li:first-child, li:last-child {}
+        p {
+          &:first-letter {}
+        }
+      SCSS
+
+      it 'visits all pseudo-selector nodes' do
+        visitor.node_order.should == %w[first-child last-child first-letter]
+      end
+    end
+
+    context 'when visitor defines visit_universal' do
+      class TestUniversalVisitor < TrackingSelectorVisitor
+        def visit_universal(universal)
+          @node_order << universal.line
+        end
+      end
+
+      let(:visitor) { TestUniversalVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        p > * {}
+        * {}
+        li {}
+        *:first-child {}
+      SCSS
+
+      it 'visits all universal-selector nodes' do
+        visitor.node_order.should == [1, 2, 4]
+      end
+    end
+
+    context 'when visitor defines visit_simple_sequence' do
+      class TestSimpleSequenceVisitor < TrackingSelectorVisitor
+        def visit_simple_sequence(seq)
+          @node_order << seq
+        end
+      end
+
+      let(:visitor) { TestSimpleSequenceVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        a, b, p[lang] {}
+        a.link + b.word {}
+        li {}
+        ul > li {}
+        p span {}
+      SCSS
+
+      it 'visits all simple sequences' do
+        visitor.node_order.count.should == 10
+      end
+    end
+
+    context 'when visitor defines visit_sequence' do
+      class TestSequenceVisitor < TrackingSelectorVisitor
+        def visit_sequence(seq)
+          @node_order << seq
+        end
+      end
+
+      let(:visitor) { TestSequenceVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        a, b, p[lang] {}
+        a.link + b.word {}
+        li {}
+        ul > li {}
+        p span {}
+      SCSS
+
+      it 'visits all sequences' do
+        visitor.node_order.count.should == 7
+      end
+    end
+
+    context 'when visitor defines visit_comma_sequence' do
+      class TestCommaSequenceVisitor < TrackingSelectorVisitor
+        def visit_comma_sequence(seq)
+          @node_order << seq
+        end
+      end
+
+      let(:visitor) { TestCommaSequenceVisitor.new }
+
+      let(:scss) { <<-SCSS }
+        a, b, p[lang] {}
+        a.link + b.word {}
+        li {}
+        ul > li {}
+        p span {}
+      SCSS
+
+      it 'visits all comma (i.e. selector) sequences' do
+        visitor.node_order.count.should == 5
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'scss_lint'
+require 'nokogiri'
+
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect, :should]
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+
+  config.before(:each) do
+    # If running a linter spec, run the described linter against the CSS code
+    # for each example. This significantly DRYs up our linter specs to contain
+    # only tests, since all the setup code is now centralized here.
+    if described_class <= SCSSLint::Linter
+      initial_indent = scss[/\A(\s*)/, 1]
+      normalized_css = scss.gsub(/^#{initial_indent}/, '')
+
+      # Use the configuration settings defined by default unless a specific
+      # configuration has been provided for the test.
+      local_config = if respond_to?(:linter_config)
+                       linter_config
+                     else
+                       SCSSLint::Config.default.linter_options(subject)
+                     end
+
+      subject.run(SCSSLint::Engine.new(code: normalized_css), local_config)
+    end
+  end
+end

data/spec/support/isolated_environment.rb

@@ -0,0 +1,25 @@
+require 'fileutils'
+require 'tmpdir'
+
+shared_context 'isolated environment' do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+
+      begin
+        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+        Dir.mkdir(virtual_home)
+        ENV['HOME'] = virtual_home
+
+        working_dir = File.join(tmpdir, 'work')
+        Dir.mkdir(working_dir)
+
+        Dir.chdir(working_dir) do
+          example.run
+        end
+      ensure
+        ENV['HOME'] = original_home
+      end
+    end
+  end
+end