scss_lint 0.38.0

data/lib/scss_lint/cli.rb

@@ -0,0 +1,215 @@
+require 'rainbow'
+require 'rainbow/ext/string'
+require 'scss_lint/options'
+
+module SCSSLint
+  # Responsible for parsing command-line options and executing the appropriate
+  # application logic based on the options specified.
+  class CLI
+    attr_reader :config, :options
+
+    # Subset of semantic exit codes conforming to `sysexits` documentation.
+    EXIT_CODES = {
+      ok:             0,
+      warning:        1,  # One or more warnings (but no errors) were reported
+      error:          2,  # One or more errors were reported
+      usage:          64, # Command line usage error
+      no_input:       66, # Input file did not exist or was not readable
+      unavailable:    69, # Required library is unavailable
+      software:       70, # Internal software error
+      config:         78, # Configuration error
+      no_files:       80, # No files matched by specified glob patterns
+      files_filtered: 81, # All matched files were filtered by exclusions
+    }
+
+    def run(args)
+      options = SCSSLint::Options.new.parse(args)
+      act_on_options(options)
+    rescue => ex
+      handle_runtime_exception(ex)
+    end
+
+  private
+
+    def act_on_options(options)
+      load_required_paths(options)
+      load_reporters(options)
+
+      if options[:help]
+        print_help(options)
+      elsif options[:version]
+        print_version
+      elsif options[:show_linters]
+        print_linters
+      elsif options[:show_formatters]
+        print_formatters
+      else
+        config = setup_configuration(options)
+        scan_for_lints(options, config)
+      end
+    end
+
+    def scan_for_lints(options, config)
+      runner = Runner.new(config)
+      runner.run(FileFinder.new(config).find(options[:files]))
+      report_lints(options, runner.lints)
+
+      if runner.lints.any?(&:error?)
+        halt :error
+      elsif runner.lints.any?
+        halt :warning
+      else
+        halt :ok
+      end
+    end
+
+    def handle_runtime_exception(exception) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/LineLength, Metrics/MethodLength
+      case exception
+      when SCSSLint::Exceptions::InvalidCLIOption
+        puts exception.message
+        puts 'Run `scss-lint --help` for usage documentation'
+        halt :usage
+      when SCSSLint::Exceptions::InvalidConfiguration
+        puts exception.message
+        halt :config
+      when SCSSLint::Exceptions::RequiredLibraryMissingError
+        puts exception.message
+        halt :unavailable
+      when SCSSLint::Exceptions::AllFilesFilteredError
+        puts exception.message
+        halt :files_filtered
+      when SCSSLint::Exceptions::NoFilesError
+        puts exception.message
+        halt :no_files
+      when Errno::ENOENT
+        puts exception.message
+        halt :no_input
+      when NoSuchLinter
+        puts exception.message
+        halt :usage
+      else
+        puts exception.message
+        puts exception.backtrace
+        puts 'Report this bug at '.color(:yellow) + BUG_REPORT_URL.color(:cyan)
+        halt :software
+      end
+    end
+
+    def setup_configuration(options)
+      config =
+        if options[:config_file]
+          Config.load(options[:config_file])
+        elsif File.exist?(Config::FILE_NAME)
+          Config.load(Config::FILE_NAME)
+        else
+          Config.default
+        end
+
+      merge_options_with_config(options, config)
+    end
+
+    # @param options [Hash]
+    # @param config [Config]
+    # @return [Config]
+    def merge_options_with_config(options, config)
+      if options[:excluded_files]
+        options[:excluded_files].each do |file|
+          config.exclude_file(file)
+        end
+      end
+
+      if options[:included_linters]
+        config.disable_all_linters
+        LinterRegistry.extract_linters_from(options[:included_linters]).each do |linter|
+          config.enable_linter(linter)
+        end
+      end
+
+      if options[:excluded_linters]
+        LinterRegistry.extract_linters_from(options[:excluded_linters]).each do |linter|
+          config.disable_linter(linter)
+        end
+      end
+
+      config
+    end
+
+    # @param options [Hash]
+    # @param lints [Array<Lint>]
+    def report_lints(options, lints)
+      sorted_lints = lints.sort_by { |l| [l.filename, l.location] }
+      options.fetch(:reporters).each do |reporter, output|
+        results = reporter.new(sorted_lints).report_lints
+        io = (output == :stdout ? $stdout : File.new(output, 'w+'))
+        io.print results if results
+      end
+    end
+
+    def load_required_paths(options)
+      Array(options[:required_paths]).each do |path|
+        require path
+      end
+    rescue LoadError => ex
+      raise SCSSLint::Exceptions::RequiredLibraryMissingError,
+            "Required library not found: #{ex.message}"
+    end
+
+    def load_reporters(options)
+      options[:reporters].map! do |reporter_name, output_file|
+        begin
+          reporter = SCSSLint::Reporter.const_get(reporter_name + 'Reporter')
+        rescue NameError
+          raise SCSSLint::Exceptions::InvalidCLIOption,
+                "Invalid output format specified: #{reporter_name}"
+        end
+        [reporter, output_file]
+      end
+    end
+
+    def print_formatters
+      puts 'Installed formatters:'
+
+      reporter_names = SCSSLint::Reporter.descendants.map do |reporter|
+        reporter.name.split('::').last.split('Reporter').first
+      end
+
+      reporter_names.sort.each do |reporter_name|
+        puts " - #{reporter_name}"
+      end
+
+      halt
+    end
+
+    def print_linters
+      puts 'Installed linters:'
+
+      linter_names = LinterRegistry.linters.map do |linter|
+        linter.name.split('::').last
+      end
+
+      linter_names.sort.each do |linter_name|
+        puts " - #{linter_name}"
+      end
+
+      halt
+    end
+
+    # @param options [Hash]
+    def print_help(options)
+      puts options[:help]
+      halt :ok
+    end
+
+    # @param options [Hash]
+    def print_version
+      puts "scss-lint #{SCSSLint::VERSION}"
+      halt :ok
+    end
+
+    # Used for ease-of testing
+    # @param exit_status [Symbol]
+    def halt(exit_status = :ok)
+      EXIT_CODES[exit_status]
+    end
+  end
+end

