radiant 0.9.1 → 1.0.0.rc1

data/vendor/plugins/haml/doc-src/SCSS_FOR_SASS_USERS.md

@@ -0,0 +1,155 @@
+# Intro to SCSS for Sass Users
+
+Sass 3 introduces a new syntax known as SCSS
+which is fully compatible with the syntax of CSS3,
+while still supporting the full power of Sass.
+This means that every valid CSS3 stylesheet
+is a valid SCSS file with the same meaning.
+In addition, SCSS understands most CSS hacks
+and vendor-specific syntax, such as [IE's old `filter` syntax](http://msdn.microsoft.com/en-us/library/ms533754%28VS.85%29.aspx).
+
+Since SCSS is a CSS extension,
+everything that works in CSS works in SCSS.
+This means that for a Sass user to understand it,
+they need only understand how the Sass extensions work.
+Most of these, such as variables, parent references, and directives work the same;
+the only difference is that SCSS requires semicolons
+and brackets instead of newlines and indentation.
+For example, a simple rule in Sass:
+
+    #sidebar
+      width: 30%
+      background-color: #faa
+
+could be converted to SCSS just by adding brackets and semicolons:
+
+    #sidebar {
+      width: 30%;
+      background-color: #faa;
+    }
+
+In addition, SCSS is completely whitespace-insensitive.
+That means the above could also be written as:
+
+    #sidebar {width: 30%; background-color: #faa}
+
+There are some differences that are slightly more complicated.
+These are detailed below.
+Note, though, that SCSS uses all the
+{file:SASS_CHANGELOG.md#3-0-0-syntax-changes syntax changes in Sass 3},
+so make sure you understand those before going forward.
+
+## Nested Selectors
+
+To nest selectors, simply define a new ruleset
+inside an existing ruleset:
+
+    #sidebar {
+      a { text-decoration: none; }
+    }
+
+Of course, white space is insignificant
+and the last trailing semicolon is optional
+so you can also do it like this:
+
+    #sidebar { a { text-decoration: none } }
+
+## Nested Properties
+
+To nest properties,
+simply create a new property set
+after an existing property's colon:
+
+    #footer {
+      border: {
+        width: 1px;
+        color: #ccc;
+        style: solid;
+      }
+    }
+
+This compiles to:
+
+    #footer {
+      border-width: 1px;
+      border-color: #cccccc;
+      border-style: solid; }
+
+## Mixins
+
+A mixin is declared with the `@mixin` directive:
+
+    @mixin rounded($amount) {
+      -moz-border-radius: $amount;
+      -webkit-border-radius: $amount;
+      border-radius: $amount;
+    }
+
+A mixin is used with the `@include` directive:
+
+    .box {
+      border: 3px solid #777;
+      @include rounded(0.5em);
+    }
+
+This syntax is also available in the indented syntax,
+although the old `=` and `+` syntax still works.
+
+This is rather verbose compared to the `=` and `+` characters used in Sass syntax.
+This is because the SCSS format is designed for CSS compatibility rather than conciseness,
+and creating new syntax when the CSS directive syntax already exists
+adds new syntax needlessly and
+could create incompatibilities with future versions of CSS.
+
+## Comments
+
+Like Sass, SCSS supports both comments that are preserved in the CSS output
+and comments that aren't.
+However, SCSS's comments are significantly more flexible.
+It supports standard multiline CSS comments with `/* */`,
+which are preserved where possible in the output.
+These comments can have whatever formatting you like;
+Sass will do its best to format them nicely.
+
+SCSS also uses `//` for comments that are thrown away, like Sass.
+Unlike Sass, though, `//` comments in SCSS may appear anywhere
+and last only until the end of the line.
+
+For example:
+
+    /* This comment is
+     * several lines long.
+     * since it uses the CSS comment syntax,
+     * it will appear in the CSS output. */
+    body { color: black; }
+
+    // These comments are only one line long each.
+    // They won't appear in the CSS output,
+    // since they use the single-line comment syntax.
+    a { color: green; }
+
+is compiled to:
+
+    /* This comment is
+     * several lines long.
+     * since it uses the CSS comment syntax,
+     * it will appear in the CSS output. */
+    body {
+      color: black; }
+
+    a {
+      color: green; }
+
+## `@import`
+
+The `@import` directive in SCSS functions just like that in Sass,
+except that it takes a quoted string to import.
+For example, this Sass:
+
+    @import themes/dark
+    @import font.sass
+
+would be this SCSS:
+
+    @import "themes/dark";
+    @import "font.sass";

data/vendor/plugins/haml/ext/extconf.rb

