scss-lint 0.29.0 → 0.30.0

data/lib/scss_lint/linter/import_path.rb

@@ -0,0 +1,62 @@
+module SCSSLint
+  # Checks formatting of the basenames of @imported partials
+  class Linter::ImportPath < Linter
+    include LinterRegistry
+
+    def visit_import(node)
+      # Ignore CSS imports
+      return if File.extname(node.imported_filename) == '.css'
+      basename = File.basename(node.imported_filename)
+      return if underscore_ok?(basename) && extension_ok?(basename)
+      add_lint(node, compose_message(node.imported_filename))
+    end
+
+  private
+
+    # Checks if the presence or absence of a leading underscore
+    # on a string is ok, given config option.
+    #
+    # @param str [String] the string to check
+    # @return [Boolean]
+    def underscore_ok?(str)
+      underscore_exists = str.start_with?('_')
+      config['leading_underscore'] ? underscore_exists : !underscore_exists
+    end
+
+    # Checks if the presence or absence of an `scss` filename
+    # extension on a string is ok, given config option.
+    #
+    # @param str [String] the string to check
+    # @return [Boolean]
+    def extension_ok?(str)
+      extension_exists = str.end_with?('.scss')
+      config['filename_extension'] ? extension_exists : !extension_exists
+    end
+
+    # Composes a helpful lint message based on the original filename
+    # and the config options.
+    #
+    # @param orig_filename [String] the original filename
+    # @return [String] the helpful  lint message
+    def compose_message(orig_filename)
+      orig_basename = File.basename(orig_filename)
+      fixed_basename = orig_basename
+
+      if config['leading_underscore']
+        fixed_basename = '_' + fixed_basename unless fixed_basename.match(/^_/)
+      else
+        fixed_basename = fixed_basename.sub(/^_/, '')
+      end
+
+      if config['filename_extension']
+        fixed_basename += '.scss' unless fixed_basename.match(/\.scss$/)
+      else
+        fixed_basename = fixed_basename.sub(/\.scss$/, '')
+      end
+
+      fixed_filename = orig_filename.sub(/(.*)#{Regexp.quote(orig_basename)}/,
+                                         "\\1#{fixed_basename}")
+      "Imported partial `#{orig_filename}` should be written as `#{fixed_filename}`"
+    end
+  end
+end

data/lib/scss_lint/linter/name_format.rb

