radiant 0.9.1 → 1.0.0.rc1

data/vendor/plugins/haml/lib/haml/error.rbc

@@ -0,0 +1,339 @@
+!RBIX
+17831730954501249321
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+28
+99
+7
+0
+65
+49
+1
+2
+13
+99
+12
+7
+2
+12
+7
+3
+12
+65
+12
+49
+4
+4
+15
+49
+2
+0
+15
+2
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+5
+x
+4
+Haml
+x
+11
+open_module
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+4
+Haml
+i
+46
+5
+66
+99
+7
+0
+45
+1
+2
+65
+49
+3
+3
+13
+99
+12
+7
+4
+12
+7
+5
+12
+65
+12
+49
+6
+4
+15
+49
+4
+0
+15
+99
+7
+7
+45
+8
+9
+43
+0
+65
+49
+3
+3
+15
+1
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+10
+x
+5
+Error
+x
+13
+StandardError
+n
+x
+10
+open_class
+x
+14
+__class_init__
+M
+1
+n
+n
+x
+5
+Error
+i
+24
+5
+66
+5
+7
+0
+47
+49
+1
+1
+15
+99
+7
+2
+7
+3
+65
+67
+49
+4
+0
+49
+5
+4
+11
+I
+5
+I
+0
+I
+0
+I
+0
+n
+p
+6
+x
+4
+line
+x
+11
+attr_reader
+x
+10
+initialize
+M
+1
+n
+n
+x
+10
+initialize
+i
+28
+23
+0
+10
+8
+1
+19
+0
+15
+23
+1
+10
+16
+1
+19
+1
+15
+20
+0
+54
+52
+0
+1
+15
+20
+1
+38
+1
+11
+I
+4
+I
+2
+I
+0
+I
+2
+n
+p
+2
+x
+10
+initialize
+x
+5
+@line
+p
+7
+I
+-1
+I
+b
+I
+10
+I
+c
+I
+17
+I
+d
+I
+1c
+x
+65
+/Users/jim/Projects/radiant/vendor/plugins/haml/lib/haml/error.rb
+p
+2
+x
+7
+message
+x
+4
+line
+x
+17
+method_visibility
+x
+15
+add_defn_method
+p
+5
+I
+2
+I
+7
+I
+a
+I
+b
+I
+18
+x
+65
+/Users/jim/Projects/radiant/vendor/plugins/haml/lib/haml/error.rb
+p
+0
+x
+13
+attach_method
+x
+11
+SyntaxError
+x
+4
+Haml
+n
+p
+5
+I
+2
+I
+3
+I
+1f
+I
+15
+I
+2e
+x
+65
+/Users/jim/Projects/radiant/vendor/plugins/haml/lib/haml/error.rb
+p
+0
+x
+13
+attach_method
+p
+3
+I
+0
+I
+1
+I
+1c
+x
+65
+/Users/jim/Projects/radiant/vendor/plugins/haml/lib/haml/error.rb
+p
+0

data/vendor/plugins/haml/lib/haml/exec.rb

@@ -1,9 +1,8 @@
 require 'optparse'
 require 'fileutils'
-require 'rbconfig'
 
 module Haml
-  # This module handles the various Haml executables (`haml`, `sass`, `css2sass`, etc).
+  # This module handles the various Haml executables (`haml`, `sass`, `sass-convert`, etc).
   module Exec
     # An abstract class that encapsulates the executable code for all three executables.
     class Generic
@@ -15,23 +14,35 @@ module Haml
 
       # Parses the command-line arguments and runs the executable.
       # Calls `Kernel#exit` at the end, so it never returns.
+      #
+      # @see #parse
       def parse!
         begin
-          @opts = OptionParser.new(&method(:set_opts))
-          @opts.parse!(@args)
-
-          process_result
-
-          @options
+          parse
         rescue Exception => e
           raise e if @options[:trace] || e.is_a?(SystemExit)
 
-          $stderr.puts e.message
+          $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
@@ -48,8 +59,8 @@ module Haml
         # SyntaxErrors have weird line reporting
         # when there's trailing whitespace,
         # which there is for Haml documents.
-        return exception.message.scan(/:(\d+)/).first.first if exception.is_a?(::SyntaxError)
-        exception.backtrace[0].scan(/:(\d+)/).first.first
+        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
@@ -68,10 +79,8 @@ module Haml
           @options[:trace] = true
         end
 
