# class Sass::Plugin::Compiler

The Compiler class handles compilation of multiple files and/or directories, including checking which CSS files are out-of-date and need to be updated and calling Sass to perform the compilation on those files.

{Sass::Plugin} uses this class to update stylesheets for a single application. Unlike {Sass::Plugin}, though, the Compiler class has no global state, and so multiple instances may be created and used independently.

If you need to compile a Sass string into CSS, please see the {Sass::Engine} class.

Unlike {Sass::Plugin}, this class doesn't keep track of whether or how many times a stylesheet should be updated. Therefore, the following `Sass::Plugin` options are ignored by the Compiler:

- `:never_update`

- `:always_check`

### Public Class Methods

new(opts = {}) click to toggle source

Creates a new compiler.

@param opts [{Symbol => Object}]

    See {file:SASS_REFERENCE.md#Options the Sass options documentation}.

    # File lib/sass/plugin/compiler.rb, line 35
    def initialize(opts = {})
      @watched_files = Set.new
      options.merge!(opts)
    end

### Public Instance Methods

clean(individual_files = []) click to toggle source

Remove all output files that would be created by calling #update_stylesheets, if they exist.

This method runs the deleting_css and deleting_sourcemap callbacks for the files that are deleted.

@param individual_files [Array<(String, String[, String])>]

    A list of files to check for updates
    **in addition to those specified by the
    {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
    The first string in each pair is the location of the Sass/SCSS file,
    the second is the location of the CSS file that it should be compiled to.
    The third string, if provided, is the location of the Sourcemap file.

    # File lib/sass/plugin/compiler.rb, line 362
    def clean(individual_files = [])
      file_list(individual_files).each do |(_, css_file, sourcemap_file)|
        if File.exist?(css_file)
          run_deleting_css css_file
          File.delete(css_file)
        end
        if sourcemap_file && File.exist?(sourcemap_file)
          run_deleting_sourcemap sourcemap_file
          File.delete(sourcemap_file)
        end
      end
      nil
    end

engine_options(additional_options = {}) click to toggle source

Non-destructively modifies {#options} so that default values are properly set, and returns the result.

@param additional_options [{Symbol => Object}] An options hash with which to merge {#options} @return [{Symbol => Object}] The modified options hash

    # File lib/sass/plugin/compiler.rb, line 337
    def engine_options(additional_options = {})
      opts = options.merge(additional_options)
      opts[:load_paths] = load_paths(opts)
      options[:sourcemap] = :auto if options[:sourcemap] == true
      options[:sourcemap] = :none if options[:sourcemap] == false
      opts
    end

file_list(individual_files = []) click to toggle source

Construct a list of files that might need to be compiled from the provided individual_files and the template_locations.

Note: this method does not cache the results as they can change across invocations when sass files are added or removed.

@param individual_files [Array<(String, String[, String])>]

    A list of files to check for updates
    **in addition to those specified by the
    {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
    The first string in each pair is the location of the Sass/SCSS file,
    the second is the location of the CSS file that it should be compiled to.
    The third string, if provided, is the location of the Sourcemap file.

@return [Array<(String, String, String)>]

    A list of [sass_file, css_file, sourcemap_file] tuples similar
    to what was passed in, but expanded to include the current state
    of the directories being updated.

    # File lib/sass/plugin/compiler.rb, line 240
    def file_list(individual_files = [])
      files = individual_files.map do |tuple|
        if engine_options[:sourcemap] == :none
          tuple[0..1]
        elsif tuple.size < 3
          [tuple[0], tuple[1], Sass::Util.sourcemap_name(tuple[1])]
        else
          tuple.dup
        end
      end

      template_location_array.each do |template_location, css_location|
        Sass::Util.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
          # Get the relative path to the file
          name = Sass::Util.relative_path_from(file, template_location).to_s
          css = css_filename(name, css_location)
          sourcemap = Sass::Util.sourcemap_name(css) unless engine_options[:sourcemap] == :none
          files << [file, css, sourcemap]
        end
      end
      files
    end

stylesheet_needs_update?(css_file, template_file) click to toggle source

Compass expects this to exist

    # File lib/sass/plugin/compiler.rb, line 346
    def stylesheet_needs_update?(css_file, template_file)
      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
    end

update_stylesheets(individual_files = []) click to toggle source

Updates out-of-date stylesheets.

Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`} to see if it's been modified more recently than the corresponding CSS file in {file:SASS_REFERENCE.md#css_location-option `:css_location`}. If it has, it updates the CSS file.

@param individual_files [Array<(String, String[, String])>]

    A list of files to check for updates
    **in addition to those specified by the
    {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
    The first string in each pair is the location of the Sass/SCSS file,
    the second is the location of the CSS file that it should be compiled to.
    The third string, if provided, is the location of the Sourcemap file.

    # File lib/sass/plugin/compiler.rb, line 201
    def update_stylesheets(individual_files = [])
      Sass::Plugin.checked_for_updates = true
      staleness_checker = StalenessChecker.new(engine_options)

      files = file_list(individual_files)
      run_updating_stylesheets(files)

      updated_stylesheets = []
      files.each do |file, css, sourcemap|
        # TODO: Does staleness_checker need to check the sourcemap file as well?
        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
          # XXX For consistency, this should return the sourcemap too, but it would
          # XXX be an API change.
          updated_stylesheets << [file, css]
          update_stylesheet(file, css, sourcemap)
        else
          run_not_updating_stylesheet(file, css, sourcemap)
        end
      end
      run_updated_stylesheets(updated_stylesheets)
    end

watch(individual_files = [], options = {}) { |modified, added, removed| ... } click to toggle source

Watches the template directory (or directories) and updates the CSS files whenever the related Sass/SCSS files change. `watch` never returns.

Whenever a change is detected to a Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}, the corresponding CSS file in {file:SASS_REFERENCE.md#css_location-option `:css_location`} will be recompiled. The CSS files of any Sass/SCSS files that import the changed file will also be recompiled.

Before the watching starts in earnest, `watch` calls {#update_stylesheets}.

Note that `watch` uses the [Listen](github.com/guard/listen) library to monitor the filesystem for changes. Listen isn't loaded until `watch` is run. The version of Listen distributed with Sass is loaded by default, but if another version has already been loaded that will be used instead.

@param individual_files [Array<(String, String[, String])>]

    A list of files to check for updates
    **in addition to those specified by the
    {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
    The first string in each pair is the location of the Sass/SCSS file,
    the second is the location of the CSS file that it should be compiled to.
    The third string, if provided, is the location of the Sourcemap file.

@param options [Hash] The options that control how watching works. @option options [Boolean] :skip_initial_update

    Don't do an initial update when starting the watcher when true

    # File lib/sass/plugin/compiler.rb, line 291
    def watch(individual_files = [], options = {})
      @inferred_directories = []
      options, individual_files = individual_files, [] if individual_files.is_a?(Hash)
      update_stylesheets(individual_files) unless options[:skip_initial_update]

      directories = watched_paths
      individual_files.each do |(source, _, _)|
        source = File.expand_path(source)
        @watched_files << Sass::Util.realpath(source).to_s
        @inferred_directories << File.dirname(source)
      end

      directories += @inferred_directories
      directories = remove_redundant_directories(directories)

      # TODO: Keep better track of what depends on what
      # so we don't have to run a global update every time anything changes.
      # XXX The :additional_watch_paths option exists for Compass to use until
      # a deprecated feature is removed. It may be removed without warning.
      directories += Array(options[:additional_watch_paths])

      options = {
        :relative_paths => false,
        # The native windows listener is much slower than the polling option, according to
        # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
        :force_polling => @options[:poll] || Sass::Util.windows?
      }

      listener = create_listener(*directories, options) do |modified, added, removed|
        on_file_changed(individual_files, modified, added, removed)
        yield(modified, added, removed) if block_given?
      end

      begin
        listener.start
        sleep
      rescue Interrupt
        # Squelch Interrupt for clean exit from Listen::Listener
      end
    end

### Private Instance Methods

child_of_directory?(parent, child) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 547
    def child_of_directory?(parent, child)
      parent_dir = parent.end_with?(File::SEPARATOR) ? parent : (parent + File::SEPARATOR)
      child.start_with?(parent_dir) || parent == child
    end

create_listener(*args, &block) click to toggle source

This is mocked out in compiler_test.rb.

    # File lib/sass/plugin/compiler.rb, line 379
    def create_listener(*args, &block)
      require 'sass-listen'
      SassListen.to(*args, &block)
    end

css_filename(name, path) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 536
    def css_filename(name, path)
      "#{path}#{File::SEPARATOR unless path.end_with?(File::SEPARATOR)}#{name}".
        gsub(/\.s[ac]ss$/, '.css')
    end

css_locations() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 532
    def css_locations
      template_location_array.to_a.map {|l| l.last}
    end

load_paths(opts = options) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 524
    def load_paths(opts = options)
      (opts[:load_paths] || []) + template_locations
    end

normalized_load_paths() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 519
    def normalized_load_paths
      @normalized_load_paths ||=
        Sass::Engine.normalize_options(:load_paths => load_paths)[:load_paths]
    end

on_file_changed(individual_files, modified, added, removed) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 400
    def on_file_changed(individual_files, modified, added, removed)
      recompile_required = false

      modified.uniq.each do |f|
        next unless watched_file?(f)
        recompile_required = true
        run_template_modified(relative_to_pwd(f))
      end

      added.uniq.each do |f|
        next unless watched_file?(f)
        recompile_required = true
        run_template_created(relative_to_pwd(f))
      end

      removed.uniq.each do |f|
        next unless watched_file?(f)
        run_template_deleted(relative_to_pwd(f))
        if (files = individual_files.find {|(source, _, _)| File.expand_path(source) == f})
          recompile_required = true
          # This was a file we were watching explicitly and compiling to a particular location.
          # Delete the corresponding file.
          try_delete_css files[1]
        else
          next unless watched_file?(f)
          recompile_required = true
          # Look for the sass directory that contained the sass file
          # And try to remove the css file that corresponds to it
          template_location_array.each do |(sass_dir, css_dir)|
            sass_dir = File.expand_path(sass_dir)
            next unless child_of_directory?(sass_dir, f)
            remainder = f[(sass_dir.size + 1)..-1]
            try_delete_css(css_filename(remainder, css_dir))
            break
          end
        end
      end

      return unless recompile_required

      # In case a file we're watching is removed and then recreated we
      # prune out the non-existant files here.
      watched_files_remaining = individual_files.select {|(source, _, _)| File.exist?(source)}
      update_stylesheets(watched_files_remaining)
    end

relative_to_pwd(f) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 541
    def relative_to_pwd(f)
      Sass::Util.relative_path_from(f, Dir.pwd).to_s
    rescue ArgumentError # when a relative path cannot be computed
      f
    end

remove_redundant_directories(directories) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 384
    def remove_redundant_directories(directories)
      dedupped = []
      directories.each do |new_directory|
        # no need to add a directory that is already watched.
        next if dedupped.any? do |existing_directory|
          child_of_directory?(existing_directory, new_directory)
        end
        # get rid of any sub directories of this new directory
        dedupped.reject! do |existing_directory|
          child_of_directory?(new_directory, existing_directory)
        end
        dedupped << new_directory
      end
      dedupped
    end

sass_file_in_directory?(directory, filename) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 511
    def sass_file_in_directory?(directory, filename)
      filename =~ /\.s[ac]ss$/ && filename.start_with?(directory + File::SEPARATOR)
    end

template_locations() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 528
    def template_locations
      template_location_array.to_a.map {|l| l.first}
    end

try_delete_css(css) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 492
    def try_delete_css(css)
      if File.exist?(css)
        run_deleting_css css
        File.delete css
      end
      map = Sass::Util.sourcemap_name(css)

      return unless File.exist?(map)

      run_deleting_sourcemap map
      File.delete map
    end

update_stylesheet(filename, css, sourcemap) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 446
    def update_stylesheet(filename, css, sourcemap)
      dir = File.dirname(css)
      unless File.exist?(dir)
        run_creating_directory dir
        FileUtils.mkdir_p dir
      end

      begin
        File.read(filename) unless File.readable?(filename) # triggers an error for handling
        engine_opts = engine_options(:css_filename => css,
                                     :filename => filename,
                                     :sourcemap_filename => sourcemap)
        mapping = nil
        run_compilation_starting(filename, css, sourcemap)
        engine = Sass::Engine.for_file(filename, engine_opts)
        if sourcemap
          rendered, mapping = engine.render_with_sourcemap(File.basename(sourcemap))
        else
          rendered = engine.render
        end
      rescue StandardError => e
        compilation_error_occurred = true
        run_compilation_error e, filename, css, sourcemap
        raise e unless options[:full_exception]
        rendered = Sass::SyntaxError.exception_to_css(e, options[:line] || 1)
      end

      write_file(css, rendered)
      if mapping
        write_file(
          sourcemap,
          mapping.to_json(
            :css_path => css, :sourcemap_path => sourcemap, :type => options[:sourcemap]))
      end
      run_updated_stylesheet(filename, css, sourcemap) unless compilation_error_occurred
    end

watched_file?(file) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 505
    def watched_file?(file)
      @watched_files.include?(file) ||
        normalized_load_paths.any? {|lp| lp.watched_file?(file)} ||
        @inferred_directories.any? {|d| sass_file_in_directory?(d, file)}
    end

watched_paths() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 515
    def watched_paths
      @watched_paths ||= normalized_load_paths.map {|lp| lp.directories_to_watch}.compact.flatten
    end

write_file(fileName, content) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 483
    def write_file(fileName, content)
      flag = 'w'
      flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
      File.open(fileName, flag) do |file|
        file.set_encoding(content.encoding)
        file.print(content)
      end
    end