@@ -0,0 +1,10 @@
+root = File.expand_path("../..", __FILE__)
+File.open(File.expand_path("lib/haml/root.rb", root), "w") do |f|
+  f << <<-RUBY
+module Haml
+  ROOT_DIR = #{root.inspect}
+end
+  RUBY
+end
+
+File.open('Makefile', 'w') { |f| f.puts("install:\n\t$(exit 0)") }

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

@@ -4,7 +4,7 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 2.2.21
+;; Version: 3.0.19
 ;; Created: 2007-03-08
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, html
@@ -57,13 +57,6 @@ 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
@@ -73,19 +66,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
-  "^ *\\(?:[%\\.#][a-z0-9_:\\-]*\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*"
+  "^[ \t]*\\(?:[%\\.#][a-z0-9_:\\-]*\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*"
   "A regexp matching the beginning of a Haml tag, through (), {}, and [].")
 
 (defvar haml-block-openers
   `(,(concat haml-tag-beg-re "[><]*[ \t]*$")
-    "^ *[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
-    ,(concat "^ *[&!]?[-=~][ \t]*\\("
-             (regexp-opt '("if" "unless" "while" "until" "else"
+    "^[ \t]*[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
+    ,(concat "^[ \t]*[&!]?[-=~][ \t]*\\("
+             (regexp-opt '("if" "unless" "while" "until" "else" "for"
                            "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.")
@@ -95,7 +88,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 "^\\( *\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?"))
+  (concat "^\\([ \t]*\\)" re "\\(\n\\(?:\\(?:\\1 .*\\| *\\)\n\\)*\\(?:\\1 .*\\| *\\)?\\)?"))
 
 (defconst haml-font-lock-keywords
   `((,(haml-nested-regexp "\\(?:-#\\|/\\).*")  0 font-lock-comment-face)
@@ -108,12 +101,11 @@ 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 "^ *:\\w+")
-(defconst haml-comment-re "^ *\\(?:-\\#\\|/\\)")
+(defconst haml-filter-re "^[ \t]*:\\w+")
+(defconst haml-comment-re "^[ \t]*\\(?:-\\#\\|/\\)")
 
 (defun haml-fontify-region (beg end keywords syntax-table syntactic-keywords)
   "Fontify a region between BEG and END using another mode's fontification.
@@ -136,7 +128,8 @@ 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 nil
+  (haml-fontify-region beg end ruby-font-lock-keywords
+                       ruby-font-lock-syntax-table
                        ruby-font-lock-syntactic-keywords))
 
 (defun haml-handle-filter (filter-name limit fn)
@@ -207,7 +200,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 "^ *\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t)
+  (when (re-search-forward "^[ \t]*\\(-\\|[&!]?[=~]\\) \\(.*\\)$" limit t)
     (haml-fontify-region-as-ruby (match-beginning 2) (match-end 2))))
 
 (defun haml-highlight-ruby-tag (limit)
@@ -222,7 +215,7 @@ For example, this will highlight all of the following:
   %p[@bar]
   %p= 'baz'
   %p{:foo => 'bar'}[@bar]= 'baz'"
-  (when (re-search-forward "^ *[%.#]" limit t)
+  (when (re-search-forward "^[ \t]*[%.#]" limit t)
     (forward-char -1)
 
     ;; Highlight tag, classes, and ids
@@ -352,7 +345,8 @@ 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)
@@ -405,7 +399,6 @@ 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
@@ -618,18 +611,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 " *")
+      (haml-move "[ \t]*")
       (unless (haml-move "[a-z0-9_:\\-]+")
-        (return-from haml-parse-new-attr-hash (haml-move " *$")))
+        (return-from haml-parse-new-attr-hash (haml-move "[ \t]*$")))
       (funcall fn 'name (match-beginning 0) (match-end 0))
-      (haml-move " *")
+      (haml-move "[ \t]*")
       (when (haml-move "=")
-        (haml-move " *")
+        (haml-move "[ \t]*")
         (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 " *")))
+        (haml-move "[ \t]*")))
     nil))
 
 (defun haml-compute-indentation ()
@@ -702,10 +695,19 @@ 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)))
+  (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)))))
     (save-excursion
-      (while (re-search-forward (concat "^" (make-string ci ?\s)) (mark) t)
-        (replace-match (make-string (max 0 (+ ci n)) ?\s))))))
+      (while (re-search-forward indent-rx (mark) t)
+        (let ((ci (current-indentation)))
+          (delete-horizontal-space)
+          (beginning-of-line)
+          (indent-to (max 0 (+ ci n))))))))
 
 (defun haml-electric-backspace (arg)
   "Delete characters or back-dent the current line.
@@ -728,8 +730,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))
-        (back-to-indentation)
-        (pop-mark)))))
+        (pop-mark)))
+    (back-to-indentation)))
 
 (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: 2.2.21
+;; Version: 3.0.19
 ;; Created: 2007-03-15
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, css
-;; Package-Requires: ((haml-mode "2.2.21"))
+;; Package-Requires: ((haml-mode "3.0.14"))
 
 ;;; Commentary:
 
@@ -43,11 +43,12 @@
   :group 'sass)
 
 (defvar sass-non-block-openers
-  '("^ *:[^ \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.")
+  '("^.*,$" ;; 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.")
 
 ;; Font lock
 
@@ -195,8 +196,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
-        unless (looking-at opener) return t
-        return nil))
+        if (looking-at opener) return nil
+        finally return t))
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))

