scss_lint 0.38.0

data/lib/scss_lint/location.rb

@@ -0,0 +1,38 @@
+module SCSSLint
+  # Stores a location of {Lint} in a source.
+  class Location
+    include Comparable
+
+    attr_reader :line, :column, :length
+
+    # @param line [Integer] One-based index
+    # @param column [Integer] One-based index
+    # @param length [Integer] Number of characters, including the first character
+    def initialize(line = 1, column = 1, length = 1)
+      raise ArgumentError, "Line must be more than 0, passed #{line}" if line < 1
+      raise ArgumentError, "Column must be more than 0, passed #{column}" if column < 1
+      raise ArgumentError, "Length must be more than 0, passed #{length}" if length < 1
+
+      @line   = line
+      @column = column
+      @length = length
+    end
+
+    def ==(other)
+      [:line, :column, :length].all? do |attr|
+        send(attr) == other.send(attr)
+      end
+    end
+
+    alias_method :eql?, :==
+
+    def <=>(other)
+      [:line, :column, :length].each do |attr|
+        result = send(attr) <=> other.send(attr)
+        return result unless result == 0
+      end
+
+      0
+    end
+  end
+end

data/lib/scss_lint/options.rb

@@ -0,0 +1,109 @@
+require 'optparse'
+
+module SCSSLint
+  # Handles option parsing for the command line application.
+  class Options
+    DEFAULT_REPORTER = ['Default', :stdout]
+
+    # Parses command line options into an options hash.
+    #
+    # @param args [Array<String>] arguments passed via the command line
+    # @return [Hash] parsed options
+    def parse(args)
+      @options = {
+        reporters: [DEFAULT_REPORTER],
+      }
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: #{parser.program_name} [options] [scss-files]"
+
+        add_display_options parser
+        add_linter_options parser
+        add_file_options parser
+        add_info_options parser
+      end.parse!(args)
+
+      # Any remaining arguments are assumed to be files
+      @options[:files] = args
+
+      @options
+    rescue OptionParser::InvalidOption => ex
+      raise SCSSLint::Exceptions::InvalidCLIOption,
+            ex.message,
+            ex.backtrace
+    end
+
+  private
+
+    def add_display_options(parser)
+      parser.on('-f', '--format Formatter', 'Specify how to display lints', String) do |format|
+        define_output_format(format)
+      end
+
+      parser.on('-r', '--require path', 'Require Ruby file', String) do |path|
+        @options[:required_paths] ||= []
+        @options[:required_paths] << path
+      end
+    end
+
+    # @param format [String]
+    def define_output_format(format)
+      return if @options[:reporters] == [DEFAULT_REPORTER] && format == 'Default'
+
+      @options[:reporters].reject! { |i| i == DEFAULT_REPORTER }
+      @options[:reporters] << [format, :stdout]
+    end
+
+    def add_linter_options(parser)
+      parser.on('-i', '--include-linter linter,...', Array,
+                'Specify which linters you want to run') do |linters|
+        @options[:included_linters] = linters
+      end
+
+      parser.on('-x', '--exclude-linter linter,...', Array,
+                "Specify which linters you don't want to run") do |linters|
+        @options[:excluded_linters] = linters
+      end
+    end
+
+    def add_file_options(parser)
+      parser.on('-c', '--config config-file', String,
+                'Specify which configuration file you want to use') do |conf_file|
+        @options[:config_file] = conf_file
+      end
+
+      parser.on('-e', '--exclude file,...', Array,
+                'List of file names to exclude') do |files|
+        @options[:excluded_files] = files
+      end
+
+      parser.on('-o', '--out path', 'Write output to a file instead of STDOUT', String) do |path|
+        define_output_path(path)
+      end
+    end
+
+    # @param path [String]
+    def define_output_path(path)
+      last_reporter, _output = @options[:reporters].pop
+      @options[:reporters] << [last_reporter, path]
+    end
+
+    def add_info_options(parser)
+      parser.on_tail('--show-formatters', 'Shows available formatters') do
+        @options[:show_formatters] = true
+      end
+
+      parser.on_tail('--show-linters', 'Display available linters') do
+        @options[:show_linters] = true
+      end
+
+      parser.on_tail('-h', '--help', 'Display help documentation') do
+        @options[:help] = parser.help
+      end
+
+      parser.on_tail('-v', '--version', 'Display version') do
+        @options[:version] = true
+      end
+    end
+  end
+end

data/lib/scss_lint/rake_task.rb

