radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/extra/haml-mode.el

@@ -4,7 +4,7 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 3.0.19
+;; Version: 2.2.21
 ;; Created: 2007-03-08
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, html
@@ -57,6 +57,13 @@ re-indented along with the line itself."
   :type 'boolean
   :group 'haml)
 
+(defface haml-tab-face
+  '((((class color)) (:background "hotpink"))
+    (t (:reverse-video t)))
+  "Face to use for highlighting tabs in Haml files."
+  :group 'faces
+  :group 'haml)
+
 (defvar haml-indent-function 'haml-indent-p
   "A function for checking if nesting is allowed.
 This function should look at the current line and return t
@@ -66,19 +73,19 @@ The function can also return a positive integer to indicate
 a specific level to which the current line could be indented.")
 
 (defconst haml-tag-beg-re
-  "^[ \t]*\\(?:[%\\.#][a-z0-9_:\\-]*\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*"
+  "^ *\\(?:[%\\.#][a-z0-9_:\\-]*\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*"
   "A regexp matching the beginning of a Haml tag, through (), {}, and [].")
 
 (defvar haml-block-openers
   `(,(concat haml-tag-beg-re "[><]*[ \t]*$")
-    "^[ \t]*[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
-    ,(concat "^[ \t]*[&!]?[-=~][ \t]*\\("
-             (regexp-opt '("if" "unless" "while" "until" "else" "for"
+    "^ *[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
+    ,(concat "^ *[&!]?[-=~][ \t]*\\("
+             (regexp-opt '("if" "unless" "while" "until" "else"
                            "begin" "elsif" "rescue" "ensure" "when"))
              "\\)")
-    "^[ \t]*/\\(\\[.*\\]\\)?[ \t]*$"
-    "^[ \t]*-#"
-    "^[ \t]*:")
+    "^ */\\(\\[.*\\]\\)?[ \t]*$"
+    "^ *-#"
+    "^ *:")
   "A list of regexps that match lines of Haml that open blocks.
 That is, a Haml line that can have text nested beneath it should
 be matched by a regexp in this list.")
@@ -88,7 +95,7 @@ be matched by a regexp in this list.")
 (defun haml-nested-regexp (re)
   "Create a regexp to match a block starting with RE.
 The line containing RE is matched, as well as all lines indented beneath it."
-  (concat "^\\([ \t]*\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?"))
+  (concat "^\\( *\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?"))
 
 (defconst haml-font-lock-keywords
   `((,(haml-nested-regexp "\\(?:-#\\|/\\).*")  0 font-lock-comment-face)
@@ -101,11 +108,12 @@ The line containing RE is matched, as well as all lines indented beneath it."
     (haml-highlight-interpolation         1 font-lock-variable-name-face prepend)
     (haml-highlight-ruby-tag              1 font-lock-preprocessor-face)
     (haml-highlight-ruby-script           1 font-lock-preprocessor-face)
+    ("^ *\\(\t\\)"                        1 'haml-tab-face)
     ("^!!!.*"                             0 font-lock-constant-face)
     ("| *$"                               0 font-lock-string-face)))
 
-(defconst haml-filter-re "^[ \t]*:\\w+")
-(defconst haml-comment-re "^[ \t]*\\(?:-\\#\\|/\\)")
+(defconst haml-filter-re "^ *:\\w+")
+(defconst haml-comment-re "^ *\\(?:-\\#\\|/\\)")
 
 (defun haml-fontify-region (beg end keywords syntax-table syntactic-keywords)
   "Fontify a region between BEG and END using another mode's fontification.
@@ -128,8 +136,7 @@ and `font-lock-syntactic-keywords', respectively."
 
 (defun haml-fontify-region-as-ruby (beg end)
   "Use Ruby's font-lock variables to fontify the region between BEG and END."
-  (haml-fontify-region beg end ruby-font-lock-keywords
-                       ruby-font-lock-syntax-table
+  (haml-fontify-region beg end ruby-font-lock-keywords nil
                        ruby-font-lock-syntactic-keywords))
 
 (defun haml-handle-filter (filter-name limit fn)
@@ -200,7 +207,7 @@ This requires that `markdown-mode' be available."
 (defun haml-highlight-ruby-script (limit)
   "Highlight a Ruby script expression (-, =, or ~).
 LIMIT works as it does in `re-search-forward'."
-  (when (re-search-forward "^[ \t]*\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t)
+  (when (re-search-forward "^ *\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t)
     (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2))))
 
 (defun haml-highlight-ruby-tag (limit)
@@ -215,7 +222,7 @@ For example, this will highlight all of the following:
   %p[@bar]
   %p= 'baz'
   %p{:foo => 'bar'}[@bar]= 'baz'"
-  (when (re-search-forward "^[ \t]*[%.#]" limit t)
+  (when (re-search-forward "^ *[%.#]" limit t)
     (forward-char -1)
 
     ;; Highlight tag, classes, and ids
@@ -345,8 +352,7 @@ With ARG, do it that many times."
           ;; Move through multiline attrs
           (when (eq (char-before) ?,)
             (save-excursion
-              (while (progn (end-of-line)
-                            (and (eq (char-before) ?,) (not (eobp))))
+              (while (progn (end-of-line) (and (eq (char-before) ?,) (not (eobp))))
                 (forward-line))
 
               (forward-line -1)
@@ -399,6 +405,7 @@ With ARG, do it that many times."
   (set (make-local-variable 'indent-region-function) 'haml-indent-region)
   (set (make-local-variable 'parse-sexp-lookup-properties) t)
   (setq comment-start "-#")
+  (setq indent-tabs-mode nil)
   (setq font-lock-defaults '((haml-font-lock-keywords) t t)))
 
 ;; Useful functions
@@ -611,18 +618,18 @@ TYPE is the type of text parsed ('name or 'value)
 and BEG and END delimit that text in the buffer."
   (let ((eol (save-excursion (end-of-line) (point))))
     (while (not (haml-move ")"))
-      (haml-move "[ \t]*")
+      (haml-move " *")
       (unless (haml-move "[a-z0-9_:\\-]+")
-        (return-from haml-parse-new-attr-hash (haml-move "[ \t]*$")))
+        (return-from haml-parse-new-attr-hash (haml-move " *$")))
       (funcall fn 'name (match-beginning 0) (match-end 0))
-      (haml-move "[ \t]*")
+      (haml-move " *")
       (when (haml-move "=")
-        (haml-move "[ \t]*")
+        (haml-move " *")
         (unless (looking-at "[\"'@a-z]") (return-from haml-parse-new-attr-hash))
         (let ((beg (point)))
           (haml-limited-forward-sexp eol)
           (funcall fn 'value beg (point)))
-        (haml-move "[ \t]*")))
+        (haml-move " *")))
     nil))
 
 (defun haml-compute-indentation ()
@@ -695,19 +702,10 @@ back-dent the line by `haml-indent-offset' spaces.  On reaching column
   "Add N spaces to the beginning of each line in the region.
 If N is negative, will remove the spaces instead.  Assumes all
 lines in the region have indentation >= that of the first line."
-  (let* ((ci (current-indentation))
-         (indent-rx
-          (concat "^"
-                  (if indent-tabs-mode
-                      (concat (make-string (/ ci tab-width) ?\t)
-                              (make-string (mod ci tab-width) ?\t))
-                    (make-string ci ?\s)))))
+  (let ((ci (current-indentation)))
     (save-excursion
-      (while (re-search-forward indent-rx (mark) t)
-        (let ((ci (current-indentation)))
-          (delete-horizontal-space)
-          (beginning-of-line)
-          (indent-to (max 0 (+ ci n))))))))
+      (while (re-search-forward (concat "^" (make-string ci ?\s)) (mark) t)
+        (replace-match (make-string (max 0 (+ ci n)) ?\s))))))
 
 (defun haml-electric-backspace (arg)
   "Delete characters or back-dent the current line.
@@ -730,8 +728,8 @@ the current line."
             (haml-mark-sexp-but-not-next-line)
           (set-mark (save-excursion (end-of-line) (point))))
         (haml-reindent-region-by (* (- arg) haml-indent-offset))
-        (pop-mark)))
-    (back-to-indentation)))
+        (back-to-indentation)
+        (pop-mark)))))
 
 (defun haml-kill-line-and-indent ()
   "Kill the current line, and re-indent all lines nested beneath it."

data/vendor/plugins/haml/extra/sass-mode.el

@@ -4,11 +4,11 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 3.0.19
+;; Version: 2.2.21
 ;; Created: 2007-03-15
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, css
-;; Package-Requires: ((haml-mode "3.0.14"))
+;; Package-Requires: ((haml-mode "2.2.21"))
 
 ;;; Commentary:
 
@@ -43,12 +43,11 @@
   :group 'sass)
 
 (defvar sass-non-block-openers
-  '("^.*,$" ;; Continued selectors
-    "^ *@\\(extend\\|debug\\|warn\\|include\\|import\\)" ;; Single-line mixins
-    "^ *[$!]" ;; Variables
-    )
-  "A list of regexps that match lines of Sass that couldn't have
-text nested beneath them.")
+  '("^ *:[^ \t]+[ \t]+[^ \t]"
+    "^ *[^ \t:]+[ \t]*[=:][ \t]*[^ \t]")
+  "A list of regexps that match lines of Sass that don't open blocks.
+That is, a Sass line that can't have text nested beneath it
+should be matched by a regexp in this list.")
 
 ;; Font lock
 