@@ -60,7 +60,7 @@ module SCSSLint
 
     CONVENTIONS = {
       'hyphenated_lowercase' => {
-        explanation: 'in lowercase with hyphens instead of underscores',
+        explanation: 'in all lowercase letters with hyphens instead of underscores',
         validator: ->(name) { name !~ /[_A-Z]/ },
       },
       'BEM' => {

data/lib/scss_lint/linter/nesting_depth.rb

@@ -0,0 +1,24 @@
+module SCSSLint
+  # Checks for rule sets nested deeper than a specified maximum depth.
+  class Linter::NestingDepth < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @max_depth = config['max_depth']
+      @depth = 1
+      yield # Continue linting children
+    end
+
+    def visit_rule(node)
+      if @depth > @max_depth
+        add_lint(node, "Nesting should be no greater than #{@max_depth}, but was #{@depth}")
+      else
+        # Only continue if we didn't exceed the max depth already (this makes
+        # the lint less noisy)
+        @depth += 1
+        yield # Continue linting children
+        @depth -= 1
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/property_sort_order.rb

@@ -26,7 +26,7 @@ module SCSSLint
       sorted_props.each_with_index do |prop, index|
         next unless prop != sortable_prop_info[index]
 
-        add_lint(sortable_props[index], lint_message)
+        add_lint(sortable_props[index], lint_message(sorted_props))
         break
       end
 
@@ -127,16 +127,9 @@ module SCSSLint
       config['order'].is_a?(String)
     end
 
-    def lint_message
-      if preset_order?
-        "Properties should be sorted according to the #{config['order']} sort order"
-      elsif @preferred_order
-        'Properties should be sorted according to the custom order ' \
-        'specified by the configuration'
-      else
-        'Properties should be sorted in order, with vendor-prefixed ' \
-        'extensions before the standardized CSS property'
-      end
+    def lint_message(sortable_prop_info)
+      props = sortable_prop_info.map { |prop| prop[:name] }.join(', ')
+      "Properties should be ordered #{props}"
     end
   end
 end

data/lib/scss_lint/linter/property_spelling.rb

@@ -3,6 +3,11 @@ module SCSSLint
   class Linter::PropertySpelling < Linter
     include LinterRegistry
 
+    KNOWN_PROPERTIES = File.open(File.join(SCSS_LINT_DATA, 'properties.txt'))
+                           .read
+                           .split
+                           .to_set
+
     def visit_root(_node)
       @extra_properties = config['extra_properties'].to_set
       yield # Continue linting children
@@ -12,7 +17,26 @@ module SCSSLint
       # Ignore properties with interpolation
       return if node.name.count > 1 || !node.name.first.is_a?(String)
 
-      name = node.name.join
+      nested_properties = node.children.select { |child| child.is_a?(Sass::Tree::PropNode) }
+      if nested_properties.any?
+        # Treat nested properties specially, as they are a concatenation of the
+        # parent with child property
+        nested_properties.each do |nested_prop|
+          check_property(nested_prop, node.name.join)
+        end
+      else
+        check_property(node)
+      end
+    end
+
+  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)
+
+      name = prefix ? "#{prefix}-" : ''
+      name += node.name.join
 
       # Ignore vendor-prefixed properties
       return if name.start_with?('-')
@@ -21,12 +45,5 @@ module SCSSLint
 
       add_lint(node, "Unknown property #{name}")
     end
-
-  private
-
-    KNOWN_PROPERTIES = File.open(File.join(SCSS_LINT_DATA, 'properties.txt'))
-                           .read
-                           .split
-                           .to_set
   end
 end

data/lib/scss_lint/linter/qualifying_element.rb

@@ -0,0 +1,42 @@
+module SCSSLint
+  # Checks for element selectors qualifying id, classe, or attribute selectors.
+  class Linter::QualifyingElement < Linter
+    include LinterRegistry
+
+    def visit_simple_sequence(seq)
+      return unless seq_contains_sel_class?(seq, Sass::Selector::Element)
+      check_id(seq) unless config['allow_element_with_id']
+      check_class(seq) unless config['allow_element_with_class']
+      check_attribute(seq) unless config['allow_element_with_attribute']
+    end
+
+  private
+
+    # Checks if a simple sequence contains a
+    # simple selector of a certain class.
+    #
+    # @param seq [Sass::Selector::SimpleSequence]
+    # @param selector_class [Sass::Selector::Simple]
+    # @returns [Boolean]
+    def seq_contains_sel_class?(seq, selector_class)
+      seq.members.any? do |simple|
+        simple.is_a?(selector_class)
+      end
+    end
+
+    def check_id(seq)
+      return unless seq_contains_sel_class?(seq, Sass::Selector::Id)
+      add_lint(seq.line, 'Avoid qualifying id selectors with an element.')
+    end
+
+    def check_class(seq)
+      return unless seq_contains_sel_class?(seq, Sass::Selector::Class)
+      add_lint(seq.line, 'Avoid qualifying class selectors with an element.')
+    end
+
+    def check_attribute(seq)
+      return unless seq_contains_sel_class?(seq, Sass::Selector::Attribute)
+      add_lint(seq.line, 'Avoid qualifying attribute selectors with an element.')
+    end
+  end
+end

data/lib/scss_lint/linter/selector_format.rb

@@ -10,36 +10,36 @@ module SCSSLint
     end
 
     def visit_attribute(attribute)
-      check(attribute) unless @ignored_types.include?('attribute')
+      check(attribute, 'attribute') unless @ignored_types.include?('attribute')
     end
 
     def visit_class(klass)
-      check(klass) unless @ignored_types.include?('class')
+      check(klass, 'class') unless @ignored_types.include?('class')
     end
 
     def visit_element(element)
-      check(element) unless @ignored_types.include?('element')
+      check(element, 'element') unless @ignored_types.include?('element')
     end
 
     def visit_id(id)
-      check(id) unless @ignored_types.include?('id')
+      check(id, 'id') unless @ignored_types.include?('id')
     end
 
     def visit_placeholder(placeholder)
-      check(placeholder) unless @ignored_types.include?('placeholder')
+      check(placeholder, 'placeholder') unless @ignored_types.include?('placeholder')
     end
 
     def visit_pseudo(pseudo)
-      check(pseudo) unless @ignored_types.include?('pseudo-selector')
+      check(pseudo, 'pseudo') unless @ignored_types.include?('pseudo-selector')
     end
 
   private
 
-    def check(node)
+    def check(node, type)
       name = node.name
 
       return if @ignored_names.include?(name)
-      return unless violation = violated_convention(name)
+      return unless violation = violated_convention(name, type)
 
       add_lint(node, "Selector `#{name}` should be " \
                      "written #{violation[:explanation]}")
@@ -58,15 +58,27 @@ module SCSSLint
         explanation: 'has no spaces with capitalized words except first',
         validator: ->(name) { name =~ /^[a-z][a-zA-Z0-9]*$/ },
       },
