scss-lint 0.25.1 → 0.26.0

data/lib/scss_lint/linter/single_line_per_property.rb

@@ -0,0 +1,53 @@
+module SCSSLint
+  # Checks that all properties in a rule set are on their own distinct lines.
+  class Linter::SingleLinePerProperty < Linter
+    include LinterRegistry
+
+    def visit_rule(node) # rubocop:disable CyclomaticComplexity
+      single_line = single_line_rule_set?(node)
+      return if single_line && config['allow_single_line_rule_sets']
+
+      properties = node.children.select { |child| child.is_a?(Sass::Tree::PropNode) }
+      return unless properties.any?
+
+      # Special case: if single line rule sets aren't allowed, we want to report
+      # when the first property isn't on a separate line from the selector
+      if single_line && !config['allow_single_line_rule_sets']
+        add_lint(properties.first,
+                 "Property '#{properties.first.name.join}' should be placed " \
+                 'on separate line from selector')
+      end
+
+      # Compare each property against the next property to see if they are on
+      # the same line
+      properties[0..-2].zip(properties[1..-1]).each do |first, second|
+        next unless first.line == second.line
+
+        add_lint(second, "Property '#{second.name.join}' should be placed on own line")
+      end
+    end
+
+  private
+
+    # Return whether this rule set occupies a single line.
+    #
+    # Note that this allows:
+    #   a,
+    #   b,
+    #   i { margin: 0; padding: 0; }
+    #
+    # and:
+    #
+    #   p { margin: 0; padding: 0; }
+    #
+    # In other words, the line of the opening curly brace is the line that the
+    # rule set is considered to occupy.
+    def single_line_rule_set?(rule)
+      rule.children.all? { |child| child.line == rule.source_range.end_pos.line }
+    end
+
+    def first_property_not_on_own_line?(rule, properties)
+      properties.any? && properties.first.line == rule.line
+    end
+  end
+end

data/lib/scss_lint/linter/single_line_per_selector.rb

@@ -14,6 +14,11 @@ module SCSSLint
 
     # A comma is invalid if it starts the line or is not the end of the line
     def invalid_comma_placement?(node)
+      # We must ignore selectors with interpolation, since there's no way to
+      # tell if the overall selector is valid since the interpolation could
+      # insert commas incorrectly. Thus we simply ignore.
+      return if node.rule.any? { |item| item.is_a?(Sass::Script::Variable) }
+
       normalize_spacing(condense_to_string(node.rule)) =~ /\n,|,[^\n]/
     end
 
@@ -21,7 +26,7 @@ module SCSSLint
     # Sass::Script::Nodes, we need to condense it into a single string that we
     # can run a regex against.
     def condense_to_string(sequence_list)
-      sequence_list.select { |item| item.is_a?(String) }.inject(:+) || ''
+      sequence_list.select { |item| item.is_a?(String) }.inject(:+)
     end
 
     # Removes extra spacing between lines in a comma-separated sequence due to

data/lib/scss_lint/linter/space_after_comma.rb

@@ -66,34 +66,42 @@ module SCSSLint
     def check_commas_after_args(args, arg_type)
       # For each arg except the last, check the character following the comma
       args[0..-2].each do |arg|
-        offset = 0
-
-        # Find the comma following this argument.
-        # The Sass parser is unpredictable in where it marks the end of the
-        # source range. Thus we need to start at the indicated range, and check
-        # left and right of that range, gradually moving further outward until
-        # we find the comma.
-        if character_at(arg.source_range.end_pos, offset) != ','
-          loop do
-            offset += 1
-            break if character_at(arg.source_range.end_pos, offset) == ','
-            offset = -offset
-            break if character_at(arg.source_range.end_pos, offset) == ','
-            offset = -offset
-          end
-        end
+        offset = find_comma_offset(arg)
 
-        # Check for space or newline after arg (we allow arguments to be split
+        # Check for space or newline after comma (we allow arguments to be split
         # up over multiple lines).
         spaces = 0
