scss-lint 0.30.0 → 0.31.0

data/lib/scss_lint/config.rb

@@ -2,9 +2,6 @@ require 'pathname'
 require 'yaml'
 
 module SCSSLint
-  # Raised when the configuration file is invalid for some reason.
-  class InvalidConfiguration < StandardError; end
-
   # Loads and manages application configuration.
   class Config
     FILE_NAME = '.scss-lint.yml'
@@ -72,7 +69,8 @@ module SCSSLint
               {}
             end
         rescue => ex
-          raise InvalidConfiguration, "Invalid configuration: #{ex.message}"
+          raise SCSSLint::Exceptions::InvalidConfiguration,
+                "Invalid configuration: #{ex.message}"
         end
 
         options = convert_single_options_to_arrays(options)
@@ -122,20 +120,25 @@ module SCSSLint
         options.fetch('linters', {}).keys.each do |class_name|
           next unless class_name.include?('*')
 
-          class_name_regex = /#{class_name.gsub('*', '[^:]+')}/
-
           wildcard_options = options['linters'].delete(class_name)
+          apply_options_to_matching_linters(class_name, options, wildcard_options)
+        end
 
-          LinterRegistry.linters.each do |linter_class|
-            name = linter_name(linter_class)
-            next unless name.match(class_name_regex)
+        options
+      end
 
-            old_options = options['linters'].fetch(name, {})
-            options['linters'][name] = smart_merge(old_options, wildcard_options)
-          end
+      def apply_options_to_matching_linters(class_name_glob, current_options, linter_options)
+        linter_names_matching_glob(class_name_glob).each do |linter_name|
+          old_options = current_options['linters'].fetch(linter_name, {})
+          current_options['linters'][linter_name] = smart_merge(old_options, linter_options)
         end
+      end
 
-        options
+      def linter_names_matching_glob(class_name_glob)
+        class_name_regex = /#{class_name_glob.gsub('*', '[^:]+')}/
+
+        LinterRegistry.linters.map { |linter_class| linter_name(linter_class) }
+                      .select { |linter_name| linter_name.match(class_name_regex) }
       end
 
       def ensure_linter_exclude_paths_are_absolute(options, original_file)

