scss_lint 0.38.0

data/lib/scss_lint/linter/leading_zero.rb

@@ -0,0 +1,49 @@
+module SCSSLint
+  # Checks for unnecessary leading zeros in numeric values with decimal points.
+  class Linter::LeadingZero < Linter
+    include LinterRegistry
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      non_string_values = remove_quoted_strings(node.value).split
+      non_string_values.each do |value|
+        next unless number = value[NUMBER_WITH_LEADING_ZERO_REGEX, 1]
+        check_for_leading_zeros(node, number)
+      end
+    end
+
+    def visit_script_number(node)
+      return unless number =
+        source_from_range(node.source_range)[NUMBER_WITH_LEADING_ZERO_REGEX, 1]
+
+      check_for_leading_zeros(node, number)
+    end
+
+  private
+
+    NUMBER_WITH_LEADING_ZERO_REGEX = /^-?(0?\.\d+)/
+
+    CONVENTIONS = {
+      'exclude_zero' => {
+        explanation: '`%s` should be written without a leading zero as `%s`',
+        validator: ->(original) { original =~ /^\.\d+$/ },
+        converter: ->(original) { original[1..-1] },
+      },
+      'include_zero' => {
+        explanation: '`%s` should be written with a leading zero as `%s`',
+        validator: ->(original) { original =~ /^0\.\d+$/ },
+        converter: ->(original) { "0#{original}" }
+      },
+    }
+
+    def check_for_leading_zeros(node, original_number)
+      style = config.fetch('style', 'exclude_zero')
+      convention = CONVENTIONS[style]
+      return if convention[:validator].call(original_number)
+
+      corrected = convention[:converter].call(original_number)
+      add_lint(node, convention[:explanation] % [original_number, corrected])
+    end
+  end
+end

data/lib/scss_lint/linter/mergeable_selector.rb

@@ -0,0 +1,60 @@
+module SCSSLint
+  # Checks for rule sets that can be merged with other rule sets.
+  class Linter::MergeableSelector < Linter
+    include LinterRegistry
+
+    def check_node(node)
+      node.children.each_with_object([]) do |child_node, seen_nodes|
+        next unless child_node.is_a?(Sass::Tree::RuleNode)
+
+        mergeable_node = find_mergeable_node(child_node, seen_nodes)
+        seen_nodes << child_node
+        next unless mergeable_node
+
+        add_lint child_node.line,
+                 "Merge rule `#{node_rule(child_node)}` with rule " \
+                 "on line #{mergeable_node.line}"
+      end
+
+      yield # Continue linting children
+    end
+
+    alias_method :visit_root, :check_node
+    alias_method :visit_rule, :check_node
+
+  private
+
+    def find_mergeable_node(node, seen_nodes)
+      seen_nodes.find do |seen_node|
+        equal?(node, seen_node) ||
+          (config['force_nesting'] && nested?(node, seen_node))
+      end
+    end
+
+    def equal?(node1, node2)
+      node_rule(node1) == node_rule(node2)
+    end
+
+    def nested?(node1, node2)
+      return false unless single_rule?(node1) && single_rule?(node2)
+
+      rule1 = node_rule(node1)
+      rule2 = node_rule(node2)
+      subrule?(rule1, rule2) || subrule?(rule2, rule1)
+    end
+
+    def node_rule(node)
+      node.rule.join
+    end
+
+    def single_rule?(node)
+      return unless node.parsed_rules
+      node.parsed_rules.members.count == 1
+    end
+
+    def subrule?(rule1, rule2)
+      "#{rule1}".start_with?("#{rule2} ") ||
+        "#{rule1}".start_with?("#{rule2}.")
+    end
+  end
+end

data/lib/scss_lint/linter/name_format.rb

