class Sass::Exec::SassScss - sass-3.4.14 Documentation

# class Sass::Exec::SassScss

The `sass` and `scss` executables.

### Attributes

default_syntax[R]

### Public Class Methods

new(args, default_syntax) click to toggle source

@param args [Array<String>] The command-line arguments

Calls superclass method Sass::Exec::Base.new

    # File lib/sass/exec/sass_scss.rb, line 7
    def initialize(args, default_syntax)
      super(args)
      @options[:sourcemap] = :auto
      @options[:for_engine] = {
        :load_paths => default_sass_path
      }
      @default_syntax = default_syntax
    end

### Protected Instance Methods

process_result() click to toggle source

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

Calls superclass method Sass::Exec::Base#process_result

    # File lib/sass/exec/sass_scss.rb, line 37
    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
          @fake_update = true
          @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

      if @options[:sourcemap] != :none && @options[:output_filename]
        @options[:sourcemap_filename] = Sass::Util.sourcemap_name(@options[:output_filename])
      end

      @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]
      @options[:for_engine][:sourcemap] = @options[:sourcemap]

      run
    end

set_opts(opts) click to toggle source

Tells optparse how to parse the arguments.

@param opts [OptionParser]

    # File lib/sass/exec/sass_scss.rb, line 21
        def set_opts(opts)
          opts.banner = <<END
    Usage: #{default_syntax} [options] [INPUT] [OUTPUT]

    Description:
      Converts SCSS or Sass files to CSS.
    END

          common_options(opts)
          watching_and_updating(opts)
          input_and_output(opts)
          miscellaneous(opts)
        end

### Private Instance Methods

colon_path?(path) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 424
    def colon_path?(path)
      !split_colon_path(path)[1].nil?
    end

