scss-lint-bliss 1.0.0

data/lib/scss_lint/linter/duplicate_property.rb

@@ -0,0 +1,58 @@
+module SCSSLint
+  # Checks for a property declared twice in a rule set.
+  class Linter::DuplicateProperty < Linter
+    include LinterRegistry
+
+    def check_properties(node)
+      static_properties(node).each_with_object({}) do |prop, prop_names|
+        prop_key = property_key(prop)
+
+        if existing_prop = prop_names[prop_key]
+          add_lint(prop, "Property `#{existing_prop.name.join}` already "\
+                         "defined on line #{existing_prop.line}")
+        else
+          prop_names[prop_key] = prop
+        end
+      end
+
+      yield # Continue linting children
+    end
+
+    alias_method :visit_rule,     :check_properties
+    alias_method :visit_mixindef, :check_properties
+
+  private
+
+    def static_properties(node)
+      node.children
+          .select { |child| child.is_a?(Sass::Tree::PropNode) }
+          .reject { |prop| prop.name.any? { |item| item.is_a?(Sass::Script::Node) } }
+    end
+
+    # Returns a key identifying the bucket this property and value correspond to
+    # for purposes of uniqueness.
+    def property_key(prop)
+      prop_key = prop.name.join
+      prop_value = property_value(prop)
+
+      # Differentiate between values for different vendor prefixes
+      prop_value.to_s.scan(/^(-[^-]+-.+)/) do |vendor_keyword|
+        prop_key << vendor_keyword.first
+      end
+
+      prop_key
+    end
+
+    def property_value(prop)
+      case prop.value
+      when Sass::Script::Funcall
+        prop.value.name
+      when Sass::Script::String
+      when Sass::Script::Tree::Literal
+        prop.value.value
+      else
+        prop.value.to_s
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/else_placement.rb

@@ -0,0 +1,48 @@
+module SCSSLint
+  # Checks where `@else` and `@else if` directives are placed with respect to
+  # the previous curly brace.
+  class Linter::ElsePlacement < Linter
+    include LinterRegistry
+
+    def visit_if(node)
+      visit_else(node, node.else) if node.else
+    end
+
+    def visit_else(if_node, else_node)
+      # Check each @else branch if there are multiple `@else if`s
+      visit_else(else_node, else_node.else) if else_node.else
+
+      # Skip @else statements on the same line as the previous @if, since we
+      # don't care about placement in that case
+      return if if_node.line == else_node.line
+
+      spaces = 0
+      while (char = character_at(else_node.source_range.start_pos, - (spaces + 1)))
+        if char == '}'
+          curly_on_same_line = true
+          break
+        end
+        spaces += 1
+      end
+
+      check_placement(else_node, curly_on_same_line)
+    end
+
+  private
+
+    def check_placement(else_node, curly_on_same_line)
+      if same_line_preferred?
+        unless curly_on_same_line
+          add_lint(else_node,
+                   '@else should be placed on same line as previous curly brace')
+        end
+      elsif curly_on_same_line
+        add_lint(else_node, '@else should be placed on its own line')
+      end
+    end
+
+    def same_line_preferred?
+      config['style'] == 'same_line'
+    end
+  end
+end

data/lib/scss_lint/linter/empty_line_between_blocks.rb

