sass 3.3.14 → 3.4.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 503f195bf2c3fc4bac4decaf569d625239681016
-  data.tar.gz: d00a8da887a958af2fb5a985cb29b8bf23e9cc12
+  metadata.gz: 86dadd4faf8e93f96f022369b902622f225c18c8
+  data.tar.gz: da7eab9db6a3ae2c4bb925c5712ed1e6e56aa135
 SHA512:
-  metadata.gz: 89e6b4e3fd304bdf2c9078b8e331b026cb0e74b1dfc07f1b6b4a4e08d2408301ad2c170eb72d91af9bd0ba9979e2b863b975904b2a15d6b221aa5ffe87374f69
-  data.tar.gz: fd12d1fbfc85b9e5e15b2683873e935dd38117e101f8f74402228c0238f3f60b9672c4bba8d6ce0761b167171fc799548dc53623b2f7b9296f5588a2a7bb49c9
+  metadata.gz: bf8198a80fd2741f7692e61345a96feb2013084f9c72633a69d6d4aa678fa816f779e09e1cbc604f6b7323cee7bbf1fb98da1b5d7e4d5a5d900ae2b428d38da2
+  data.tar.gz: 64a53c27f497151504a188189e70369e1bb57207b7d6f2a3e04b94aa6fc36b29f66ed9151bc8ce175f90bc1b0e893ee7f81dc63d68c4feb6334136649c5cf9f5

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2014 Hampton Catlin, Natalie Weizenbaum, and Chris Eppstein
+Copyright (c) 2006-2013 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -199,11 +199,11 @@ and now occasionally consults on the language issues. Hampton lives in San
 Francisco, California and works as VP of Technology
 at [Moovweb](http://www.moovweb.com/).
 
-[Natalie Weizenbaum](http://nex-3.com) is the primary developer and architect of
-Sass. Her hard work has kept the project alive by endlessly answering forum
+[Nathan Weizenbaum](http://nex-3.com) is the primary developer and architect of
+Sass. His hard work has kept the project alive by endlessly answering forum
 posts, fixing bugs, refactoring, finding speed improvements, writing
 documentation, implementing new features, and getting Hampton coffee (a fitting
-task for a girl genius). Natalie lives in Seattle, Washington and works on
+task for a boy-genius). Nathan lives in Seattle, Washington and works on
 [Dart](http://dartlang.org) application libraries at Google.
 
 [Chris Eppstein](http://acts-as-architect.blogspot.com) is a core contributor to
@@ -214,8 +214,8 @@ his wife and daughter. He is an Engineer for
 [LinkedIn.com](http://linkedin.com), where one of his responsibilities is to
 maintain Sass & Compass.
 
-If you use this software, you must pay Hampton a compliment. And buy Natalie
-some candy. Maybe pet a kitten. Yeah. Pet that kitty.
+If you use this software, you must pay Hampton a compliment. And
+buy Nathan some jelly beans. Maybe pet a kitten. Yeah. Pet that kitty.
 
 Beyond that, the implementation is licensed under the MIT License.
 Okay, fine, I guess that means compliments aren't __required__.

data/VERSION

@@ -1 +1 @@
-3.3.14
+3.4.0.rc.1

data/VERSION_DATE

@@ -1 +1 @@
-02 August 2014 01:35:06 UTC
+12 July 2014 01:42:30 UTC

data/VERSION_NAME

@@ -1 +1 @@
-Maptastic Maple
+Selective Steve

data/bin/sass

@@ -9,5 +9,5 @@ rescue LoadError
 end
 require 'sass/exec'
 
-opts = Sass::Exec::Sass.new(ARGV)
+opts = Sass::Exec::SassScss.new(ARGV, :sass)
 opts.parse!

data/bin/scss

@@ -9,5 +9,5 @@ rescue LoadError
 end
 require 'sass/exec'
 
-opts = Sass::Exec::Scss.new(ARGV)
+opts = Sass::Exec::SassScss.new(ARGV, :scss)
 opts.parse!

data/lib/sass.rb

@@ -1,11 +1,6 @@
 dir = File.dirname(__FILE__)
 $LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
 
-# This is necessary to set so that the Haml code that tries to load Sass
-# knows that Sass is indeed loading,
-# even if there's some crazy autoload stuff going on.
-SASS_BEGUN_TO_LOAD = true unless defined?(SASS_BEGUN_TO_LOAD)
-
 require 'sass/version'
 
 # The module that contains everything Sass-related:

data/lib/sass/css.rb

@@ -67,9 +67,7 @@ module Sass
     def check_encoding!
       return if @checked_encoding
       @checked_encoding = true
-      @template, @original_encoding = Sass::Util.check_sass_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
+      @template, @original_encoding = Sass::Util.check_sass_encoding(@template)
     end
 
     # Parses the CSS template and applies various transformations

data/lib/sass/engine.rb

@@ -30,6 +30,8 @@ require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
 require 'sass/tree/charset_node'
 require 'sass/tree/at_root_node'
+require 'sass/tree/keyframe_rule_node'
+require 'sass/tree/error_node'
 require 'sass/tree/visitors/base'
 require 'sass/tree/visitors/perform'
 require 'sass/tree/visitors/cssize'
@@ -190,22 +192,13 @@ module Sass
         options[:filesystem_importer].new(p.to_s)
       end
 
-      # Remove any deprecated importers if the location is imported explicitly
-      options[:load_paths].reject! do |importer|
-        importer.is_a?(Sass::Importers::DeprecatedPath) &&
-          options[:load_paths].find do |other_importer|
-            other_importer.is_a?(Sass::Importers::Filesystem) &&
-              other_importer != importer &&
-              other_importer.root == importer.root
-          end
-      end
-
       # Backwards compatibility
       options[:property_syntax] ||= options[:attribute_syntax]
       case options[:property_syntax]
       when :alternate; options[:property_syntax] = :new
       when :normal; options[:property_syntax] = :old
       end
+      options[:sourcemap] = :auto if options[:sourcemap] == true
 
       options
     end
@@ -271,8 +264,8 @@ module Sass
     #   cannot be converted to UTF-8
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def render
-      return encode_and_set_charset(_to_tree.render) unless @options[:quiet]
-      Sass::Util.silence_sass_warnings {encode_and_set_charset(_to_tree.render)}
+      return _to_tree.render unless @options[:quiet]
+      Sass::Util.silence_sass_warnings {_to_tree.render}
     end
 
     # Render the template to CSS and return the source map.
@@ -315,7 +308,7 @@ module Sass
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
     def source_encoding
       check_encoding!
-      @original_encoding
+      @source_encoding
     end
 
     # Gets a set of all the documents
@@ -360,7 +353,10 @@ Error generating source map: couldn't determine public URL for "#{filename}".
   Without a public URL, there's nothing for the source map to link to.
   An importer was not set for this file.
 ERR
-      elsif Sass::Util.silence_warnings {importer.public_url(filename, sourcemap_dir).nil?}
+      elsif Sass::Util.silence_warnings do
+              sourcemap_dir = nil if @options[:sourcemap] == :file
+              importer.public_url(filename, sourcemap_dir).nil?
+            end
         raise Sass::SyntaxError.new(<<ERR)
 Error generating source map: couldn't determine public URL for "#{filename}".
   Without a public URL, there's nothing for the source map to link to.
@@ -375,23 +371,12 @@ ERR
       rendered << "/*# sourceMappingURL="
       rendered << Sass::Util.escape_uri(sourcemap_uri)
       rendered << " */\n"
-      rendered = encode_and_set_charset(rendered)
       return rendered, sourcemap
     end
 
-    def encode_and_set_charset(rendered)
-      return rendered if Sass::Util.ruby1_8?
-      begin
-        # Try to convert the result to the original encoding,
-        # but if that doesn't work fall back on UTF-8
-        rendered = rendered.encode(source_encoding)
-      rescue EncodingError
-      end
-      rendered.gsub(Regexp.new('\A@charset "(.*?)"'.encode(source_encoding)),
-        "@charset \"#{source_encoding.name}\"".encode(source_encoding))
-    end
-
     def _to_tree
+      check_encoding!
+
       if (@options[:cache] || @options[:read_cache]) &&
           @options[:filename] && @options[:importer]
         key = sassc_key
@@ -403,8 +388,6 @@ ERR
         end
       end
 
-      check_encoding!
-
       if @options[:syntax] == :scss
         root = Sass::SCSS::Parser.new(@template, @options[:filename], @options[:importer]).parse
       else
@@ -436,9 +419,7 @@ ERR
     def check_encoding!
       return if @checked_encoding
       @checked_encoding = true
-      @template, @original_encoding = Sass::Util.check_sass_encoding(@template) do |msg, line|
-        raise Sass::SyntaxError.new(msg, :line => line)
-      end
+      @template, @source_encoding = Sass::Util.check_sass_encoding(@template)
     end
 
     def tabulate(string)
@@ -446,7 +427,7 @@ ERR
       comment_tab_str = nil
       first = true
       lines = []
-      string.gsub(/\r\n|\r|\n/, "\n").scan(/^[^\n]*?$/).each_with_index do |line, index|
+      string.scan(/^[^\n]*?$/).each_with_index do |line, index|
         index += (@options[:line] || 1)
         if line.strip.empty?
           lines.last.text << "\n" if lines.last && lines.last.comment?
@@ -792,7 +773,7 @@ WARNING
 
     DIRECTIVES = Set[:mixin, :include, :function, :return, :debug, :warn, :for,
       :each, :while, :if, :else, :extend, :import, :media, :charset, :content,
-      :at_root]
+      :at_root, :error]
 
     # @comment
     #   rubocop:disable MethodLength
@@ -834,6 +815,14 @@ WARNING
       Tree::DebugNode.new(parse_script(value, :offset => offset))
     end
 
+    def parse_error_directive(parent, line, root, value, offset)
+      raise SyntaxError.new("Invalid error directive '@error': expected expression.") unless value
+      raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath error directives.",
+        :line => @line + 1) unless line.children.empty?
+      offset = line.offset + line.text.index(value).to_i
+      Tree::ErrorNode.new(parse_script(value, :offset => offset))
+    end
+
     def parse_extend_directive(parent, line, root, value, offset)
       raise SyntaxError.new("Invalid extend directive '@extend': expected expression.") unless value
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath extend directives.",
@@ -1027,7 +1016,7 @@ WARNING
         return node
       end
 
-      unless (str = scanner.scan(Sass::SCSS::RX::STRING))
+      unless (quoted_val = scanner.scan(Sass::SCSS::RX::STRING))
         scanned = scanner.scan(/[^,;]+/)
         node = Tree::ImportNode.new(scanned)
         start_parser_offset = to_parser_offset(offset)
@@ -1039,21 +1028,21 @@ WARNING
       end
 
       start_offset = offset
-      offset += str.length
-      val = scanner[1] || scanner[2]
+      offset += scanner.matched.length
+      val = Sass::Script::Value::String.value(scanner[1] || scanner[2])
       scanned = scanner.scan(/\s*/)
       if !scanner.match?(/[,;]|$/)
         offset += scanned.length if scanned
         media_parser = Sass::SCSS::Parser.new(scanner,
           @options[:filename], @options[:importer], @line, offset)
         media = media_parser.parse_media_query_list
-        node = Tree::CssImportNode.new(str || uri, media.to_a)
+        node = Tree::CssImportNode.new(quoted_val, media.to_a)
         node.source_range = Sass::Source::Range.new(
           Sass::Source::Position.new(@line, to_parser_offset(start_offset)),
           Sass::Source::Position.new(@line, media_parser.offset),
           @options[:filename], @options[:importer])
       elsif val =~ %r{^(https?:)?//}
-        node = Tree::CssImportNode.new("url(#{val})")
+        node = Tree::CssImportNode.new(quoted_val)
         node.source_range = Sass::Source::Range.new(
           Sass::Source::Position.new(@line, to_parser_offset(start_offset)),
           Sass::Source::Position.new(@line, to_parser_offset(offset)),

data/lib/sass/environment.rb

@@ -41,7 +41,7 @@ module Sass
             if @#{name}s.include?(name)
               @#{name}s[name] = value
               true
-            elsif @parent
+            elsif @parent && !@parent.global?
               @parent.try_set_#{name}(name, value)
             else
               false
@@ -53,6 +53,10 @@ module Sass
             @#{name}s ||= {}
             @#{name}s[name.tr('_', '-')] = value
           end
+
+          def set_global_#{name}(name, value)
+            global_env.set_#{name}(name, value)
+          end
         RUBY
       end
     end
@@ -76,19 +80,6 @@ module Sass
     # Sass::Callable
     inherited_hash_reader :function
 
-    # Whether a warning has been emitted for assigning to the given
-    # global variable. This is a set of tuples containing the name of
-    # the variable, its filename, and its line number.
-    #
-    # @return [Set<[String, String, int]>]
-    attr_reader :global_warning_given
-
-    # Whether a warning has been emitted for misusing a deprecated false value.
-    # This is a set of tuples containing the filename and its line number.
-    #
-    # @return [Set<[String, int]>]
-    attr_reader :deprecated_false_warning_given
-
     # @param options [{Symbol => Object}] The options hash. See
     #   {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
     # @param parent [Environment] See \{#parent}
@@ -96,8 +87,13 @@ module Sass
       @parent = parent
       @options = options || (parent && parent.options) || {}
       @stack = Sass::Stack.new if @parent.nil?
-      @global_warning_given = Set.new
-      @deprecated_false_warning_given = Set.new
+    end
+
+    # Returns whether this is the global environment.
+    #
+    # @return [Boolean]
+    def global?
+      @parent.nil?
     end
 
     # The environment of the caller of this environment's mixin or function.
@@ -128,7 +124,7 @@ module Sass
     #
     # @return [Environment]
     def global_env
-      @global_env ||= @parent.nil? ? self : @parent.global_env
+      @global_env ||= global? ? self : @parent.global_env
     end
 
     # The import/mixin stack.

data/lib/sass/error.rb

@@ -140,8 +140,8 @@ module Sass
     def sass_backtrace_str(default_filename = "an unknown file")
       lines = message.split("\n")
       msg = lines[0] + lines[1..-1].
-        map {|l| "\n" + (" " * "Syntax error: ".size) + l}.join
-      "Syntax error: #{msg}" +
+        map {|l| "\n" + (" " * "Error: ".size) + l}.join
+      "Error: #{msg}" +
         Sass::Util.enum_with_index(sass_backtrace).map do |entry, i|
           "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
             " of #{entry[:filename] || default_filename}" +
@@ -153,15 +153,13 @@ module Sass
       # Returns an error report for an exception in CSS format.
       #
       # @param e [Exception]
-      # @param options [{Symbol => Object}] The options passed to {Sass::Engine#initialize}
+      # @param line_offset [Fixnum] The number of the first line of the Sass template.
       # @return [String] The error report
       # @raise [Exception] `e`, if the
       #   {file:SASS_REFERENCE.md#full_exception-option `:full_exception`} option
       #   is set to false.
-      def exception_to_css(e, options)
-        raise e unless options[:full_exception]
-
-        header = header_string(e, options)
+      def exception_to_css(e, line_offset = 1)
+        header = header_string(e, line_offset)
 
         <<END
 /*
@@ -178,12 +176,11 @@ END
 
       private
 
-      def header_string(e, options)
+      def header_string(e, line_offset)
         unless e.is_a?(Sass::SyntaxError) && e.sass_line && e.sass_template
           return "#{e.class}: #{e.message}"
         end
 
-        line_offset = options[:line] || 1
         line_num = e.sass_line + 1 - line_offset
         min = [line_num - 6, 0].max
         section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]

data/lib/sass/exec.rb

@@ -1,775 +1,9 @@
-require 'optparse'
-require 'fileutils'
-
 module Sass
-  # This module handles the various Sass executables (`sass` and `sass-convert`).
+  # This module handles the Sass executables (`sass` and `sass-convert`).
   module Exec
-    # An abstract class that encapsulates the executable code for all three executables.
-    class Generic
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        @args = args
-        @options = {}
-      end
-
-      # Parses the command-line arguments and runs the executable.
-      # Calls `Kernel#exit` at the end, so it never returns.
-      #
-      # @see #parse
-      def parse!
-        # rubocop:disable RescueException
-        begin
-          parse
-        rescue Exception => e
-          raise e if @options[:trace] || e.is_a?(SystemExit)
-
-          $stderr.print "#{e.class}: " unless e.class == RuntimeError
-          $stderr.puts "#{e.message}"
-          $stderr.puts "  Use --trace for backtrace."
-          exit 1
-        end
-        exit 0
-        # rubocop:enable RescueException
-      end
-
-      # Parses the command-line arguments and runs the executable.
-      # This does not handle exceptions or exit the program.
-      #
-      # @see #parse!
-      def parse
-        @opts = OptionParser.new(&method(:set_opts))
-        @opts.parse!(@args)
-
-        process_result
-
-        @options
-      end
-
-      # @return [String] A description of the executable
-      def to_s
-        @opts.to_s
-      end
-
-      protected
-
-      # Finds the line of the source template
-      # on which an exception was raised.
-      #
-      # @param exception [Exception] The exception
-      # @return [String] The line number
-      def get_line(exception)
-        # SyntaxErrors have weird line reporting
-        # when there's trailing whitespace
-        if exception.is_a?(::SyntaxError)
-          return (exception.message.scan(/:(\d+)/).first || ["??"]).first
-        end
-        (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
-      end
-
-      # Tells optparse how to parse the arguments
-      # available for all executables.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can add their own options.
-      #
-      # @param opts [OptionParser]
-      def set_opts(opts)
-        opts.on('-s', '--stdin', :NONE,
-                'Read input from standard input instead of an input file') do
-          @options[:input] = $stdin
-        end
-
-        opts.on('--trace', :NONE, 'Show a full traceback on error') do
-          @options[:trace] = true
-        end
-
-        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
-          @options[:unix_newlines] = true if ::Sass::Util.windows?
-        end
-
-        opts.on_tail("-?", "-h", "--help", "Show this message") do
-          puts opts
-          exit
-        end
-
-        opts.on_tail("-v", "--version", "Print version") do
-          puts("Sass #{::Sass.version[:string]}")
-          exit
-        end
-      end
-
-      # Processes the options set by the command-line arguments.
-      # In particular, sets `@options[:input]` and `@options[:output]`
-      # (and `@options[:sourcemap]` if one has been specified)
-      # to appropriate IO streams.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can run their respective programs.
-      def process_result
-        input, output = @options[:input], @options[:output]
-        args = @args.dup
-        input ||=
-          begin
-            filename = args.shift
-            @options[:filename] = filename
-            open_file(filename) || $stdin
-          end
-        @options[:output_filename] = args.shift
-        output ||= @options[:output_filename] || $stdout
-
-        if @options[:sourcemap] && @options[:output_filename]
-          @options[:sourcemap_filename] = Util.sourcemap_name(@options[:output_filename])
-        end
-
-        @options[:input], @options[:output] = input, output
-      end
-
-      COLORS = {:red => 31, :green => 32, :yellow => 33}
-
-      # Prints a status message about performing the given action,
-      # colored using the given color (via terminal escapes) if possible.
-      #
-      # @param name [#to_s] A short name for the action being performed.
-      #   Shouldn't be longer than 11 characters.
-      # @param color [Symbol] The name of the color to use for this action.
-      #   Can be `:red`, `:green`, or `:yellow`.
-      def puts_action(name, color, arg)
-        return if @options[:for_engine][:quiet]
-        printf color(color, "%11s %s\n"), name, arg
-        STDOUT.flush
-      end
-
-      # Same as `Kernel.puts`, but doesn't print anything if the `--quiet` option is set.
-      #
-      # @param args [Array] Passed on to `Kernel.puts`
-      def puts(*args)
-        return if @options[:for_engine][:quiet]
-        Kernel.puts(*args)
-      end
-
-      # Wraps the given string in terminal escapes
-      # causing it to have the given color.
-      # If terminal esapes aren't supported on this platform,
-      # just returns the string instead.
-      #
-      # @param color [Symbol] The name of the color to use.
-      #   Can be `:red`, `:green`, or `:yellow`.
-      # @param str [String] The string to wrap in the given color.
-      # @return [String] The wrapped string.
-      def color(color, str)
-        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
-
-        # Almost any real Unix terminal will support color,
-        # so we just filter for Windows terms (which don't set TERM)
-        # and not-real terminals, which aren't ttys.
-        return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
-        "\e[#{COLORS[color]}m#{str}\e[0m"
-      end
-
-      def write_output(text, destination)
-        if destination.is_a?(String)
-          open_file(destination, 'w') {|file| file.write(text)}
-        else
-          destination.write(text)
-        end
-      end
-
-      private
-
-      def open_file(filename, flag = 'r')
-        return if filename.nil?
-        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
-        file = File.open(filename, flag)
-        return file unless block_given?
-        yield file
-        file.close
-      end
-
-      def handle_load_error(err)
-        dep = err.message[/^no such file to load -- (.*)/, 1]
-        raise err if @options[:trace] || dep.nil? || dep.empty?
-        $stderr.puts <<MESSAGE
-Required dependency #{dep} not found!
-    Run "gem install #{dep}" to get it.
-  Use --trace for backtrace.
-MESSAGE
-        exit 1
-      end
-    end
-
-    # The `sass` executable.
-    class Sass < Generic
-      attr_reader :default_syntax
-
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @options[:for_engine] = {
-          :load_paths => default_sass_path
-        }
-        @default_syntax = :sass
-      end
-
-      protected
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      # @comment
-      #   rubocop:disable MethodLength
-      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
-      # @comment
-      #   rubocop:enable MethodLength
-
-      # Processes the options set by the command-line arguments,
-      # and runs the Sass compiler appropriately.
-      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
-
-      private
-
-      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] += Compass.configuration.sass_load_paths
-      end
-
-      def interactive
-        require 'sass/repl'
-        ::Sass::Repl.new(@options).run
-      end
-
-      # @comment
-      #   rubocop:disable MethodLength
-      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 <<MSG if @args.empty?
-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
-MSG
-
-        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 <<MSG if err
-File #{@args[1]} #{err}.
-    Did you mean: #{@default_syntax} #{flag} #{@args[0]}:#{@args[1]}
-MSG
-        end
-
-        dirs, files = @args.map {|name| split_colon_path(name)}.
-          partition {|i, _| File.directory? i}
-        files.map! do |from, to|
-          to ||= from.gsub(/\.[^.]*?$/, '.css')
-          sourcemap = 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
-      # @comment
-      #   rubocop:enable MethodLength
-
-      def colon_path?(path)
-        !split_colon_path(path)[1].nil?
-      end
-
-      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
-
-      # Whether path is likely to be meant as the destination
-      # in a source:dest pair.
-      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
-
-      def default_sass_path
-        if 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)}
-        else
-          [::Sass::Importers::DeprecatedPath.new(".")]
-        end
-      end
-    end
-
-    class Scss < Sass
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @default_syntax = :scss
-      end
-    end
-
-    # The `sass-convert` executable.
-    class SassConvert < Generic
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        require 'sass'
-        @options[:for_tree] = {}
-        @options[:for_engine] = {:cache => false, :read_cache => true}
-      end
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      # @comment
-      #   rubocop:disable MethodLength
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: sass-convert [options] [INPUT] [OUTPUT]
-
-Description:
-  Converts between CSS, Sass, and SCSS files.
-  E.g. converts from SCSS to Sass,
-  or converts from CSS to SCSS (adding appropriate nesting).
-
-Options:
-END
-
-        opts.on('-F', '--from FORMAT',
-          'The format to convert from. Can be css, scss, sass.',
-          'By default, this is inferred from the input filename.',
-          'If there is none, defaults to css.') do |name|
-          @options[:from] = name.downcase.to_sym
-          raise "sass-convert no longer supports LessCSS." if @options[:from] == :less
-          unless [:css, :scss, :sass].include?(@options[:from])
-            raise "Unknown format for sass-convert --from: #{name}"
-          end
-        end
-
-        opts.on('-T', '--to FORMAT',
-          'The format to convert to. Can be scss or sass.',
-          'By default, this is inferred from the output filename.',
-          'If there is none, defaults to sass.') do |name|
-          @options[:to] = name.downcase.to_sym
-          unless [:scss, :sass].include?(@options[:to])
-            raise "Unknown format for sass-convert --to: #{name}"
-          end
-        end
-
-        opts.on('-R', '--recursive',
-          'Convert all the files in a directory. Requires --from and --to.') do
-          @options[:recursive] = true
-        end
-
-        opts.on('-i', '--in-place',
-          'Convert a file to its own syntax.',
-          'This can be used to update some deprecated syntax.') do
-          @options[:in_place] = true
-        end
-
-        opts.on('--dasherize', 'Convert underscores to dashes') do
-          @options[:for_tree][:dasherize] = true
-        end
-
-        opts.on('--indent NUM',
-          'How many spaces to use for each level of indentation. Defaults to 2.',
-          '"t" means use hard tabs.') do |indent|
-
-          if indent == 't'
-            @options[:for_tree][:indent] = "\t"
-          else
-            @options[:for_tree][:indent] = " " * indent.to_i
-          end
-        end
-
-        opts.on('--old', 'Output the old-style ":prop val" property syntax.',
-                         'Only meaningful when generating Sass.') do
-          @options[:for_tree][:old] = true
-        end
-
-        opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
-          @options[:for_engine][:read_cache] = false
-        end
-
-        unless ::Sass::Util.ruby1_8?
-          opts.on('-E encoding',
-                  'Specify the default encoding for Sass and CSS files.') do |encoding|
-            Encoding.default_external = encoding
-          end
-        end
-
-        super
-      end
-      # @comment
-      #   rubocop:enable MethodLength
-
-      # Processes the options set by the command-line arguments,
-      # and runs the CSS compiler appropriately.
-      def process_result
-        require 'sass'
-
-        if @options[:recursive]
-          process_directory
-          return
-        end
-
-        super
-        input = @options[:input]
-        if File.directory?(input)
-          raise "Error: '#{input.path}' is a directory (did you mean to use --recursive?)"
-        end
-        output = @options[:output]
-        output = input if @options[:in_place]
-        process_file(input, output)
-      end
-
-      private
-
-      def process_directory
-        unless (input = @options[:input] = @args.shift)
-          raise "Error: directory required when using --recursive."
-        end
-
-        output = @options[:output] = @args.shift
-        raise "Error: --from required when using --recursive." unless @options[:from]
-        raise "Error: --to required when using --recursive." unless @options[:to]
-        unless File.directory?(@options[:input])
-          raise "Error: '#{@options[:input]}' is not a directory"
-        end
-        if @options[:output] && File.exist?(@options[:output]) &&
-          !File.directory?(@options[:output])
-          raise "Error: '#{@options[:output]}' is not a directory"
-        end
-        @options[:output] ||= @options[:input]
-
-        if @options[:to] == @options[:from] && !@options[:in_place]
-          fmt = @options[:from]
-          raise "Error: converting from #{fmt} to #{fmt} without --in-place"
-        end
-
-        ext = @options[:from]
-        ::Sass::Util.glob("#{@options[:input]}/**/*.#{ext}") do |f|
-          output =
-            if @options[:in_place]
-              f
-            elsif @options[:output]
-              output_name = f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
-              output_name[0...@options[:input].size] = @options[:output]
-              output_name
-            else
-              f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
-            end
-
-          unless File.directory?(File.dirname(output))
-            puts_action :directory, :green, File.dirname(output)
-            FileUtils.mkdir_p(File.dirname(output))
-          end
-          puts_action :convert, :green, f
-          if File.exist?(output)
-            puts_action :overwrite, :yellow, output
-          else
-            puts_action :create, :green, output
-          end
-
-          input = open_file(f)
-          process_file(input, output)
-        end
-      end
-
-      def process_file(input, output)
-        if input.is_a?(File)
-          @options[:from] ||=
-            case input.path
-            when /\.scss$/; :scss
-            when /\.sass$/; :sass
-            when /\.less$/; raise "sass-convert no longer supports LessCSS."
-            when /\.css$/; :css
-            end
-        elsif @options[:in_place]
-          raise "Error: the --in-place option requires a filename."
-        end
-
-        if output.is_a?(File)
-          @options[:to] ||=
-            case output.path
-            when /\.scss$/; :scss
-            when /\.sass$/; :sass
-            end
-        end
-
-        @options[:from] ||= :css
-        @options[:to] ||= :sass
-        @options[:for_engine][:syntax] = @options[:from]
-
-        out =
-          ::Sass::Util.silence_sass_warnings do
-            if @options[:from] == :css
-              require 'sass/css'
-              ::Sass::CSS.new(input.read, @options[:for_tree]).render(@options[:to])
-            else
-              if input.is_a?(File)
-                ::Sass::Engine.for_file(input.path, @options[:for_engine])
-              else
-                ::Sass::Engine.new(input.read, @options[:for_engine])
-              end.to_tree.send("to_#{@options[:to]}", @options[:for_tree])
-            end
-          end
-
-        output = input.path if @options[:in_place]
-        write_output(out, output)
-      rescue ::Sass::SyntaxError => e
-        raise e if @options[:trace]
-        file = " of #{e.sass_filename}" if e.sass_filename
-        raise "Error on line #{e.sass_line}#{file}: #{e.message}\n  Use --trace for backtrace"
-      rescue LoadError => err
-        handle_load_error(err)
-      end
-    end
   end
 end
+
+require 'sass/exec/base'
+require 'sass/exec/sass_scss'
+require 'sass/exec/sass_convert'