scss-lint-bliss 1.0.0

data/lib/scss_lint/linter/single_line_per_property.rb

@@ -0,0 +1,59 @@
+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
+
+      check_adjacent_properties(properties)
+    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
+
+    # Compare each property against the next property to see if they are on
+    # the same line.
+    #
+    # @param properties [Array<Sass::Tree::PropNode>]
+    def check_adjacent_properties(properties)
+      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
+  end
+end

data/lib/scss_lint/linter/single_line_per_selector.rb

@@ -0,0 +1,35 @@
+module SCSSLint
+  # Checks that selector sequences are split over multiple lines by comma.
+  class Linter::SingleLinePerSelector < Linter
+    include LinterRegistry
+
+    MESSAGE = 'Each selector in a comma sequence should be on its own line'
+
+    def visit_comma_sequence(node)
+      return unless node.members.count > 1
+
+      check_comma_on_own_line(node)
+
+      node.members[1..-1].each_with_index do |sequence, index|
+        check_sequence_commas(node, sequence, index)
+      end
+    end
+
+  private
+
+    def check_comma_on_own_line(node)
+      return unless node.members[0].members[1] == "\n"
+      add_lint(node, MESSAGE)
+    end
+
+    def check_sequence_commas(node, sequence, index)
+      if sequence.members[0] != "\n"
+        # Next sequence doesn't reside on its own line
+        add_lint(node.line + index, MESSAGE)
+      elsif sequence.members[1] == "\n"
+        # Comma is on its own line
+        add_lint(node.line + index, MESSAGE)
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/space_after_comma.rb

@@ -0,0 +1,110 @@
+module SCSSLint
+  # Checks for spaces after commas in argument lists.
+  class Linter::SpaceAfterComma < Linter
+    include LinterRegistry
+
+    def visit_mixindef(node)
+      check_definition(node, :mixin)
+      yield
+    end
+
+    def visit_mixin(node)
+      check_invocation(node, :mixin)
+      yield
+    end
+
+    def visit_function(node)
+      check_definition(node, :function)
+      yield
+    end
+
+    def visit_script_funcall(node)
+      check_invocation(node, :function)
+      yield
+    end
+
+    def visit_script_listliteral(node)
+      check_commas_after_args(node.elements, 'lists') if node.separator == :comma
+      yield
+    end
+
+  private
+
+    # Check parameters of a function/mixin definition
+    def check_definition(node, type)
+      # Use the default value's source range if one is defined, since that will
+      # be the item with the comma after it
+      args = node.args.map { |name, default_value| default_value || name }
+      args << node.splat if node.splat
+
+      check_commas_after_args(args, "#{type} parameters")
+    end
+
+    # Check arguments passed to a function/mixin invocation
+    def check_invocation(node, type)
+      args = sort_args_by_position(node.args,
+                                   node.splat,
+                                   node.keywords.values,
+                                   node.kwarg_splat)
+
+      check_commas_after_args(args, "#{type} arguments")
+    end
+
+    # Since keyword arguments are not guaranteed to be in order, use the source
+    # range to order arguments so we check them in the order they were declared.
+    def sort_args_by_position(*args)
+      args.flatten.compact.sort_by do |arg|
+        pos = arg.source_range.end_pos
+        [pos.line, pos.offset]
+      end
+    end
+
+    EXPECTED_SPACES_AFTER_COMMA = 1
+
+    # Check the comma after each argument in a list for a space following it,
+    # reporting a lint using the given [arg_type].
+    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|
+        # Sometimes the line we're looking at doesn't even contain a comma!
+        next unless engine.lines[arg.line - 1].include?(',')
+
+        offset = find_comma_offset(arg)
+
+        # Check for space or newline after comma (we allow arguments to be split
+        # up over multiple lines).
+        spaces = 0
+        while (char = character_at(arg.source_range.end_pos, offset + 1)) == ' '
+          spaces += 1
+          offset += 1
+        end
+        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_after_property_colon.rb

