Class: Sass::Plugin::Compiler

### Home Classes Methods

### In Files

- lib/sass/plugin/compiler.rb

### Parent

Object

### Methods

- ::new
- #clean
- #engine_options
- #file_list
- #stylesheet_needs_update?
- #update_stylesheets
- #watch

### Included Modules

- Sass::Plugin::Configuration

### Class/Module Index

Quicksearch

- Sass
- Sass::BaseEnvironment
- Sass::CSS
- Sass::CacheStores
- Sass::CacheStores::Base
- Sass::CacheStores::Chain
- Sass::CacheStores::Filesystem
- Sass::CacheStores::Memory
- Sass::CacheStores::Null
- Sass::Callbacks
- Sass::Callbacks::InstanceMethods
- Sass::Engine
- Sass::Engine::Line
- Sass::Environment
- Sass::Exec
- Sass::Exec::Base
- Sass::Exec::SassConvert
- Sass::Exec::SassScss
- Sass::Exec::SassScss::Sass::Plugin.compiler
- Sass::Features
- Sass::Importers
- Sass::Importers::Base
- Sass::Importers::Filesystem
- Sass::Logger
- Sass::Logger::Base
- Sass::Logger::LogLevel
- Sass::Logger::LogLevel::ClassMethods
- Sass::Media
- Sass::Media::Query
- Sass::Media::QueryList
- Sass::Plugin
- Sass::Plugin::Compiler
- Sass::Plugin::Configuration
- Sass::Plugin::MerbBootLoader
- Sass::Plugin::Rack
- Sass::Plugin::StalenessChecker
- Sass::ReadOnlyEnvironment
- Sass::Repl
- Sass::SCSS
- Sass::SCSS::CssParser
- Sass::SCSS::Parser
- Sass::SCSS::RX
- Sass::SCSS::ScriptLexer
- Sass::SCSS::ScriptParser
- Sass::SCSS::StaticParser
- Sass::Script
- Sass::Script::CssLexer
- Sass::Script::CssParser
- Sass::Script::Functions
- Sass::Script::Functions::EvaluationContext
- Sass::Script::Lexer
- Sass::Script::Parser
- Sass::Script::Tree
- Sass::Script::Tree::Funcall
- Sass::Script::Tree::Interpolation
- Sass::Script::Tree::ListLiteral
- Sass::Script::Tree::Literal
- Sass::Script::Tree::MapLiteral
- Sass::Script::Tree::Node
- Sass::Script::Tree::Operation
- Sass::Script::Tree::Selector
- Sass::Script::Tree::StringInterpolation
- Sass::Script::Tree::UnaryOperation
- Sass::Script::Tree::Variable
- Sass::Script::Value
- Sass::Script::Value::ArgList
- Sass::Script::Value::Base
- Sass::Script::Value::Bool
- Sass::Script::Value::Color
- Sass::Script::Value::Helpers
- Sass::Script::Value::List
- Sass::Script::Value::Map
- Sass::Script::Value::Null
- Sass::Script::Value::Number
- Sass::Selector
- Sass::Selector::AbstractSequence
- Sass::Selector::Attribute
- Sass::Selector::Class
- Sass::Selector::CommaSequence
- Sass::Selector::Element
- Sass::Selector::Id
- Sass::Selector::Parent
- Sass::Selector::Placeholder
- Sass::Selector::Pseudo
- Sass::Selector::Sequence
- Sass::Selector::Simple
- Sass::Selector::SimpleSequence
- Sass::Selector::Universal
- Sass::SemiGlobalEnvironment
- Sass::Shared
- Sass::Source
- Sass::Source::Map
- Sass::Source::Map::Mapping
- Sass::Source::Position
- Sass::Source::Range
- Sass::Stack
- Sass::Stack::Frame
- Sass::Supports
- Sass::Supports::Condition
- Sass::Supports::Declaration
- Sass::Supports::Interpolation
- Sass::Supports::Negation
- Sass::Supports::Operator
- Sass::SyntaxError
- Sass::Tree
- Sass::Tree::AtRootNode
- Sass::Tree::CharsetNode
- Sass::Tree::CommentNode
- Sass::Tree::ContentNode
- Sass::Tree::CssImportNode
- Sass::Tree::DebugNode
- Sass::Tree::DirectiveNode
- Sass::Tree::EachNode
- Sass::Tree::ErrorNode
- Sass::Tree::ExtendNode
- Sass::Tree::ForNode
- Sass::Tree::FunctionNode
- Sass::Tree::IfNode
- Sass::Tree::ImportNode
- Sass::Tree::KeyframeRuleNode
- Sass::Tree::MediaNode
- Sass::Tree::MixinDefNode
- Sass::Tree::MixinNode
- Sass::Tree::Node
- Sass::Tree::PropNode
- Sass::Tree::ReturnNode
- Sass::Tree::RootNode
- Sass::Tree::RuleNode
- Sass::Tree::SupportsNode
- Sass::Tree::TraceNode
- Sass::Tree::VariableNode
- Sass::Tree::Visitors
- Sass::Tree::Visitors::Base
- Sass::Tree::Visitors::CheckNesting
- Sass::Tree::Visitors::Convert
- Sass::Tree::Visitors::Cssize
- Sass::Tree::Visitors::Cssize::Bubble
- Sass::Tree::Visitors::DeepCopy
- Sass::Tree::Visitors::Extend
- Sass::Tree::Visitors::Perform
- Sass::Tree::Visitors::SetOptions
- Sass::Tree::Visitors::ToCss
- Sass::Tree::WarnNode
- Sass::Tree::WhileNode
- Sass::UnitConversionError
- Sass::Util
- Sass::Util::CrossPlatformRandom
- Sass::Util::MultibyteStringScanner
- Sass::Util::NormalizedMap
- Sass::Util::SubsetMap
- Sass::Util::Test
- Sass::Version
- ActionController
- ActionController::Base
- Object
- OrderedHash

No matching classes.

# 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#sass_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 371
    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 346
    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 355
    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 = {}) 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 = {})
      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
        directories << File.dirname(source)
      end
      directories = remove_redundant_directories(directories)

      # A Listen version prior to 2.0 will write a test file to a directory to
      # see if a watcher supports watching that directory. That breaks horribly
      # on read-only directories, so we filter those out.
      unless Sass::Util.listen_geq_2?
        directories = directories.select {|d| File.directory?(d) && File.writable?(d)}
      end

      # 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.
      listener_args = directories +
                      Array(options[:additional_watch_paths]) +
                      [{:relative_paths => false}]

      # The native windows listener is much slower than the polling option, according to
      # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
      poll = @options[:poll] || Sass::Util.windows?
      if poll && Sass::Util.listen_geq_2?
        # In Listen 2.0.0 and on, :force_polling is an option. In earlier
        # versions, it's a method on the listener (called below).
        listener_args.last[:force_polling] = true
      end

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

      if poll && !Sass::Util.listen_geq_2?
        # In Listen 2.0.0 and on, :force_polling is an option (set above). In
        # earlier versions, it's a method on the listener.
        listener.force_polling(true)
      end

      listen_to(listener)
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.