@@ -196,8 +195,8 @@ LIMIT is the limit of the search."
 (defun sass-indent-p ()
   "Return non-nil if the current line can have lines nested beneath it."
   (loop for opener in sass-non-block-openers
-        if (looking-at opener) return nil
-        finally return t))
+        unless (looking-at opener) return t
+        return nil))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))

data/vendor/plugins/haml/haml.gemspec

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'rake'
 
 # Note that Haml's gem-compilation process requires access to the filesystem.
 # This means that it cannot be automatically run by e.g. GitHub's gem system.
@@ -9,7 +10,7 @@ HAML_GEMSPEC = Gem::Specification.new do |spec|
   spec.name = File.exist?(File.dirname(__FILE__) + '/EDGE_GEM_VERSION') ? 'haml-edge' : 'haml'
   spec.summary = "An elegant, structured XHTML/XML templating engine.\nComes with Sass, a similar CSS templating engine."
   spec.version = File.read(File.dirname(__FILE__) + '/VERSION').strip
-  spec.authors = ['Nathan Weizenbaum', 'Chris Eppstein', 'Hampton Catlin']
+  spec.authors = ['Nathan Weizenbaum', 'Hampton Catlin']
   spec.email = 'haml@googlegroups.com'
   spec.description = <<-END
       Haml (HTML Abstraction Markup Language) is a layer on top of XHTML or XML
