simple-templater 0.0.1.4 → 0.0.1.5

data/gems/gems/haml-2.2.16/extra/sass-mode.el

@@ -1,206 +0,0 @@
-;;; 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/gems/gems/haml-2.2.16/extra/update_watch.rb

@@ -1,13 +0,0 @@
-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/gems/gems/haml-2.2.16/init.rb

@@ -1,16 +0,0 @@
-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/gems/gems/haml-2.2.16/lib/haml/buffer.rb

@@ -1,302 +0,0 @@
-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 [{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 [{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 [{String => String}] The attribute hash to merge into
-    # @param from [{String => String}] The attribute hash to merge from
-    # @return [{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