-        if RbConfig::CONFIG['host_os'] =~ /mswin|windows/i
-          opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
-            @options[:unix_newlines] = true
-          end
+        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
+          @options[:unix_newlines] = true if ::Haml::Util.windows?
         end
 
         opts.on_tail("-?", "-h", "--help", "Show this message") do
@@ -93,21 +102,50 @@ module Haml
       # so they can run their respective programs.
       def process_result
         input, output = @options[:input], @options[:output]
-        input_file, output_file = if input
-                                    [nil, open_file(@args[0], 'w')]
-                                  else
-                                    @options[:filename] = @args[0]
-                                    [open_file(@args[0]), open_file(@args[1], 'w')]
-                                  end
-
-        input  ||= input_file
-        output ||= output_file
-        input  ||= $stdin
-        output ||= $stdout
+        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)
+        printf color(color, "%11s %s\n"), name, arg
+      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')
@@ -115,6 +153,17 @@ module Haml
         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
 
     # An abstrac class that encapsulates the code
@@ -149,18 +198,29 @@ END
         opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir|
           original_dir = dir
 
+          env = File.join(dir, "config", "environment.rb")
+          if File.exists?(File.join(dir, "Gemfile"))
+            puts("haml --rails isn't needed for Rails 3 or greater.",
+              "Add 'gem \"haml\"' to your Gemfile instead.", "",
+              "haml --rails will no longer work in the next version of #{@name}.", "")
+          elsif File.exists?(env) && File.open(env) {|env| env.grep(/config\.gem/)}
+            puts("haml --rails isn't needed for Rails 2.1 or greater.",
+              "Add 'config.gem \"haml\"' to config/environment.rb instead.", "",
+              "haml --rails will no longer work in the next version of #{@name}.", "")
+          end
+
           dir = File.join(dir, 'vendor', 'plugins')
 
           unless File.exists?(dir)
             puts "Directory #{dir} doesn't exist"
-            exit
+            exit 1
           end
 
           dir = File.join(dir, 'haml')
 
           if File.exists?(dir)
             print "Directory #{dir} already exists, overwrite [y/N]? "
-            exit if gets !~ /y/i
+            exit 2 if gets !~ /y/i
             FileUtils.rm_rf(dir)
           end
 
@@ -168,7 +228,7 @@ END
             Dir.mkdir(dir)
           rescue SystemCallError
             puts "Cannot create #{dir}"
-            exit
+            exit 1
           end
 
           File.open(File.join(dir, 'init.rb'), 'w') do |file|
@@ -218,10 +278,35 @@ END
       def set_opts(opts)
         super
 