@@ -0,0 +1,84 @@
+module SCSSLint
+  # Checks for spaces following the colon that separates a property's name from
+  # its value.
+  class Linter::SpaceAfterPropertyColon < Linter
+    include LinterRegistry
+
+    def visit_rule(node)
+      if config['style'] == 'aligned'
+        check_properties_alignment(node)
+      end
+
+      yield # Continue linting children
+    end
+
+    def visit_prop(node)
+      spaces = spaces_after_colon(node)
+
+      case config['style']
+      when 'no_space'
+        check_for_no_spaces(node, spaces)
+      when 'one_space'
+        check_for_one_space(node, spaces)
+      when 'at_least_one_space'
+        check_for_at_least_one_space(node, spaces)
+      end
+
+      yield # Continue linting children
+    end
+
+  private
+
+    def check_for_no_spaces(node, spaces)
+      return if spaces == 0
+      add_lint(node, 'Colon after property should not be followed by any spaces')
+    end
+
+    def check_for_one_space(node, spaces)
+      return if spaces == 1
+      add_lint(node, 'Colon after property should be followed by one space')
+    end
+
+    def check_for_at_least_one_space(node, spaces)
+      return if spaces >= 1
+      add_lint(node, 'Colon after property should be followed by at least one space')
+    end
+
+    def check_properties_alignment(rule_node)
+      properties = rule_node.children.select { |node| node.is_a?(Sass::Tree::PropNode) }
+
+      properties.each_slice(2) do |prop1, prop2|
+        next unless prop2
+        next unless value_offset(prop1) != value_offset(prop2)
+        add_lint(prop1, 'Property values should be aligned')
+        break
+      end
+    end
+
+    # Offset of value for property
+    def value_offset(prop)
+      src_range = prop.name_source_range
+      src_range.start_pos.offset +
+        (src_range.end_pos.offset - src_range.start_pos.offset) +
+        spaces_after_colon(prop)
+    end
+
+    def spaces_after_colon(node)
+      spaces = 0
+      offset = 1
+
+      # Find the colon after the property name
+      while character_at(node.name_source_range.start_pos, offset - 1) != ':'
+        offset += 1
+      end
+
+      # Count spaces after the colon
+      while character_at(node.name_source_range.start_pos, offset) == ' '
+        spaces += 1
+        offset += 1
+      end
+
+      spaces
+    end
+  end
+end

data/lib/scss_lint/linter/space_after_property_name.rb

@@ -0,0 +1,27 @@
+module SCSSLint
+  # Checks for spaces following the name of a property and before the colon
+  # separating the property's name from its value.
+  class Linter::SpaceAfterPropertyName < Linter
+    include LinterRegistry
+
+    def visit_prop(node)
+      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

@@ -0,0 +1,72 @@
+module SCSSLint
+  # Checks for the presence of a single space before an opening brace.
+  class Linter::SpaceBeforeBrace < Linter
+    include LinterRegistry
+
+    def check_node(node)
+      source = source_from_range(node.source_range).strip
+
+      # Only lint `@include`s which have curly braces
+      if source[-1] == '{'
+        check_for_space(node, source)
+      end
+
+      yield
+    end
+
+    alias_method :visit_function, :check_node
+    alias_method :visit_each, :check_node
+    alias_method :visit_for, :check_node
+    alias_method :visit_function, :check_node
+    alias_method :visit_mixindef, :check_node
+    alias_method :visit_mixin, :check_node
+    alias_method :visit_rule, :check_node
+    alias_method :visit_while, :check_node
+
+  private
+
+    def check_for_space(node, string)
+      line = node.source_range.end_pos.line
+
+      if config['allow_single_line_padding'] && node_on_single_line?(node)
+        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
+        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/space_between_parens.rb

