scss_lint 0.42.2 → 0.43.0

data/lib/scss_lint/linter/mergeable_selector.rb

@@ -7,6 +7,8 @@ module SCSSLint
       node.children.each_with_object([]) do |child_node, seen_nodes|
         next unless child_node.is_a?(Sass::Tree::RuleNode)
 
+        next if whitelist_contains(child_node)
+
         mergeable_node = find_mergeable_node(child_node, seen_nodes)
         seen_nodes << child_node
         next unless mergeable_node
@@ -27,12 +29,30 @@ module SCSSLint
   private
 
     def find_mergeable_node(node, seen_nodes)
+      return if multiple_parent_references?(node)
+
       seen_nodes.find do |seen_node|
         equal?(node, seen_node) ||
           (config['force_nesting'] && nested?(node, seen_node))
       end
     end
 
+    def multiple_parent_references?(rule_node)
+      return unless rules = rule_node.parsed_rules
+
+      # Iterate over each sequence counting all parent references
+      total_parent_references = rules.members.inject(0) do |sum, seq|
+        sum + seq.members.inject(0) do |ssum, simple_seq|
+          next ssum unless simple_seq.respond_to?(:members)
+          ssum + simple_seq.members.count do |member|
+            member.is_a?(Sass::Selector::Parent)
+          end
+        end
+      end
+
+      total_parent_references > 1
+    end
+
     def equal?(node1, node2)
       node_rule(node1) == node_rule(node2)
     end
@@ -58,5 +78,14 @@ module SCSSLint
       "#{rule1}".start_with?("#{rule2} ") ||
         "#{rule1}".start_with?("#{rule2}.")
     end
+
+    def whitelist_contains(node)
+      if @whitelist.nil?
+        @whitelist = config['whitelist'] || []
+        @whitelist = [@whitelist] if @whitelist.is_a? String
+      end
+
+      @whitelist.include?(node_rule(node))
+    end
   end
 end

data/lib/scss_lint/linter/property_spelling.rb

@@ -9,7 +9,9 @@ module SCSSLint
                            .to_set
 
     def visit_root(_node)
-      @extra_properties = config['extra_properties'].to_set
+      @extra_properties = Array(config['extra_properties']).to_set
+      @disabled_properties = Array(config['disabled_properties']).to_set
+
       yield # Continue linting children
     end
 
@@ -32,18 +34,28 @@ module SCSSLint
   private
 
     def check_property(node, prefix = nil) # rubocop:disable CyclomaticComplexity
-      # Ignore properties with interpolation
-      return if node.name.count > 1 || !node.name.first.is_a?(String)
+      return if contains_interpolation?(node)
 
       name = prefix ? "#{prefix}-" : ''
       name += node.name.join
 
       # Ignore vendor-prefixed properties
       return if name.start_with?('-')
-      return if KNOWN_PROPERTIES.include?(name) ||
-        @extra_properties.include?(name)
+      return if known_property?(name) && !@disabled_properties.include?(name)
+
+      if @disabled_properties.include?(name)
+        add_lint(node, "Property #{name} is prohibited")
+      else
+        add_lint(node, "Unknown property #{name}")
+      end
+    end
+
+    def known_property?(name)
+      KNOWN_PROPERTIES.include?(name) || @extra_properties.include?(name)
+    end
 
-      add_lint(node, "Unknown property #{name}")
+    def contains_interpolation?(node)
+      node.name.count > 1 || !node.name.first.is_a?(String)
     end
   end
 end

data/lib/scss_lint/linter/pseudo_element.rb

@@ -0,0 +1,18 @@
+module SCSSLint
+  # Checks for the use of double colons with pseudo elements.
+  class Linter::PseudoElement < Linter
+    include LinterRegistry
+
+    PSEUDO_ELEMENTS = %w[after backdrop before first-letter first-line selection]
+
+    def visit_pseudo(pseudo)
+      if PSEUDO_ELEMENTS.include?(pseudo.name)
+        return if pseudo.syntactic_type == :element
+        add_lint(pseudo, 'Begin pseudo elements with double colons: `::`')
+      else
+        return if pseudo.syntactic_type != :element
+        add_lint(pseudo, 'Begin pseudo classes with a single colon: `:`')
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/single_line_per_selector.rb