@@ -24,12 +25,36 @@ HAML_GEMSPEC = Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard', '>= 0.5.3'
   spec.add_development_dependency 'maruku', '>= 0.5.9'
 
-  readmes = Dir['*'].reject{ |x| x =~ /(^|[^.a-z])[a-z]+/ || x == "TODO" }
-  spec.executables = ['haml', 'html2haml', 'sass', 'css2sass', 'sass-convert']
-  spec.files = Dir['rails/init.rb', 'lib/**/*', 'vendor/fssm/**/*',
-    'bin/*', 'test/**/*', 'extra/**/*', 'Rakefile', 'init.rb',
-    '.yardopts'] + readmes
+  have_revision = true
+  unless File.exist?('REVISION')
+    begin
+      # We need the revision file to exist,
+      # so we just create it if it doesn't.
+      # It'll usually just get overwritten, though.
+      File.open('REVISION', 'w') { |f| f.puts "(unknown)" }
+    rescue
+      # If the file can't be created (e.g. on Heroku) continue without it
+      have_revision = false
+    end
+  end
+
+  readmes = FileList.new('*') do |list|
+    list.exclude(/(^|[^.a-z])[a-z]+/)
+    list.exclude('TODO')
+    list.include('REVISION') if have_revision
+  end.to_a
+  spec.executables = ['haml', 'html2haml', 'sass', 'css2sass']
+  spec.files = FileList['rails/init.rb', 'lib/**/*', 'bin/*', 'test/**/*',
+    'extra/**/*', 'Rakefile', 'init.rb', '.yardopts'].to_a + readmes
   spec.homepage = 'http://haml-lang.com/'
-  spec.has_rdoc = false
-  spec.test_files = Dir['test/**/*_test.rb']
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = readmes
+  spec.rdoc_options += [
+    '--title', 'Haml',
+    '--main', 'README.rdoc',
+    '--exclude', 'lib/haml/buffer.rb',
+    '--line-numbers',
+    '--inline-source'
+   ]
+  spec.test_files = FileList['test/**/*_test.rb'].to_a
 end

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