@@ -0,0 +1,35 @@
+module SCSSLint
+  # Checks for the presence of spaces between parentheses.
+  class Linter::SpaceBetweenParens < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      @spaces = config['spaces']
+
+      engine.lines.each_with_index do |line, index|
+        line.gsub(%r{((//|/\*).*$)}, '').scan(/
+          (^(\t|\s)*\))?  # Capture leading spaces and tabs followed by a `)`
+          (
+            \([ ]*(?!$)   # Find `( ` as long as its not EOL )
+            |
+            [ ]*\)
+          )?
+        /x) do |match|
+          check(match[2], index) if match[2]
+        end
+      end
+    end
+
+  private
+
+    def check(str, index)
+      spaces = str.count ' '
+      return if spaces == @spaces
+
+      location = Location.new(index + 1)
+      message = "Expected #{pluralize(@spaces, 'space')} " \
+                "between parentheses instead of #{spaces}"
+      add_lint(location, message)
+    end
+  end
+end

data/lib/scss_lint/linter/string_quotes.rb

@@ -0,0 +1,94 @@
+module SCSSLint
+  # Checks the type of quotes used in string literals.
+  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
+
+    def visit_script_stringinterpolation(node)
+      # We can't statically determine what the resultant string looks like when
+      # string interpolation is used, e.g. "one #{$var} three" could be a very
+      # different string depending on $var = `'" + "'` or $var = `two`.
+      #
+      # Thus we manually skip the substrings in the string interpolation and
+      # visit the expressions in the interpolation itself.
+      node.children.reject { |child| child.is_a?(Sass::Script::Tree::Literal) }
+                   .each { |child| visit(child) }
+    end
+
+    def visit_script_string(node)
+      check_quotes(node, source_from_range(node.source_range))
+    end
+
+    def visit_import(node)
+      # `@import` source range conveniently includes only the quoted string
+      check_quotes(node, source_from_range(node.source_range))
+    end
+
+    def visit_charset(node)
+      # `@charset` source range includes entire declaration, so exclude that prefix
+      source = source_from_range(node.source_range)[('@charset'.length)..-1]
+
+      check_quotes(node, source)
+    end
+
+  private
+
+    def check_quotes(node, source)
+      source = source.strip
+      string = extract_string_without_quotes(source)
+      return unless string
+
+      case source[0]
+      when '"'
+        check_double_quotes(node, string)
+      when "'"
+        check_single_quotes(node, string)
+      end
+    end
+
+    STRING_WITHOUT_QUOTES_REGEX = %r{
+      \A
+      ["'](.*)["']    # Extract text between quotes
+      \s*\)?\s*;?\s*  # Sometimes the Sass parser includes a trailing ) or ;
+      (//.*)?         # Exclude any trailing comments that might have snuck in
+      \z
+    }x
+
+    def extract_string_without_quotes(source)
+      return unless match = STRING_WITHOUT_QUOTES_REGEX.match(source)
+      match[1]
+    end
+
+    def check_double_quotes(node, string)
+      if config['style'] == 'single_quotes'
+        add_lint(node, 'Prefer single quoted strings') if string !~ /'/
+      else
+        if string =~ /(?<! \\) \\"/x && string !~ /'/
+          add_lint(node, 'Use single-quoted strings when writing double ' \
+                         'quotes to avoid having to escape the double quotes')
+        end
+      end
+    end
+
+    def check_single_quotes(node, string)
+      if config['style'] == 'single_quotes'
+        if string =~ /(?<! \\) \\'/x && string !~ /"/
+          add_lint(node, 'Use double-quoted strings when writing single ' \
+                         'quotes to avoid having to escape the single quotes')
+        elsif string =~ /(?<! \\) \\"/x
+          add_lint(node, "Don't escape double quotes in single-quoted strings")
+        end
+      else
+        add_lint(node, 'Prefer double-quoted strings') if string !~ /"/
+      end
+    end
+  end
+end