scss-lint-bliss 1.0.0

data/spec/scss_lint/config_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe SCSSLint::Config do
+  class SCSSLint::Linter::FakeConfigLinter < SCSSLint::Linter; end
+
+  module SCSSLint::Linter::SomeNamespace
+    class FakeLinter1 < SCSSLint::Linter; end
+    class FakeLinter2 < SCSSLint::Linter; end
+  end
+
+  let(:default_file) { File.open(described_class::DEFAULT_FILE).read }
+
+  # This complex stubbing bypasses the built-in caching of the methods, and at
+  # the same time gives us full control over the "default" configuration.
+  before do
+    described_class
+      .stub(:load_file_contents)
+      .with(described_class::DEFAULT_FILE)
+      .and_return(default_file)
+
+    described_class
+      .stub(:default_options_hash)
+      .and_return(described_class.send(:load_options_hash_from_file, described_class::DEFAULT_FILE))
+
+    described_class
+      .stub(:default)
+      .and_return(described_class.load(described_class::DEFAULT_FILE, merge_with_default: false))
+  end
+
+  describe '.default' do
+    subject { described_class.default }
+
+    it 'has a configuration defined for all registered linters' do
+      SCSSLint::LinterRegistry.linters.map(&:new).each do |linter|
+        subject.linter_options(linter).should_not be_nil
+      end
+    end
+  end
+
+  describe '.load' do
+    let(:config_dir) { '/path/to' }
+    let(:file_name) { "/#{config_dir}/config.yml" }
+
+    let(:default_file) { <<-FILE }
+    linters:
+      FakeConfigLinter:
+        enabled: true
+        list: [1, 2, 3]
+      OtherFakeConfigLinter:
+        enabled: false
+    FILE
+
+    subject { described_class.load(file_name) }
+
+    before do
+      described_class.stub(:load_file_contents)
+                     .with(file_name)
+                     .and_return(config_file)
+    end
+
+    context 'with an empty config file' do
+      let(:config_file) { '' }
+
+      it 'returns the default configuration' do
+        subject.options.should == described_class.default.options
+      end
+    end
+
+    context 'with a config file containing only comments' do
+      let(:config_file) { '# This is a comment' }
+
+      it 'returns the default configuration' do
+        subject.options.should == described_class.default.options
+      end
+    end
+
+    context 'with a file configuring an unknown linter' do
+      let(:config_file) { 'linters: { MadeUpLinterName: { enabled: true } }' }
+
+      it 'stores a warning for the unknown linter' do
+        subject.warnings
+               .any? { |warning| warning.include?('MadeUpLinterName') }
+               .should be true
+      end
+    end
+
+    context 'with a config file setting the same configuration as the default' do
+      let(:config_file) { default_file }
+
+      it 'returns a configuration equivalent to the default' do
+        subject.options.should == described_class.default.options
+      end
+    end
+
+    context 'with a config file setting the same subset of settings as the default' do
+      let(:config_file) { <<-FILE }
+      linters:
+        FakeConfigLinter:
+          enabled: true
+      FILE
+
+      it 'returns a configuration equivalent to the default' do
+        subject.options.should == described_class.default.options
+      end
+    end
+
+    context 'with a config file setting a list value different from the default' do
+      let(:config_file) { <<-FILE }
+      linters:
+        FakeConfigLinter:
+          list: [4, 5, 6]
+      FILE
+
+      it 'overrides the default value with the new value' do
+        subject.options['linters']['FakeConfigLinter']['list'].should == [4, 5, 6]
+      end
+    end
+
+    context 'when a wildcard is used for a namespaced linter' do
+      let(:default_file) { <<-FILE }
+      linters:
+        SomeNamespace::*:
+          enabled: false
+      FILE
+
+      let(:config_file) { <<-FILE }
+      linters:
+        SomeNamespace::*:
+          enabled: true
+      FILE
+
+      before do
+        SCSSLint::LinterRegistry.stub(:linters)
+          .and_return([SCSSLint::Linter::SomeNamespace::FakeLinter1,
+                       SCSSLint::Linter::SomeNamespace::FakeLinter2])
+      end
+
+      it 'returns the same options for all linters under that namespace' do
+        subject.linter_options(SCSSLint::Linter::SomeNamespace::FakeLinter1)
+          .should eq('enabled' => true)
+        subject.linter_options(SCSSLint::Linter::SomeNamespace::FakeLinter2)
+          .should eq('enabled' => true)
+      end
+    end
+  end
+
+  describe '#linter_options' do
+    let(:config) { described_class.new(options) }
+
+    let(:linter_options) do
+      {
+        'enabled' => true,
+        'some_option' => 'some_value',
+      }
+    end
+
+    let(:options) do
+      {
+        'linters' => {
+          'FakeConfigLinter' => linter_options
+        }
+      }
+    end
+
+    it 'returns the options for the specified linter' do
+      config.linter_options(SCSSLint::Linter::FakeConfigLinter.new)
+        .should == linter_options
+    end
+  end
+
+  describe '#excluded_file?' do
+    include_context 'isolated environment'
+
+    let(:config_dir) { 'path/to' }
+    let(:file_name) { "#{config_dir}/config.yml" }
+    let(:config) { described_class.load(file_name) }
+
+    before do
+      described_class.stub(:load_file_contents)
+                     .with(file_name)
+                     .and_return(config_file)
+    end
+
+    context 'when no exclusion is specified' do
+      let(:config_file) { 'linters: {}' }
+
+      it 'does not exclude any files' do
+        config.excluded_file?('anything/you/want.scss').should be false
+      end
+    end
+
+    context 'when an exclusion is specified' do
+      let(:config_file) { "exclude: 'foo/bar/baz/**'" }
+
+      it 'does not exclude anything not matching the glob' do
+        config.excluded_file?("#{config_dir}/foo/bar/something.scss").should be false
+        config.excluded_file?("#{config_dir}/other/something.scss").should be false
+      end
+
+      it 'excludes anything matching the glob' do
+        config.excluded_file?("#{config_dir}/foo/bar/baz/excluded.scss").should be true
+        config.excluded_file?("#{config_dir}/foo/bar/baz/dir/excluded.scss").should be true
+      end
+    end
+  end
+
+  describe '#excluded_file_for_linter?' do
+    include_context 'isolated environment'
+
+    let(:config_dir) { 'path/to' }
+    let(:file_name) { "#{config_dir}/config.yml" }
+    let(:config) { described_class.load(file_name) }
+
+    before do
+      described_class.stub(:load_file_contents)
+                     .with(file_name)
+                     .and_return(config_file)
+    end
+
+    context 'when no exclusion is specified in linter' do
+      let(:config_file) { <<-FILE }
+      linters:
+        FakeConfigLinter:
+          enabled: true
+      FILE
+
+      it 'does not exclude any files' do
+        config.excluded_file_for_linter?(
+          "#{config_dir}/anything/you/want.scss",
+          SCSSLint::Linter::FakeConfigLinter.new
+        ).should == false
+      end
+    end
+
+    context 'when an exclusion is specified in linter' do
+      let(:config_file) { <<-FILE }
+      linters:
+        FakeConfigLinter:
+          enabled: true
+          exclude:
+            - 'anything/you/want.scss'
+      FILE
+
+      it 'excludes file for the linter' do
+        config.excluded_file_for_linter?(
+          "#{config_dir}/anything/you/want.scss",
+          SCSSLint::Linter::FakeConfigLinter.new
+        ).should == true
+      end
+    end
+  end
+end