@@ -10,28 +10,44 @@ module SCSSLint
 
       check_comma_on_own_line(node)
 
-      node.members[1..-1].each_with_index do |sequence, index|
-        check_sequence_commas(node, sequence, index)
+      line_offset = 0
+      node.members[1..-1].each do |sequence|
+        line_offset += 1 if sequence_start_of_line?(sequence)
+        check_multiline_sequence(node, sequence, line_offset)
+        check_sequence_commas(node, sequence, line_offset)
       end
     end
 
     def visit_sequence(node)
-      node.members[1..-1].each_with_index do |item, index|
-        next unless item == "\n"
+      # Only execute if this is first or only sequence in a comma sequence. If
+      # it is the only sequence, then it won't be in a comma sequence, which is
+      # why we define a separate visit_* method specifically for this case.
+      return if node.members.first == "\n"
 
-        add_lint(node.line + index, MESSAGE)
-      end
+      check_multiline_sequence(node, node, 0)
     end
 
   private
 
+    def sequence_start_of_line?(sequence)
+      sequence.members[0] == "\n"
+    end
+
     def check_comma_on_own_line(node)
       return unless node.members[0].members[1] == "\n"
       add_lint(node, MESSAGE)
     end
 
+    # Checks if an individual sequence is split over multiple lines
+    def check_multiline_sequence(node, sequence, index)
+      return unless sequence.members.size > 1
+      return unless sequence.members[2..-1].any? { |member| member == "\n" }
+
+      add_lint(node.line + index, MESSAGE)
+    end
+
     def check_sequence_commas(node, sequence, index)
-      if sequence.members[0] != "\n"
+      if !sequence_start_of_line?(sequence)
         # Next sequence doesn't reside on its own line
         add_lint(node.line + index, MESSAGE)
       elsif sequence.members[1] == "\n"

data/lib/scss_lint/linter/space_after_property_colon.rb

@@ -73,16 +73,15 @@ module SCSSLint
 
     def whitespace_after_colon(node)
       whitespace = []
-      offset = 1
+      offset = 0
+      start_pos = node.name_source_range.start_pos
 
       # Find the colon after the property name
-      while character_at(node.name_source_range.start_pos, offset - 1) != ':'
-        offset += 1
-      end
+      offset = offset_to(start_pos, ':', offset) + 1
 
       # Count spaces after the colon
-      while [' ', "\t", "\n"].include? character_at(node.name_source_range.start_pos, offset)
-        whitespace << character_at(node.name_source_range.start_pos, offset)
+      while [' ', "\t", "\n"].include? character_at(start_pos, offset)
+        whitespace << character_at(start_pos, offset)
         offset += 1
       end
 

data/lib/scss_lint/linter/space_after_property_name.rb

@@ -15,13 +15,7 @@ module SCSSLint
     # Deals with a weird Sass bug where the name_source_range of a PropNode does
     # not start at the beginning of the property name.
     def property_name_colon_offset(node)
-      offset = 0
-
-      while character_at(node.name_source_range.start_pos, offset) != ':'
-        offset += 1
-      end
-
-      offset
+      offset_to(node.name_source_range.start_pos, ':')
     end
   end
 end

data/lib/scss_lint/linter/space_after_variable_name.rb

@@ -12,7 +12,7 @@ module SCSSLint
   private
 
     def spaces_before_colon?(node)
-      source_from_range(node.source_range) =~ /\s+:/
+      source_from_range(node.source_range) =~ /\A[^:]+\s+:/
     end
   end
 end

data/lib/scss_lint/linter/space_around_operator.rb

@@ -28,7 +28,7 @@ module SCSSLint
 
   private
 
