scss_lint 0.38.0

data/lib/scss_lint/constants.rb

@@ -0,0 +1,8 @@
+# Global application constants.
+module SCSSLint
+  SCSS_LINT_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
+  SCSS_LINT_DATA = File.join(SCSS_LINT_HOME, 'data')
+
+  REPO_URL = 'https://github.com/brigade/scss-lint'
+  BUG_REPORT_URL = "#{REPO_URL}/issues"
+end

data/lib/scss_lint/control_comment_processor.rb

@@ -0,0 +1,126 @@
+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 command = extract_command(node)
+
+      linters = command[:linters]
+      return unless linters.include?('all') || linters.include?(@linter.name)
+
+      process_command(command[:action], node)
+
+      # Is the control comment the only thing on this line?
+      return if node.is_a?(Sass::Tree::RuleNode) ||
+                %r{^\s*(//|/\*)}.match(@linter.engine.lines[node.line - 1])
+
+      # Otherwise, pop since we only want 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 extract_command(node)
+      comment =
+        case node
+        when Sass::Tree::CommentNode
+          node.value.first
+        when Sass::Tree::RuleNode
+          node.rule.select { |chunk| chunk.is_a?(String) }.join
+        end
+
+      return unless match = %r{
+        (/|\*)\s* # Comment start marker
+        scss-lint:
+        (?<action>disable|enable)\s+
+        (?<linters>.*?)
+        \s*(?:\*/|\n) # Comment end marker or end of line
+      }x.match(comment)
+
+      {
+        action: match[:action],
+        linters: match[:linters].split(/\s*,\s*|\s+/),
+      }
+    end
+
+    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
+      prev_child = node
+      until [nil, prev_child].include?(child = last_child(child))
+        prev_child = child
+      end
+
+      # Fall back to prev_child if last_child() returned nil (i.e. node had no
+      # children with line numbers)
+      end_line = (child || prev_child).line
+
+      @disabled_lines.merge(start_line..end_line)
+    end
+
+    # Gets the child of the node that resides on the lowest line in the file.
+    #
+    # This is necessary due to the fact that our monkey patching of the parse
+    # tree's {#children} method does not return nodes sorted by their line
+    # number.
+    #
+    # Returns `nil` if node has no children or no children with associated line
+    # numbers.
+    #
+    # @param node [Sass::Tree::Node, Sass::Script::Tree::Node]
+    # @return [Sass::Tree::Node, Sass::Script::Tree::Node]
+    def last_child(node)
+      last = node.children.inject(node) do |lowest, child|
+        return lowest unless child.respond_to?(:line)
+        lowest.line < child.line ? child : lowest
+      end
+
+      # In this case, none of the children have associated line numbers or the
+      # node has no children at all, so return `nil`.
+      return if last == node
+
+      last
+    end
+  end
+end

data/lib/scss_lint/engine.rb

@@ -0,0 +1,56 @@
+require 'sass'
+
+module SCSSLint
+  class FileEncodingError < StandardError; end
+
+  # Contains all information for a parsed SCSS file, including its name,
+  # contents, and parse tree.
+  class Engine
+    ENGINE_OPTIONS = { cache: false, syntax: :scss }
+
+    attr_reader :contents, :filename, :lines, :tree
+
+    # Creates a parsed representation of an SCSS document from the given string
+    # or file.
+    #
+    # @param options [Hash]
+    # @option options [String] :file The file to load
+    # @option options [String] :code The code to parse
+    def initialize(options = {})
+      if options[:file]
+        build_from_file(options[:file])
+      elsif options[:code]
+        build_from_string(options[:code])
+      end
+
+      # Need to force encoding to avoid Windows-related bugs.
+      # Need `to_a` for Ruby 1.9.3.
+      @lines = @contents.force_encoding('UTF-8').lines.to_a
+      @tree = @engine.to_tree
+    rescue Encoding::UndefinedConversionError, Sass::SyntaxError => error
+      if error.is_a?(Encoding::UndefinedConversionError) ||
+         error.message.match(/invalid.*(byte sequence|character)/i)
+        raise FileEncodingError,
+              "Unable to parse SCSS file: #{error}",
+              error.backtrace
+      else
+        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

@@ -0,0 +1,21 @@
+module SCSSLint::Exceptions
+  # Raised when all files matched by the specified glob patterns were filtered
+  # by exclude patterns.
+  class AllFilesFilteredError < StandardError; end
+
+  # 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
+
+  # Raised when no files were specified or specified glob patterns did not match
+  # any files.
+  class NoFilesError < StandardError; end
+
+  # Raised when a required library (specified via command line) does not exist.
+  class RequiredLibraryMissingError < StandardError; end
+end

data/lib/scss_lint/file_finder.rb

@@ -0,0 +1,68 @@
+require 'find'
+
+module SCSSLint
+  # Finds all SCSS files that should be linted given a set of paths, globs, and
+  # configuration.
+  class FileFinder
+    # List of extensions of files to include when only a directory is specified
+    # as a path.
+    VALID_EXTENSIONS = %w[.css .scss]
+
+    # Create a {FileFinder}.
+    #
+    # @param config [SCSSLint::Config]
+    def initialize(config)
+      @config = config
+    end
+
+    # Find all files that match given the specified options.
+    #
+    # @param patterns [Array<String>] a list of file paths and glob patterns
+    def find(patterns)
+      # If no explicit patterns given, use patterns listed in config
+      patterns = @config.scss_files if patterns.empty?
+
+      matched_files = extract_files_from(patterns)
+      if matched_files.empty?
+        raise SCSSLint::Exceptions::NoFilesError,
+              "No SCSS files matched by the patterns: #{patterns.join(' ')}"
+      end
+
+      filtered_files = matched_files.reject { |file| @config.excluded_file?(file) }
+      if filtered_files.empty?
+        raise SCSSLint::Exceptions::AllFilesFilteredError,
+              "All files matched by the patterns [#{patterns.join(', ')}] " \
+              "were excluded by the patterns: [#{@config.exclude_patterns.join(', ')}]"
+      end
+
+      filtered_files
+    end
+
+  private
+
+    # @param list [Array]
+    def extract_files_from(list)
+      files = []
+
+      list.each do |file|
+        if File.directory?(file)
+          Find.find(file) do |f|
+            files << f if scssish_file?(f)
+          end
+        else
+          files << file # Otherwise include file as-is
+        end
+      end
+
+      files.uniq
+    end
+
+    # @param file [String]
+    # @return [true,false]
+    def scssish_file?(file)
+      return false unless FileTest.file?(file)
+
+      VALID_EXTENSIONS.include?(File.extname(file))
+    end
+  end
+end

data/lib/scss_lint/lint.rb

@@ -0,0 +1,24 @@
+module SCSSLint
+  # Stores information about a single problem that was detected by a [Linter].
+  class Lint
+    attr_reader :linter, :filename, :location, :description, :severity
+
+    # @param linter [SCSSLint::Linter]
+    # @param filename [String]
+    # @param location [SCSSLint::Location]
+    # @param description [String]
+    # @param severity [Symbol]
+    def initialize(linter, filename, location, description, severity = :warning)
+      @linter      = linter
+      @filename    = filename
+      @location    = location
+      @description = description
+      @severity    = severity
+    end
+
+    # @return [Boolean]
+    def error?
+      severity == :error
+    end
+  end
+end

data/lib/scss_lint/linter.rb

@@ -0,0 +1,161 @@
+module SCSSLint
+  # Defines common functionality available to all linters.
+  class Linter < Sass::Tree::Visitors::Base
+    include SelectorVisitor
+    include Utils
+
+    attr_reader :config, :engine, :lints
+
+    # Create a linter.
+    def initialize
+      @lints = []
+    end
+
+    # Run this linter against a parsed document with the given configuration,
+    # returning the lints that were found.
+    #
+    # @param engine [Engine]
+    # @param config [Config]
+    # @return [Array<Lint>]
+    def run(engine, config)
+      @lints = []
+      @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
+    # configuration file and in lint descriptions.
+    def name
+      self.class.name.split('::')[2..-1].join('::')
+    end
+
+  protected
+
+    # Helper for creating lint from a parse tree node
+    #
+    # @param node_or_line_or_location [Sass::Script::Tree::Node, Fixnum, SCSSLint::Location]
+    # @param message [String]
+    def add_lint(node_or_line_or_location, message)
+      @lints << Lint.new(self,
+                         engine.filename,
+                         extract_location(node_or_line_or_location),
+                         message,
+                         @config.fetch('severity', :warning).to_sym)
+    end
+
+    # Extract {SCSSLint::Location} from a {Sass::Source::Range}.
+    #
+    # @param range [Sass::Source::Range]
+    # @return [SCSSLint::Location]
+    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
+                 line_source = engine.lines[range.start_pos.line - 1]
+                 line_source.length - range.start_pos.offset + 1
+               end
+
+      Location.new(range.start_pos.line, range.start_pos.offset, length)
+    end
+
+    # @param source_position [Sass::Source::Position]
+    # @param offset [Integer]
+    # @return [String] the character at the given [Sass::Source::Position]
+    def character_at(source_position, offset = 0)
+      actual_line   = source_position.line - 1
+      actual_offset = source_position.offset + offset - 1
+
+      engine.lines[actual_line][actual_offset]
+    end
+
+    # Extracts the original source code given a range.
+    #
+    # @param source_range [Sass::Source::Range]
+    # @return [String] the original source code
+    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
+
+      if current_line == last_line
+        source = engine.lines[current_line][start_pos..(source_range.end_pos.offset - 1)]
+      else
+        source = engine.lines[current_line][start_pos..-1]
+      end
+
+      current_line += 1
+      while current_line < last_line
+        source += "#{engine.lines[current_line]}"
+        current_line += 1
+      end
+
+      if source_range.start_pos.line != source_range.end_pos.line
+        source += "#{(engine.lines[current_line] || '')[0...source_range.end_pos.offset]}"
+      end
+
+      source
+    end
+
+    # Returns whether a given node spans only a single line.
+    #
+    # @param node [Sass::Tree::Node]
+    # @return [true,false] whether the node spans a single line
+    def node_on_single_line?(node)
+      return if node.source_range.start_pos.line != node.source_range.end_pos.line
+
+      # The Sass parser reports an incorrect source range if the trailing curly
+      # brace is on the next line, e.g.
+      #
+      #   p {
+      #   }
+      #
+      # Since we don't want to count this as a single line node, check if the
+      # last character on the first line is an opening curly brace.
+      engine.lines[node.line - 1].strip[-1] != '{'
+    end
+
+    # Modified so we can also visit selectors in linters
+    #
+    # @param node [Sass::Tree::Node, Sass::Script::Tree::Node,
+    #   Sass::Script::Value::Base]
+    def visit(node)
+      # Visit the selector of a rule if parsed rules are available
+      if node.is_a?(Sass::Tree::RuleNode) && node.parsed_rules
+        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
+    #
+    # @param parent [Sass::Tree::Node, Sass::Script::Tree::Node,
+    #   Sass::Script::Value::Base]
+    def visit_children(parent)
+      parent.children.each do |child|
+        child.node_parent = parent
+        visit(child)
+      end
+    end
+
+  private
+
+    def extract_location(node_or_line_or_location)
+      if node_or_line_or_location.is_a?(Location)
+        node_or_line_or_location
+      elsif node_or_line_or_location.respond_to?(:source_range) &&
+            node_or_line_or_location.source_range
+        location_from_range(node_or_line_or_location.source_range)
+      elsif node_or_line_or_location.respond_to?(:line)
+        Location.new(node_or_line_or_location.line)
+      else
+        Location.new(node_or_line_or_location)
+      end
+    end
+  end
+end