@@ -17,7 +17,6 @@ module Haml
 
   # A string representing the version of Haml.
   # A more fine-grained representation is available from Haml.version.
-  # @api public
   VERSION = version[:string] unless defined?(Haml::VERSION)
 
   # Initializes Haml for Rails.
@@ -38,7 +37,5 @@ module Haml
 end
 
 require 'haml/util'
-unless $0 =~ /sass(-convert)?$/
-  require 'haml/engine'
-  require 'haml/railtie'
-end
+require 'haml/engine'
+require 'haml/railtie'

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

@@ -233,43 +233,30 @@ RUBY
 
     # Merges two attribute hashes.
     # This is the same as `to.merge!(from)`,
-    # except that it merges id, class, and data attributes.
+    # except that it merges id and class attributes.
     #
     # ids are concatenated with `"_"`,
     # and classes are concatenated with `" "`.
-    # data hashes are simply merged.
     #
     # Destructively modifies both `to` and `from`.
     #
     # @param to [{String => String}] The attribute hash to merge into
-    # @param from [{String => #to_s}] The attribute hash to merge from
+    # @param from [{String => String}] The attribute hash to merge from
     # @return [{String => String}] `to`, after being merged
     def self.merge_attrs(to, from)
-      from['id'] = Precompiler.filter_and_join(from['id'], '_') if from['id']
       if to['id'] && from['id']
         to['id'] << '_' << from.delete('id').to_s
       elsif to['id'] || from['id']
         from['id'] ||= to['id']
       end
 
-      from['class'] = Precompiler.filter_and_join(from['class'], ' ') if from['class']
       if to['class'] && from['class']
         # Make sure we don't duplicate class names
-        from['class'] = (from['class'].to_s.split(' ') | to['class'].split(' ')).sort.join(' ')
+        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).sort.join(' ')
       elsif to['class'] || from['class']
         from['class'] ||= to['class']
       end
 
-      from_data = from['data'].is_a?(Hash)
-      to_data = to['data'].is_a?(Hash)
-      if from_data && to_data
-        to['data'] = to['data'].merge(from['data'])
-      elsif to_data
-        to = Haml::Util.map_keys(to.delete('data')) {|name| "data-#{name}"}.merge(to)
-      elsif from_data
-        from = Haml::Util.map_keys(from.delete('data')) {|name| "data-#{name}"}.merge(from)
-      end
-
       to.merge!(from)
     end
 
@@ -291,12 +278,7 @@ RUBY
       ref = ref[0]
       # Let's make sure the value isn't nil. If it is, return the default Hash.
       return {} if ref.nil?
-      class_name =
-        if ref.respond_to?(:haml_object_ref)
-          ref.haml_object_ref
-        else
-          underscore(ref.class)
-        end
+      class_name = underscore(ref.class)
       id = "#{class_name}_#{ref.id || 'new'}"
       if prefix
         class_name = "#{ prefix }_#{ class_name}"

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

@@ -85,21 +85,14 @@ module Haml
         :format => :xhtml,
         :escape_html => false,
       }
-
-
-      template = check_haml_encoding(template) do |msg, line|
-        raise Haml::Error.new(msg, line)
-      end
-
       unless ruby1_8?
-        @options[:encoding] = Encoding.default_internal || template.encoding
-        @options[:encoding] = "utf-8" if @options[:encoding].name == "US-ASCII"
+        @options[:encoding] = Encoding.default_internal || "utf-8"
       end
       @options.merge! options.reject {|k, v| v.nil?}
       @index = 0
 
       unless [:xhtml, :html4, :html5].include?(@options[:format])
-        raise Haml::Error, "Invalid output format #{@options[:format].inspect}"
+        raise Haml::Error, "Invalid format #{@options[:format].inspect}"
       end
 
       if @options[:encoding] && @options[:encoding].is_a?(Encoding)
@@ -120,9 +113,7 @@ module Haml
 
       precompile
     rescue Haml::Error => e
-      if @index || e.line
-        e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}"
-      end
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
       raise
     end
 
@@ -190,7 +181,7 @@ module Haml
     ensure
       # Get rid of the current buffer
       scope_object.instance_eval do
-        @haml_buffer = buffer.upper if buffer
+        @haml_buffer = buffer.upper
       end
     end
     alias_method :to_html, :render

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