+      'hyphenated_BEM' => {
+        explanation: 'in hyphenated BEM (Block Element Modifier) format',
+        validator: ->(name) { name !~ /[A-Z]|-{3}|_{3}|[^_]_[^_]/ },
+      },
       'BEM' => {
         explanation: 'in BEM (Block Element Modifier) format',
-        validator: ->(name) { name !~ /[A-Z]|-{3}|_{3}|[^_]_[^_]/ },
+        validator: lambda do |name|
+          name =~ /
+            ^[a-z]([-]?[a-z0-9]+)*
+            (__[a-z0-9]([-]?[a-z0-9]+)*)?
+            ((_[a-z0-9]([-]?[a-z0-9]+)*){2})?$
+          /x
+        end,
       },
     }
 
     # Checks the given name and returns the violated convention if it failed.
-    def violated_convention(name_string)
-      convention_name = config['convention'] || 'hyphenated_lowercase'
+    def violated_convention(name_string, type)
+      convention_name = config["#{type}_convention"] ||
+                        config['convention'] ||
+                        'hyphenated_lowercase'
 
       convention = CONVENTIONS[convention_name] || {
         explanation: "must match regex /#{convention_name}/",

data/lib/scss_lint/linter/space_after_property_colon.rb

@@ -65,13 +65,13 @@ module SCSSLint
       spaces = 0
       offset = 1
 
-      # Handle quirk where Sass parser doesn't include colon in source range
-      # when property name is followed by spaces
-      if character_at(node.name_source_range.end_pos, offset) == ':'
+      # Find the colon after the property name
+      while character_at(node.name_source_range.start_pos, offset - 1) != ':'
         offset += 1
       end
 
-      while character_at(node.name_source_range.end_pos, offset) == ' '
+      # Count spaces after the colon
+      while character_at(node.name_source_range.start_pos, offset) == ' '
         spaces += 1
         offset += 1
       end

data/lib/scss_lint/linter/space_after_property_name.rb

@@ -5,8 +5,23 @@ module SCSSLint
     include LinterRegistry
 
     def visit_prop(node)
-      return unless character_at(node.name_source_range.end_pos) != ':'
+      offset = property_name_colon_offset(node)
+      return unless character_at(node.name_source_range.start_pos, offset - 1) == ' '
       add_lint node, 'Property name should be immediately followed by a colon'
     end
+
+  private
+
+    # 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
+    end
   end
 end

data/lib/scss_lint/linter/space_before_brace.rb

@@ -27,19 +27,46 @@ 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)
-        unless char_before_is_whitespace
-          add_lint(line, 'Opening curly brace `{` should be ' \
-                         'preceded by at least one space')
-        end
+        return unless string[-2] != ' '
+        add_lint(line, 'Opening curly brace in a single line rule set '\
+                       '`{` should be preceded by at least one space')
       else
-        if !char_before_is_whitespace || string[-3] == ' '
-          add_lint(line, 'Opening curly brace `{` should be ' \
-                         'preceded by one space')
-        end
+        return unless chars_before_incorrect(string)
+        style_message = (config['style'] == 'new_line') ? 'a new line' : 'one space'
+        add_lint(line, 'Opening curly brace `{` should be ' \
+                       "preceded by #{style_message}")
       end
     end
