scss-lint 0.25.1 → 0.26.0

data/spec/scss_lint/linter_registry_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe SCSSLint::LinterRegistry do
+  context 'when including the LinterRegistry module' do
+    after do
+      described_class.linters.delete(FakeLinter)
+    end
+
+    it 'adds the linter to the set of registered linters' do
+      expect do
+        class FakeLinter < SCSSLint::Linter
+          include SCSSLint::LinterRegistry
+        end
+      end.to change { described_class.linters.count }.by(1)
+    end
+  end
+
+  describe '.extract_linters_from' do
+    module SCSSLint
+      class Linter::SomeLinter < Linter; end
+      class Linter::SomeOtherLinter < Linter; end
+    end
+
+    let(:linters) do
+      [SCSSLint::Linter::SomeLinter, SCSSLint::Linter::SomeOtherLinter]
+    end
+
+    before do
+      described_class.stub(:linters).and_return(linters)
+    end
+
+    context 'when the linters exist' do
+      let(:linter_names) { %w[SomeLinter SomeOtherLinter] }
+
+      it 'returns the linters' do
+        subject.extract_linters_from(linter_names).should == linters
+      end
+    end
+
+    context "when the linters don't exist" do
+      let(:linter_names) { ['SomeRandomLinter'] }
+
+      it 'raises an error' do
+        expect do
+          subject.extract_linters_from(linter_names)
+        end.to raise_error(SCSSLint::NoSuchLinter)
+      end
+    end
+  end
+end

data/spec/scss_lint/location_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe SCSSLint::Location do
+  let(:engine) { described_class.new(css) }
+
+  describe '#<=>' do
+    let(:locations) do
+      [
+        SCSSLint::Location.new(2, 2, 2),
+        SCSSLint::Location.new(2, 2, 1),
+        SCSSLint::Location.new(2, 1, 2),
+        SCSSLint::Location.new(2, 1, 1),
+        SCSSLint::Location.new(1, 2, 2),
+        SCSSLint::Location.new(1, 2, 1),
+        SCSSLint::Location.new(1, 1, 2),
+        SCSSLint::Location.new(1, 1, 1)
+      ]
+    end
+
+    it 'allows locations to be sorted' do
+      locations.sort.should == [
+        SCSSLint::Location.new(1, 1, 1),
+        SCSSLint::Location.new(1, 1, 2),
+        SCSSLint::Location.new(1, 2, 1),
+        SCSSLint::Location.new(1, 2, 2),
+        SCSSLint::Location.new(2, 1, 1),
+        SCSSLint::Location.new(2, 1, 2),
+        SCSSLint::Location.new(2, 2, 1),
+        SCSSLint::Location.new(2, 2, 2)
+      ]
+    end
+
+    context 'when the same location is passed' do
+      let(:location) { SCSSLint::Location.new(1, 1, 1) }
+      let(:other_location) { SCSSLint::Location.new(1, 1, 1) }
+
+      it 'returns 0' do
+        (location <=> other_location).should == 0
+      end
+    end
+  end
+end

data/spec/scss_lint/reporter/config_reporter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe SCSSLint::Reporter::ConfigReporter do
+  subject { YAML.load(result) }
+  let(:result) { described_class.new(lints).report_lints }
+
+  describe '#report_lints' do
+    context 'when there are no lints' do
+      let(:lints) { [] }
+
+      it 'returns nil' do
+        result.should be_nil
+      end
+    end
+
+    context 'when there are lints' do
+      let(:linters) do
+        [SCSSLint::Linter::FinalNewline, SCSSLint::Linter::BorderZero,
+         SCSSLint::Linter::BorderZero, nil]
+      end
+      let(:lints) do
+        linters.each.map do |linter|
+          SCSSLint::Lint.new(linter ? linter.new : nil, '',
+                             SCSSLint::Location.new, '')
+        end
+      end
+
+      it 'adds one entry per linter' do
+        subject['linters'].size.should eq 2
+      end
+
+      it 'sorts linters by name' do
+        subject['linters'].map(&:first).should eq %w[BorderZero FinalNewline]
+      end
+
+      it 'disables all found linters' do
+        subject['linters']['BorderZero']['enabled'].should eq false
+        subject['linters']['FinalNewline']['enabled'].should eq false
+      end
+    end
+  end
+end

