middleman 0.11.5 → 0.12.0.pre

data/lib/middleman/vendor/gems/gems/haml-2.2.14/extra/sass-mode.el

@@ -0,0 +1,206 @@
+;;; 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: 2.2.7
+;; Created: 2007-03-15
+;; By: Nathan Weizenbaum
+;; Keywords: markup, language, css
+;; Package-Requires: ((haml-mode "2.2.7"))
+
+;;; 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 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
+
+(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)
+    (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.
+This syntax is taken from `sass-line-keywords'.
+LIMIT is the limit of the search."
+  (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 ()
+  "Highlight a section of SassScript after the last match."
+  (end-of-line)
+  (sass-highlight-script (match-end 0) (point)))
+
+(defun sass-highlight-directive ()
+  "Highlight a Sass 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 ()
+  "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))
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.sass$" . sass-mode))
+
+;; Setup/Activation
+(provide 'sass-mode)
+;;; sass-mode.el ends here

data/lib/middleman/vendor/gems/gems/haml-2.2.14/extra/update_watch.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'sinatra'
+require 'json'
+set :port, 3123
+set :environment, :production
+enable :lock
+Dir.chdir(File.dirname(__FILE__) + "/..")
+
+post "/" do
+  puts "Recieved payload!"
+  puts "Rev: #{`git name-rev HEAD`.strip}"
+  system %{rake handle_update --trace REF=#{JSON.parse(params["payload"])["ref"].inspect}}
+end

data/lib/middleman/vendor/gems/gems/haml-2.2.14/init.rb

@@ -0,0 +1,16 @@
+begin
+  require File.join(File.dirname(__FILE__), 'lib', 'haml') # From here
+rescue LoadError
+  begin
+    require 'haml' # From gem
+  rescue LoadError => e
+    # gems:install may be run to install Haml with the skeleton plugin
+    # but not the gem itself installed.
+    # Don't die if this is the case.
+    raise e unless defined?(Rake) && Rake.application.top_level_tasks.include?('gems:install')
+  end
+end
+
+# Load Haml and Sass.
+# Haml may be undefined if we're running gems:install.
+Haml.init_rails(binding) if defined?(Haml)

data/lib/middleman/vendor/gems/gems/haml-2.2.14/lib/haml.rb

@@ -0,0 +1,40 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'haml/version'
+
+# The module that contains everything Haml-related:
+#
+# * {Haml::Engine} is the class used to render Haml within Ruby code.
+# * {Haml::Helpers} contains Ruby helpers available within Haml templates.
+# * {Haml::Template} interfaces with web frameworks (Rails in particular).
+# * {Haml::Error} is raised when Haml encounters an error.
+# * {Haml::HTML} handles conversion of HTML to Haml.
+#
+# Also see the {file:HAML_REFERENCE.md full Haml reference}.
+module Haml
+  extend Haml::Version
+
+  # A string representing the version of Haml.
+  # A more fine-grained representation is available from Haml.version.
+  VERSION = version[:string] unless defined?(Haml::VERSION)
+
+  # Initializes Haml for Rails.
+  #
+  # This method is called by `init.rb`,
+  # which is run by Rails on startup.
+  # We use it rather than putting stuff straight into `init.rb`
+  # so we can change the initialization behavior
+  # without modifying the file itself.
+  #
+  # @param binding [Binding] The context of the `init.rb` file.
+  #   This isn't actually used;
+  #   it's just passed in in case it needs to be used in the future
+  def self.init_rails(binding)
+    # No &method here for Rails 2.1 compatibility
+    %w[haml/template sass sass/plugin].each {|f| require f}
+  end
+end
+
+require 'haml/util'
+require 'haml/engine'

data/lib/middleman/vendor/gems/gems/haml-2.2.14/lib/haml/buffer.rb

@@ -0,0 +1,302 @@
+module Haml
+  # This class is used only internally. It holds the buffer of HTML that
+  # is eventually output as the resulting document.
+  # It's called from within the precompiled code,
+  # and helps reduce the amount of processing done within `instance_eval`ed code.
+  class Buffer
+    include Haml::Helpers
+    include Haml::Util
+
+    # The string that holds the compiled HTML. This is aliased as
+    # `_erbout` for compatibility with ERB-specific code.
+    #
+    # @return [String]
+    attr_accessor :buffer
+
+    # The options hash passed in from {Haml::Engine}.
+    #
+    # @return [Hash<String, Object>]
+    # @see Haml::Engine#options_for_buffer
+    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?}).
+    #
+    # @return [Buffer]
+    attr_accessor :upper
+
+    # nil if there's no capture_haml block running,
+    # and the position at which it's beginning the capture if there is one.
+    #
+    # @return [Fixnum, nil]
+    attr_accessor :capture_position
+
+    # @return [Boolean]
+    # @see #active?
+    attr_writer :active
+
+    # @return [Boolean] Whether or not the format is XHTML
+    def xhtml?
+      not html?
+    end
+
+    # @return [Boolean] Whether or not the format is any flavor of HTML
+    def html?
+      html4? or html5?
+    end
+
+    # @return [Boolean] Whether or not the format is HTML4
+    def html4?
+      @options[:format] == :html4
+    end
+
+    # @return [Boolean] Whether or not the format is HTML5.
+    def html5?
+      @options[:format] == :html5
+    end
+
+    # @return [Boolean] Whether or not this buffer is a top-level template,
+    #   as opposed to a nested partial
+    def toplevel?
+      upper.nil?
+    end
+
+    # Whether or not this buffer is currently being used to render a Haml template.
+    # Returns `false` if a subtemplate is being rendered,
+    # even if it's a subtemplate of this buffer's template.
+    #
+    # @return [Boolean]
+    def active?
+      @active
+    end
+
+    # @return [Fixnum] The current indentation level of the document
+    def tabulation
+      @real_tabs + @tabulation
+    end
+
+    # Sets the current tabulation of the document.
+    #
+    # @param val [Fixnum] The new tabulation
+    def tabulation=(val)
+      val = val - @real_tabs
+      @tabulation = val > -1 ? val : 0
+    end
+
+    # @param upper [Buffer] The parent buffer
+    # @param options [Hash<Symbol, Object>] An options hash.
+    #   See {Haml::Engine#options\_for\_buffer}
+    def initialize(upper = nil, options = {})
+      @active = true
+      @upper = upper
+      @options = options
+      @buffer = ruby1_8? ? "" : "".encode(Encoding.find(options[:encoding]))
+      @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
+
+    # Appends text to the buffer, properly tabulated.
+    # Also modifies the document's indentation.
+    #
+    # @param text [String] The text to append
+    # @param tab_change [Fixnum] The number of tabs by which to increase
+    #   or decrease the document's indentation
+    # @param dont_tab_up [Boolean] If true, don't indent the first line of `text`
+    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
+
+    # Modifies the indentation of the document.
+    #
+    # @param tab_change [Fixnum] The number of tabs by which to increase
+    #   or decrease the document's indentation
+    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)
+      <% # Escape HTML here so that the safety of the string is preserved in Rails
+         result_name = escape_html ? "html_escape(result.to_s)" : "result.to_s" %>
+      <% 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_name %>.<% if nuke_inner_whitespace %>strip<% else %>rstrip<% end %>
+      <% else %>
+        result = <%= result_name %><% if nuke_inner_whitespace %>.strip<% end %>
+      <% 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 appends 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
+
+    # Remove the whitespace from the right side of the buffer string.
+    # Doesn't do anything if we're at the beginning of a capture_haml block.
+    def rstrip!
+      if capture_position.nil?
+        buffer.rstrip!
+        return
+      end
+
+      buffer << buffer.slice!(capture_position..-1).rstrip
+    end
+
+    # Merges two attribute hashes.
+    # This is the same as `to.merge!(from)`,
+    # except that it merges id and class attributes.
+    #
+    # ids are concatenated with `"_"`,
+    # and classes are concatenated with `" "`.
+    #
+    # Destructively modifies both `to` and `from`.
+    #
+    # @param to [Hash<String, String>] The attribute hash to merge into
+    # @param from [Hash<String, String>] The attribute hash to merge from
+    # @return [Hash<String, String>] `to`, after being merged
+    def self.merge_attrs(to, from)
+      if to['id'] && from['id']
+        to['id'] << '_' << from.delete('id').to_s
+      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(' ')).sort.join(' ')
+      elsif to['class'] || from['class']
+        from['class'] ||= to['class']
+      end
+
+      to.merge!(from)
+    end
+
+    private
+
+    @@tab_cache = {}
+    # Gets `count` 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