@@ -0,0 +1,106 @@
+require 'rake'
+require 'rake/tasklib'
+
+module SCSSLint
+  # Rake task for scss-lint CLI.
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'scss_lint/rake_task'
+  #   SCSSLint::RakeTask.new
+  #
+  #   # ...and then execute from the command line:
+  #   rake scss_lint
+  #
+  # You can also specify the list of files as explicit task arguments:
+  #
+  # @example
+  #   # Add the following to your Rakefile...
+  #   require 'scss_lint/rake_task'
+  #   SCSSLint::RakeTask.new
+  #
+  #   # ...and then execute from the command line (single quotes prevent shell
+  #   # glob expansion and allow us to have a space after commas):
+  #   rake 'scss_lint[app/assets/**/*.scss, other_files/**/*.scss]'
+  class RakeTask < Rake::TaskLib
+    # Name of the task.
+    # @return [String]
+    attr_accessor :name
+
+    # Configuration file to use.
+    # @return [String]
+    attr_accessor :config
+
+    # List of files to lint (can contain shell globs).
+    #
+    # Note that this will be ignored if you explicitly pass a list of files as
+    # task arguments via the command line or in the task definition.
+    # @return [Array<String>]
+    attr_accessor :files
+
+    # Create the task so it is accessible via +Rake::Task['scss_lint']+.
+    def initialize(name = :scss_lint)
+      @name = name
+      @files = ['.'] # Search for everything under current directory by default
+      @quiet = false
+
+      yield self if block_given?
+
+      define
+    end
+
+  private
+
+    def define
+      # Generate a default description if one hasn't been provided
+      desc default_description unless ::Rake.application.last_description
+
+      task(name, [:files]) do |_task, task_args|
+        # Lazy-load so task doesn't affect Rakefile load time
+        require 'scss_lint'
+        require 'scss_lint/cli'
+
+        run_cli(task_args)
+      end
+    end
+
+    def run_cli(task_args)
+      cli_args = ['--config', config] if config
+
+      result = SCSSLint::CLI.new.run(Array(cli_args) + files_to_lint(task_args))
+
+      message =
+        case result
+        when CLI::EXIT_CODES[:error], CLI::EXIT_CODES[:warning]
+          'scss-lint found one or more lints'
+        when CLI::EXIT_CODES[:ok]
+          'scss-lint found no lints'
+        else
+          'scss-lint failed with an error'
+        end
+
+      puts message
+      exit result unless result == 0
+    end
+
+    def files_to_lint(task_args)
+      # Note: we're abusing Rake's argument handling a bit here. We call the
+      # first argument `files` but it's actually only the first file--we pull
+      # the rest out of the `extras` from the task arguments. This is so we
+      # can specify an arbitrary list of files separated by commas on the
+      # command line or in a custom task definition.
+      explicit_files = Array(task_args[:files]) + Array(task_args.extras)
+
+      explicit_files.any? ? explicit_files : files
+    end
+
+    # Friendly description that shows the full command that will be executed.
+    def default_description
+      description = 'Run `scss-lint'
+      description += " --config #{config}" if config
+      description += " #{files.join(' ')}" if files.any?
+      description += ' [files...]`'
+      description
+    end
+  end
+end

data/lib/scss_lint/reporter.rb

@@ -0,0 +1,18 @@
+module SCSSLint
+  # Responsible for displaying lints to the user in some format.
+  class Reporter
+    attr_reader :lints
+
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    def initialize(lints)
+      @lints = lints
+    end
+
+    def report_lints
+      raise NotImplementedError, 'You must implement report_lints'
+    end
+  end
+end

data/lib/scss_lint/reporter/config_reporter.rb

@@ -0,0 +1,26 @@
+module SCSSLint
+  # Returns a YAML configuration where all linters are disabled which
+  # caused a lint.
+  class Reporter::ConfigReporter < Reporter
+    def report_lints
+      { 'linters' => disabled_linters }.to_yaml unless lints.empty?
+    end
+
+  private
+
+    def disabled_linters
+      linters.each_with_object({}) do |linter, m|
+        m[linter] = { 'enabled' => false }
+      end
+    end
+
+    def linters
+      lints.map { |lint| linter_name(lint.linter) }.compact.uniq.sort
+    end
+
+    def linter_name(linter)
+      return unless linter
+      linter.class.to_s.split('::').last
+    end
+  end
+end

data/lib/scss_lint/reporter/default_reporter.rb

