honkster-haml 2.1.0

data/extra/sass-mode.el

@@ -0,0 +1,137 @@
+;;; 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-syntax-table
+  (let ((st (make-syntax-table)))
+    (modify-syntax-entry ?- "w" st)
+    st))
+
+(defconst sass-selector-font-lock-keywords
+  '(("&"       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)))
+    ;; Attribute selectors (e.g. p[foo=bar])
+    ("\\[\\([^]=]+\\)" (1 font-lock-variable-name-face)
+     ("[~|$^*]?=\\([^]=]+\\)" nil nil (1 font-lock-string-face)))))
+
+(defconst sass-font-lock-keywords
+  '((sass-highlight-line 1 nil nil t)))
+
+(defconst sass-line-keywords
+  '(("@.*"     0 font-lock-constant-face)
+    ("/[/*].*" 0 font-lock-comment-face)
+    (".*"      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) or (REGEXP 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. Otherwise, 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) 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)
+              (funcall subexp-or-fn))
+            (end-of-line)
+            (return t)))))))
+
+(defun sass-highlight-selector ()
+  "Highlight a CSS selector starting at `point'
+and ending at `end-of-line'."
+  (end-of-line)
+  (let ((font-lock-keywords sass-selector-font-lock-keywords)
+        (font-lock-syntax-table sass-selector-syntax-table))
+    (font-lock-fontify-region
+     (point) (progn (end-of-line) (point))))
+  t)
+
+;; Constants
+
+;; Mode setup
+
+;;;###autoload
+(define-derived-mode sass-mode haml-mode "Sass"
+  "Major mode for editing Sass files."
+  (set-syntax-table (make-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 nil 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

data/lib/haml/engine.rb

@@ -0,0 +1,268 @@
+require 'haml/helpers'
+require 'haml/buffer'
+require 'haml/precompiler'
+require 'haml/filters'
+require 'haml/error'
+
+module Haml
+  # This is the class where all the parsing and processing of the Haml
+  # template is done. It can be directly used by the user by creating a
+  # new instance and calling <tt>to_html</tt> to render the template. For example:
+  #
+  #   template = File.read('templates/really_cool_template.haml')
+  #   haml_engine = Haml::Engine.new(template)
+  #   output = haml_engine.to_html
+  #   puts output
+  class Engine
+    include Precompiler
+
+    # Allow reading and writing of the options hash
+    attr :options, true
+
+    # This string contains the source code that is evaluated
+    # to produce the Haml document.
+    attr :precompiled, true
+
+    # A string containing the indentation used for the Haml document.
+    # nil if the indentation is ambiguous
+    # (for example, for a single-level document).
+    attr :indentation, true
+
+    # 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
+
+    # Creates a new instace of Haml::Engine that will compile the given
+    # template string when <tt>render</tt> is called.
+    # See the Haml module documentation for available options.
+    #
+    #--
+    # When adding options, remember to add information about them
+    # to lib/haml.rb!
+    #++
+    #
+    def initialize(template, options = {})
+      @options = {
+        :suppress_eval => false,
+        :attr_wrapper => "'",
+
+        # Don't forget to update the docs in lib/haml.rb if you update these
+        :autoclose => %w[meta img link br hr input area param col base],
+        :preserve => %w[textarea pre],
+
+        :filename => '(haml)',
+        :line => 1,
+        :ugly => false,
+        :format => :xhtml,
+        :escape_html => false
+      }
+      @options.merge! options
+      @index = 0
+
+      unless [:xhtml, :html4, :html5].include?(@options[:format])
+        raise Haml::Error, "Invalid format #{@options[:format].inspect}"
+      end
+
+      # :eod is a special end-of-document marker
+      @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
+      @template_index = 0
+      @to_close_stack = []
+      @output_tabs = 0
+      @template_tabs = 0
+      @flat = false
+      @newlines = 0
+      @precompiled = ''
+      @to_merge = []
+      @tab_change  = 0
+      @temp_count = 0
+
+      if @options[:filters]
+        warn <<END
+DEPRECATION WARNING:
+The Haml :filters option is deprecated and will be removed in version 2.2.
+Filters are now automatically registered.
+END
+      end
+
+      precompile
+    rescue Haml::Error => e
+      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
+      raise
+    end
+
+    # Processes the template and returns the result as a string.
+    #
+    # +scope+ is the context in which the template is evaluated.
+    # If it's a Binding or Proc object,
+    # Haml uses it as the second argument to Kernel#eval;
+    # otherwise, Haml just uses its #instance_eval context.
+    #
+    # Note that Haml modifies the evaluation context
+    # (either the scope object or the "self" object of the scope binding).
+    # It extends Haml::Helpers, and various instance variables are set
+    # (all prefixed with "haml").
+    # For example:
+    #
+    #   s = "foobar"
+    #   Haml::Engine.new("%p= upcase").render(s) #=> "<p>FOOBAR</p>"
+    #
+    #   # s now extends Haml::Helpers
+    #   s.responds_to?(:html_attrs) #=> true
+    #
+    # +locals+ is a hash of local variables to make available to the template.
+    # For example:
+    #
+    #   Haml::Engine.new("%p= foo").render(Object.new, :foo => "Hello, world!") #=> "<p>Hello, world!</p>"
+    #
+    # If a block is passed to render,
+    # that block is run when +yield+ is called
+    # within the template.
+    #
+    # Due to some Ruby quirks,
+    # if scope is a Binding or Proc object and a block is given,
+    # the evaluation context may not be quite what the user expects.
+    # In particular, it's equivalent to passing <tt>eval("self", scope)</tt> as scope.
+    # This won't have an effect in most cases,
+    # but if you're relying on local variables defined in the context of scope,
+    # they won't work.
+    def render(scope = Object.new, locals = {}, &block)
+      buffer = Haml::Buffer.new(scope.instance_variable_get('@haml_buffer'), options_for_buffer)
+
+      if scope.is_a?(Binding) || scope.is_a?(Proc)
+        scope_object = eval("self", scope)
+        scope = scope_object.instance_eval{binding} if block_given?
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      set_locals(locals.merge(:_hamlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
+
+      scope_object.instance_eval do
+        extend Haml::Helpers
+        @haml_buffer = buffer
+      end
+
+      eval(@precompiled, scope, @options[:filename], @options[:line])
+
+      # Get rid of the current buffer
+      scope_object.instance_eval do
+        @haml_buffer = buffer.upper
+      end
+
+      buffer.buffer
+    end
+    alias_method :to_html, :render
+
+    # Returns a proc that, when called,
+    # renders the template and returns the result as a string.
+    #
+    # +scope+ works the same as it does for render.
+    #
+    # The first argument of the returned proc is a hash of local variable names to values.
+    # However, due to an unfortunate Ruby quirk,
+    # the local variables which can be assigned must be pre-declared.
+    # This is done with the +local_names+ argument.
+    # For example:
+    #
+    #   # This works
+    #   Haml::Engine.new("%p= foo").render_proc(Object.new, :foo).call :foo => "Hello!"
+    #     #=> "<p>Hello!</p>"
+    #
+    #   # This doesn't
+    #   Haml::Engine.new("%p= foo").render_proc.call :foo => "Hello!"
+    #     #=> NameError: undefined local variable or method `foo'
+    #
+    # The proc doesn't take a block;
+    # any yields in the template will fail.
+    def render_proc(scope = Object.new, *local_names)
+      if scope.is_a?(Binding) || scope.is_a?(Proc)
+        scope_object = eval("self", scope)
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      eval("Proc.new { |*_haml_locals| _haml_locals = _haml_locals[0] || {};" +
+           precompiled_with_ambles(local_names) + "}\n", scope, @options[:filename], @options[:line])
+    end
+
+    # Defines a method on +object+
+    # with the given name
+    # that renders the template and returns the result as a string.
+    #
+    # If +object+ is a class or module,
+    # the method will instead by defined as an instance method.
+    # For example:
+    #
+    #   t = Time.now
+    #   Haml::Engine.new("%p\n  Today's date is\n  .date= self.to_s").def_method(t, :render)
+    #   t.render #=> "<p>\n  Today's date is\n  <div class='date'>Fri Nov 23 18:28:29 -0800 2007</div>\n</p>\n"
+    #
+    #   Haml::Engine.new(".upcased= upcase").def_method(String, :upcased_div)
+    #   "foobar".upcased_div #=> "<div class='upcased'>FOOBAR</div>\n"
+    #
+    # The first argument of the defined method is a hash of local variable names to values.
+    # However, due to an unfortunate Ruby quirk,
+    # the local variables which can be assigned must be pre-declared.
+    # This is done with the +local_names+ argument.
+    # For example:
+    #
+    #   # This works
+    #   obj = Object.new
+    #   Haml::Engine.new("%p= foo").def_method(obj, :render, :foo)
+    #   obj.render(:foo => "Hello!") #=> "<p>Hello!</p>"
+    #
+    #   # This doesn't
+    #   obj = Object.new
+    #   Haml::Engine.new("%p= foo").def_method(obj, :render)
+    #   obj.render(:foo => "Hello!") #=> NameError: undefined local variable or method `foo'
+    #
+    # Note that Haml modifies the evaluation context
+    # (either the scope object or the "self" object of the scope binding).
+    # It extends Haml::Helpers, and various instance variables are set
+    # (all prefixed with "haml").
+    def def_method(object, name, *local_names)
+      method = object.is_a?(Module) ? :module_eval : :instance_eval
+
+      object.send(method, "def #{name}(_haml_locals = {}); #{precompiled_with_ambles(local_names)}; end",
+                  @options[:filename], @options[:line])
+    end
+
+    private
+
+    def set_locals(locals, scope, scope_object)
+      scope_object.send(:instance_variable_set, '@_haml_locals', locals)
+      set_locals = locals.keys.map { |k| "#{k} = @_haml_locals[#{k.inspect}]" }.join("\n")
+      eval(set_locals, scope)
+    end
+
+    # Returns a hash of options that Haml::Buffer cares about.
+    # This should remain loadable from #inspect.
+    def options_for_buffer
+      {
+        :autoclose => @options[:autoclose],
+        :preserve => @options[:preserve],
+        :attr_wrapper => @options[:attr_wrapper],
+        :ugly => @options[:ugly],
+        :format => @options[:format]
+      }
+    end
+  end
+end

data/lib/haml/error.rb

@@ -0,0 +1,22 @@
+module Haml
+  # An exception raised by Haml code.
+  class Error < StandardError
+    # :stopdoc:
+
+    # By default, an error is taken to refer to the line of the template
+    # that was being processed when the exception was raised.
+    # However, if line is non-nil, it + 1 is used instead.
+    attr_reader :line
+
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+    # :startdoc:
+  end
+
+  # SyntaxError is the type of exception raised when Haml encounters an
+  # ill-formatted document.
+  # It's not particularly interesting, except in that it includes Haml::Error.
+  class SyntaxError < Haml::Error; end
+end