data/vendor/plugins/haml/haml.gemspec

@@ -1,5 +1,4 @@
 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.
@@ -10,7 +9,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', 'Hampton Catlin']
+  spec.authors = ['Nathan Weizenbaum', 'Chris Eppstein', 'Hampton Catlin']
   spec.email = 'haml@googlegroups.com'
   spec.description = <<-END
       Haml (HTML Abstraction Markup Language) is a layer on top of XHTML or XML
@@ -25,36 +24,12 @@ HAML_GEMSPEC = Gem::Specification.new do |spec|
   spec.add_development_dependency 'yard', '>= 0.5.3'
   spec.add_development_dependency 'maruku', '>= 0.5.9'
 
-  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
+  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
   spec.homepage = 'http://haml-lang.com/'
-  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
+  spec.has_rdoc = false
+  spec.test_files = Dir['test/**/*_test.rb']
 end

data/vendor/plugins/haml/init.rbc

@@ -0,0 +1,404 @@
+!RBIX
+17831730954501249321
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+239
+26
+93
+0
+15
+29
+37
+0
+5
+45
+0
+1
+45
+0
+2
+65
+49
+3
+0
+49
+4
+1
+7
+5
+64
+7
+6
+64
+49
+7
+3
+47
+49
+8
+1
+30
+8
+191
+26
+93
+1
+15
+24
+13
+45
+9
+10
+12
+49
+11
+1
+10
+54
+8
+186
+15
+26
+93
+2
+15
+29
+73
+0
+5
+7
+6
+64
+47
+49
+8
+1
+30
+8
+180
+26
+93
+3
+15
+24
+13
+45
+9
+12
+12
+49
+11
+1
+10
+90
+8
+175
+15
+24
+19
+0
+15
+26
+93
+4
+15
+29
+110
+0
+7
+13
+98
+14
+1
+30
+8
+116
+25
+92
+4
+27
+8
+121
+15
+7
+15
+8
+122
+1
+13
+9
+160
+15
+45
+13
+16
+49
+17
+0
+49
+18
+0
+7
+19
+64
+49
+20
+1
+13
+10
+160
+15
+45
+13
+21
+49
+17
+0
+49
+18
+0
+7
+22
+64
+49
+20
+1
+9
+165
+1
+8
+172
+5
+20
+0
+47
+49
+23
+1
+25
+8
+180
+15
+92
+3
+27
+34
+92
+2
+27
+25
+8
+191
+15
+92
+1
+27
+34
+92
+0
+27
+15
+26
+93
+5
+15
+29
+210
+0
+7
+24
+98
+14
+1
+30
+8
+216
+25
+92
+5
+27
+8
+221
+15
+7
+15
+8
+222
+1
+9
+235
+45
+24
+25
+5
+48
+26
+49
+27
+1
+8
+236
+1
+15
+2
+11
+I
+c
+I
+1
+I
+0
+I
+0
+n
+p
+28
+x
+4
+File
+n
+n
+x
+11
+active_path
+x
+7
+dirname
+s
+3
+lib
+s
+4
+haml
+x
+4
+join
+x
+7
+require
+x
+9
+LoadError
+n
+x
+3
+===
+n
+x
+4
+Rake
+x
+16
+vm_const_defined
+s
+8
+constant
+n
+x
+11
+application
+x
+15
+top_level_tasks
+s
+4
+gems
+x
+8
+include?
+n
+s
+12
+gems:install
+x
+5
+raise
+x
+4
+Haml
+n
+x
+7
+binding
+x
+10
+init_rails
+p
+31
+I
+0
+I
+2
+I
+25
+I
+0
+I
+2a
+I
+3
+I
+37
+I
+5
+I
+49
+I
+0
+I
+4e
+I
+6
+I
+5b
+I
+d
+I
+5c
+I
+6
+I
+5f
+I
+a
+I
+7e
+I
+b
+I
+91
+I
+c
+I
+a5
+I
+a
+I
+ac
+I
+0
+I
+c3
+I
+12
+I
+ec
+I
+0
+I
+ef
+x
+55
+/Users/jim/Projects/radiant/vendor/plugins/haml/init.rb
+p
+1
+x
+1
+e