data/spec/scss_lint/engine_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe SCSSLint::Engine do
+  let(:engine) { described_class.new(code: scss) }
+
+  context 'when a @media directive is present' do
+    let(:scss) { <<-SCSS }
+      @media only screen {
+      }
+    SCSS
+
+    it 'has a parse tree' do
+      engine.tree.should_not be_nil
+    end
+  end
+
+  context 'when the file being linted has an invalid byte sequence' do
+    let(:scss) { "\xC0\u0001" }
+
+    it 'raises a SyntaxError' do
+      expect { engine }.to raise_error(SCSSLint::FileEncodingError)
+    end
+  end
+end

data/spec/scss_lint/file_finder_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe SCSSLint::FileFinder do
+  let(:config) { SCSSLint::Config.default }
+
+  subject { described_class.new(config) }
+
+  describe '#find' do
+    include_context 'isolated environment'
+
+    subject { super().find(patterns) }
+
+    context 'when no patterns are given' do
+      let(:patterns) { [] }
+
+      context 'and there are no SCSS files under the current directory' do
+        it 'raises an error' do
+          expect { subject }.to raise_error SCSSLint::Exceptions::NoFilesError
+        end
+      end
+
+      context 'and there are SCSS files under the current directory' do
+        before do
+          `touch blah.scss`
+          `mkdir -p more`
+          `touch more/more.scss`
+        end
+
+        it { should == ['blah.scss', 'more/more.scss'] }
+      end
+
+      context 'and a default set of files is specified in the config' do
+        let(:files) { ['file1.scss', 'file2.scss'] }
+
+        before do
+          config.stub(:scss_files).and_return(files)
+        end
+
+        it { should == files }
+      end
+    end
+
+    context 'when files without valid extension are given' do
+      let(:patterns) { ['test.txt'] }
+
+      context 'and those files exist' do
+        before do
+          `touch test.txt`
+        end
+
+        it { should == ['test.txt'] }
+      end
+
+      context 'and those files do not exist' do
+        it { should == ['test.txt'] }
+      end
+    end
+
+    context 'when directories are given' do
+      let(:patterns) { ['some-dir'] }
+
+      context 'and those directories exist' do
+        before do
+          `mkdir -p some-dir`
+        end
+
+        context 'and they contain SCSS files' do
+          before do
+            `touch some-dir/test.scss`
+          end
+
+          it { should == ['some-dir/test.scss'] }
+
+          context 'and those SCSS files are excluded by the config' do
+            before do
+              config.exclude_file('some-dir/test.scss')
+            end
+
+            it 'raises an error' do
+              expect { subject }.to raise_error SCSSLint::Exceptions::AllFilesFilteredError
+            end
+          end
+        end
+
+        context 'and they contain CSS files' do
+          before do
+            `touch some-dir/test.css`
+          end
+
+          it { should == ['some-dir/test.css'] }
+        end
+
+        context 'and they contain more directories with files with recognized extensions' do
+          before do
+            `mkdir -p some-dir/more-dir`
+            `touch some-dir/more-dir/test.scss`
+          end
+
+          it { should == ['some-dir/more-dir/test.scss'] }
+
+          context 'and those SCSS files are excluded by the config' do
+            before do
+              config.exclude_file('**/*.scss')
+            end
+
+            it 'raises an error' do
+              expect { subject }.to raise_error SCSSLint::Exceptions::AllFilesFilteredError
+            end
+          end
+        end
+
+        context 'and they contain no SCSS files' do
+          before do
+            `touch some-dir/test.txt`
+          end
+
+          it 'raises an error' do
+            expect { subject }.to raise_error SCSSLint::Exceptions::NoFilesError
+          end
+        end
+      end
+
+      context 'and those directories do not exist' do
+        it { should == ['some-dir'] }
+      end
+    end
+
+    context 'when the same file is specified multiple times' do
+      let(:patterns) { ['test.scss'] * 3 }
+
+      it { should == ['test.scss'] }
+    end
+  end
+end