data/spec/scss_lint/reporter/default_reporter_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe SCSSLint::Reporter::DefaultReporter do
+  subject { SCSSLint::Reporter::DefaultReporter.new(lints) }
+
+  describe '#report_lints' do
+    context 'when there are no lints' do
+      let(:lints) { [] }
+
+      it 'returns nil' do
+        subject.report_lints.should be_nil
+      end
+    end
+
+    context 'when there are lints' do
+      let(:filenames)    { ['some-filename.scss', 'other-filename.scss'] }
+      let(:lines)        { [502, 724] }
+      let(:descriptions) { ['Description of lint 1', 'Description of lint 2'] }
+      let(:severities)   { [:warning] * 2 }
+      let(:lints) do
+        filenames.each_with_index.map do |filename, index|
+          location = SCSSLint::Location.new(lines[index])
+          SCSSLint::Lint.new(nil, filename, location, descriptions[index],
+                             severities[index])
+        end
+      end
+
+      it 'prints each lint on its own line' do
+        subject.report_lints.count("\n").should == 2
+      end
+
+      it 'prints a trailing newline' do
+        subject.report_lints[-1].should == "\n"
+      end
+
+      it 'prints the filename for each lint' do
+        filenames.each do |filename|
+          subject.report_lints.scan(/#{filename}/).count.should == 1
+        end
+      end
+
+      it 'prints the line number for each lint' do
+        lines.each do |line|
+          subject.report_lints.scan(/#{line}/).count.should == 1
+        end
+      end
+
+      it 'prints the description for each lint' do
+        descriptions.each do |description|
+          subject.report_lints.scan(/#{description}/).count.should == 1
+        end
+      end
+
+      context 'when lints are warnings' do
+        it 'prints the warning severity code on each line' do
+          subject.report_lints.split("\n").each do |line|
+            line.scan(/\[W\]/).count.should == 1
+          end
+        end
+      end
+
+      context 'when lints are errors' do
+        let(:severities) { [:error] * 2 }
+
+        it 'prints the error severity code on each line' do
+          subject.report_lints.split("\n").each do |line|
+            line.scan(/\[E\]/).count.should == 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/scss_lint/reporter/files_reporter_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe SCSSLint::Reporter::FilesReporter do
+  subject { described_class.new(lints) }
+
+  describe '#report_lints' do
+    context 'when there are no lints' do
+      let(:lints) { [] }
+
+      it 'returns nil' do
+        subject.report_lints.should be_nil
+      end
+    end
+
+    context 'when there are lints' do
+      let(:filenames)    { ['some-filename.scss', 'some-filename.scss', 'other-filename.scss'] }
+      let(:lints) do
+        filenames.map do |filename|
+          SCSSLint::Lint.new(nil, filename, SCSSLint::Location.new, '')
+        end
+      end
+
+      it 'prints each file on its own line' do
+        subject.report_lints.count("\n").should == 2
+      end
+
+      it 'prints a trailing newline' do
+        subject.report_lints[-1].should == "\n"
+      end
+
+      it 'prints the filename for each lint' do
+        filenames.each do |filename|
+          subject.report_lints.scan(/#{filename}/).count.should == 1
+        end
+      end
+    end
+  end
+end

data/spec/scss_lint/reporter/xml_reporter_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe SCSSLint::Reporter::XMLReporter do
+  subject { SCSSLint::Reporter::XMLReporter.new(lints) }
+
+  describe '#report_lints' do
+    let(:xml) { Nokogiri::XML(subject.report_lints) }
+
+    shared_examples_for 'XML document' do
+      it 'has an encoding of UTF-8' do
+        xml.encoding.should == 'utf-8'
+      end
+
+      it 'has an XML version of 1.0' do
+        xml.version.should == '1.0'
+      end
+
+      it 'contains a <lint> root element' do
+        xml.root.name.should == 'lint'
+      end
+    end
+
+    context 'when there are no lints' do
+      let(:lints) { [] }
+
+      it_should_behave_like 'XML document'
+    end
+
+    context 'when there are lints' do
+      let(:filenames)    { ['f1.scss', 'f2.scss', 'f1.scss'] }
+      # Include invalid XML characters in the third description to validate
+      # that escaping happens for preventing broken XML output
+      let(:descriptions) { ['lint 1', 'lint 2', 'lint 3 " \' < & >'] }
+      let(:severities)   { [:warning] * 3 }
+
+      let(:locations)    do
+        [
+          SCSSLint::Location.new(5,  2, 3),
+          SCSSLint::Location.new(7,  6, 2),
+          SCSSLint::Location.new(9, 10, 1)
+        ]
+      end
+
+      let(:lints) do
+        filenames.each_with_index.map do |filename, index|
+          SCSSLint::Lint.new(nil, filename, locations[index],
+                             descriptions[index], severities[index])
+        end
+      end
+
+      it_should_behave_like 'XML document'
+
+      it 'contains an <issue> node for each lint' do
+        xml.xpath('//issue').count.should == 3
+      end
+
+      it 'contains a <file> node for each file' do
+        xml.xpath('//file').map { |node| node[:name] }
+          .should =~ filenames.uniq
+      end
+
+      it 'contains <issue> nodes grouped by <file>' do
+        xml.xpath('//file').map do |file_node|
+          file_node.xpath('./issue').count
+        end.should =~ [1, 2]
+      end
+
+      it 'marks each issue with a line number' do
+        xml.xpath('//issue[@line]').map { |node| node[:line] }
+          .should =~ locations.map { |location| location.line.to_s }
+      end
+
+      it 'marks each issue with a column number' do
+        xml.xpath('//issue[@column]').map { |node| node[:column] }
+          .should =~ locations.map { |location| location.column.to_s }
+      end
+
+      it 'marks each issue with a length' do
+        xml.xpath('//issue[@length]').map { |node| node[:length] }
+          .should =~ locations.map { |location| location.length.to_s }
+      end
+
+      it 'marks each issue with a reason containing the lint description' do
+        xml.xpath('//issue[@reason]').map { |node| node[:reason] }
+          .should =~ descriptions
+      end
+
+      context 'when lints are warnings' do
+        it 'marks each issue with a severity of "warning"' do
+          xml.xpath("//issue[@severity='warning']").count == 3
+        end
+      end
+
+      context 'when lints are errors' do
+        let(:severities) { [:error] * 3 }
+
+        it 'marks each issue with a severity of "error"' do
+          xml.xpath("//issue[@severity='error']").count == 3
+        end
+      end
+    end
+  end
+end

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,132 @@
+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])
+    SCSSLint::Config.stub(:for_file)
+  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 no files are given' do
+      let(:files) { [] }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error SCSSLint::NoFilesError
+      end
+    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).with(files.last).and_raise(error)
+      end
+
+      it 'records the error as a lint' do
+        expect { subject }.to change { runner.lints.count }.by(1)
+      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