@@ -0,0 +1,85 @@
+module SCSSLint
+  # Reports the lack of empty lines between block defintions.
+  class Linter::EmptyLineBetweenBlocks < Linter
+    include LinterRegistry
+
+    def visit_function(node)
+      check(node, '@function')
+      yield
+    end
+
+    def visit_mixin(node)
+      # Ignore @includes which don't have any block content
+      check(node, '@include') if node.children
+                                     .any? { |child| child.is_a?(Sass::Tree::Node) }
+      yield
+    end
+
+    def visit_mixindef(node)
+      check(node, '@mixin')
+      yield
+    end
+
+    def visit_rule(node)
+      check(node, 'Rule')
+      yield
+    end
+
+  private
+
+    MESSAGE_FORMAT = '%s declaration should be %s by an empty line'
+
+    def check(node, type)
+      return if config['ignore_single_line_blocks'] && node_on_single_line?(node)
+      check_preceding_node(node, type)
+      check_following_node(node, type)
+    end
+
+    def check_following_node(node, type)
+      return unless (following_node = next_node(node)) &&
+                    (next_start_line = following_node.line)
+
+      # Special case: ignore comments immediately after a closing brace
+      line = engine.lines[next_start_line - 1].strip
+      return if following_node.is_a?(Sass::Tree::CommentNode) &&
+                line =~ %r{\s*\}?\s*/(/|\*)}
+
+      # Otherwise check if line before the next node's starting line is blank
+      line = engine.lines[next_start_line - 2].strip
+      return if line.empty?
+
+      add_lint(next_start_line - 1, MESSAGE_FORMAT % [type, 'followed'])
+    end
+
+    # In cases where the previous node is not a block declaration, we won't
+    # have run any checks against it, so we need to check here if the previous
+    # line is an empty line
+    def check_preceding_node(node, type)
+      case prev_node(node)
+      when
+        nil,
+        Sass::Tree::FunctionNode,
+        Sass::Tree::MixinNode,
+        Sass::Tree::MixinDefNode,
+        Sass::Tree::RuleNode,
+        Sass::Tree::CommentNode
+        # Ignore
+      else
+        unless engine.lines[node.line - 2].strip.empty?
+          add_lint(node.line, MESSAGE_FORMAT % [type, 'preceded'])
+        end
+      end
+    end
+
+    def next_node(node)
+      return unless siblings = node_siblings(node)
+      siblings[siblings.index(node) + 1] if siblings.count > 1
+    end
+
+    def prev_node(node)
+      return unless siblings = node_siblings(node)
+      index = siblings.index(node)
+      siblings[index - 1] if index > 0 && siblings.count > 1
+    end
+  end
+end

data/lib/scss_lint/linter/empty_rule.rb

@@ -0,0 +1,11 @@
+module SCSSLint
+  # Checks for rules with no content.
+  class Linter::EmptyRule < Linter
+    include LinterRegistry
+
+    def visit_rule(node)
+      add_lint(node, 'Empty rule') if node.children.empty?
+      yield # Continue linting children
+    end
+  end
+end

data/lib/scss_lint/linter/final_newline.rb

@@ -0,0 +1,20 @@
+module SCSSLint
+  # Checks for final newlines at the end of a file.
+  class Linter::FinalNewline < Linter
+    include LinterRegistry
+
+    def visit_root(_node)
+      return if engine.lines.empty?
+
+      ends_with_newline = engine.lines[-1][-1] == "\n"
+
+      if config['present']
+        add_lint(engine.lines.count,
+                 'Files should end with a trailing newline') unless ends_with_newline
+      else
+        add_lint(engine.lines.count,
+                 'Files should not end with a trailing newline') if ends_with_newline
+      end
+    end
+  end
+end

data/lib/scss_lint/linter/hex_length.rb

