haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/lib/sass/environment.rb

@@ -1,166 +0,0 @@
-require 'set'
-
-module Sass
-  # The lexical environment for SassScript.
-  # This keeps track of variable, mixin, and function definitions.
-  #
-  # A new environment is created for each level of Sass nesting.
-  # This allows variables to be lexically scoped.
-  # The new environment refers to the environment in the upper scope,
-  # so it has access to variables defined in enclosing scopes,
-  # but new variables are defined locally.
-  #
-  # Environment also keeps track of the {Engine} options
-  # so that they can be made available to {Sass::Script::Functions}.
-  class Environment
-    # The enclosing environment,
-    # or nil if this is the global environment.
-    #
-    # @return [Environment]
-    attr_reader :parent
-    attr_writer :options
-
-    # @param parent [Environment] See \{#parent}
-    def initialize(parent = nil)
-      @parent = parent
-      unless parent
-        @stack = []
-        @mixins_in_use = Set.new
-        set_var("important", Script::String.new("!important"))
-      end
-    end
-
-    # The options hash.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @return [{Symbol => Object}]
-    def options
-      @options || parent_options || {}
-    end
-
-    # Push a new stack frame onto the mixin/include stack.
-    #
-    # @param frame_info [{Symbol => Object}]
-    #   Frame information has the following keys:
-    #
-    #   `:filename`
-    #   : The name of the file in which the lexical scope changed.
-    #
-    #   `:mixin`
-    #   : The name of the mixin in which the lexical scope changed,
-    #     or `nil` if it wasn't within in a mixin.
-    #
-    #   `:line`
-    #   : The line of the file on which the lexical scope changed. Never nil.
-    def push_frame(frame_info)
-      top_of_stack = stack.last
-      if top_of_stack && top_of_stack.delete(:prepared)
-        top_of_stack.merge!(frame_info)
-      else
-        stack.push(top_of_stack = frame_info)
-      end
-      mixins_in_use << top_of_stack[:mixin] if top_of_stack[:mixin] && !top_of_stack[:prepared]
-    end
-
-    # Like \{#push\_frame}, but next time a stack frame is pushed,
-    # it will be merged with this frame.
-    #
-    # @param frame_info [{Symbol => Object}] Same as for \{#push\_frame}.
-    def prepare_frame(frame_info)
-      push_frame(frame_info.merge(:prepared => true))
-    end
-
-    # Pop a stack frame from the mixin/include stack.
-    def pop_frame
-      stack.pop if stack.last && stack.last[:prepared]
-      popped = stack.pop
-      mixins_in_use.delete(popped[:mixin]) if popped && popped[:mixin]
-    end
-
-    # A list of stack frames in the mixin/include stack.
-    # The last element in the list is the most deeply-nested frame.
-    #
-    # @return [Array<{Symbol => Object}>] The stack frames,
-    #   of the form passed to \{#push\_frame}.
-    def stack
-      @stack ||= @parent.stack
-    end
-
-    # A set of names of mixins currently present in the stack.
-    #
-    # @return [Set<String>] The mixin names.
-    def mixins_in_use
-      @mixins_in_use ||= @parent.mixins_in_use
-    end
-
-    def stack_trace
-      trace = []
-      stack.reverse.each_with_index do |entry, i|
-        msg = "#{i == 0 ? "on" : "from"} line #{entry[:line]}"
-        msg << " of #{entry[:filename] || "an unknown file"}"
-        msg << ", in `#{entry[:mixin]}'" if entry[:mixin]
-        trace << msg
-      end
-      trace
-    end
-
-    private
-
-    def parent_options
-      @parent_options ||= @parent && @parent.options
-    end
-
-    class << self
-      private
-      UNDERSCORE, DASH = '_', '-'
-
-      # Note: when updating this,
-      # update sass/yard/inherited_hash.rb as well.
-      def inherited_hash(name)
-        class_eval <<RUBY, __FILE__, __LINE__ + 1
-          def #{name}(name)
-            _#{name}(name.tr(UNDERSCORE, DASH))
-          end
-
-          def _#{name}(name)
-            (@#{name}s && @#{name}s[name]) || @parent && @parent._#{name}(name)
-          end
-          protected :_#{name}
-
-          def set_#{name}(name, value)
-            name = name.tr(UNDERSCORE, DASH)
-            @#{name}s[name] = value unless try_set_#{name}(name, value)
-          end
-
-          def try_set_#{name}(name, value)
-            @#{name}s ||= {}
-            if @#{name}s.include?(name)
-              @#{name}s[name] = value
-              true
-            elsif @parent
-              @parent.try_set_#{name}(name, value)
-            else
-              false
-            end
-          end
-          protected :try_set_#{name}
-
-          def set_local_#{name}(name, value)
-            @#{name}s ||= {}
-            @#{name}s[name.tr(UNDERSCORE, DASH)] = value
-          end
-RUBY
-      end
-    end
-
-    # variable
-    # Script::Literal
-    inherited_hash :var
-    # mixin
-    # Sass::Callable
-    inherited_hash :mixin
-    # function
-    # Sass::Callable
-    inherited_hash :function
-  end
-end

data/vendor/sass/lib/sass/error.rb

@@ -1,201 +0,0 @@
-module Sass
-  # An exception class that keeps track of
-  # the line of the Sass template it was raised on
-  # and the Sass file that was being parsed (if applicable).
-  #
-  # All Sass errors are raised as {Sass::SyntaxError}s.
-  #
-  # When dealing with SyntaxErrors,
-  # it's important to provide filename and line number information.
-  # This will be used in various error reports to users, including backtraces;
-  # see \{#sass\_backtrace} for details.
-  #
-  # Some of this information is usually provided as part of the constructor.
-  # New backtrace entries can be added with \{#add\_backtrace},
-  # which is called when an exception is raised between files (e.g. with `@import`).
-  #
-  # Often, a chunk of code will all have similar backtrace information -
-  # the same filename or even line.
-  # It may also be useful to have a default line number set.
-  # In those situations, the default values can be used
-  # by omitting the information on the original exception,
-  # and then calling \{#modify\_backtrace} in a wrapper `rescue`.
-  # When doing this, be sure that all exceptions ultimately end up
-  # with the information filled in.
-  class SyntaxError < StandardError
-    # The backtrace of the error within Sass files.
-    # This is an array of hashes containing information for a single entry.
-    # The hashes have the following keys:
-    #
-    # `:filename`
-    # : The name of the file in which the exception was raised,
-    #   or `nil` if no filename is available.
-    #
-    # `:mixin`
-    # : The name of the mixin in which the exception was raised,
-    #   or `nil` if it wasn't raised in a mixin.
-    #
-    # `:line`
-    # : The line of the file on which the error occurred. Never nil.
-    #
-    # This information is also included in standard backtrace format
-    # in the output of \{#backtrace}.
-    #
-    # @return [Aray<{Symbol => Object>}]
-    attr_accessor :sass_backtrace
-
-    # The text of the template where this error was raised.
-    #
-    # @return [String]
-    attr_accessor :sass_template
-
-    # @param msg [String] The error message
-    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def initialize(msg, attrs = {})
-      @message = msg
-      @sass_backtrace = []
-      add_backtrace(attrs)
-    end
-
-    # The name of the file in which the exception was raised.
-    # This could be `nil` if no filename is available.
-    #
-    # @return [String, nil]
-    def sass_filename
-      sass_backtrace.first[:filename]
-    end
-
-    # The name of the mixin in which the error occurred.
-    # This could be `nil` if the error occurred outside a mixin.
-    #
-    # @return [Fixnum]
-    def sass_mixin
-      sass_backtrace.first[:mixin]
-    end
-
-    # The line of the Sass template on which the error occurred.
-    #
-    # @return [Fixnum]
-    def sass_line
-      sass_backtrace.first[:line]
-    end
-
-    # Adds an entry to the exception's Sass backtrace.
-    #
-    # @param attrs [{Symbol => Object}] The information in the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def add_backtrace(attrs)
-      sass_backtrace << attrs.reject {|k, v| v.nil?}
-    end
-
-    # Modify the top Sass backtrace entries
-    # (that is, the most deeply nested ones)
-    # to have the given attributes.
-    #
-    # Specifically, this goes through the backtrace entries
-    # from most deeply nested to least,
-    # setting the given attributes for each entry.
-    # If an entry already has one of the given attributes set,
-    # the pre-existing attribute takes precedence
-    # and is not used for less deeply-nested entries
-    # (even if they don't have that attribute set).
-    #
-    # @param attrs [{Symbol => Object}] The information to add to the backtrace entry.
-    #   See \{#sass\_backtrace}
-    def modify_backtrace(attrs)
-      attrs = attrs.reject {|k, v| v.nil?}
-      # Move backwards through the backtrace
-      (0...sass_backtrace.size).to_a.reverse.each do |i|
-        entry = sass_backtrace[i]
-        sass_backtrace[i] = attrs.merge(entry)
-        attrs.reject! {|k, v| entry.include?(k)}
-        break if attrs.empty?
-      end
-    end
-
-    # @return [String] The error message
-    def to_s
-      @message
-    end
-
-    # Returns the standard exception backtrace,
-    # including the Sass backtrace.
-    #
-    # @return [Array<String>]
-    def backtrace
-      return nil if super.nil?
-      return super if sass_backtrace.all? {|h| h.empty?}
-      sass_backtrace.map do |h|
-        "#{h[:filename] || "(sass)"}:#{h[:line]}" +
-          (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
-      end + super
-    end
-
-    # Returns a string representation of the Sass backtrace.
-    #
-    # @param default_filename [String] The filename to use for unknown files
-    # @see #sass_backtrace
-    # @return [String]
-    def sass_backtrace_str(default_filename = "an unknown file")
-      lines = self.message.split("\n")
-      msg = lines[0] + lines[1..-1].
-        map {|l| "\n" + (" " * "Syntax error: ".size) + l}.join
-      "Syntax 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}" +
-          (entry[:mixin] ? ", in `#{entry[:mixin]}'" : "")
-      end.join
-    end
-
-    class << self
-      # Returns an error report for an exception in CSS format.
-      #
-      # @param e [Exception]
-      # @param options [{Symbol => Object}] The options passed to {Sass::Engine#initialize}
-      # @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)
-
-        <<END
-/*
-#{header}
-
-Backtrace:\n#{e.backtrace.join("\n")}
-*/
-body:before {
-  white-space: pre;
-  font-family: monospace;
-  content: "#{header.gsub('"', '\"').gsub("\n", '\\A ')}"; }
-END
-      end
-
-      private
-
-      def header_string(e, options)
-        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]
-        return e.sass_backtrace_str if section.nil? || section.empty?
-
-        e.sass_backtrace_str + "\n\n" + Sass::Util.enum_with_index(section).
-          map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
-      end
-    end
-  end
-
-  # The class for Sass errors that are raised due to invalid unit conversions
-  # in SassScript.
-  class UnitConversionError < SyntaxError; end
-end

data/vendor/sass/lib/sass/exec.rb

@@ -1,672 +0,0 @@
-require 'optparse'
-require 'fileutils'
-
-module Sass
-  # This module handles the various 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!
-        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
-      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
-        return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
-        (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]`
-      # 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
-        output ||= open_file(args.shift, 'w') || $stdout
-
-        @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
-      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?
-        return "\e[#{COLORS[color]}m#{str}\e[0m"
-      end
-
-      private
-
-      def open_file(filename, flag = 'r')
-        return if filename.nil?
-        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
-        File.open(filename, flag)
-      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 => ['.'] + (ENV['SASSPATH'] || '').split(File::PATH_SEPARATOR)
-        }
-        @default_syntax = :sass
-      end
-
-      protected
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      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('-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
-        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('--precision NUMBER_OF_DIGITS', Integer,
-                'How many digits of precision to use when outputting decimal numbers. Defaults to 3.') do |precision|
-          ::Sass::Script::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 extra information in the generated CSS 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
-
-        unless ::Sass::Util.ruby1_8?
-          opts.on('-E encoding', 'Specify the default encoding for Sass files.') do |encoding|
-            Encoding.default_external = encoding
-          end
-        end
-      end
-
-      # 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]
-
-        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)
-
-          output.write(engine.render)
-          output.close() if output.is_a? File
-        rescue ::Sass::SyntaxError => e
-          raise e if @options[:trace]
-          raise e.sass_backtrace_str("standard input")
-        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
-
-      def watch_or_update
-        require 'sass/plugin'
-        ::Sass::Plugin.options.merge! @options[:for_engine]
-        ::Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
-
-        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! {|from, to| [from, to || from.gsub(/\.[^.]*?$/, '.css')]}
-        dirs.map! {|from, to| [from, to || from]}
-        ::Sass::Plugin.options[:template_location] = dirs
-
-        ::Sass::Plugin.on_updating_stylesheet do |_, css|
-          if File.exists? css
-            puts_action :overwrite, :yellow, css
-          else
-            puts_action :create, :green, css
-          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_compilation_error do |error, _, _|
-          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})"
-        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 {|template| puts ">>> Change detected to: #{template}"}
-        ::Sass::Plugin.on_template_created {|template| puts ">>> New template detected: #{template}"}
-        ::Sass::Plugin.on_template_deleted {|template| puts ">>> Deleted template detected: #{template}"}
-
-        ::Sass::Plugin.watch(files)
-      end
-
-      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)
-        return Dir.glob(File.join(path, "*.s[ca]ss")).empty?
-      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]
-      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, less.',
-          'By default, this is inferred from the input filename.',
-          'If there is none, defaults to css.') do |name|
-          @options[:from] = name.downcase.to_sym
-          unless [:css, :scss, :sass, :less].include?(@options[:from])
-            raise "Unknown format for sass-convert --from: #{name}"
-          end
-          try_less_note if @options[:from] == :less
-        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('--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
-
-      # 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]
-        raise "Error: '#{input.path}' is a directory (did you mean to use --recursive?)" if File.directory?(input)
-        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]
-        raise "Error: '#{@options[:input]}' is not a directory" unless File.directory?(@options[:input])
-        if @options[:output] && File.exists?(@options[:output]) && !File.directory?(@options[:output])
-          raise "Error: '#{@options[:output]}' is not a directory"
-        end
-        @options[:output] ||= @options[:input]
-
-        from = @options[:from]
-        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]
-        Dir.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.exists?(output)
-            puts_action :overwrite, :yellow, output
-          else
-            puts_action :create, :green, output
-          end
-
-          input = open_file(f)
-          output = @options[:in_place] ? input : open_file(output, "w")
-          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$/; :less
-            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])
-            elsif @options[:from] == :less
-              require 'sass/less'
-              try_less_note
-              input = input.read if input.is_a?(IO) && !input.is_a?(File) # Less is dumb
-              Less::Engine.new(input).to_tree.to_sass_tree.send("to_#{@options[:to]}", @options[:for_tree])
-            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 = File.open(input.path, 'w') if @options[:in_place]
-        output.write(out)
-      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
-
-      @@less_note_printed = false
-      def try_less_note
-        return if @@less_note_printed
-        @@less_note_printed = true
-        warn <<NOTE
-* NOTE: Sass and Less are different languages, and they work differently.
-* I'll do my best to translate, but some features -- especially mixins --
-* should be checked by hand.
-NOTE
-      end
-    end
-  end
-end