-        while character_at(arg.source_range.end_pos, offset + 1) =~ / |\n/
+        while (char = character_at(arg.source_range.end_pos, offset + 1)) == ' '
           spaces += 1
           offset += 1
         end
-        next if spaces == EXPECTED_SPACES_AFTER_COMMA
+        next if char == "\n" || # Ignore trailing spaces
+                spaces == EXPECTED_SPACES_AFTER_COMMA
 
         add_lint arg, "Commas in #{arg_type} should be followed by a single space"
       end
     end
+
+    # Find the comma following this argument.
+    #
+    # The Sass parser is unpredictable in where it marks the end of the
+    # source range. Thus we need to start at the indicated range, and check
+    # left and right of that range, gradually moving further outward until
+    # we find the comma.
+    def find_comma_offset(arg)
+      offset = 0
+
+      if character_at(arg.source_range.end_pos, offset) != ','
+        loop do
+          offset += 1
+          break if character_at(arg.source_range.end_pos, offset) == ','
+          offset = -offset
+          break if character_at(arg.source_range.end_pos, offset) == ','
+          offset = -offset
+        end
+      end
+
+      offset
+    end
   end
 end

data/lib/scss_lint/linter/space_before_brace.rb

@@ -27,16 +27,17 @@ module SCSSLint
 
     def check_for_space(node, string)
       line = node.source_range.end_pos.line
+      char_before_is_whitespace = ["\n", ' '].include?(string[-2])
 
       if config['allow_single_line_padding'] && node_on_single_line?(node)
-        if string[-2] != ' '
+        unless char_before_is_whitespace
           add_lint(line, 'Opening curly brace `{` should be ' \
-                              'preceded by at least one space')
+                         'preceded by at least one space')
         end
       else
-        if string[-2] != ' ' || string[-3] == ' '
+        if !char_before_is_whitespace || string[-3] == ' '
           add_lint(line, 'Opening curly brace `{` should be ' \
-                              'preceded by one space')
+                         'preceded by one space')
         end
       end
     end

data/lib/scss_lint/linter/trailing_semicolon.rb

@@ -0,0 +1,53 @@
+module SCSSLint
+  # Checks for a trailing semicolon on statements within rule sets.
+  class Linter::TrailingSemicolon < Linter
+    include LinterRegistry
+
+    def visit_prop(node)
+      if has_nested_properties?(node)
+        yield # Continue checking children
+      else
+        check_semicolon(node)
+      end
+    end
+
+    def visit_extend(node)
+      check_semicolon(node)
+    end
+
+    def visit_mixin(node)
+      check_semicolon(node)
+    end
+
+    def visit_variable(node)
+      check_semicolon(node)
+    end
+
+  private
+
+    def has_nested_properties?(node)
+      node.children.any? { |n| n.is_a?(Sass::Tree::PropNode) }
+    end
+
+    def check_semicolon(node)
+      if has_space_before_semicolon?(node)
+        line = node.source_range.start_pos.line
+        add_lint line, 'Declaration should be terminated by a semicolon'
+      elsif !ends_with_semicolon?(node)
+        line = node.source_range.start_pos.line
+        add_lint line,
+                 'Declaration should not have a space before ' \
+                 'the terminating semicolon'
+      end
+    end
+
+    # Checks that the node is ended by a semicolon (with no whitespace)
+    def ends_with_semicolon?(node)
+      source_from_range(node.source_range) =~ /;$/
+    end
+
+    def has_space_before_semicolon?(node)
+      source_from_range(node.source_range) =~ /\s;$/
+    end
+  end
+end

data/lib/scss_lint/linter/unnecessary_parent_reference.rb