+        opts.on('--scss',
+                'Use the CSS-superset SCSS syntax.') do
+          @options[:for_engine][:syntax] = :scss
+        end
+        opts.on('--watch', 'Watch files or directories for changes.',
+                           'The location of the generated CSS can be set using a colon:',
+                           '  sass --watch input.sass:output.css',
+                           '  sass --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('-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('-q', '--quiet', 'Silence warnings during compilation.') do
+          @options[:for_engine][:quiet] = 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 sass line.') do
           @options[:for_engine][:line_numbers] = true
@@ -233,30 +318,44 @@ 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 ::Haml::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
-        if @options[:interactive]
-          require 'sass'
-          require 'sass/repl'
-          ::Sass::Repl.new(@options).run
-          return
+        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
 
+        return interactive if @options[:interactive]
+        return watch_or_update if @options[:watch] || @options[:update]
         super
 
         begin
           input = @options[:input]
           output = @options[:output]
 
+          @options[:for_engine][:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
           tree =
             if input.is_a?(File) && !@options[:check_syntax]
               ::Sass::Files.tree_for(input.path, @options[:for_engine])
@@ -273,9 +372,105 @@ END
           output.close() if output.is_a? File
         rescue ::Sass::SyntaxError => e
           raise e if @options[:trace]
-          raise "Syntax error on line #{get_line e}: #{e.message}"
+          raise e.sass_backtrace_str("standard input")
         end
       end
+
+      private
+
+      def interactive
+        require 'sass'
+        require 'sass/repl'
+        ::Sass::Repl.new(@options).run
+      end
+
+      def watch_or_update
+        require 'sass'
+        require 'sass/plugin'
+        ::Sass::Plugin.options.merge! @options[:for_engine]
+        ::Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
+
+        raise <<MSG if @args.empty?
+What files should I watch? Did you mean something like:
+    sass --watch input.sass:output.css
+    sass --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: sass #{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 && ::Haml::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
 
     # The `haml` executable.
@@ -309,6 +504,11 @@ END
           @options[:for_engine][:escape_html] = true
         end
 
+        opts.on('-q', '--double-quote-attributes',
+                'Set attribute wrapper to double-quotes (default is single).') do
+          @options[:for_engine][:attr_wrapper] = '"'
+        end
+
         opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
           @options[:requires] << file
         end
@@ -317,6 +517,14 @@ END
           @options[:load_paths] << path
         end
 
+        unless ::Haml::Util.ruby1_8?
+          opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+            external, internal = encoding.split(':')
+            Encoding.default_external = external if external && !external.empty?
+            Encoding.default_internal = internal if internal && !internal.empty?
+          end
+        end
+
         opts.on('--debug', "Print out the precompiled Ruby source.") do
           @options[:debug] = true
         end
@@ -368,17 +576,7 @@ END
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
-
         @module_opts = {}
-
-        begin
-          require 'haml/html'
-        rescue LoadError => err
-          dep = err.message.scan(/^no such file to load -- (.*)/)[0]
-          raise err if @options[:trace] || dep.nil? || dep.empty?
-          $stderr.puts "Required dependency #{dep} not found!\n  Use --trace for backtrace."
-          exit 1
-        end
       end
 
       # Tells optparse how to parse the arguments.
@@ -393,12 +591,20 @@ Description: Transforms an HTML file into corresponding Haml code.
 Options:
 END
 
-        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
-          @module_opts[:rhtml] = true
+        opts.on('-e', '--erb', 'Parse ERb tags.') do
+          @module_opts[:erb] = true
         end
 
-        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
-          @options[:no_rhtml] = true
+        opts.on('--no-erb', "Don't parse ERb tags.") do
+          @options[:no_erb] = true
+        end
+
+        opts.on('-r', '--rhtml', 'Deprecated; same as --erb.') do
+          @module_opts[:erb] = true
+        end
+
+        opts.on('--no-rhtml', "Deprecated; same as --no-erb.") do
+          @options[:no_erb] = true
         end
 
         opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
@@ -413,25 +619,31 @@ END
       def process_result
         super
 
+        require 'haml/html'
+
         input = @options[:input]
         output = @options[:output]
 
-        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
+        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:erb] &&= @options[:no_erb] != false
 
         output.write(::Haml::HTML.new(input, @module_opts).render)
+      rescue ::Haml::Error => e
+        raise "#{e.is_a?(::Haml::SyntaxError) ? "Syntax error" : "Error"} on line " +
+          "#{get_line e}: #{e.message}"
+      rescue LoadError => err
+        handle_load_error(err)
       end
     end
 
-    # The `css2sass` executable.
-    class CSS2Sass < Generic
+    # The `sass-convert` executable.
+    class SassConvert < Generic
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
-
-        @module_opts = {}
-
-        require 'sass/css'
+        require 'sass'
+        @options[:for_tree] = {}
+        @options[:for_engine] = {:cache => false, :read_cache => true}
       end
 
       # Tells optparse how to parse the arguments.
@@ -439,18 +651,67 @@ END
       # @param opts [OptionParser]
       def set_opts(opts)
         opts.banner = <<END
-Usage: css2sass [options] [INPUT] [OUTPUT]
+Usage: sass-convert [options] [INPUT] [OUTPUT]
 
-Description: Transforms a CSS file into corresponding Sass code.
+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('--old', 'Output the old-style ":prop val" property syntax') do
-          @module_opts[:old] = true
+        opts.on('-F', '--from FORMAT',
+          'The format to convert from. Can be css, scss, sass, less, or sass2.',
+          'sass2 is the same as sass, but updates more old syntax to new.',
+          '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, :sass2].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_tail('-a', '--alternate', 'Ignored') {}
+        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 ::Haml::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
@@ -458,12 +719,143 @@ END
       # Processes the options set by the command-line arguments,
       # and runs the CSS compiler appropriately.
       def process_result
-        super
+        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]
+        from = :sass if from == :sass2
+        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]
+        ext = :sass if ext == :sass2
+        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
+
+        if @options[:from] == :sass2
+          @options[:from] = :sass
+          @options[:for_engine][:sass2] = true
+        end
+
+        @options[:from] ||= :css
+        @options[:to] ||= :sass
+        @options[:for_engine][:syntax] = @options[:from]
+
+        out =
+          ::Haml::Util.silence_haml_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::Files.tree_for(input.path, @options[:for_engine])
+              else
+                ::Sass::Engine.new(input.read, @options[:for_engine]).to_tree
+              end.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
 
-        output.write(::Sass::CSS.new(input, @module_opts).render)
+      @@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