@@ -0,0 +1,56 @@
+module SCSSLint
+  # Checks that hexadecimal colors are written in the desired number of
+  # characters.
+  class Linter::HexLength < Linter
+    include LinterRegistry
+
+    HEX_REGEX = /(#(\h{3}|\h{6}))(?!\h)/
+
+    def visit_script_color(node)
+      return unless hex = source_from_range(node.source_range)[HEX_REGEX, 1]
+      check_hex(hex, node)
+    end
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      node.value.scan(HEX_REGEX) do |match|
+        check_hex(match.first, node)
+      end
+    end
+
+  private
+
+    def check_hex(hex, node)
+      return if expected(hex) == hex
+
+      add_lint(node, "Color `#{hex}` should be written as `#{expected(hex)}`")
+    end
+
+    def expected(hex)
+      return short_hex_form(hex) if can_be_shorter?(hex) && short_style?
+      return long_hex_form(hex) if hex.length == 4 && !short_style?
+
+      hex
+    end
+
+    def can_be_shorter?(hex)
+      hex.length == 7 &&
+        hex[1] == hex[2] &&
+        hex[3] == hex[4] &&
+        hex[5] == hex[6]
+    end
+
+    def short_hex_form(hex)
+      [hex[0..1], hex[3], hex[5]].join
+    end
+
+    def long_hex_form(hex)
+      [hex[0..1], hex[1], hex[2], hex[2], hex[3], hex[3]].join
+    end
+
+    def short_style?
+      config['style'] == 'short'
+    end
+  end
+end

data/lib/scss_lint/linter/hex_notation.rb

@@ -0,0 +1,38 @@
+module SCSSLint
+  # Checks if hexadecimal colors are written lowercase / uppercase.
+  class Linter::HexNotation < Linter
+    include LinterRegistry
+
+    HEX_REGEX = /(#(\h{3}|\h{6}))(?!\h)/
+
+    def visit_script_color(node)
+      return unless hex = source_from_range(node.source_range)[HEX_REGEX, 1]
+      check_hex(hex, node)
+    end
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      node.value.scan(HEX_REGEX) do |match|
+        check_hex(match.first, node)
+      end
+    end
+
+  private
+
+    def check_hex(hex, node)
+      return if expected(hex) == hex
+
+      add_lint(node, "Color `#{hex}` should be written as `#{expected(hex)}`")
+    end
+
+    def expected(color)
+      return color.downcase if lowercase_style?
+      color.upcase
+    end
+
+    def lowercase_style?
+      config['style'] == 'lowercase'
+    end
+  end
+end

data/lib/scss_lint/linter/hex_validation.rb

@@ -0,0 +1,23 @@
+module SCSSLint
+  # Checks for invalid hexadecimal colors.
+  class Linter::HexValidation < Linter
+    include LinterRegistry
+
+    def visit_script_string(node)
+      return unless node.type == :identifier
+
+      node.value.scan(/(#\h+)/) do |match|
+        check_hex(match.first, node)
+      end
+    end
+
+  private
+
+    HEX_REGEX = /(#(\h{3}|\h{6}|\h{8}))(?!\h)/
+
+    def check_hex(hex, node)
+      return if HEX_REGEX.match(hex)
+      add_lint(node, "Colors must have either three or six digits: `#{hex}`")
+    end
+  end
+end

data/lib/scss_lint/linter/id_selector.rb

@@ -0,0 +1,10 @@
+module SCSSLint
+  # Checks for the use of an ID selector.
+  class Linter::IdSelector < Linter
+    include LinterRegistry
+
+    def visit_id(id)
+      add_lint(id, 'Avoid using id selectors')
+    end
+  end
+end

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/important_rule.rb

@@ -0,0 +1,12 @@
+module SCSSLint
+  # Reports the use of !important in properties.
+  class Linter::ImportantRule < Linter
+    include LinterRegistry
+
+    def visit_prop(node)
+      return unless source_from_range(node.source_range).include?('!important')
+
+      add_lint(node, '!important should not be used')
+    end
+  end
+end

data/lib/scss_lint/linter/indentation.rb

@@ -0,0 +1,197 @@
+module SCSSLint
+  # Checks for consistent indentation of nested declarations and rule sets.
+  class Linter::Indentation < Linter # rubocop:disable ClassLength
+    include LinterRegistry
+
+    def visit_root(_node)
+      @indent_width = config['width'].to_i
+      @indent_character = config['character'] || 'space'
+      @indent = 0
+      yield
+    end
+
+    def check_and_visit_children(node)
+      # Don't continue checking children as the moment a parent's indentation is
+      # off it's likely the children will be as will. We don't display the child
+      # indentation problems as that would likely make the lint too noisy.
+      return if check_indentation(node)
+
+      @indent += @indent_width
+      yield
+      @indent -= @indent_width
+    end
+
+    def check_indentation(node)
+      return unless node.line
+
+      # Ignore the case where the node is on the same line as its previous
+      # sibling or its parent, as indentation isn't possible
+      return if nodes_on_same_line?(previous_node(node), node)
+
+      if @indent_character == 'tab'
+        other_character = ' '
+        other_character_name = 'space'
+      else
+        other_character = "\t"
+        other_character_name = 'tab'
+      end
+
+      check_indent_width(node, other_character, @indent_character, other_character_name)
+    end
+
+    def check_indent_width(node, other_character, character_name, other_character_name)
+      actual_indent = node_indent(node)
+
+      if actual_indent.include?(other_character)
+        add_lint(node.line,
+                 "Line should be indented with #{character_name}s, " \
+                 "not #{other_character_name}s")
+        return true
+      end
+
+      if config['allow_non_nested_indentation']
+        check_arbitrary_indent(node, actual_indent.length, character_name)
+      else
+        check_regular_indent(node, actual_indent.length, character_name)
+      end
+    end
+
+    # Deal with `else` statements
+    def visit_if(node, &block)
+      check_and_visit_children(node, &block)
+      visit(node.else) if node.else
+    end
+
+    # Need to define this explicitly since @at-root directives can contain
+    # inline selectors which produces the same parse tree as if the selector was
+    # nested within it. For example:
+    #
+    #   @at-root {
+    #     .something {
+    #       ...
+    #     }
+    #   }
+    #
+    # ...and...
+    #
+    #   @at-root .something {
+    #     ...
+    #   }
+    #
+    # ...produce the same parse tree, but result in different indentation
+    # levels.
+    def visit_atroot(node, &block)
+      if at_root_contains_inline_selector?(node)
+        return if check_indentation(node)
+        yield
+      else
+        check_and_visit_children(node, &block)
+      end
+    end
+
+    # Define node types that increase indentation level
+    alias_method :visit_directive, :check_and_visit_children
+    alias_method :visit_each,      :check_and_visit_children
+    alias_method :visit_for,       :check_and_visit_children
+    alias_method :visit_function,  :check_and_visit_children
+    alias_method :visit_media,     :check_and_visit_children
+    alias_method :visit_mixin,     :check_and_visit_children
+    alias_method :visit_mixindef,  :check_and_visit_children
+    alias_method :visit_prop,      :check_and_visit_children
+    alias_method :visit_rule,      :check_and_visit_children
+    alias_method :visit_supports,  :check_and_visit_children
+    alias_method :visit_while,     :check_and_visit_children
+
+    # Define node types to check indentation of (notice comments are left out)
+    alias_method :visit_charset,   :check_indentation
+    alias_method :visit_content,   :check_indentation
+    alias_method :visit_cssimport, :check_indentation
+    alias_method :visit_extend,    :check_indentation
+    alias_method :visit_import,    :check_indentation
+    alias_method :visit_return,    :check_indentation
+    alias_method :visit_variable,  :check_indentation
+    alias_method :visit_warn,      :check_indentation
+
+  private
+
+    def nodes_on_same_line?(node1, node2)
+      return unless node1
+
+      node1.line == node2.line ||
+        (node1.source_range && node1.source_range.end_pos.line == node2.line)
+    end
+
+    def at_root_contains_inline_selector?(node)
+      return unless node.children.any?
+      return unless first_child_source = node.children.first.source_range
+
+      same_position?(node.source_range.end_pos, first_child_source.start_pos)
+    end
+
+    def check_regular_indent(node, actual_indent, character_name)
+      return if actual_indent == @indent
+
+      add_lint(node.line,
+               "Line should be indented #{@indent} #{character_name}s, " \
+               "but was indented #{actual_indent} #{character_name}s")
+      true
+    end
+
+    def check_arbitrary_indent(node, actual_indent, character_name) # rubocop:disable CyclomaticComplexity, MethodLength, LineLength
+      # Allow rulesets to be indented any amount when the indent is zero, as
+      # long as it's a multiple of the indent width
+      if ruleset_under_root_node?(node)
+        unless actual_indent % @indent_width == 0
+          add_lint(node.line,
+                   "Line must be indented a multiple of #{@indent_width} " \
+                   "#{character_name}s, but was indented #{actual_indent} #{character_name}s")
+          return true
+        end
+      end
+
+      if @indent == 0
+        unless node.is_a?(Sass::Tree::RuleNode) || actual_indent == 0
+          add_lint(node.line,
+                   "Line should be indented 0 #{character_name}s, " \
+                   "but was indented #{actual_indent} #{character_name}s")
+          return true
+        end
+      elsif !one_shift_greater_than_parent?(node, actual_indent)
+        parent_indent = node_indent(node.node_parent).length
+        expected_indent = parent_indent + @indent_width
+
+        add_lint(node.line,
+                 "Line should be indented #{expected_indent} #{character_name}s, " \
+                 "but was indented #{actual_indent} #{character_name}s")
+        return true
+      end
+    end
+
+    # Returns whether node is a ruleset not nested within any other ruleset.
+    #
+    # @param node [Sass::Tree::Node]
+    # @return [true,false]
+    def ruleset_under_root_node?(node)
+      @indent == 0 && node.is_a?(Sass::Tree::RuleNode)
+    end
+
+    # Returns whether node is indented exactly one indent width greater than its
+    # parent.
+    #
+    # @param node [Sass::Tree::Node]
+    # @return [true,false]
+    def one_shift_greater_than_parent?(node, actual_indent)
+      parent_indent = node_indent(node.node_parent).length
+      expected_indent = parent_indent + @indent_width
+      expected_indent == actual_indent
+    end
+
+    # Return indentation of a node.
+    #
+    # @param node [Sass::Tree::Node]
+    # @return [Integer]
+    def node_indent(node)
+      engine.lines[node.line - 1][/^(\s*)/, 1]
+    end
+  end
+end