-    def check(node, operation_sources) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
+    def check(node, operation_sources) # rubocop:disable Metrics/AbcSize, Metrics/LineLength, Metrics/MethodLength
       match = operation_sources.operator_source.match(/
         (?<left_space>\s*)
         (?<operator>\S+)
@@ -41,17 +41,33 @@ module SCSSLint
       # just don't worry about space with a newline.
       left_newline = match[:left_space].include?("\n")
       right_newline = match[:right_space].include?("\n")
-      if config['style'] == 'one_space'
-        if (match[:left_space] != ' ' && !left_newline) ||
-          (match[:right_space] != ' ' && !right_newline)
+
+      case config['style']
+      when 'one_space'
+        if one_space_exists?(match, left_newline, right_newline)
           add_lint(node, operation_sources.space_msg(match[:operator]))
         end
-      elsif (match[:left_space] != '' && !left_newline) ||
-        (match[:right_space] != '' && !right_newline)
-        add_lint(node, operation_sources.no_space_msg(match[:operator]))
+      when 'at_least_one_space'
+        unless spaces_exist?(match, left_newline, right_newline)
+          add_lint(node, operation_sources.space_msg(match[:operator]))
+        end
+      else
+        if spaces_exist?(match, left_newline, right_newline)
+          add_lint(node, operation_sources.no_space_msg(match[:operator]))
+        end
       end
     end
 
+    def one_space_exists?(match, left_newline, right_newline)
+      (match[:left_space] != ' ' && !left_newline) ||
+        (match[:right_space] != ' ' && !right_newline)
+    end
+
+    def spaces_exist?(match, left_newline, right_newline)
+      (match[:left_space] != '' && !left_newline) ||
+        (match[:right_space] != '' && !right_newline)
+    end
+
     # A helper class for storing and adjusting the sources of the different
     # components of an Operation node.
     class OperationSources

data/lib/scss_lint/linter/string_quotes.rb

@@ -3,14 +3,7 @@ module SCSSLint
   class Linter::StringQuotes < Linter
     include LinterRegistry
 
-    def visit_comment(_node)
-      # Sass allows you to write Sass Script in non-silent comments (/* ... */).
-      # Unfortunately, it doesn't report correct source ranges for these script
-      # nodes.
-      # It's unlikely that a developer wanted to lint the script they wrote in a
-      # comment, so just ignore this case entirely and stop traversing the
-      # children of comment nodes.
-    end
+    CHARSET_DIRECTIVE_LENGTH = '@charset'.length
 
     def visit_script_stringinterpolation(node)
       # We can't statically determine what the resultant string looks like when
@@ -34,7 +27,7 @@ module SCSSLint
 
     def visit_charset(node)
       # `@charset` source range includes entire declaration, so exclude that prefix
-      source = source_from_range(node.source_range)[('@charset'.length)..-1]
+      source = source_from_range(node.source_range)[(CHARSET_DIRECTIVE_LENGTH)..-1]
 
       check_quotes(node, source)
     end

data/lib/scss_lint/linter/trailing_semicolon.rb

@@ -15,6 +15,16 @@ module SCSSLint
       # !default`.
       return check_semicolon(node) if node.global || node.guarded
 
+      # If the variable is a multi-line ListLiteral or MapLiteral, then
+      # `node.expr` will give us everything except the last right paren, and
+      # the semicolon if it exists. In these cases, use the source range of
+      # `node` as above.
+      if (node.expr.is_a?(Sass::Script::Tree::ListLiteral) ||
+          node.expr.is_a?(Sass::Script::Tree::MapLiteral)) &&
+         !node_on_single_line?(node)
+        return check_semicolon(node)
+      end
+
       check_semicolon(node.expr)
     end
 

data/lib/scss_lint/options.rb

@@ -77,6 +77,11 @@ module SCSSLint
         @options[:excluded_files] = files
       end
 
+      parser.on('--stdin-file-path file-path', String,
+                'Specify the path to assume for the file passed via STDIN') do |stdin_file_path|
+        @options[:stdin_file_path] = stdin_file_path
+      end
+
       parser.on('-o', '--out path', 'Write output to a file instead of STDOUT', String) do |path|
         define_output_path(path)
       end

data/lib/scss_lint/runner.rb

@@ -12,7 +12,7 @@ module SCSSLint
       @linters.map!(&:new)
     end
 
-    # @param files [Array]
+    # @param files [Array<Hash>] list of file object/path hashes
     def run(files)
       @files = files
       @files.each do |file|
@@ -22,16 +22,18 @@ module SCSSLint
 
   private
 
-    # @param file [String]
+    # @param file [Hash]
+    # @option file [String] File object
+    # @option path [String] path to File (determines which Linter config to apply)
     def find_lints(file)
-      engine = Engine.new(file: file)
+      engine = Engine.new(file)
 
       @linters.each do |linter|
         begin
-          run_linter(linter, engine, file)
+          run_linter(linter, engine, file[:path])
         rescue => error
           raise SCSSLint::Exceptions::LinterError,
-                "#{linter.class} raised unexpected error linting file #{file}: " \
+                "#{linter.class} raised unexpected error linting file #{file[:path]}: " \
                 "'#{error.message}'",
                 error.backtrace
         end
@@ -40,12 +42,12 @@ module SCSSLint
       @lints << Lint.new(nil, ex.sass_filename, Location.new(ex.sass_line),
                          "Syntax Error: #{ex}", :error)
     rescue FileEncodingError => ex
-      @lints << Lint.new(nil, file, Location.new, ex.to_s, :error)
+      @lints << Lint.new(nil, file[:path], Location.new, ex.to_s, :error)
     end
 
     # For stubbing in tests.
-    def run_linter(linter, engine, file)
-      return if @config.excluded_file_for_linter?(file, linter)
+    def run_linter(linter, engine, file_path)
+      return if @config.excluded_file_for_linter?(file_path, linter)
       @lints += linter.run(engine, @config.linter_options(linter))
     end
   end

data/lib/scss_lint/selector_visitor.rb

@@ -22,13 +22,21 @@ module SCSSLint
       end
     end
 
+    # The class name of a node, in snake_case form, e.g.
+    # `Sass::Selector::SimpleSequence` -> `simple_sequence`.
+    #
+    # The name is memoized as a class variable on the node itself.
     def selector_node_name(node)
-      # Converts the class name of a node into snake_case form, e.g.
-      # `Sass::Selector::SimpleSequence` -> `simple_sequence`
-      name = node.class.name.gsub(/.*::(.*?)$/, '\\1')
+      if node.class.class_variable_defined?(:@@snake_case_name)
+        return node.class.class_variable_get(:@@snake_case_name)
+      end
+
+      rindex = node.class.name.rindex('::')
+      name = node.class.name[(rindex + 2)..-1]
       name.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
       name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
       name.downcase!
+      node.class.class_variable_set(:@@snake_case_name, name)
     end
   end
 end

data/lib/scss_lint/version.rb

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

data/spec/scss_lint/cli_spec.rb

@@ -154,6 +154,20 @@ describe SCSSLint::CLI do
       end
     end
 
+    context 'when the --stdin-file-path argument is specified' do
+      let(:flags) { ['--stdin-file-path', 'some-fake-file-path.scss'] }
+
+      before do
+        STDIN.stub(:read).and_return('// Nothing interesting')
+      end
+
+      it 'passes STDIN and the file path as a file tuple to the runner' do
+        SCSSLint::Runner.any_instance.should_receive(:run)
+                        .with([file: STDIN, path: 'some-fake-file-path.scss'])
+        safe_run
+      end
+    end
+
     context 'when specified SCSS file globs match no files' do
       before do
         SCSSLint::FileFinder.any_instance.stub(:find)

data/spec/scss_lint/linter/chained_classes_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe SCSSLint::Linter::ChainedClasses do
+  context 'with a single class' do
+    let(:scss) { <<-SCSS }
+      .class {}
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a single class with a descendant ' do
+    let(:scss) { <<-SCSS }
+      .class .descendant {}
+    SCSS
+
+    it { should_not report_lint }
+  end
+
+  context 'with a chained class' do
+    let(:scss) { <<-SCSS }
+      .chained.class {}
+    SCSS
+
+    it { should report_lint line: 1 }
+  end
+
+  context 'with a chained class in a nested rule set' do
+    let(:scss) { <<-SCSS }
+      p {
+        .chained.class {}
+      }
+    SCSS
+
+    it { should report_lint line: 2 }
+  end
+
+  context 'with a chained class in part of a sequence' do
+    let(:scss) { <<-SCSS }
+      .some .sequence .with .chained.class .in .it {}
+    SCSS
+
+    it { should report_lint line: 1 }
+  end
+end