scss_lint 0.38.0

data/lib/scss_lint/linter/property_spelling.rb

@@ -0,0 +1,49 @@
+module SCSSLint
+  # Checks for misspelled properties.
+  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
+    end
+
+    def visit_prop(node)
+      # Ignore properties with interpolation
+      return if node.name.count > 1 || !node.name.first.is_a?(String)
+
+      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?('-')
+      return if KNOWN_PROPERTIES.include?(name) ||
+        @extra_properties.include?(name)
+
+      add_lint(node, "Unknown property #{name}")
+    end
+  end
+end

data/lib/scss_lint/linter/property_units.rb

@@ -0,0 +1,59 @@
+module SCSSLint
+  # Check for allowed units
+  class Linter::PropertyUnits < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @globally_allowed_units = config['global'].to_set
+      @allowed_units_for_property = config['properties']
+
+      yield # Continue linting children
+    end
+
+    def visit_prop(node)
+      property = node.name.join
+
+      # Handle nested properties by ensuring the full name is extracted
+      if @nested_under
+        property = "#{@nested_under}-#{property}"
+      end
+
+      if node.value.respond_to?(:value) &&
+         units = node.value.value.to_s[/(?:^|\s)(?:\d+|\d*\.?\d+)([a-z%]+)/i, 1]
+        check_units(node, property, units)
+      end
+
+      @nested_under = property
+      yield # Continue linting nested properties
+      @nested_under = nil
+    end
+
+  private
+
+    # Checks if a property value's units are allowed.
+    #
+    # @param node [Sass::Tree::Node]
+    # @param property [String]
+    # @param units [String]
+    def check_units(node, property, units)
+      allowed_units = allowed_units_for_property(property)
+      return if allowed_units.include?(units)
+
+      add_lint(node,
+               "#{units} units not allowed on `#{property}`; must be one of " \
+               "(#{allowed_units.to_a.sort.join(', ')})")
+    end
+
+    # Return the list of allowed units for a property.
+    #
+    # @param property [String]
+    # @return Array<String>
+    def allowed_units_for_property(property)
+      if @allowed_units_for_property.key?(property)
+        @allowed_units_for_property[property]
+      else
+        @globally_allowed_units
+      end
+    end
+  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_depth.rb

@@ -0,0 +1,64 @@
+module SCSSLint
+  # Checks for selectors with large depths of applicability.
+  class Linter::SelectorDepth < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @max_depth = config['max_depth']
+      @depth = 0
+      yield # Continue
+    end
+
+    def visit_rule(node)
+      old_depth = @depth
+      @depth = max_sequence_depth(node.parsed_rules, @depth)
+
+      if @depth > @max_depth
+        add_lint(node.parsed_rules || node,
+                 'Selector should have depth of applicability no greater ' \
+                 "than #{@max_depth}, but was #{@depth}")
+      end
+
+      yield # Continue linting children
+      @depth = old_depth
+    end
+
+  private
+
+    # Find the maximum depth of all sequences in a comma sequence.
+    def max_sequence_depth(comma_sequence, current_depth)
+      # Sequence contains interpolation; assume a depth of 1
+      return current_depth + 1 unless comma_sequence
+
+      comma_sequence.members.map { |sequence| sequence_depth(sequence, current_depth) }.max
+    end
+
+    def sequence_depth(sequence, current_depth)
+      separators, simple_sequences = sequence.members.partition do |item|
+        item.is_a?(String)
+      end
+
+      parent_selectors = simple_sequences.count do |item|
+        next if item.is_a?(Array) # @keyframe percentages end up as Arrays
+        item.rest.any? { |i| i.is_a?(Sass::Selector::Parent) }
+      end
+
+      # Take the number of simple sequences and subtract one for each sibling
+      # combinator, as these "combine" simple sequences such that they do not
+      # increase depth.
+      depth = simple_sequences.size -
+        separators.count { |item| item == '~' || item == '+'  }
+
+      if parent_selectors > 0
+        # If parent selectors are present, add the current depth for each
+        # additional parent selector.
+        depth += parent_selectors * (current_depth - 1)
+      else
+        # Otherwise this just descends from the containing selector
+        depth += current_depth
+      end
+
+      depth
+    end
+  end
+end

data/lib/scss_lint/linter/selector_format.rb