@@ -0,0 +1,27 @@
+module SCSSLint
+  # Reports a single line per lint.
+  class Reporter::DefaultReporter < Reporter
+    def report_lints
+      return unless lints.any?
+
+      lints.map do |lint|
+        "#{location(lint)} #{type(lint)} #{message(lint)}"
+      end.join("\n") + "\n"
+    end
+
+  private
+
+    def location(lint)
+      "#{lint.filename.color(:cyan)}:#{lint.location.line.to_s.color(:magenta)}"
+    end
+
+    def type(lint)
+      lint.error? ? '[E]'.color(:red) : '[W]'.color(:yellow)
+    end
+
+    def message(lint)
+      linter_name = "#{lint.linter.name}: ".color(:green) if lint.linter
+      "#{linter_name}#{lint.description}"
+    end
+  end
+end

data/lib/scss_lint/reporter/files_reporter.rb

@@ -0,0 +1,8 @@
+module SCSSLint
+  # Reports a single line per file.
+  class Reporter::FilesReporter < Reporter
+    def report_lints
+      lints.map(&:filename).uniq.join("\n") + "\n" if lints.any?
+    end
+  end
+end

data/lib/scss_lint/reporter/json_reporter.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module SCSSLint
+  # Reports lints in a JSON format.
+  class Reporter::JSONReporter < Reporter
+    def report_lints
+      output = {}
+      lints.group_by(&:filename).each do |filename, file_lints|
+        output[filename] = file_lints.map do |lint|
+          issue_hash(lint)
+        end
+      end
+      JSON.pretty_generate(output)
+    end
+
+  private
+
+    def issue_hash(lint)
+      {
+        'line' => lint.location.line,
+        'column' => lint.location.column,
+        'length' => lint.location.length,
+        'severity' => lint.severity,
+        'reason' => lint.description,
+      }.tap do |hash|
+        hash['linter'] = lint.linter.name if lint.linter
+      end
+    end
+  end
+end

data/lib/scss_lint/reporter/xml_reporter.rb

@@ -0,0 +1,33 @@
+module SCSSLint
+  # Reports lints in an XML format.
+  class Reporter::XMLReporter < Reporter
+    def report_lints
+      output = '<?xml version="1.0" encoding="utf-8"?>'
+
+      output << '<lint>'
+      lints.group_by(&:filename).each do |filename, file_lints|
+        output << "<file name=#{filename.encode(xml: :attr)}>"
+
+        file_lints.each do |lint|
+          output << issue_tag(lint)
+        end
+
+        output << '</file>'
+      end
+      output << '</lint>'
+
+      output
+    end
+
+  private
+
+    def issue_tag(lint)
+      "<issue linter=\"#{lint.linter.name if lint.linter}\" " \
+             "line=\"#{lint.location.line}\" " \
+             "column=\"#{lint.location.column}\" " \
+             "length=\"#{lint.location.length}\" " \
+             "severity=\"#{lint.severity}\" " \
+             "reason=#{lint.description.encode(xml: :attr)} />"
+    end
+  end
+end

data/lib/scss_lint/runner.rb

@@ -0,0 +1,51 @@
+module SCSSLint
+  # Finds and aggregates all lints found by running the registered linters
+  # against a set of SCSS files.
+  class Runner
+    attr_reader :lints
+
+    # @param config [Config]
+    def initialize(config)
+      @config  = config
+      @lints   = []
+      @linters = LinterRegistry.linters.map(&:new)
+    end
+
+    # @param files [Array]
+    def run(files)
+      files.each do |file|
+        find_lints(file)
+      end
+    end
+
+  private
+
+    # @param file [String]
+    def find_lints(file)
+      engine = Engine.new(file: file)
+
+      @linters.each do |linter|
+        begin
+          run_linter(linter, engine, file)
+        rescue => error
+          raise SCSSLint::Exceptions::LinterError,
+                "#{linter.class} raised unexpected error linting file #{file}: " \
+                "'#{error.message}'",
+                error.backtrace
+        end
+      end
+    rescue Sass::SyntaxError => ex
+      @lints << Lint.new(nil, ex.sass_filename, Location.new(ex.sass_line),
+                         "Syntax Error: #{ex}", :error)
+    rescue FileEncodingError => ex
+      @lints << Lint.new(nil, file, Location.new, ex.to_s, :error)
+    end
+
+    # For stubbing in tests.
+    def run_linter(linter, engine, file)
+      return unless @config.linter_enabled?(linter)
+      return if @config.excluded_file_for_linter?(file, linter)
+      @lints += linter.run(engine, @config.linter_options(linter))
+    end
+  end
+end