data/lib/scss_lint/control_comment_processor.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+module SCSSLint
+  # Tracks which lines have been disabled for a given linter.
+  class ControlCommentProcessor
+    def initialize(linter)
+      @disable_stack = []
+      @disabled_lines = Set.new
+      @linter = linter
+    end
+
+    # Filter lints given the comments that were processed in the document.
+    #
+    # @param lints [Array<SCSSLint::Lint>]
+    def filter_lints(lints)
+      lints.reject { |lint| @disabled_lines.include?(lint.location.line) }
+    end
+
+    # Executed before a node has been visited.
+    #
+    # @param node [Sass::Tree::Node]
+    def before_node_visit(node)
+      return unless node.is_a?(Sass::Tree::CommentNode)
+
+      return unless match = /(?x)
+        \*\s* # Comment line start marker
+        scss-lint:
+        (?<command>disable|enable)\s+
+        (?<linters>.*?)
+        \s*(?:\*\/|\n) # Comment end marker or end of line
+      /.match(node.value.first)
+
+      linters = match[:linters].split(/\s*,\s*|\s+/)
+      return unless linters.include?('all') || linters.include?(@linter.name)
+
+      process_command(match[:command], node)
+
+      # Is the control comment the only thing on this line?
+      return if %r{^\s*(//|/\*)}.match(@linter.engine.lines[node.line - 1])
+
+      # If so, pop since we only want the comment to apply to the single line
+      pop_control_comment_stack(node)
+    end
+
+    # Executed after a node has been visited.
+    #
+    # @param node [Sass::Tree::Node]
+    def after_node_visit(node)
+      while @disable_stack.any? && @disable_stack.last.node_parent == node
+        pop_control_comment_stack(node)
+      end
+    end
+
+  private
+
+    def process_command(command, node)
+      case command
+      when 'disable'
+        @disable_stack << node
+      when 'enable'
+        pop_control_comment_stack(node)
+      end
+    end
+
+    def pop_control_comment_stack(node)
+      return unless comment_node = @disable_stack.pop
+
+      start_line = comment_node.line
+
+      # Find the deepest child that has a line number to which a lint might
+      # apply (if it is a control comment enable node, it will be the line of
+      # the comment itself).
+      child = node
+      while child.children.last.is_a?(Sass::Tree::Node)
+        child = child.children.last
+      end
+
+      end_line = child.line
+
+      @disabled_lines.merge(start_line..end_line)
+    end
+  end
+end

data/lib/scss_lint/engine.rb

@@ -10,14 +10,15 @@ module SCSSLint
 
     attr_reader :contents, :filename, :lines, :tree
 
+    # Creates a parsed representation of an SCSS document from the given string
+    # or file.
+    #
+    # @param scss_or_filename [String]
     def initialize(scss_or_filename)
       if File.exist?(scss_or_filename)
-        @filename = scss_or_filename
-        @engine = Sass::Engine.for_file(scss_or_filename, ENGINE_OPTIONS)
-        @contents = File.open(scss_or_filename, 'r').read
+        build_from_file(scss_or_filename)
       else
-        @engine = Sass::Engine.new(scss_or_filename, ENGINE_OPTIONS)
-        @contents = scss_or_filename
+        build_from_string(scss_or_filename)
       end
 
       # Need to force encoding to avoid Windows-related bugs.
@@ -34,5 +35,20 @@ module SCSSLint
         raise
       end
     end
+
+  private
+
+    # @param path [String]
+    def build_from_file(path)
+      @filename = path
+      @engine = Sass::Engine.for_file(path, ENGINE_OPTIONS)
+      @contents = File.open(path, 'r').read
+    end
+
+    # @param scss [String]
+    def build_from_string(scss)
+      @engine = Sass::Engine.new(scss, ENGINE_OPTIONS)
+      @contents = scss
+    end
   end
 end

data/lib/scss_lint/exceptions.rb

@@ -1,4 +1,10 @@
 module SCSSLint::Exceptions
+  # Raised when an invalid flag is given via the command line.
+  class InvalidCLIOption < StandardError; end
+
+  # Raised when the configuration file is invalid for some reason.
+  class InvalidConfiguration < StandardError; end
+
   # Raised when an unexpected error occurs in a linter
   class LinterError < StandardError; end
 end

data/lib/scss_lint/linter.rb

@@ -17,7 +17,9 @@ module SCSSLint
     def run(engine, config)
       @config = config
       @engine = engine
+      @comment_processor = ControlCommentProcessor.new(self)
       visit(engine.tree)
+      @lints = @comment_processor.filter_lints(@lints)
     end
 
     # Return the human-friendly name of this linter as specified in the
@@ -44,7 +46,7 @@ module SCSSLint
     #
     # @param range [Sass::Source::Range]
     # @return [SCSSLint::Location]
-    def location_from_range(range)
+    def location_from_range(range) # rubocop:disable Metrics/AbcSize
       length = if range.start_pos.line == range.end_pos.line
                  range.end_pos.offset - range.start_pos.offset
                else
@@ -69,7 +71,7 @@ module SCSSLint
     #
     # @param source_range [Sass::Source::Range]
     # @return [String] the original source code
-    def source_from_range(source_range)
+    def source_from_range(source_range) # rubocop:disable Metrics/AbcSize
       current_line = source_range.start_pos.line - 1
       last_line    = source_range.end_pos.line - 1
       start_pos    = source_range.start_pos.offset - 1
@@ -121,7 +123,9 @@ module SCSSLint
         visit_selector(node.parsed_rules)
       end
 
+      @comment_processor.before_node_visit(node)
       super
+      @comment_processor.after_node_visit(node)
     end
 
     # Redefine so we can set the `node_parent` of each node

data/lib/scss_lint/linter/bang_format.rb

@@ -16,25 +16,36 @@ module SCSSLint
 
   private
 
+    # Start from the back and move towards the front so that any !important or
+    # !default !'s will be found *before* quotation marks. Then we can
+    # stop at quotation marks to protect against linting !'s within strings
+    # (e.g. `content`)
     def find_bang_offset(range)
+      stopping_characters = ['!', '\'', '"']
       offset = 0
-      offset += 1 while character_at(range.start_pos, offset) != '!'
+      offset -= 1 until stopping_characters.include?(character_at(range.end_pos, offset))
       offset
     end
 
+    def is_before_wrong?(range, offset)
+      before_expected = config['space_before_bang'] ? / / : /[^ ]/
+      before_actual = character_at(range.end_pos, offset - 1)
+      (before_actual =~ before_expected).nil?
+    end
+
+    def is_after_wrong?(range, offset)
+      after_expected = config['space_after_bang'] ? / / : /[^ ]/
+      after_actual = character_at(range.end_pos, offset + 1)
+      (after_actual =~ after_expected).nil?
+    end
+
     def check_spacing(node)
       range = node.value_source_range
       offset = find_bang_offset(range)
 
-      before_expected = config['space_before_bang'] ? / / : /[^ ]/
-      before_actual = character_at(range.start_pos, offset - 1)
-      before_is_wrong = (before_actual =~ before_expected).nil?
-
-      after_expected = config['space_after_bang'] ? / / : /[^ ]/
-      after_actual = character_at(range.start_pos, offset + 1)
-      after_is_wrong = (after_actual =~ after_expected).nil?
+      return if character_at(range.end_pos, offset) != '!'
 
-      before_is_wrong || after_is_wrong
+      is_before_wrong?(range, offset) || is_after_wrong?(range, offset)
     end
   end
 end

data/lib/scss_lint/linter/duplicate_property.rb

@@ -3,16 +3,46 @@ module SCSSLint
   class Linter::DuplicateProperty < Linter
     include LinterRegistry
 
-    def visit_rule(node)
-      check_properties(node)
-    end
+    def check_properties(node)
+      static_properties(node).each_with_object({}) do |prop, prop_names|
+        prop_key = property_key(prop)
 
-    def visit_mixindef(node)
-      check_properties(node)
+        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
@@ -24,30 +54,5 @@ module SCSSLint
         prop.value.to_s
       end
     end
-
-    def check_properties(node)
-      properties = node.children
-                       .select { |child| child.is_a?(Sass::Tree::PropNode) }
-                       .reject { |prop| prop.name.any? { |item| item.is_a?(Sass::Script::Node) } }
-
-      prop_names = {}
-
-      properties.each do |prop|
-        name = prop.name.join
-
-        prop_hash = name
-        prop_value = property_value(prop)
-
-        prop_value.to_s.scan(/^(-[^-]+-.+)/) do |vendor_keyword|
-          prop_hash << vendor_keyword.first
-        end
-
-        if existing_prop = prop_names[prop_hash]
-          add_lint(prop, "Property `#{name}` already defined on line #{existing_prop.line}")
-        else
-          prop_names[prop_hash] = prop
-        end
-      end
-    end
   end
 end

data/lib/scss_lint/linter/empty_line_between_blocks.rb

@@ -42,7 +42,7 @@ module SCSSLint
       # 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*/(/|\*)}
+                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

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

@@ -126,8 +126,9 @@ module SCSSLint
 
     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, node.children.first.source_range.start_pos)
+      same_position?(node.source_range.end_pos, first_child_source.start_pos)
     end
   end
 end

data/lib/scss_lint/linter/leading_zero.rb

@@ -8,21 +8,21 @@ module SCSSLint
 
       non_string_values = remove_quoted_strings(node.value).split
       non_string_values.each do |value|
-        next unless number = value[FRACTIONAL_DIGIT_REGEX, 1]
-        check_number(node, number)
+        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)[FRACTIONAL_DIGIT_REGEX, 1]
+        source_from_range(node.source_range)[NUMBER_WITH_LEADING_ZERO_REGEX, 1]
 
-      check_number(node, number)
+      check_for_leading_zeros(node, number)
     end
 
   private
 
-    FRACTIONAL_DIGIT_REGEX = /^-?(0?\.\d+)/
+    NUMBER_WITH_LEADING_ZERO_REGEX = /^-?(0?\.\d+)/
 
     CONVENTIONS = {
       'exclude_zero' => {
@@ -37,7 +37,7 @@ module SCSSLint
       },
     }
 
-    def check_number(node, original_number)
+    def check_for_leading_zeros(node, original_number)
       style = config.fetch('style', 'exclude_zero')
       convention = CONVENTIONS[style]
       return if convention[:validator].call(original_number)

data/lib/scss_lint/linter/name_format.rb

@@ -46,12 +46,23 @@ module SCSSLint
     ].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)
 
       add_lint(node, "Name of #{node_type} `#{node_text}` should be " \
                      "written #{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('%', ''))