@@ -1,8 +1,9 @@
 require 'optparse'
 require 'fileutils'
+require 'rbconfig'
 
 module Haml
-  # This module handles the various Haml executables (`haml`, `sass`, `sass-convert`, etc).
+  # This module handles the various Haml executables (`haml`, `sass`, `css2sass`, etc).
   module Exec
     # An abstract class that encapsulates the executable code for all three executables.
     class Generic
@@ -14,35 +15,23 @@ 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
-          parse
+          @opts = OptionParser.new(&method(:set_opts))
+          @opts.parse!(@args)
+
+          process_result
+
+          @options
         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."
+          $stderr.puts e.message
           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
@@ -59,8 +48,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
@@ -79,8 +68,10 @@ module Haml
           @options[:trace] = true
         end
 
-        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
-          @options[:unix_newlines] = true if ::Haml::Util.windows?
+        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
         end
 
         opts.on_tail("-?", "-h", "--help", "Show this message") do
@@ -102,50 +93,21 @@ module Haml
       # 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
+        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
 
         @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')
@@ -153,17 +115,6 @@ 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
@@ -198,29 +149,18 @@ 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 1
+            exit
           end
 
           dir = File.join(dir, 'haml')
 
           if File.exists?(dir)
             print "Directory #{dir} already exists, overwrite [y/N]? "
-            exit 2 if gets !~ /y/i
+            exit if gets !~ /y/i
             FileUtils.rm_rf(dir)
           end
 
@@ -228,7 +168,7 @@ END
             Dir.mkdir(dir)
           rescue SystemCallError
             puts "Cannot create #{dir}"
-            exit 1
+            exit
           end
 
           File.open(File.join(dir, 'init.rb'), 'w') do |file|
@@ -278,35 +218,10 @@ 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
@@ -318,44 +233,30 @@ 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[:update] && !@options[:watch] &&
-            @args.first && colon_path?(@args.first)
-          if @args.size == 1
-            @args = split_colon_path(@args.first)
-          else
-            @options[:update] = true
-          end
+        if @options[:interactive]
+          require 'sass'
+          require 'sass/repl'
+          ::Sass::Repl.new(@options).run
+          return
         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])
@@ -372,105 +273,9 @@ END
           output.close() if output.is_a? File
         rescue ::Sass::SyntaxError => e
           raise e if @options[:trace]
-          raise e.sass_backtrace_str("standard input")
+          raise "Syntax error on line #{get_line e}: #{e.message}"
         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.
@@ -504,11 +309,6 @@ MSG
           @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
@@ -517,14 +317,6 @@ MSG
           @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
@@ -576,7 +368,17 @@ MSG
       # @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.
@@ -591,20 +393,12 @@ Description: Transforms an HTML file into corresponding Haml code.
 Options:
 END
 
-        opts.on('-e', '--erb', 'Parse ERb tags.') do
-          @module_opts[:erb] = true
+        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
+          @module_opts[:rhtml] = true
         end
 
-        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
+        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
+          @options[:no_rhtml] = true
         end
 
         opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
@@ -619,31 +413,25 @@ END
       def process_result
         super
 
-        require 'haml/html'
-
         input = @options[:input]
         output = @options[:output]
 
-        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:erb] &&= @options[:no_erb] != false
+        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:rhtml] &&= @options[:no_rhtml] != 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 `sass-convert` executable.
-    class SassConvert < Generic
+    # The `css2sass` executable.
+    class CSS2Sass < 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}
+
+        @module_opts = {}
+
+        require 'sass/css'
       end
 
       # Tells optparse how to parse the arguments.
@@ -651,67 +439,18 @@ END
       # @param opts [OptionParser]
       def set_opts(opts)
         opts.banner = <<END
-Usage: sass-convert [options] [INPUT] [OUTPUT]
+Usage: css2sass [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).
+Description: Transforms a CSS file into corresponding Sass code.
 
 Options:
 END
 
-        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
+        opts.on('--old', 'Output the old-style ":prop val" property syntax') do
+          @module_opts[:old] = 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 ::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
+        opts.on_tail('-a', '--alternate', 'Ignored') {}
 
         super
       end
@@ -719,143 +458,12 @@ 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]
-        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
 
-      @@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
+        output.write(::Sass::CSS.new(input, @module_opts).render)
       end
     end
   end