@@ -0,0 +1,117 @@
+module SCSSLint
+  # Checks the format of declared names of functions, mixins, variables, and
+  # placeholders.
+  class Linter::NameFormat < Linter
+    include LinterRegistry
+
+    def visit_extend(node)
+      check_placeholder(node)
+    end
+
+    def visit_function(node)
+      check_name(node, 'function')
+      yield # Continue into content block of this function definition
+    end
+
+    def visit_mixin(node)
+      check_name(node, 'mixin') unless FUNCTION_WHITELIST.include?(node.name)
+      yield # Continue into content block of this mixin's block
+    end
+
+    def visit_mixindef(node)
+      check_name(node, 'mixin')
+      yield # Continue into content block of this mixin definition
+    end
+
+    def visit_script_funcall(node)
+      check_name(node, 'function') unless FUNCTION_WHITELIST.include?(node.name)
+    end
+
+    def visit_script_variable(node)
+      check_name(node, 'variable')
+    end
+
+    def visit_variable(node)
+      check_name(node, 'variable')
+      yield # Continue into expression tree for this variable definition
+    end
+
+  private
+
+    FUNCTION_WHITELIST = %w[
+      rotateX rotateY rotateZ
+      scaleX scaleY scaleZ
+      skewX skewY
+      translateX translateY translateZ
+    ].to_set
+
+    def check_name(node, node_type, node_text = node.name)
+      node_text = trim_underscore_prefix(node_text)
+      return unless violation = violated_convention(node_text, node_type)
+
+      add_lint(node,
+               "Name of #{node_type} `#{node_text}` #{violation[:explanation]}")
+    end
+
+    # Removes underscore prefix from name if leading underscores are allowed.
+    def trim_underscore_prefix(name)
+      if config['allow_leading_underscore']
+        # Remove if there is a single leading underscore
+        name = name.gsub(/^_(?!_)/, '')
+      end
+
+      name
+    end
+
+    def check_placeholder(node)
+      extract_string_selectors(node.selector).any? do |selector_str|
+        check_name(node, 'placeholder', selector_str.gsub('%', ''))
+      end
+    end
+
+    CONVENTIONS = {
+      'camel_case' => {
+        explanation: 'should be written in camelCase format',
+        validator: ->(name) { name =~ /^[a-z][a-zA-Z0-9]*$/ },
+      },
+      'snake_case' => {
+        explanation: 'should be written in snake_case',
+        validator: ->(name) { name !~ /[^_a-z0-9]/ },
+      },
+      'hyphenated_lowercase' => {
+        explanation: 'should be written in all lowercase letters with hyphens ' \
+                     'instead of underscores',
+        validator: ->(name) { name !~ /[_A-Z]/ },
+      },
+    }
+
+    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/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/placeholder_in_extend.rb

@@ -0,0 +1,22 @@
+module SCSSLint
+  # Checks that `@extend` is always used with a placeholder selector.
+  class Linter::PlaceholderInExtend < Linter
+    include LinterRegistry
+
+    def visit_extend(node)
+      # Ignore if it cannot be statically determined that this selector is a
+      # placeholder since its prefix is dynamically generated
+      return if node.selector.first.is_a?(Sass::Script::Tree::Node)
+
+      # The array returned by the parser is a bit awkward in that it splits on
+      # every word boundary (so %placeholder becomes ['%', 'placeholder']).
+      selector = node.selector.join
+
+      # Ignore if this is a placeholder
+      return if selector.start_with?('%')
+
+      add_lint(node, 'Prefer using placeholder selectors (e.g. ' \
+                     '%some-placeholder) with @extend')
+    end
+  end
+end

data/lib/scss_lint/linter/property_count.rb

@@ -0,0 +1,44 @@
+module SCSSLint
+  # Checks that the number of properties in a rule set is under a defined limit.
+  class Linter::PropertyCount < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @property_count = {} # Lookup table of counts for rule sets
+      @max = config['max_properties']
+      yield # Continue linting children
+    end
+
+    def visit_rule(node)
+      count = property_count(node)
+
+      if count > @max
+        add_lint node,
+                 "Rule set contains (#{count}/#{@max}) properties" \
+                 "#{' (including properties in nested rule sets)' if config['include_nested']}"
+
+        # Don't lint nested rule sets as we already have them in the count
+        return if config['include_nested']
+      end
+
+      yield # Lint nested rule sets
+    end
+
+  private
+
+    def property_count(rule_node)
+      @property_count[rule_node] ||=
+        begin
+          count = rule_node.children.count { |node| node.is_a?(Sass::Tree::PropNode) }
+
+          if config['include_nested']
+            count += rule_node.children.inject(0) do |sum, node|
+              node.is_a?(Sass::Tree::RuleNode) ? sum + property_count(node) : sum
+            end
+          end
+
+          count
+        end
+    end
+  end
+end

data/lib/scss_lint/linter/property_sort_order.rb

