Class: Sass::Exec::Sass

Inherits:

Generic

• Object
• Generic
• Sass::Exec::Sass

Defined in:

lib/sass/exec.rb

Overview

The sass executable.

Direct Known Subclasses

Scss

Constant Summary

Constants inherited from Generic

Generic::COLORS

Instance Attribute Summary

• #default_syntax readonly

  Returns the value of attribute default_syntax.

Instance Method Summary

• #initialize(args) ⇒ Sass constructor

  A new instance of Sass.

• #process_result protected

  Processes the options set by the command-line arguments, and runs the Sass compiler appropriately.

• #set_opts(opts) protected

  Tells optparse how to parse the arguments.

Methods inherited from Generic

#color, #get_line, #parse, #parse!, #puts, #puts_action, #to_s, #write_output

Constructor Details

#initialize(args) ⇒ Sass

Returns a new instance of Sass.

Parameters:

• args (Array<String>) —

  The command-line arguments

# File 'lib/sass/exec.rb', line 205

def initialize(args)
  super
  @options[:for_engine] = {
    :load_paths => default_sass_path
  }
  @default_syntax = :sass
end

Instance Attribute Details

#default_syntax (readonly)

Returns the value of attribute default_syntax.

# File 'lib/sass/exec.rb', line 202

def default_syntax
  @default_syntax
end

Instance Method Details

#process_result (protected)

Processes the options set by the command-line arguments, and runs the Sass compiler appropriately.

# File 'lib/sass/exec.rb', line 333

def process_result
  require 'sass'

  if !@options[:update] && !@options[:watch] &&
      @args.first && colon_path?(@args.first)
    if @args.size == 1
      @args = split_colon_path(@args.first)
    else
      @options[:update] = true
    end
  end
  load_compass if @options[:compass]
  return interactive if @options[:interactive]
  return watch_or_update if @options[:watch] || @options[:update]
  super
  @options[:for_engine][:filename] = @options[:filename]
  @options[:for_engine][:css_filename] = @options[:output] if @options[:output].is_a?(String)
  @options[:for_engine][:sourcemap_filename] = @options[:sourcemap_filename]

  begin
    input = @options[:input]
    output = @options[:output]

    @options[:for_engine][:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
    @options[:for_engine][:syntax] ||= @default_syntax
    engine =
      if input.is_a?(File) && !@options[:check_syntax]
        ::Sass::Engine.for_file(input.path, @options[:for_engine])
      else
        # We don't need to do any special handling of @options[:check_syntax] here,
        # because the Sass syntax checking happens alongside evaluation
        # and evaluation doesn't actually evaluate any code anyway.
        ::Sass::Engine.new(input.read, @options[:for_engine])
      end

    input.close if input.is_a?(File)

    if @options[:sourcemap]
      unless @options[:sourcemap_filename]
        raise "Can't generate a sourcemap for an input without a path."
      end

      relative_sourcemap_path = ::Sass::Util.pathname(@options[:sourcemap_filename]).
        relative_path_from(::Sass::Util.pathname(@options[:output_filename]).dirname)
      rendered, mapping = engine.render_with_sourcemap(relative_sourcemap_path.to_s)
      write_output(rendered, output)
      write_output(mapping.to_json(
          :css_path => @options[:output_filename],
          :sourcemap_path => @options[:sourcemap_filename]) + "\n",
        @options[:sourcemap_filename])
    else
      write_output(engine.render, output)
    end
  rescue ::Sass::SyntaxError => e
    raise e if @options[:trace]
    raise e.sass_backtrace_str("standard input")
  ensure
    output.close if output.is_a? File
  end
end

#set_opts(opts) (protected)

Tells optparse how to parse the arguments.

Parameters:

• opts (OptionParser)

# File 'lib/sass/exec.rb', line 220

def set_opts(opts)
  super

  opts.banner = <<END
Usage: #{default_syntax} [options] [INPUT] [OUTPUT]

Description:
  Converts SCSS or Sass files to CSS.

Options:
END

  if @default_syntax == :sass
    opts.on('--scss',
            'Use the CSS-superset SCSS syntax.') do
      @options[:for_engine][:syntax] = :scss
    end
  else
    opts.on('--sass',
            'Use the Indented syntax.') do
      @options[:for_engine][:syntax] = :sass
    end
  end
  opts.on('--watch', 'Watch files or directories for changes.',
                     'The location of the generated CSS can be set using a colon:',
                     "  #{@default_syntax} --watch input.#{@default_syntax}:output.css",
                     "  #{@default_syntax} --watch input-dir:output-dir") do
    @options[:watch] = true
  end
  opts.on('--update', 'Compile files or directories to CSS.',
                      'Locations are set like --watch.') do
    @options[:update] = true
  end
  opts.on('--stop-on-error', 'If a file fails to compile, exit immediately.',
                             'Only meaningful for --watch and --update.') do
    @options[:stop_on_error] = true
  end
  opts.on('--poll', 'Check for file changes manually, rather than relying on the OS.',
                    'Only meaningful for --watch.') do
    @options[:poll] = true
  end
  opts.on('-f', '--force', 'Recompile all Sass files, even if the CSS file is newer.',
                           'Only meaningful for --update.') do
    @options[:force] = true
  end
  opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
    require 'stringio'
    @options[:check_syntax] = true
    @options[:output] = StringIO.new
  end
  style_desc = 'Output style. Can be nested (default), compact, compressed, or expanded.'
  opts.on('-t', '--style NAME', style_desc) do |name|
    @options[:for_engine][:style] = name.to_sym
  end
  opts.on('--precision NUMBER_OF_DIGITS', Integer,
          "How many digits of precision to use when outputting decimal numbers." +
          "Defaults to #{::Sass::Script::Value::Number.precision}.") do |precision|
    ::Sass::Script::Value::Number.precision = precision
  end
  opts.on('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
    @options[:for_engine][:quiet] = true
  end
  opts.on('--compass', 'Make Compass imports available and load project configuration.') do
    @options[:compass] = true
  end
  opts.on('-g', '--debug-info',
          'Emit output that can be used by the FireSass Firebug plugin.') do
    @options[:for_engine][:debug_info] = true
  end
  opts.on('-l', '--line-numbers', '--line-comments',
          'Emit comments in the generated CSS indicating the corresponding source line.') do
    @options[:for_engine][:line_numbers] = true
  end
  opts.on('-i', '--interactive',
          'Run an interactive SassScript shell.') do
    @options[:interactive] = true
  end
  opts.on('-I', '--load-path PATH', 'Add a sass import path.') do |path|
    @options[:for_engine][:load_paths] << path
  end
  opts.on('-r', '--require LIB', 'Require a Ruby library before running Sass.') do |lib|
    require lib
  end
  opts.on('--cache-location PATH',
          'The path to put cached Sass files. Defaults to .sass-cache.') do |loc|
    @options[:for_engine][:cache_location] = loc
  end
  opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
    @options[:for_engine][:cache] = false
  end
  opts.on('--sourcemap', 'Create sourcemap files next to the generated CSS files.') do
    @options[:sourcemap] = true
  end

  encoding_desc = if ::Sass::Util.ruby1_8?
                    'Does not work in ruby 1.8.'
                  else
                    'Specify the default encoding for Sass files.'
                  end
  opts.on('-E', '--default-encoding ENCODING', encoding_desc) do |encoding|
    if ::Sass::Util.ruby1_8?
      $stderr.puts "Specifying the encoding is not supported in ruby 1.8."
      exit 1
    else
      Encoding.default_external = encoding
    end
  end
end