data/lib/scss_lint/config.rb

@@ -0,0 +1,251 @@
+require 'yaml'
+
+module SCSSLint
+  # Loads and manages application configuration.
+  class Config
+    FILE_NAME = '.scss-lint.yml'
+    DEFAULT_FILE = File.join(SCSS_LINT_HOME, 'config', 'default.yml')
+
+    attr_reader :options, :warnings
+
+    class << self
+      def default
+        load(DEFAULT_FILE, merge_with_default: false)
+      end
+
+      # Loads a configuration from a file, merging it with the default
+      # configuration.
+      def load(file, options = {})
+        config_options = load_options_hash_from_file(file)
+
+        if options.fetch(:merge_with_default, true)
+          config_options = smart_merge(default_options_hash, config_options)
+        end
+
+        Config.new(config_options)
+      end
+
+      def linter_name(linter)
+        linter = linter.is_a?(Class) ? linter : linter.class
+        linter.name.split('::')[2..-1].join('::')
+      end
+
+    private
+
+      def default_options_hash
+        @default_options_hash ||= load_options_hash_from_file(DEFAULT_FILE)
+      end
+
+      # Recursively load config files, fetching files specified by `include`
+      # directives and merging the file's config with the files specified.
+      def load_options_hash_from_file(file)
+        file_contents = load_file_contents(file)
+
+        begin
+          options =
+            if yaml = YAML.load(file_contents)
+              yaml.to_hash
+            else
+              {}
+            end
+        rescue => ex
+          raise SCSSLint::Exceptions::InvalidConfiguration,
+                "Invalid configuration: #{ex.message}"
+        end
+
+        options = convert_single_options_to_arrays(options)
+        options = merge_wildcard_linter_options(options)
+        options = ensure_exclude_paths_are_absolute(options, file)
+        options = ensure_linter_exclude_paths_are_absolute(options, file)
+        options
+      end
+
+      # Convert any config options that accept a single value or an array to an
+      # array form so that merging works.
+      def convert_single_options_to_arrays(options)
+        options = options.dup
+
+        if options['exclude']
+          # Ensure exclude is an array, since we allow user to specify a single
+          # string.
+          options['exclude'] = [options['exclude']].flatten
+        end
+
+        options
+      end
+
+      # Merge options from wildcard linters into individual linter configs
+      def merge_wildcard_linter_options(options)
+        options = options.dup
+
+        options.fetch('linters', {}).keys.each do |class_name|
+          next unless class_name.include?('*')
+
+          wildcard_options = options['linters'].delete(class_name)
+          apply_options_to_matching_linters(class_name, options, wildcard_options)
+        end
+
+        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
+
+      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)
+        options = options.dup
+
+        options['linters'] ||= {}
+
+        options['linters'].keys.each do |linter_name|
+          options['linters'][linter_name] =
+            ensure_exclude_paths_are_absolute(options['linters'][linter_name], original_file)
+        end
+
+        options
+      end
+
+      # Ensure all excludes are absolute paths
+      def ensure_exclude_paths_are_absolute(options, original_file)
+        options = options.dup
+
+        if options['exclude']
+          excludes = [options['exclude']].flatten
+
+          options['exclude'] = excludes.map do |exclusion_glob|
+            if exclusion_glob.start_with?('/')
+              exclusion_glob
+            else
+              # Expand the path assuming it is relative to the config file itself
+              File.expand_path(exclusion_glob, File.expand_path(File.dirname(original_file)))
+            end
+          end
+        end
+
+        options
+      end
+
+      def path_relative_to_config(relative_include_path, base_config_path)
+        if relative_include_path.start_with?('/')
+          relative_include_path
+        else
+          path = File.join(File.dirname(base_config_path), relative_include_path)
+          # Remove double backslashes appearing in Windows paths.
+          path.gsub(%r{^//}, File::SEPARATOR)
+        end
+      end
+
+      # For easy stubbing in tests
+      def load_file_contents(file)
+        File.open(file, 'r').read
+      end
+
+      # Merge two hashes, concatenating lists and further merging nested hashes.
+      def smart_merge(parent, child)
+        parent.merge(child) do |_key, old, new|
+          case old
+          when Hash
+            smart_merge(old, new)
+          else
+            new
+          end
+        end
+      end
+    end
+
+    def initialize(options)
+      @options = options
+      @warnings = []
+
+      validate_linters
+    end
+
+    def enabled_linters
+      LinterRegistry.extract_linters_from(@options['linters'].keys).select do |linter|
+        linter_options(linter)['enabled']
+      end
+    end
+
+    def linter_enabled?(linter)
+      linter_options(linter)['enabled']
+    end
+
+    def enable_linter(linter)
+      linter_options(linter)['enabled'] = true
+    end
+
+    def disable_linter(linter)
+      linter_options(linter)['enabled'] = false
+    end
+
+    def disable_all_linters
+      @options['linters'].values.each do |linter_config|
+        linter_config['enabled'] = false
+      end
+    end
+
+    def linter_options(linter)
+      @options['linters'][self.class.linter_name(linter)]
+    end
+
+    def excluded_file?(file_path)
+      abs_path = File.expand_path(file_path)
+
+      @options.fetch('exclude', []).any? do |exclusion_glob|
+        File.fnmatch(exclusion_glob, abs_path)
+      end
+    end
+
+    def exclude_patterns
+      @options.fetch('exclude', [])
+    end
+
+    def excluded_file_for_linter?(file_path, linter)
+      abs_path = File.expand_path(file_path)
+
+      linter_options(linter).fetch('exclude', []).any? do |exclusion_glob|
+        File.fnmatch(exclusion_glob, abs_path)
+      end
+    end
+
+    def exclude_file(file_path)
+      abs_path = File.expand_path(file_path)
+
+      @options['exclude'] ||= []
+      @options['exclude'] << abs_path
+    end
+
+    # @return Array
+    def scss_files
+      if path = @options['scss_files']
+        Dir[path]
+      else
+        []
+      end
+    end
+
+  private
+
+    def validate_linters
+      return unless linters = @options['linters']
+
+      linters.keys.each do |name|
+        begin
+          Linter.const_get(name)
+        rescue NameError
+          @warnings << "Linter #{name} does not exist; ignoring"
+        end
+      end
+    end
+  end
+end