@@ -0,0 +1,198 @@
+module SCSSLint
+  # Checks the declaration order of properties.
+  class Linter::PropertySortOrder < Linter # rubocop:disable ClassLength
+    include LinterRegistry
+
+    def visit_root(_node)
+      @preferred_order = extract_preferred_order_from_config
+
+      if @preferred_order && config['separate_groups']
+        @group = assign_groups(@preferred_order)
+      end
+
+      yield # Continue linting children
+    end
+
+    def check_order(node)
+      sortable_props = node.children.select do |child|
+        child.is_a?(Sass::Tree::PropNode) && !ignore_property?(child)
+      end
+
+      if sortable_props.count >= config.fetch('min_properties', 2)
+        sortable_prop_info = sortable_props
+          .map do |child|
+            name = child.name.join
+            /^(?<vendor>-\w+(-osx)?-)?(?<property>.+)/ =~ name
+            { name: name, vendor: vendor, property: "#{@nested_under}#{property}", node: child }
+          end
+
+        check_sort_order(sortable_prop_info)
+        check_group_separation(sortable_prop_info) if @group
+      end
+
+      yield # Continue linting children
+    end
+
+    alias_method :visit_media, :check_order
+    alias_method :visit_mixin, :check_order
+    alias_method :visit_rule,  :check_order
+    alias_method :visit_prop,  :check_order
+
+    def visit_prop(node, &block)
+      # Handle nested properties by appending the parent property they are
+      # nested under to the name
+      @nested_under = "#{node.name.join}-"
+      check_order(node, &block)
+      @nested_under = nil
+    end
+
+    def visit_if(node, &block)
+      check_order(node, &block)
+      visit(node.else) if node.else
+    end
+
+  private
+
+    # When enforcing whether a blank line should separate "groups" of
+    # properties, we need to assign those properties to group numbers so we can
+    # quickly tell traversing from one property to the other that a blank line
+    # is required (since the group number would change).
+    def assign_groups(order)
+      group_number = 0
+      last_was_empty = false
+
+      order.each_with_object({}) do |property, group|
+        # A gap indicates the start of the next group
+        if property.nil? || property.strip.empty?
+          group_number += 1 unless last_was_empty # Treat multiple gaps as single gap
+          last_was_empty = true
+          next
+        end
+
+        last_was_empty = false
+
+        group[property] = group_number
+      end
+    end
+
+    def check_sort_order(sortable_prop_info)
+      sorted_props = sortable_prop_info
+        .sort { |a, b| compare_properties(a, b) }
+
+      sorted_props.each_with_index do |prop, index|
+        next unless prop != sortable_prop_info[index]
+
+        add_lint(sortable_prop_info[index][:node], lint_message(sorted_props))
+        break
+      end
+    end
+
+    def check_group_separation(sortable_prop_info) # rubocop:disable AbcSize
+      group_number = @group[sortable_prop_info.first[:property]]
+
+      sortable_prop_info[0..-2].zip(sortable_prop_info[1..-1]).each do |first, second|
+        next unless @group[second[:property]] != group_number
+
+        # We're now in the next group
+        group_number = @group[second[:property]]
+
+        # The group number has changed, so ensure this property is separated
+        # from the previous property by at least a line (could be a comment,
+        # we don't care, but at least one line that isn't another property).
+        next if first[:node].line < second[:node].line - 1
+
+        add_lint second[:node], "Property #{second[:name]} should be " \
+                                'separated from the previous group of ' \
+                                "properties ending with #{first[:name]}"
+      end
+    end
+
+    # Compares two properties which can contain a vendor prefix. It allows for a
+    # sort order like:
+    #
+    #   p {
+    #     border: ...
+    #     -moz-border-radius: ...
+    #     -o-border-radius: ...
+    #     -webkit-border-radius: ...
+    #     border-radius: ...
+    #     color: ...
+    #   }
+    #
+    # ...where vendor-prefixed properties come before the standard property, and
+    # are ordered amongst themselves by vendor prefix.
+    def compare_properties(a, b)
+      if a[:property] == b[:property]
+        compare_by_vendor(a, b)
+      else
+        if @preferred_order
+          compare_by_order(a, b, @preferred_order)
+        else
+          a[:property] <=> b[:property]
+        end
+      end
+    end
+
+    def compare_by_vendor(a, b)
+      if a[:vendor] && b[:vendor]
+        a[:vendor] <=> b[:vendor]
+      elsif a[:vendor]
+        -1
+      elsif b[:vendor]
+        1
+      else
+        0
+      end
+    end
+
+    def compare_by_order(a, b, order)
+      (order.index(a[:property]) || Float::INFINITY) <=>
+        (order.index(b[:property]) || Float::INFINITY)
+    end
+
+    def extract_preferred_order_from_config
+      case config['order']
+      when nil
+        nil # No custom order specified
+      when Array
+        config['order']
+      when String
+        begin
+          file = File.open(File.join(SCSS_LINT_DATA,
+                                     'property-sort-orders',
+                                     "#{config['order']}.txt"))
+          file.read.split("\n").reject { |line| line =~ /^(#|\s*$)/ }
+        rescue Errno::ENOENT
+          raise SCSSLint::Exceptions::LinterError,
+                "Preset property sort order '#{config['order']}' does not exist"
+        end
+      else
+        raise SCSSLint::Exceptions::LinterError,
+              'Invalid property sort order specified -- must be the name of a '\
+              'preset or an array of strings'
+      end
+    end
+
+    # Return whether to ignore a property in the sort order.
+    #
+    # This includes:
+    # - properties containing interpolation
+    # - properties not explicitly defined in the sort order (if ignore_unspecified is set)
+    def ignore_property?(prop_node)
+      return true if prop_node.name.any? { |part| !part.is_a?(String) }
+
+      config['ignore_unspecified'] &&
+        @preferred_order &&
+        !@preferred_order.include?(prop_node.name.join)
+    end
+
+    def preset_order?
+      config['order'].is_a?(String)
+    end
+
+    def lint_message(sortable_prop_info)
+      props = sortable_prop_info.map { |prop| prop[:name] }.join(', ')
+      "Properties should be ordered #{props}"
+    end
+  end
+end