haml-edge 2.1.1

data/extra/sass-mode.el

@@ -0,0 +1,200 @@
+;;; sass-mode.el --- Major mode for editing Sass files
+
+;; Copyright (c) 2007, 2008 Nathan Weizenbaum
+
+;; Author: Nathan Weizenbaum
+;; URL: http://github.com/nex3/haml/tree/master
+;; Version: 1.0
+;; Keywords: markup, language
+
+;;; Commentary:
+
+;; Because Sass's indentation schema is similar
+;; to that of YAML and Python, many indentation-related
+;; functions are similar to those in yaml-mode and python-mode.
+
+;; To install, save this on your load path and add the following to
+;; your .emacs file:
+;;
+;; (require 'sass-mode)
+
+;;; Code:
+
+(require 'haml-mode)
+
+;; User definable variables
+
+(defgroup sass nil
+  "Support for the Sass template language."
+  :group 'languages
+  :prefix "sass-")
+
+(defcustom sass-mode-hook nil
+  "Hook run when entering Sass mode."
+  :type 'hook
+  :group 'sass)
+
+(defcustom sass-indent-offset 2
+  "Amount of offset per level of indentation."
+  :type 'integer
+  :group 'sass)
+
+(defvar sass-non-block-openers
+  '("^ *:[^ \t]+[ \t]+[^ \t]"
+    "^ *[^ \t:]+[ \t]*[=:][ \t]*[^ \t]")
+  "A list of regexps that match lines of Sass that couldn't have
+text nested beneath them.")
+
+;; Font lock
+
+(defconst sass-selector-font-lock-keywords
+  '(;; Attribute selectors (e.g. p[foo=bar])
+    ("\\[\\([^]=]+\\)" (1 font-lock-variable-name-face)
+     ("[~|$^*]?=\\([^]=]+\\)" nil nil (1 font-lock-string-face)))
+    ("&"       0 font-lock-constant-face)
+    ("\\.\\w+" 0 font-lock-type-face)
+    ("#\\w+"   0 font-lock-keyword-face)
+    ;; Pseudo-selectors, optionally with arguments (e.g. :first, :nth-child(12))
+    ("\\(::?\\w+\\)" (1 font-lock-function-name-face)
+     ("(\\([^)]+\\))" nil nil (1 font-lock-string-face)))))
+
+(defconst sass-script-font-lock-keywords
+  `(("\"\\([^\"\\\\]\\|\\\\.\\)*\"" 0 font-lock-string-face)
+    ("!\\w+" 0 font-lock-variable-name-face)
+    ("#[0-9a-fA-F]\\{0,6\\}" 0 font-lock-preprocessor-face)
+    (,(regexp-opt
+       '("true" "false" "black" "silver" "gray" "white" "maroon" "red"
+         "purple" "fuchsia" "green" "lime" "olive" "yellow" "navy"
+         "blue" "teal" "aqua"))
+     0 font-lock-constant-face)
+    (,(regexp-opt '("and" "or" "not")) 0 font-lock-keyword-face)))
+
+(defconst sass-syntax-table
+  (let ((st (make-syntax-table)))
+    (modify-syntax-entry ?- "w" st)
+    st))
+
+(defconst sass-script-syntax-table
+  (let ((st (make-syntax-table sass-syntax-table)))
+    (modify-syntax-entry ?- "." st)
+    st))
+
+(defconst sass-font-lock-keywords
+  '((sass-highlight-line 1 nil nil t)))
+
+(defconst sass-line-keywords
+  '(("@\\(\\w+\\)"    0 font-lock-keyword-face sass-highlight-directive)
+    ("/[/*].*"  0 font-lock-comment-face)
+    ("[=+]\\w+" 0 font-lock-function-name-face sass-highlight-script-after-match)
+    ("!\\w+"    0 font-lock-variable-name-face sass-highlight-script-after-match)
+    (":\\w+"    0 font-lock-variable-name-face)
+    ("\\w+\s*:" 0 font-lock-variable-name-face)
+    ("\\(\\w+\\)\s*="  1 font-lock-variable-name-face sass-highlight-script-after-match)
+    ("\\(:\\w+\\)\s*=" 1 font-lock-variable-name-face sass-highlight-script-after-match)
+    (".*"      sass-highlight-selector))
+  "A list of full-line Sass syntax to highlight,
+used by `sass-highlight-line'.
+
+Each item is either of the form (REGEXP SUBEXP FACE), (REGEXP FN),
+or (REGEXP SUBEXP FACE FN). Each REGEXP is run successively on the
+beginning of non-whitespace on the current line until one matches.
+If it has SUBEXP and FACE, then SUBEXP is highlighted using FACE.
+If it has FN, FN is run.")
+
+(defun sass-highlight-line (limit)
+  "Highlight a single line using some Sass single-line syntax,
+taken from `sass-line-keywords'."
+  (save-match-data
+    (when (re-search-forward "^ *\\(.+\\)$" limit t)
+      (goto-char (match-beginning 1))
+      (dolist (keyword sass-line-keywords)
+        (destructuring-bind (keyword subexp-or-fn &optional face fn) keyword
+          (when (looking-at keyword)
+            (if (integerp subexp-or-fn)
+                (put-text-property (match-beginning subexp-or-fn)
+                                   (match-end subexp-or-fn)
+                                   'face face)
+              (setq fn subexp-or-fn))
+            (when fn (funcall fn))
+            (end-of-line)
+            (return t)))))))
+
+(defun sass-highlight-selector ()
+  "Highlight a CSS selector starting at `point'
+and ending at `end-of-line'."
+  (let ((font-lock-keywords sass-selector-font-lock-keywords)
+        font-lock-multiline)
+    (font-lock-fontify-region
+     (point) (progn (end-of-line) (point))))
+  t)
+
+(defun sass-highlight-script (beg end)
+  "Highlight a section of SassScript between BEG and END."
+  (save-match-data
+    (with-syntax-table sass-script-syntax-table
+      (let ((font-lock-keywords sass-script-font-lock-keywords)
+            font-lock-syntax-table
+            font-lock-extend-region-functions)
+        (font-lock-fontify-region beg end)))))
+
+(defun sass-highlight-script-after-match ()
+  (end-of-line)
+  (sass-highlight-script (match-end 0) (point)))
+
+(defun sass-highlight-directive ()
+  (goto-char (match-end 0))
+  (block nil
+    (case (intern (match-string 1))
+      (for
+       (unless (looking-at " +!\\w+") (return))
+       (put-text-property (match-beginning 0) (match-end 0)
+                          'face font-lock-variable-name-face)
+       (goto-char (match-end 0))
+       (unless (looking-at " +from") (return))
+       (put-text-property (match-beginning 0) (match-end 0)
+                          'face font-lock-keyword-face)
+       (goto-char (match-end 0))
+       (when (looking-at " +\\(.+?\\) +\\(to\\|through\\)")
+         (sass-highlight-script (match-beginning 1) (match-end 1))
+         (put-text-property (match-beginning 2) (match-end 2)
+                            'face font-lock-keyword-face))
+       (sass-highlight-script-after-match))
+
+      (else
+       (unless (looking-at " +if") (return))
+       (put-text-property (match-beginning 0) (match-end 0)
+                          'face font-lock-keyword-face)
+       (sass-highlight-script-after-match))
+
+      ((if while debug) (sass-highlight-script-after-match)))))
+
+;; Constants
+
+;; Mode setup
+
+;;;###autoload
+(define-derived-mode sass-mode haml-mode "Sass"
+  "Major mode for editing Sass files."
+  (set-syntax-table sass-syntax-table)
+  (setq font-lock-extend-region-functions
+        '(font-lock-extend-region-wholelines font-lock-extend-region-multiline))
+  (setq font-lock-multiline nil)
+  (setq comment-start "/*")
+  (set (make-local-variable 'haml-indent-function) 'sass-indent-p)
+  (set (make-local-variable 'haml-indent-offset) sass-indent-offset)
+  (setq font-lock-defaults '(sass-font-lock-keywords t t)))
+
+;; Indentation
+
+(defun sass-indent-p ()
+  "Returns t 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))
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))
+
+;; Setup/Activation
+(provide 'sass-mode)
+;;; sass-mode.el ends here

data/init.rb

@@ -0,0 +1,8 @@
+begin
+  require File.join(File.dirname(__FILE__), 'lib', 'haml') # From here
+rescue LoadError
+  require 'haml' # From gem
+end
+
+# Load Haml and Sass
+Haml.init_rails(binding)

data/lib/haml/buffer.rb

@@ -0,0 +1,255 @@
+module Haml
+  # This class is used only internally. It holds the buffer of XHTML that
+  # is eventually output by Haml::Engine's to_html method. It's called
+  # from within the precompiled code, and helps reduce the amount of
+  # processing done within instance_eval'd code.
+  class Buffer
+    include Haml::Helpers
+    include Haml::Util
+
+    # The string that holds the compiled XHTML. This is aliased as
+    # _erbout for compatibility with ERB-specific code.
+    attr_accessor :buffer
+
+    # The options hash passed in from Haml::Engine.
+    attr_accessor :options
+
+    # The Buffer for the enclosing Haml document.
+    # This is set for partials and similar sorts of nested templates.
+    # It's nil at the top level (see #toplevel?).
+    attr_accessor :upper
+
+    # See #active?
+    attr_writer :active
+
+    # True if the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # True if the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # True if the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # True if the format is HTML5
+    def html5?
+      @options[:format] == :html5
+    end
+
+    # True if this buffer is a top-level template,
+    # as opposed to a nested partial.
+    def toplevel?
+      upper.nil?
+    end
+
+    # True if this buffer is currently being used to render a Haml template.
+    # However, this returns false if a subtemplate is being rendered,
+    # even if it's a subtemplate of this buffer's template.
+    def active?
+      @active
+    end
+
+    # Gets the current tabulation of the document.
+    def tabulation
+      @real_tabs + @tabulation
+    end
+
+    # Sets the current tabulation of the document.
+    def tabulation=(val)
+      val = val - @real_tabs
+      @tabulation = val > -1 ? val : 0
+    end
+
+    # Creates a new buffer.
+    def initialize(upper = nil, options = {})
+      @active = true
+      @upper = upper
+      @options = {
+        :attr_wrapper => "'",
+        :ugly => false,
+        :format => :xhtml
+      }.merge options
+      @buffer = ""
+      @tabulation = 0
+
+      # The number of tabs that Engine thinks we should have
+      # @real_tabs + @tabulation is the number of tabs actually output
+      @real_tabs = 0
+    end
+
+    def push_text(text, tab_change, dont_tab_up)
+      if @tabulation > 0
+        # Have to push every line in by the extra user set tabulation.
+        # Don't push lines with just whitespace, though,
+        # because that screws up precompiled indentation.
+        text.gsub!(/^(?!\s+$)/m, tabs)
+        text.sub!(tabs, '') if dont_tab_up
+      end
+
+      @buffer << text
+      @real_tabs += tab_change
+    end
+
+    def adjust_tabs(tab_change)
+      @real_tabs += tab_change
+    end
+
+    Haml::Util.def_static_method(self, :format_script, [:result],
+                                 :preserve_script, :in_tag, :preserve_tag, :escape_html,
+                                 :nuke_inner_whitespace, :interpolated, :ugly, <<RUBY)
+      <% unless ugly %>
+        # If we're interpolated,
+        # then the custom tabulation is handled in #push_text.
+        # The easiest way to avoid it here is to reset @tabulation.
+        <% if interpolated %>
+          old_tabulation = @tabulation
+          @tabulation = 0
+        <% end %>
+
+        tabulation = @real_tabs
+        result = result.to_s.<% if nuke_inner_whitespace %>strip<% else %>rstrip<% end %>
+      <% else %>
+        result = result.to_s<% if nuke_inner_whitespace %>.strip<% end %>
+      <% end %>
+
+      <% if escape_html %> result = html_escape(result) <% end %>
+
+      <% if preserve_tag %>
+        result = Haml::Helpers.preserve(result)
+      <% elsif preserve_script %>
+        result = Haml::Helpers.find_and_preserve(result, options[:preserve])
+      <% end %>
+
+      <% if ugly %>
+        return result
+      <% else %>
+
+        has_newline = result.include?("\\n") 
+        <% if in_tag && !nuke_inner_whitespace %>
+          <% unless preserve_tag %> if !has_newline <% end %>
+          @real_tabs -= 1
+          <% if interpolated %> @tabulation = old_tabulation <% end %>
+          return result
+          <% unless preserve_tag %> end <% end %>
+        <% end %>
+
+        # Precompiled tabulation may be wrong
+        <% if !interpolated && !in_tag %>
+          result = tabs + result if @tabulation > 0
+        <% end %>
+
+        if has_newline
+          result = result.gsub "\\n", "\\n" + tabs(tabulation)
+
+          # Add tabulation if it wasn't precompiled
+          <% if in_tag && !nuke_inner_whitespace %> result = tabs(tabulation) + result <% end %>
+        end
+
+        <% if in_tag && !nuke_inner_whitespace %>
+          result = "\\n\#{result}\\n\#{tabs(tabulation-1)}"
+          @real_tabs -= 1
+        <% end %>
+        <% if interpolated %> @tabulation = old_tabulation <% end %>
+        result
+      <% end %>
+RUBY
+
+    # Takes the various information about the opening tag for an
+    # element, formats it, and adds it to the buffer.
+    def open_tag(name, self_closing, try_one_line, preserve_tag, escape_html, class_id,
+                 nuke_outer_whitespace, nuke_inner_whitespace, obj_ref, content, *attributes_hashes)
+      tabulation = @real_tabs
+
+      attributes = class_id
+      attributes_hashes.each do |old|
+        self.class.merge_attrs(attributes, to_hash(old.map {|k, v| [k.to_s, v]}))
+      end
+      self.class.merge_attrs(attributes, parse_object_ref(obj_ref)) if obj_ref
+
+      if self_closing && xhtml?
+        str = " />" + (nuke_outer_whitespace ? "" : "\n")
+      else
+        str = ">" + ((if self_closing && html?
+                        nuke_outer_whitespace
+                      else
+                        try_one_line || preserve_tag || nuke_inner_whitespace
+                      end) ? "" : "\n")
+      end
+
+      attributes = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
+      @buffer << "#{nuke_outer_whitespace || @options[:ugly] ? '' : tabs(tabulation)}<#{name}#{attributes}#{str}"
+
+      if content
+        @buffer << "#{content}</#{name}>" << (nuke_outer_whitespace ? "" : "\n")
+        return
+      end
+
+      @real_tabs += 1 unless self_closing || nuke_inner_whitespace
+    end
+
+    def self.merge_attrs(to, from)
+      if to['id'] && from['id']
+        to['id'] << '_' << from.delete('id')
+      elsif to['id'] || from['id']
+        from['id'] ||= to['id']
+      end
+
+      if to['class'] && from['class']
+        # Make sure we don't duplicate class names
+        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).join(' ')
+      elsif to['class'] || from['class']
+        from['class'] ||= to['class']
+      end
+
+      to.merge!(from)
+    end
+
+    private
+
+    # Some of these methods are exposed as public class methods
+    # so they can be re-used in helpers.
+
+    @@tab_cache = {}
+    # Gets <tt>count</tt> tabs. Mostly for internal use.
+    def tabs(count = 0)
+      tabs = [count + @tabulation, 0].max
+      @@tab_cache[tabs] ||= '  ' * tabs
+    end
+
+    # Takes an array of objects and uses the class and id of the first
+    # one to create an attributes hash.
+    # The second object, if present, is used as a prefix,
+    # just like you can do with dom_id() and dom_class() in Rails
+    def parse_object_ref(ref)
+      prefix = ref[1]
+      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 = underscore(ref.class)
+      id = "#{class_name}_#{ref.id || 'new'}"
+      if prefix
+        class_name = "#{ prefix }_#{ class_name}"
+        id = "#{ prefix }_#{ id }"
+      end
+
+      {'id' => id, 'class' => class_name}
+    end
+
+    # Changes a word from camel case to underscores.
+    # Based on the method of the same name in Rails' Inflector,
+    # but copied here so it'll run properly without Rails.
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '_').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end