data/spec/scss_lint/linter/bang_format_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::BangFormat do
+  context 'when no bang is used' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important is used correctly' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000 !important;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !important has no space before' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000!important;
+      }
+    SCSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'when !important has a space after' do
+    let(:scss) { <<-SCSS }
+      p {
+        color: #000 ! important;
+      }
+    SCSS
+
+    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(:scss) { <<-SCSS }
+      p {
+        color: #000 ! important;
+      }
+    SCSS
+
+    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(:scss) { <<-SCSS }
+      p {
+        color: #000 ! important;
+      }
+    SCSS
+
+    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(:scss) { <<-SCSS }
+      p {
+        color: #000!important;
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when ! appears within a string' do
+    let(:scss) { <<-SCSS }
+      p:before { content: "!important"; }
+      p:before { content: "imp!ortant"; }
+      p:after { content: '!'; }
+      div:before { content: 'important!'; }
+      div:after { content: '  !  '; }
+      p[attr="foo!bar"] {};
+      p[attr='foo!bar'] {};
+      p[attr="!foobar"] {};
+      p[attr='foobar!'] {};
+      $foo: 'bar!';
+      $foo: "bar!";
+      $foo: "!bar";
+      $foo: "b!ar";
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'when !<word> is not followed by a semicolon' do
+    let(:scss) { <<-SCSS }
+      .class {
+        margin: 0 !important
+      }
+    SCSS
+
+    it 'does not loop forever' do
+      subject.should_not report_lint
+    end
+  end
+
+  context 'when property contains a list literal with an empty list' do
+    let(:scss) { <<-SCSS }
+      p {
+        content: 0 ();
+      }
+    SCSS
+
+    it { should_not report_lint }
+  end
+end