scss-lint 0.25.1 → 0.26.0

data/spec/scss_lint/config_spec.rb

@@ -0,0 +1,439 @@
+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
+      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.should == described_class.default
+      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.should == described_class.default
+      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.should == described_class.default
+      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.should == described_class.default
+      end
+    end
+
+    context 'with a file that includes another configuration file' do
+      let(:included_file_path) { '../included_file.yml' }
+
+      let(:config_file) { <<-FILE }
+      inherit_from: #{included_file_path}
+
+      linters:
+        FakeConfigLinter:
+          enabled: true
+          some_other_option: some_other_value
+      FILE
+
+      before do
+        described_class.stub(:load_file_contents)
+                       .with("#{config_dir}/" + included_file_path)
+                       .and_return(included_file)
+      end
+
+      context 'and the included file has a different setting from the default' do
+        let(:included_file) { <<-FILE }
+          linters:
+            OtherFakeConfigLinter:
+              enabled: true
+              some_option: some_value
+        FILE
+
+        it 'reflects the different setting of the included file' do
+          subject.options['linters']['OtherFakeConfigLinter']
+            .should == { 'enabled' => true, 'some_option' => 'some_value' }
+        end
+
+        it 'reflects the different setting of the file that included the file' do
+          subject.options['linters']['FakeConfigLinter']
+            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
+        end
+      end
+
+      context 'and the included file has the same setting as the default' do
+        let(:included_file) { <<-FILE }
+          linters:
+            OtherFakeConfigLinter:
+              enabled: false
+        FILE
+
+        it 'does not alter the default configuration' do
+          subject.options['linters']['OtherFakeConfigLinter']
+            .should == { 'enabled' => false }
+        end
+
+        it 'reflects the different setting of the file that included the file' do
+          subject.options['linters']['FakeConfigLinter']
+            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
+        end
+      end
+
+      context 'and the included file includes another file' do
+        let(:other_included_file_path) { '/some/abs/other_included_file.yml' }
+
+        let(:other_included_file) { <<-FILE }
+          linters:
+            OtherFakeConfigLinter:
+              yet_another_option: yet_another_value
+        FILE
+
+        let(:included_file) { <<-FILE }
+          inherit_from: #{other_included_file_path}
+
+          linters:
+            OtherFakeConfigLinter:
+              enabled: true
+              some_option: some_value
+        FILE
+
+        before do
+          described_class.stub(:load_file_contents)
+                         .with(other_included_file_path)
+                         .and_return(other_included_file)
+        end
+
+        it "reflects the different setting of the included file's included file" do
+          subject.options['linters']['OtherFakeConfigLinter']
+            .should == {
+              'enabled' => true,
+              'some_option' => 'some_value',
+              'yet_another_option' => 'yet_another_value',
+            }
+        end
+
+        it 'reflects the different setting of the file that included the file' do
+          subject.options['linters']['FakeConfigLinter']
+            .should == { 'enabled' => true, 'some_other_option' => 'some_other_value' }
+        end
+      end
+    end
+
+    context 'with a file that includes multiple configuration files' do
+      let(:included_file_path) { '../included_file.yml' }
+      let(:other_included_file_path) { '/some/dir/other_included_file.yml' }
+
+      let(:config_file) { <<-FILE }
+      inherit_from:
+        - #{included_file_path}
+        - #{other_included_file_path}
+
+      linters:
+        FakeConfigLinter:
+          enabled: true
+          some_other_option: some_other_value
+      FILE
+
+      before do
+        described_class.stub(:load_file_contents)
+                       .with("#{config_dir}/" + included_file_path)
+                       .and_return(included_file)
+
+        described_class.stub(:load_file_contents)
+                       .with(other_included_file_path)
+                       .and_return(other_included_file)
+      end
+
+      context 'and the included files have settings different from each other' do
+        let(:included_file) { <<-FILE }
+          linters:
+            OtherFakeConfigLinter:
+              enabled: true
+              some_option: earlier_value
+              some_other_option: value
+        FILE
+
+        let(:other_included_file) { <<-FILE }
+          linters:
+            OtherFakeConfigLinter:
+              enabled: true
+              some_option: later_value
+        FILE
+
+        it 'uses the value of the file that was included last' do
+          subject.options['linters']['OtherFakeConfigLinter']['some_option']
+            .should == 'later_value'
+        end
+
+        it 'loads settings from both included files' do
+          subject.options['linters']['OtherFakeConfigLinter']
+            .should == {
+              'enabled' => true,
+              'some_option' => 'later_value',
+              'some_other_option' => 'value',
+            }
+        end
+      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 '.for_file' do
+    include_context 'isolated environment'
+
+    let(:linted_file) { File.join('foo', 'bar', 'baz', 'file-being-linted.scss') }
+    subject { described_class.for_file(linted_file) }
+
+    before do
+      described_class.instance_variable_set(:@dir_to_config, nil) # Clear cache
+      FileUtils.mkpath(File.dirname(linted_file))
+      FileUtils.touch(linted_file)
+    end
+
+    context 'when there are no configuration files in the directory hierarchy' do
+      it { should be_nil }
+    end
+
+    context 'when there is a configuration file in the same directory' do
+      let(:config_file) { File.join('foo', 'bar', 'baz', '.scss-lint.yml') }
+      before { FileUtils.touch(config_file) }
+
+      it 'loads that configuration file' do
+        described_class.should_receive(:load).with(File.expand_path(config_file))
+        subject
+      end
+    end
+
+    context 'when there is a configuration file in the parent directory' do
+      let(:config_file) { File.join('foo', 'bar', '.scss-lint.yml') }
+      before { FileUtils.touch(config_file) }
+
+      it 'loads that configuration file' do
+        described_class.should_receive(:load).with(File.expand_path(config_file))
+        subject
+      end
+    end
+
+    context 'when there is a configuration file in some ancestor directory' do
+      let(:config_file) { File.join('foo', '.scss-lint.yml') }
+      before { FileUtils.touch(config_file) }
+
+      it 'loads that configuration file' do
+        described_class.should_receive(:load).with(File.expand_path(config_file))
+        subject
+      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(css) }
+
+  context 'when a @media directive is present' do
+    let(:css) { <<-CSS }
+      @media only screen {
+      }
+    CSS
+
+    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(:css) { "\xC0\u0001" }
+
+    it 'raises a SyntaxError' do
+      expect { engine }.to raise_error(SCSSLint::FileEncodingError)
+    end
+  end
+end