@@ -0,0 +1,36 @@
+module SCSSLint
+  # Checks for unnecessary uses of the parent reference (&) in nested selectors.
+  class Linter::UnnecessaryParentReference < Linter
+    include LinterRegistry
+
+    MESSAGE = 'Unnecessary parent selector'
+
+    def visit_comma_sequence(comma_sequence)
+      @multiple_sequences = comma_sequence.members.size > 1
+    end
+
+    def visit_sequence(sequence)
+      return unless sequence_starts_with_parent?(sequence.members.first)
+
+      # Special case: allow an isolated parent to appear if it is part of a
+      # comma sequence of more than one sequence, as this could be used to DRY
+      # up code.
+      return if @multiple_sequences && isolated_parent?(sequence)
+
+      add_lint(sequence.members.first.line, MESSAGE)
+    end
+
+  private
+
+    def isolated_parent?(sequence)
+      sequence.members.size == 1 &&
+        sequence_starts_with_parent?(sequence.members.first)
+    end
+
+    def sequence_starts_with_parent?(simple_sequence)
+      return unless simple_sequence.is_a?(Sass::Selector::SimpleSequence)
+      simple_sequence.members.size == 1 &&
+        simple_sequence.members.first.is_a?(Sass::Selector::Parent)
+    end
+  end
+end

data/lib/scss_lint/reporter/default_reporter.rb

@@ -6,8 +6,13 @@ module SCSSLint
 
       lints.map do |lint|
         type = lint.error? ? '[E]'.color(:red) : '[W]'.color(:yellow)
-        "#{lint.filename.color(:cyan)}:" << "#{lint.location.line}".color(:magenta) <<
-                                    " #{type} #{lint.description}"
+
+        linter_name = "#{lint.linter.name}: ".color(:green) if lint.linter
+        message = "#{linter_name}#{lint.description}"
+
+        "#{lint.filename.color(:cyan)}:" <<
+          "#{lint.location.line}".color(:magenta) <<
+          " #{type} #{message}"
       end.join("\n") + "\n"
     end
   end

data/lib/scss_lint/reporter/xml_reporter.rb

@@ -9,7 +9,8 @@ module SCSSLint
         output << "<file name=#{filename.encode(xml: :attr)}>"
 
         file_lints.each do |lint|
-          output << "<issue line=\"#{lint.location.line}\" " \
+          output << "<issue linter=\"#{lint.linter.name if lint.linter}\" " \
+                           "line=\"#{lint.location.line}\" " \
                            "column=\"#{lint.location.column}\" " \
                            "length=\"#{lint.location.length}\" " \
                            "severity=\"#{lint.severity}\" " \

data/lib/scss_lint/runner.rb

@@ -1,5 +1,4 @@
 module SCSSLint
-  class LinterError < StandardError; end
   class NoFilesError < StandardError; end
 
   # Finds and aggregates all lints found by running the registered linters
@@ -40,9 +39,9 @@ module SCSSLint
         next if config.excluded_file_for_linter?(file, linter)
 
         begin
-          linter.run(engine, config.linter_options(linter))
+          run_linter(linter, engine, config)
         rescue => error
-          raise LinterError,
+          raise SCSSLint::Exceptions::LinterError,
                 "#{linter.class} raised unexpected error linting file #{file}: " \
                 "'#{error.message}'",
                 error.backtrace
@@ -53,5 +52,10 @@ module SCSSLint
     rescue FileEncodingError => ex
       @lints << Lint.new(nil, file, Location.new, ex.to_s, :error)
     end
+
+    # For stubbing in tests.
+    def run_linter(linter, engine, config)
+      linter.run(engine, config.linter_options(linter))
+    end
   end
 end

data/lib/scss_lint/version.rb

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