@@ -0,0 +1,102 @@
+module SCSSLint
+  # Checks that selector names use a specified convention
+  class Linter::SelectorFormat < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @ignored_names = Array(config['ignored_names']).to_set
+      @ignored_types = Array(config['ignored_types']).to_set
+      yield
+    end
+
+    def visit_attribute(attribute)
+      check(attribute, 'attribute') unless @ignored_types.include?('attribute')
+    end
+
+    def visit_class(klass)
+      check(klass, 'class') unless @ignored_types.include?('class')
+    end
+
+    def visit_element(element)
+      check(element, 'element') unless @ignored_types.include?('element')
+    end
+
+    def visit_id(id)
+      check(id, 'id') unless @ignored_types.include?('id')
+    end
+
+    def visit_placeholder(placeholder)
+      check(placeholder, 'placeholder') unless @ignored_types.include?('placeholder')
+    end
+
+  private
+
+    def check(node, type)
+      name = node.name
+
+      return if @ignored_names.include?(name)
+      return unless violation = violated_convention(name, type)
+
+      add_lint(node, "Selector `#{name}` #{violation[:explanation]}")
+    end
+
+    CONVENTIONS = {
+      'hyphenated_lowercase' => {
+        explanation: 'should be written in lowercase with hyphens',
+        validator: ->(name) { name !~ /[^\-a-z0-9]/ },
+      },
+      'snake_case' => {
+        explanation: 'should be written in lowercase with underscores',
+        validator: ->(name) { name !~ /[^_a-z0-9]/ },
+      },
+      'camel_case' => {
+        explanation: 'should be written in camelCase format',
+        validator: ->(name) { name =~ /^[a-z][a-zA-Z0-9]*$/ },
+      },
+      'hyphenated_BEM' => {
+        explanation: 'should be written in hyphenated BEM (Block Element Modifier) format',
+        validator: ->(name) { name !~ /[A-Z]|-{3}|_{3}|[^_]_[^_]/ },
+      },
+      'strict_BEM' => {
+        explanation: 'should be written in BEM (Block Element Modifier) format',
+        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, type)
+      convention_name = convention_name(type)
+
+      existing_convention = CONVENTIONS[convention_name]
+
+      convention = (existing_convention || {
+        validator: ->(name) { name =~ /#{convention_name}/ }
+      }).merge(
+        explanation: convention_explanation(type), # Allow explanation to be customized
+      )
+
+      convention unless convention[:validator].call(name_string)
+    end
+
+    def convention_name(type)
+      config["#{type}_convention"] ||
+        config['convention'] ||
+        'hyphenated_lowercase'
+    end
+
+    def convention_explanation(type)
+      existing_convention = CONVENTIONS[convention_name(type)]
+
+      config["#{type}_convention_explanation"] ||
+        config['convention_explanation'] ||
+        (existing_convention && existing_convention[:explanation]) ||
+        "should match regex /#{convention_name(type)}/"
+    end
+  end
+end

data/lib/scss_lint/linter/shorthand.rb

@@ -0,0 +1,139 @@
+# rubocop:disable Metrics/CyclomaticComplexity
+module SCSSLint
+  # Checks for the use of the shortest form for properties that can be written
+  # in shorthand.
+  class Linter::Shorthand < Linter
+    include LinterRegistry
+
+    # @param node [Sass::Tree::Node]
+    def visit_prop(node)
+      property_name = node.name.join
+      return unless SHORTHANDABLE_PROPERTIES.include?(property_name)
+
+      case node.value
+      when Sass::Script::Tree::Literal
+        check_script_literal(property_name, node.value)
+      when Sass::Script::Tree::ListLiteral
+        check_script_list(property_name, node.value)
+      end
+    end
+
+  private
+
+    SHORTHANDABLE_PROPERTIES = %w[
+      border-color
+      border-radius
+      border-style
+      border-width
+      margin
+      padding
+    ]
+
+    # @param prop [String]
+    # @param list [Sass::Script::Tree::ListLiteral]
+    def check_script_list(prop, list)
+      check_shorthand(prop, list, list.children.map(&:to_sass))
+    end
+
+    # @param prop [String]
+    # @param literal [Sass::Script::Tree::Literal]
+    def check_script_literal(prop, literal)
+      value = literal.value
+
+      # HACK: node_parent may not be initialized at this point, so we need to
+      # set it ourselves
+      value.node_parent = literal
+      return unless value.is_a?(Sass::Script::Value::String)
+
+      check_script_string(prop, value)
+    end
+
+    LIST_LITERAL_REGEX = /
+      \A
+      (\S+\s+\S+(\s+\S+){0,2})   # Two to four values separated by spaces
+      (\s+!\w+)?                 # Ignore `!important` priority overrides
+      \z
+    /x
+
+    # @param prop [String]
+    # @param script_string [Sass::Script::Value::String]
+    def check_script_string(prop, script_string)
+      return unless script_string.type == :identifier
+      return unless values = script_string.value.strip[LIST_LITERAL_REGEX, 1]
+
+      check_shorthand(prop, script_string, values.split)
+    end
+
+    # @param prop [String]
+    # @param node [Sass::Script::Value::String]
+    # @param values [Array<String>]
+    def check_shorthand(prop, node, values)
+      return unless (2..4).member?(values.count)
+
+      shortest_form = condensed_shorthand(*values)
+      return if values == shortest_form
+
+      add_lint(node, "Shorthand form for property `#{prop}` should be " \
+                     "written more concisely as `#{shortest_form.join(' ')}` " \
+                     "instead of `#{values.join(' ')}`")
+    end
+
+    # @param top [String]
+    # @param right [String]
+    # @param bottom [String]
+    # @param left [String]
+    # @return [Array]
+    def condensed_shorthand(top, right, bottom = nil, left = nil)
+      if condense_to_one_value?(top, right, bottom, left)
+        [top]
+      elsif condense_to_two_values?(top, right, bottom, left)
+        [top, right]
+      elsif condense_to_three_values?(top, right, bottom, left)
+        [top, right, bottom]
+      else
+        [top, right, bottom, left].compact
+      end
+    end
+
+    # @param top [String]
+    # @param right [String]
+    # @param bottom [String]
+    # @param left [String]
+    # @return [Boolean]
+    def condense_to_one_value?(top, right, bottom, left)
+      return unless allowed?(1)
+      return unless top == right
+
+      top == bottom && (bottom == left || left.nil?) ||
+        bottom.nil? && left.nil?
+    end
+
+    # @param top [String]
+    # @param right [String]
+    # @param bottom [String]
+    # @param left [String]
+    # @return [Boolean]
+    def condense_to_two_values?(top, right, bottom, left)
+      return unless allowed?(2)
+
+      top == bottom && right == left ||
+        top == bottom && left.nil? && top != right
+    end
+
+    # @param right [String]
+    # @param left [String]
+    # @return [Boolean]
+    def condense_to_three_values?(_, right, __, left)
+      return unless allowed?(3)
+
+      right == left
+    end
+
+    # @param size [Number]
+    # @return [Boolean]
+    def allowed?(size)
+      return false unless config['allowed_shorthands']
+      config['allowed_shorthands'].map(&:to_i).include?(size)
+    end
+  end
+end