common_options(opts) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 68
    def common_options(opts)
      opts.separator ''
      opts.separator 'Common Options:'

      opts.on('-I', '--load-path PATH', 'Specify 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('--compass', 'Make Compass imports available and load project configuration.') do
        @options[:compass] = true
      end

      opts.on('-t', '--style NAME', 'Output style. Can be nested (default), compact, '                                      'compressed, or expanded.') do |name|
        @options[:for_engine][:style] = name.to_sym
      end

      opts.on("-?", "-h", "--help", "Show this help message.") do
        puts opts
        exit
      end

      opts.on("-v", "--version", "Print the Sass version.") do
        puts("Sass #{Sass.version[:string]}")
        exit
      end
    end

default_sass_path() click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 448
    def default_sass_path
      return unless ENV['SASS_PATH']
      # The select here prevents errors when the environment's
      # load paths specified do not exist.
      ENV['SASS_PATH'].split(File::PATH_SEPARATOR).select {|d| File.directory?(d)}
    end

input_and_output(opts) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 135
        def input_and_output(opts)
          opts.separator ''
          opts.separator 'Input and Output:'

          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 Sass syntax.') do
              @options[:for_engine][:syntax] = :sass
            end
          end

          # This is optional for backwards-compatibility with Sass 3.3, which didn't
          # enable sourcemaps by default and instead used "--sourcemap" to do so.
          opts.on(:OPTIONAL, '--sourcemap=TYPE',
              'How to link generated output to the source files.',
              '  auto (default): relative paths where possible, file URIs elsewhere',
              '  file: always absolute file URIs',
              '  inline: include the source text in the sourcemap',
              '  none: no sourcemaps') do |type|
            if type && !%w[auto file inline none].include?(type)
              $stderr.puts "Unknown sourcemap type #{type}.\n\n"
              $stderr.puts opts
              exit
            elsif type.nil?
              Sass::Util.sass_warn "DEPRECATION WARNING: Passing --sourcemap without a value is deprecated.
    Sourcemaps are now generated by default, so this flag has no effect.
    ".rstrip
            end

            @options[:sourcemap] = (type || :auto).to_sym
          end

          opts.on('-s', '--stdin', :NONE,
                  'Read input from standard input instead of an input file.',
                  'This is the default if no input file is specified.') do
            @options[:input] = $stdin
          end

          encoding_option(opts)

          opts.on('--unix-newlines', 'Use Unix-style newlines in written files.',
                                     ('Always true on Unix.' unless Sass::Util.windows?)) do
            @options[:unix_newlines] = true if Sass::Util.windows?
          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
        end

interactive() click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 254
    def interactive
      require 'sass/repl'
      Sass::Repl.new(@options).run
    end

load_compass() click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 236
    def load_compass
      begin
        require 'compass'
      rescue LoadError
        require 'rubygems'
        begin
          require 'compass'
        rescue LoadError
          puts "ERROR: Cannot load compass."
          exit 1
        end
      end
      Compass.add_project_configuration
      Compass.configuration.project_path ||= Dir.pwd
      @options[:for_engine][:load_paths] ||= []
      @options[:for_engine][:load_paths] += Compass.configuration.sass_load_paths
    end

miscellaneous(opts) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 197
    def miscellaneous(opts)
      opts.separator ''
      opts.separator 'Miscellaneous:'

      opts.on('-i', '--interactive',
              'Run an interactive SassScript shell.') do
        @options[:interactive] = true
      end

      opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
        require 'stringio'
        @options[:check_syntax] = true
        @options[:output] = StringIO.new
      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('--cache-location PATH',
              'The path to save parsed Sass files. Defaults to .sass-cache.') do |loc|
        @options[:for_engine][:cache_location] = loc
      end

      opts.on('-C', '--no-cache', "Don't cache parsed Sass files.") do
        @options[:for_engine][:cache] = false
      end

      opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error.') do
        @options[:trace] = true
      end

      opts.on('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
        @options[:for_engine][:quiet] = true
      end
    end

probably_dest_dir?(path) click to toggle source

Whether path is likely to be meant as the destination in a source:dest pair.

    # File lib/sass/exec/sass_scss.rb, line 442
    def probably_dest_dir?(path)
      return false unless path
      return false if colon_path?(path)
      Sass::Util.glob(File.join(path, "*.s[ca]ss")).empty?
    end

run() click to toggle source

@comment

    rubocop:enable MethodLength

    # File lib/sass/exec/sass_scss.rb, line 386
    def run
      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] != :none && @options[:sourcemap_filename]
        relative_sourcemap_path = Sass::Util.relative_path_from(
          @options[:sourcemap_filename], 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(
            :type => @options[:sourcemap],
            :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
      write_output(Sass::SyntaxError.exception_to_css(e), output) if output.is_a?(String)
      raise e
    ensure
      output.close if output.is_a? File
    end

split_colon_path(path) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 428
    def split_colon_path(path)
      one, two = path.split(':', 2)
      if one && two && Sass::Util.windows? &&
          one =~ /\A[A-Za-z]\Z/ && two =~ /\A[\/\]/
        # If we're on Windows and we were passed a drive letter path,
        # don't split on that colon.
        one2, two = two.split(':', 2)
        one = one + ':' + one2
      end
      return one, two
    end

watch_or_update() click to toggle source

@comment

    rubocop:disable MethodLength

    # File lib/sass/exec/sass_scss.rb, line 261
        def watch_or_update
          require 'sass/plugin'
          Sass::Plugin.options.merge! @options[:for_engine]
          Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
          Sass::Plugin.options[:poll] = @options[:poll]
          Sass::Plugin.options[:sourcemap] = @options[:sourcemap]

          if @options[:force]
            raise "The --force flag may only be used with --update." unless @options[:update]
            Sass::Plugin.options[:always_update] = true
          end

          raise "What files should I watch? Did you mean something like:
        #{@default_syntax} --watch input.#{@default_syntax}:output.css
        #{@default_syntax} --watch input-dir:output-dir
    " if @args.empty?

          if !colon_path?(@args[0]) && probably_dest_dir?(@args[1])
            flag = @options[:update] ? "--update" : "--watch"
            err =
              if !File.exist?(@args[1])
                "doesn't exist"
              elsif @args[1] =~ /\.css$/
                "is a CSS file"
              end
            raise "File #{@args[1]} #{err}.
        Did you mean: #{@default_syntax} #{flag} #{@args[0]}:#{@args[1]}
    " if err
          end

          # Watch the working directory for changes without adding it to the load
          # path. This preserves the pre-3.4 behavior when the working directory was
          # on the load path. We should remove this when we can look for directories
          # to watch by traversing the import graph.
          class << Sass::Plugin.compiler
            # We have to use a class var to make this visible to #watched_file? and
            # #watched_paths.
            # rubocop:disable ClassVars
            @@working_directory = Sass::Util.realpath('.').to_s
            # rubocop:ensable ClassVars

            def watched_file?(file)
              super(file) ||
                (file =~ /\.s[ac]ss$/ && file.start_with?(@@working_directory + File::SEPARATOR))
            end

            def watched_paths
              @watched_paths ||= super + [@@working_directory]
            end
          end

          dirs, files = @args.map {|name| split_colon_path(name)}.
            partition {|i, _| File.directory? i}

          if @fake_update && !dirs.empty?
            # Issue 1602.
            Sass::Util.sass_warn "DEPRECATION WARNING: Compiling directories without --update or --watch is
    deprecated and won't work in future versions of Sass. Instead use:
      #{@default_syntax} --update #{@args}
    ".strip
          end

          files.map! do |from, to|
            to ||= from.gsub(/\.[^.]*?$/, '.css')
            sourcemap = Sass::Util.sourcemap_name(to) if @options[:sourcemap]
            [from, to, sourcemap]
          end
          dirs.map! {|from, to| [from, to || from]}
          Sass::Plugin.options[:template_location] = dirs

          Sass::Plugin.on_updated_stylesheet do |_, css, sourcemap|
            [css, sourcemap].each do |file|
              next unless file
              puts_action :write, :green, file
            end
          end

          had_error = false
          Sass::Plugin.on_creating_directory {|dirname| puts_action :directory, :green, dirname}
          Sass::Plugin.on_deleting_css {|filename| puts_action :delete, :yellow, filename}
          Sass::Plugin.on_deleting_sourcemap {|filename| puts_action :delete, :yellow, filename}
          Sass::Plugin.on_compilation_error do |error, _, _|
            if error.is_a?(SystemCallError) && !@options[:stop_on_error]
              had_error = true
              puts_action :error, :red, error.message
              STDOUT.flush
              next
            end

            raise error unless error.is_a?(Sass::SyntaxError) && !@options[:stop_on_error]
            had_error = true
            puts_action :error, :red,
              "#{error.sass_filename} (Line #{error.sass_line}: #{error.message})"
            STDOUT.flush
          end

          if @options[:update]
            Sass::Plugin.update_stylesheets(files)
            exit 1 if had_error
            return
          end

          puts ">>> Sass is watching for changes. Press Ctrl-C to stop."

          Sass::Plugin.on_template_modified do |template|
            puts ">>> Change detected to: #{template}"
            STDOUT.flush
          end
          Sass::Plugin.on_template_created do |template|
            puts ">>> New template detected: #{template}"
            STDOUT.flush
          end
          Sass::Plugin.on_template_deleted do |template|
            puts ">>> Deleted template detected: #{template}"
            STDOUT.flush
          end

          Sass::Plugin.watch(files)
        end

watching_and_updating(opts) click to toggle source

    # File lib/sass/exec/sass_scss.rb, line 100
    def watching_and_updating(opts)
      opts.separator ''
      opts.separator 'Watching and Updating:'

      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

      # Polling is used by default on Windows.
      unless Sass::Util.windows?
        opts.on('--poll', 'Check for file changes manually, rather than relying on the OS.',
                          'Only meaningful for --watch.') do
          @options[:poll] = true
        end
      end

      opts.on('--update', 'Compile files or directories to CSS.',
                          'Locations are set like --watch.') do
        @options[:update] = true
      end

      opts.on('-f', '--force', 'Recompile every Sass file, even if the CSS file is newer.',
                               'Only meaningful for --update.') do
        @options[:force] = 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
    end