+
+    # Check if the characters before the end of the string
+    # are not what they should be
+    def chars_before_incorrect(string)
+      if config['style'] != 'new_line'
+        return !single_space_before(string)
+      end
+      !newline_before_nonwhitespace(string)
+    end
+
+    # Check if there is one space and only one
+    # space before the end of the string
+    def single_space_before(string)
+      return false if string[-2] != ' '
+      return false if string[-3] == ' '
+      true
+    end
+
+    # Check if, starting from the end of a string
+    # and moving backwards, towards the beginning,
+    # we find a new line before any non-whitespace characters
+    def newline_before_nonwhitespace(string)
+      offset = -2
+      while /\S/.match(string[offset]).nil?
+        return true if string[offset] == "\n"
+        offset -= 1
+      end
+      false
+    end
   end
 end

data/lib/scss_lint/linter/trailing_semicolon.rb

@@ -27,6 +27,10 @@ module SCSSLint
       end
     end
 
+    def visit_import(node)
+      check_semicolon(node)
+    end
+
   private
 
     def check_semicolon(node)
@@ -46,7 +50,7 @@ module SCSSLint
 
     # Checks that the node is ended by a semicolon (with no whitespace)
     def ends_with_semicolon?(node)
-      source_from_range(node.source_range) =~ /;$/
+      source_from_range(node.source_range) =~ /;(\s*})?$/
     end
 
     def ends_with_multiple_semicolons?(node)
@@ -55,7 +59,7 @@ module SCSSLint
     end
 
     def has_space_before_semicolon?(node)
-      source_from_range(node.source_range) =~ /\s;$/
+      source_from_range(node.source_range) =~ /\s;(\s*})?$/
     end
   end
 end

data/lib/scss_lint/linter/vendor_prefixes.rb

@@ -0,0 +1,64 @@
+module SCSSLint
+  # Checks for vendor prefixes.
+  class Linter::VendorPrefixes < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @identifiers = Set.new(extract_identifiers_from_config)
+      @identifiers.merge(Set.new(config['include']))
+      @exclusions = Set.new(config['exclude'])
+      yield
+    end
+
+    def check_node(node)
+      name = node.name.is_a?(Array) ? node.name.join : node.name
+      # Ignore '@' from @keyframes node name
+      check_identifier(node, name.gsub(/^@/, ''))
+
+      # Check for values
+      return unless node.respond_to?(:value) && node.value.respond_to?(:to_sass)
+      check_identifier(node, node.value.to_sass)
+    end
+
+    alias_method :visit_prop, :check_node
+    alias_method :visit_pseudo, :check_node
+    alias_method :visit_directive, :check_node
+
+  private
+
+    def check_identifier(node, identifier)
+      return unless identifier =~ /^[_-]/
+
+      # Strip vendor prefix to check against identifiers.
+      # (Also strip closing parentheticals from values like linear-gradient.)
+      stripped_identifier = identifier.gsub(/(^[_-][a-zA-Z0-9_]+-|\(.*\))/, '')
+      return if @exclusions.include?(stripped_identifier)
+      return unless @identifiers.include?(stripped_identifier)
+
+      add_lint(node, 'Avoid vendor prefixes.')
+    end
+
+    def extract_identifiers_from_config
+      case config['identifier_list']
+      when nil
+        nil
+      when Array
+        config['identifier_list']
+      when String
+        begin
+          file = File.open(File.join(SCSS_LINT_DATA,
+                                     'prefixed-identifiers',
+                                     "#{config['identifier_list']}.txt"))
+          file.read.split("\n").reject { |line| line =~ /^(#|\s*$)/ }
+        rescue Errno::ENOENT
+          raise SCSSLint::Exceptions::LinterError,
+                "Identifier list '#{config['identifier_list']}' does not exist"
+        end
+      else
+        raise SCSSLint::Exceptions::LinterError,
+              'Invalid identifier list specified -- must be the name of a '\
+              'preset or an array of strings'
+      end
+    end
+  end
+end