data/spec/scss_lint/cli_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+require 'scss_lint/cli'
+
+describe SCSSLint::CLI do
+  let(:config_options) do
+    {
+      'linters' => {
+        'FakeTestLinter1' => { 'enabled' => true },
+        'FakeTestLinter2' => { 'enabled' => true },
+      },
+    }
+  end
+
+  let(:config) { SCSSLint::Config.new(config_options) }
+
+  class SCSSLint::Linter::FakeTestLinter1 < SCSSLint::Linter; end
+  class SCSSLint::Linter::FakeTestLinter2 < SCSSLint::Linter; end
+
+  before do
+    # Silence console output
+    @output = ''
+    STDOUT.stub(:write) { |*args| @output.<<(*args) }
+
+    SCSSLint::Config.stub(:load).and_return(config)
+    SCSSLint::LinterRegistry.stub(:linters)
+                            .and_return([SCSSLint::Linter::FakeTestLinter1,
+                                         SCSSLint::Linter::FakeTestLinter2])
+  end
+
+  describe '#parse_arguments' do
+    let(:files)   { ['file1.scss', 'file2.scss'] }
+    let(:flags) { [] }
+    subject       { SCSSLint::CLI.new(flags + files) }
+
+    def safe_parse
+      subject.parse_arguments
+    rescue SystemExit
+      # Keep running tests
+    end
+
+    context 'when the config_file flag is set' do
+      let(:config_file) { 'my-config-file.yml' }
+      let(:flags) { ['-c', config_file] }
+
+      it 'loads that config file' do
+        SCSSLint::Config.should_receive(:load).with(config_file)
+        safe_parse
+      end
+
+      context 'and the config file is invalid' do
+        before do
+          SCSSLint::Config.should_receive(:load)
+                          .with(config_file)
+                          .and_raise(SCSSLint::InvalidConfiguration)
+        end
+
+        it 'halts with a configuration error code' do
+          subject.should_receive(:halt).with(:config)
+          safe_parse
+        end
+      end
+    end
+
+    context 'when the excluded files flag is set' do
+      let(:flags) { ['-e', 'file1.scss,file3.scss'] }
+
+      it 'sets the :excluded_files option' do
+        safe_parse
+        subject.options[:excluded_files].should =~ ['file1.scss', 'file3.scss']
+      end
+    end
+
+    context 'when the include linters flag is set' do
+      let(:flags) { %w[-i FakeTestLinter2] }
+
+      it 'enables only the included linters' do
+        safe_parse
+        subject.config.enabled_linters.should == [SCSSLint::Linter::FakeTestLinter2]
+      end
+
+      context 'and the included linter does not exist' do
+        let(:flags) { %w[-i NonExistentLinter] }
+
+        it 'halts with a configuration error code' do
+          subject.should_receive(:halt).with(:config)
+          safe_parse
+        end
+      end
+    end
+
+    context 'when the exclude linters flag is set' do
+      let(:flags) { %w[-x FakeTestLinter1] }
+
+      it 'includes all linters except the excluded one' do
+        safe_parse
+        subject.config.enabled_linters.should == [SCSSLint::Linter::FakeTestLinter2]
+      end
+    end
+
+    context 'when the format flag is set' do
+      context 'and the format is valid' do
+        let(:flags) { %w[--format XML] }
+
+        it 'sets the :reporter option to the correct reporter' do
+          safe_parse
+          subject.options[:reporter].should == SCSSLint::Reporter::XMLReporter
+        end
+      end
+
+      context 'and the format is invalid' do
+        let(:flags) { %w[--format InvalidFormat] }
+
+        it 'sets the :reporter option to the correct reporter' do
+          subject.should_receive(:halt).with(:config)
+          safe_parse
+        end
+      end
+    end
+
+    context 'when the show formatters flag is set' do
+      let(:flags) { ['--show-formatters'] }
+
+      it 'prints the formatters' do
+        subject.should_receive(:print_formatters)
+        safe_parse
+      end
+    end
+
+    context 'when the show linters flag is set' do
+      let(:flags) { ['--show-linters'] }
+
+      it 'prints the linters' do
+        subject.should_receive(:print_linters)
+        safe_parse
+      end
+    end
+
+    context 'when the help flag is set' do
+      let(:flags) { ['-h'] }
+
+      it 'prints a help message' do
+        subject.should_receive(:print_help)
+        safe_parse
+      end
+    end
+
+    context 'when the version flag is set' do
+      let(:flags) { ['-v'] }
+
+      it 'prints the program version' do
+        subject.should_receive(:print_version)
+        safe_parse
+      end
+    end
+
+    context 'when an invalid option is specified' do
+      let(:flags) { ['--non-existant-option'] }
+
+      it 'prints a help message' do
+        subject.should_receive(:print_help)
+        safe_parse
+      end
+    end
+
+    context 'when no files are specified' do
+      let(:files) { [] }
+
+      it 'sets :files option to the empty list' do
+        safe_parse
+        subject.options[:files].should be_empty
+      end
+    end
+
+    context 'when files are specified' do
+      it 'sets :files option to the list of files' do
+        safe_parse
+        subject.options[:files].should =~ files
+      end
+    end
+  end
+
+  describe '#run' do
+    let(:files)   { ['file1.scss', 'file2.scss'] }
+    let(:options) { {} }
+    subject       { SCSSLint::CLI.new(options) }
+
+    before do
+      subject.stub(:extract_files_from).and_return(files)
+    end
+
+    def safe_run
+      subject.run
+    rescue SystemExit
+      # Keep running tests
+    end
+
+    context 'when no files are specified' do
+      let(:files) { [] }
+
+      it 'exits with a no-input status code' do
+        subject.should_receive(:halt).with(:no_input)
+        safe_run
+      end
+    end
+
+    context 'when files are specified' do
+      it 'passes the set of files to the runner' do
+        SCSSLint::Runner.any_instance.should_receive(:run).with(files)
+        safe_run
+      end
+
+      it 'uses the default reporter' do
+        SCSSLint::Reporter::DefaultReporter.any_instance
+          .should_receive(:report_lints)
+        safe_run
+      end
+    end
+
+    context 'when there are no lints' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([])
+      end
+
+      it 'exits cleanly' do
+        subject.should_not_receive(:halt)
+        safe_run
+      end
+
+      it 'outputs nothing' do
+        safe_run
+        @output.should be_empty
+      end
+    end
+
+    context 'when there are only warnings' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([
+          SCSSLint::Lint.new(
+            SCSSLint::Linter::FakeTestLinter1.new,
+            'some-file.scss',
+            SCSSLint::Location.new(1, 1, 1),
+            'Some description',
+            :warning,
+          ),
+        ])
+      end
+
+      it 'exits cleanly' do
+        subject.should_receive(:halt).with(:warning)
+        safe_run
+      end
+
+      it 'outputs the warnings' do
+        safe_run
+        @output.should include 'Some description'
+      end
+    end
+
+    context 'when there are errors' do
+      before do
+        SCSSLint::Runner.any_instance.stub(:lints).and_return([
+          SCSSLint::Lint.new(
+            SCSSLint::Linter::FakeTestLinter1.new,
+            'some-file.scss',
+            SCSSLint::Location.new(1, 1, 1),
+            'Some description',
+            :error,
+          ),
+        ])
+      end
+
+      it 'exits with an error status code' do
+        subject.should_receive(:halt).with(:error)
+        safe_run
+      end
+
+      it 'outputs the errors' do
+        safe_run
+        @output.should include 'Some description'
+      end
+    end
+
+    context 'when the runner raises an error' do
+      let(:backtrace) { %w[file1.rb file2.rb] }
+      let(:message) { 'Some error message' }
+
+      let(:error) do
+        StandardError.new(message).tap { |e| e.set_backtrace(backtrace) }
+      end
+
+      before { SCSSLint::Runner.stub(:new).and_raise(error) }
+
+      it 'exits with an internal software error status code' do
+        subject.should_receive(:halt).with(:software)
+        safe_run
+      end
+
+      it 'outputs the error message' do
+        safe_run
+        @output.should include message
+      end
+
+      it 'outputs the backtrace' do
+        safe_run
+        @output.should include backtrace.join("\n")
+      end
+
+      it 'outputs a link to the issue tracker' do
+        safe_run
+        @output.should include SCSSLint::BUG_REPORT_URL
+      end
+    end
+  end
+end