class Sass::Plugin::Compiler - sass-3.2.19 Documentation

# 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(options = {}) click to toggle source

Creates a new compiler.

@param options [{Symbol => Object}]

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

    # File lib/sass/plugin/compiler.rb, line 37
    def initialize(options = {})
      self.options.merge!(options)
    end

### Public Instance Methods

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 302
    def engine_options(additional_options = {})
      opts = options.merge(additional_options)
      opts[:load_paths] = load_paths(opts)
      opts
    end

on_updating_stylesheet(&block)
Also aliased as: on_updating_stylesheet_without_deprecation_warning
Alias for: on_updating_stylesheet_with_deprecation_warning
on_updating_stylesheet_with_deprecation_warning(&block) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 86
    def on_updating_stylesheet_with_deprecation_warning(&block)
      Sass::Util.sass_warn("Sass::Compiler#on_updating_stylesheet callback is deprecated and will be removed in a future release. Use Sass::Compiler#on_updated_stylesheet instead, which is run after stylesheet compilation.")
      on_updating_stylesheet_without_deprecation_warning(&block)
    end

Also aliased as: on_updating_stylesheet
on_updating_stylesheet_without_deprecation_warning(&block)
Alias for: on_updating_stylesheet
stylesheet_needs_update?(css_file, template_file) click to toggle source

Compass expects this to exist

    # File lib/sass/plugin/compiler.rb, line 309
    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)>]

    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.

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

      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 = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
          css = css_filename(name, css_location)
          individual_files << [file, css]
        end
      end

      run_updating_stylesheets individual_files

      individual_files.each do |file, css|
        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
          update_stylesheet(file, css)
        else
          run_not_updating_stylesheet(file, css)
        end
      end
    end

watch(individual_files = []) 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)>]

    A list of files to watch 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.

    # File lib/sass/plugin/compiler.rb, line 234
    def watch(individual_files = [])
      update_stylesheets(individual_files)

      load_listen!

      template_paths = template_locations # cache the locations
      individual_files_hash = individual_files.inject({}) do |h, files|
        parent = File.dirname(files.first)
        (h[parent] ||= []) << files unless template_paths.include?(parent)
        h
      end
      directories = template_paths + individual_files_hash.keys +
        [{:relative_paths => true}]

      # TODO: Keep better track of what depends on what
      # so we don't have to run a global update every time anything changes.
      listener = Listen::MultiListener.new(*directories) do |modified, added, removed|
        modified.each do |f|
          parent = File.dirname(f)
          if files = individual_files_hash[parent]
            next unless files.first == f
          else
            next unless f =~ /\.s[ac]ss$/
          end
          run_template_modified(f)
        end

        added.each do |f|
          parent = File.dirname(f)
          if files = individual_files_hash[parent]
            next unless files.first == f
          else
            next unless f =~ /\.s[ac]ss$/
          end
          run_template_created(f)
        end

        removed.each do |f|
          parent = File.dirname(f)
          if files = individual_files_hash[parent]
            next unless files.first == f
            try_delete_css files[1]
          else
            next unless f =~ /\.s[ac]ss$/
            try_delete_css f.gsub(/\.s[ac]ss$/, '.css')
          end
          run_template_deleted(f)
        end

        update_stylesheets(individual_files)
      end

      # The native windows listener is much slower than the polling
      # option, according to https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e#commitcomment-1295118
      listener.force_polling(true) if @options[:poll] || Sass::Util.windows?

      begin
        listener.start
      rescue Exception => e
        raise e unless e.is_a?(Interrupt)
      end
    end

### Private Instance Methods

css_filename(name, path) click to toggle source

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

css_locations() click to toggle source

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

load_listen!() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 315
    def load_listen!
      if defined?(gem)
        begin
          gem 'listen', '~> 0.7'
          require 'listen'
        rescue Gem::LoadError
          dir = Sass::Util.scope("vendor/listen/lib")
          $LOAD_PATH.unshift dir
          begin
            require 'listen'
          rescue LoadError => e
            e.message << "\n" <<
              if File.exists?(scope(".git"))
                'Run "git submodule update --init" to get the recommended version.'
              else
                'Run "gem install listen" to get it.'
              end
            raise e
          end
        end
      else
        begin
          require 'listen'
        rescue LoadError => e
          dir = Sass::Util.scope("vendor/listen/lib")
          if $LOAD_PATH.include?(dir)
            raise e unless File.exists?(scope(".git"))
            e.message << "\n" <<
              'Run "git submodule update --init" to get the recommended version.'
          else
            $LOAD_PATH.unshift dir
            retry
          end
        end
      end
    end

load_paths(opts = options) click to toggle source

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

template_locations() click to toggle source

    # File lib/sass/plugin/compiler.rb, line 394
    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 384
    def try_delete_css(css)
      return unless File.exists?(css)
      run_deleting_css css
      File.delete css
    end

update_stylesheet(filename, css) click to toggle source

    # File lib/sass/plugin/compiler.rb, line 352
    def update_stylesheet(filename, css)
      dir = File.dirname(css)
      unless File.exists?(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)
        result = Sass::Engine.for_file(filename, engine_opts).render
      rescue Exception => e
        compilation_error_occured = true
        run_compilation_error e, filename, css
        result = Sass::SyntaxError.exception_to_css(e, options)
      else
        run_updating_stylesheet filename, css
      end

      write_file(css, result)
      run_updated_stylesheet(filename, css) unless compilation_error_occured
    end

write_file(css, content) click to toggle source

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