;ELC ;;; Compiled ;;; in Emacs version 24.5.1 ;;; with all optimizations. ;;; This file contains utf-8 non-ASCII characters, ;;; and so cannot be loaded into Emacs 22 or earlier. (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (string-lessp emacs-version "23") (error "`%s' was compiled for Emacs 23 or later" #$)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\300\302\303\304#\210\300\305\303\304#\210\300\306\303\304#\210\300\307\303\304#\204$\300\310\311\304#\210\312\313\303\314\315\316\317\320&\210\321\322\303\323\324\325\315\313&\210\321\326\327\330\324\331\315\313&\210\321\332\304\333\324\334\315\313&\207" [require ruby-mode css-mode nil t textile-mode markdown-mode js javascript-mode "javascript" custom-declare-group haml "Support for the Haml template language." :group languages :prefix "haml-" custom-declare-variable haml-mode-hook "Hook run when entering Haml mode." :type hook haml-indent-offset 2 "Amount of offset per level of indentation." integer haml-backspace-backdents-nesting "Non-nil to have `haml-electric-backspace' re-indent blocks of code.\nThis means that all code nested beneath the backspaced line is\nre-indented along with the line itself." boolean] 8) #@281 A function for checking if nesting is allowed. This function should look at the current line and return t if the next line could be nested within this line. The function can also return a positive integer to indicate a specific level to which the current line could be indented. (defvar haml-indent-function 'haml-indent-p (#$ . 1271)) #@72 A regexp matching the beginning of a Haml tag, through (), {}, and []. (defconst haml-tag-beg-re "^[ ]*\\([%\\.#][a-z0-9_:\\-]+\\)+\\(?:(.*)\\|{.*}\\|\\[.*\\]\\)*" (#$ . 1614)) #@164 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. (defvar haml-block-openers (byte-code "\301P\302\303\304BBB\207" [haml-tag-beg-re "[><]*[ ]*$" "^[ ]*[&!]?[-=~].*do[ ]*\\(|.*|[ ]*\\)?$" "^[ ]*[&!]?[-=~][ ]*\\(\\(?:begin\\|e\\(?:ls\\(?:e\\|if\\)\\|nsure\\)\\|for\\|if\\|rescue\\|un\\(?:less\\|til\\)\\|wh\\(?:en\\|ile\\)\\)\\)" ("^[ ]*/\\(\\[.*\\]\\)?[ ]*$" "^[ ]*-#" "^[ ]*:")] 4) (#$ . 1799)) #@129 Create a regexp to match a block starting with RE. The line containing RE is matched, as well as all lines indented beneath it. (defalias 'haml-nested-regexp #[(re) "\301\302Q\207" [re "^\\([ ]*\\)\\(" "\\)\\([ ]*\\(?:\n\\(?:\\1 +[^\n]*\\)?\\)*\n?\\)$"] 3 (#$ . 2325)]) (defconst haml-font-lock-keywords '((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) haml-highlight-comment haml-highlight-filter ("^!!!.*" 0 font-lock-constant-face) ("\\s| *$" 0 font-lock-string-face))) (defconst haml-filter-re (haml-nested-regexp ":[[:alnum:]_\\-]+")) (defconst haml-comment-re (haml-nested-regexp "\\(?:-\\#\\|/\\)[^\n]*")) #@50 Highlight any -# or / comment found up to LIMIT. (defalias 'haml-highlight-comment #[(limit) "\304 \305#\205\306\224\306\225\307 \n\310\311$\210\nb*\207" [haml-comment-re limit end beg re-search-forward t 0 put-text-property face font-lock-comment-face] 5 (#$ . 3085)]) #@300 Fontify a region between BEG and END using another mode's fontification. KEYWORDS, SYNTAX-TABLE, SYNTACTIC-KEYWORDS and SYNTAX-PROPERTIZE-FN are the values of that mode's `font-lock-keywords', `font-lock-syntax-table', `font-lock-syntactic-keywords', and `syntax-propertize-function' respectively. (defalias 'haml-fontify-region #[(beg end keywords syntax-table syntactic-keywords syntax-propertize-fn) "\212\306 \307\216 \n \f\310\311\312\211\211\f \214S}\210\313S\". \207" [save-match-data-internal keywords syntax-table syntactic-keywords syntax-propertize-fn font-lock-keywords-case-fold-search match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) undecided t nil font-lock-fontify-region font-lock-extend-region-functions font-lock-keywords-only font-lock-dont-widen font-lock-multiline syntax-propertize-function font-lock-syntactic-keywords font-lock-syntax-table font-lock-keywords beg end] 9 (#$ . 3367)]) #@75 Use Ruby's font-lock variables to fontify the region between BEG and END. (defalias 'haml-fontify-region-as-ruby #[(beg end) "\305 \n \306\304!\205\f\f\307\310!\205\310&\207" [beg end ruby-font-lock-keywords ruby-font-lock-syntax-table ruby-font-lock-syntactic-keywords haml-fontify-region boundp fboundp ruby-syntax-propertize-function] 8 (#$ . 4357)]) #@118 Fontify CSS code from BEG to END. This requires that `css-mode' is available. `css-mode' is included with Emacs 23. (defalias 'haml-fontify-region-as-css #[(beg end) "\304\302!\205\305 \n \306\211&\207" [beg end css-font-lock-keywords css-mode-syntax-table boundp haml-fontify-region nil] 7 (#$ . 4723)]) #@209 Fontify javascript code from BEG to END. This requires that Karl Landström's javascript mode be available, either as the "js.el" bundled with Emacs >= 23, or as "javascript.el" found in ELPA and elsewhere. (defalias 'haml-fontify-region-as-javascript #[(beg end) "\306\307!\203\n\206\306\310!\205 \306\307!\203\n\206\"\306\310!\205\" \306\307!\205)\311\211\205K\312\313!\203?\204?\313 \210\314 \315\f&+\207" [js--font-lock-keywords-3 js-font-lock-keywords-3 js-mode-syntax-table javascript-mode-syntax-table syntax-propertize syntax-table featurep js javascript-mode js-syntax-propertize fboundp js--update-quick-match-re haml-fontify-region nil keywords js--quick-match-re-func beg end] 8 (#$ . 5040)]) #@279 Highlight textile from BEG to END. This requires that `textile-mode' be available. Note that the results are not perfect, since `textile-mode' expects certain constructs such as "h1." to be at the beginning of a line, and indented Haml filters always have leading whitespace. (defalias 'haml-fontify-region-as-textile #[(beg end) "\303\302!\205\304 \n\305\211\211&\207" [beg end textile-font-lock-keywords boundp haml-fontify-region nil] 7 (#$ . 5780)]) #@87 Highlight markdown from BEG to END. This requires that `markdown-mode' be available. (defalias 'haml-fontify-region-as-markdown #[(beg end) "\304\302!\205\305 \n \306\211&\207" [beg end markdown-mode-font-lock-keywords markdown-mode-syntax-table boundp haml-fontify-region nil] 7 (#$ . 6246)]) #@266 An alist of (FILTER-NAME . FUNCTION) used to fontify code regions. FILTER-NAME is a string and FUNCTION is a function which will be used to fontify the filter's indented code region. FUNCTION will be passed the extents of that region in two arguments BEG and END. (defvar haml-fontify-filter-functions-alist '(("ruby" . haml-fontify-region-as-ruby) ("css" . haml-fontify-region-as-css) ("javascript" . haml-fontify-region-as-javascript) ("textile" . haml-fontify-region-as-textile) ("markdown" . haml-fontify-region-as-markdown)) (#$ . 6552)) #@61 Highlight any :filter region found in the text up to LIMIT. (defalias 'haml-highlight-filter #[(limit) "\306 \307#\2059\310\311\224\311\225T\312\n$\210\313\311!\314\315O\316\224T\316\225\317 \320\216\321 \"A\2060\322\f \"\210*\323\225b+\207" [haml-filter-re limit font-lock-preprocessor-face code-end code-start filter-name re-search-forward t put-text-property 2 face match-string 1 nil 3 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) assoc #[(beg end) "\302 \303\304$\207" [beg end put-text-property face font-lock-string-face] 5] 0 save-match-data-internal haml-fontify-filter-functions-alist] 5 (#$ . 7102)]) #@78 Regexp to match trailing ruby code which may continue onto subsequent lines. (defconst haml-possibly-multiline-code-re "\\(\\(?:.*?,[ ]*\n\\)*.*\\)" (#$ . 7783)) #@64 Regexp to match -, = or ~ blocks and any continued code lines. (defconst haml-ruby-script-re (concat "^[ ]*\\(-\\|[&!]?\\(?:=\\|~\\)\\)[^=]" haml-possibly-multiline-code-re) (#$ . 7952)) #@97 Highlight a Ruby script expression (-, =, or ~). LIMIT works as it does in `re-search-forward'. (defalias 'haml-highlight-ruby-script #[(limit) "\302 \303#\205\304\305\224\305\225\"\207" [haml-ruby-script-re limit re-search-forward t haml-fontify-region-as-ruby 2] 4 (#$ . 8146)]) #@121 Try matching and moving to the end of regular expression RE. Returns non-nil if the expression was sucessfully matched. (defalias 'haml-move #[(re) "\301!\205 \302\225b\210\303\207" [re looking-at 0 t] 2 (#$ . 8437)]) #@348 Highlight Ruby code within a Haml tag. LIMIT works as it does in `re-search-forward'. This highlights the tag attributes and object refs of the tag, as well as the script expression (-, =, or ~) following the tag. For example, this will highlight all of the following: %p{:foo => 'bar'} %p[@bar] %p= 'baz' %p{:foo => 'bar'}[@bar]= 'baz' (defalias 'haml-highlight-ruby-tag #[(limit) "\306\307\310#\205a\311u\210\312\313!\203?\314\315\224\315\225\316\317\224f\320 \321\"\203&\n\2029\320 \322\"\2031 \2029\320 \323\"\2059\f)$\210\202 \324\325\215\210\312\326!\210\327\330 P!\203Y\331\332\224\332\225\"\210\202`\311u\210\327\333!\210\310\207" [limit #1=#:--cl-var-- font-lock-keyword-face font-lock-function-name-face font-lock-variable-name-face haml-possibly-multiline-code-re re-search-forward "^[ ]*[%.#]" t -1 haml-move "\\([.#%]\\)[a-z0-9_:\\-]*" put-text-property 0 face 1 eql 37 35 46 --cl-block-loop-- (byte-code "\212\302\210`)\303\302f\304\"\203!\305u\210`\306!\210\307 `\"\210)\202\221\303\302f\310\"\203?\305u\210\311\312!\203\221m\204\221\305y\210\313 \210\202,\303\302f\314\"\203\214`\306!\210l\203\202`Sf\315=\203\202m\204\202\302y\210\212\302\210`)\316`\"@\317Y\203w\302\210\202~ b\210\306!\210)\202M\307 T`\"\210)\202\221\320\321\302\"\210)\202" [eol beg nil eql 91 1 haml-limited-forward-sexp haml-fontify-region-as-ruby 40 haml-parse-new-attr-hash #[(type beg end) "\304\305\"\203\306 \n\307 $\207\304\310\"\205\311 \n\"\207" [type beg end font-lock-constant-face eql name put-text-property face value haml-fontify-region-as-ruby] 5] beginning-of-line 123 44 parse-partial-sexp 0 throw --cl-block-loop--] 3) "[<>&!]+" looking-at "\\([=~]\\) " haml-fontify-region-as-ruby 2 "\\(\\)"] 7 (#$ . 8664)]) #@87 Highlight Ruby interpolation (#{foo}). LIMIT works as it does in `re-search-forward'. (defalias 'haml-highlight-interpolation #[(limit) "\304\305\306#\205/\307 \310\216\311u\210`\312!\210\313\nT`\"\210)`Sf\314=\203-\315`S`\316 $\210*\306\207" [limit save-match-data-internal beg font-lock-variable-name-face re-search-forward "\\(#{\\)" t match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) -1 haml-limited-forward-sexp haml-fontify-region-as-ruby 125 put-text-property face] 5 (#$ . 10441)]) #@104 Move forward using `forward-sexp' or to LIMIT, whichever comes first. With ARG, do it that many times. (defalias 'haml-limited-forward-sexp #[(limit &optional arg) "\301\302\303\304\217)\207" [forward-sexp-function nil err (byte-code "\214`}\210\302 !)\207" [limit arg forward-sexp] 2) ((scan-error (byte-code "A@\302\232\204\303\304A\"\210 b\207" [err limit "Unbalanced parentheses" signal scan-error] 3)))] 3 (#$ . 10992)]) #@77 If point is inside a block matching RE, return (start . end) for the block. (defalias 'haml-find-containing-block #[(re) "\212`\304\211\305 \210\306 !\204\307 \304\310#\203+\306 !\203+\n\311\225W\203+\311\224\311\225 \2052 B,\207" [end start pos re nil beginning-of-line looking-at re-search-backward t 0] 4 (#$ . 11430)]) #@226 Maybe extend the font lock region using EXTENDER. With point at the beginning of the font lock region, EXTENDER is called. If it returns a (START . END) pair, those positions are used to possibly extend the font lock region. (defalias 'haml-maybe-extend-region #[(extender) " \212b\210\f \211\203 @^ A]* U?\206%\n U?*\207" [font-lock-beg font-lock-end old-end old-beg extender new-bounds] 3 (#$ . 11772)]) #@63 Extend the font-lock region to any subsequent indented lines. (defalias 'haml-extend-region-nested-below #[nil "\300\301!\207" [haml-maybe-extend-region #[nil "\300 \210\301\302\303!!\205\304\224\304\225B\207" [beginning-of-line looking-at haml-nested-regexp "[^ ].*" 0] 3]] 2 (#$ . 12197)]) #@75 Extend the font-lock region to the smallest containing block matching RE. (defalias 'haml-extend-region-to-containing-block #[(re) "\300\301!\207" [haml-maybe-extend-region #[nil "\301!\207" [re haml-find-containing-block] 2]] 2 (#$ . 12498)]) #@53 Extend the font-lock region to an enclosing filter. (defalias 'haml-extend-region-filter #[nil "\301!\207" [haml-filter-re haml-extend-region-to-containing-block] 2 (#$ . 12749)]) #@54 Extend the font-lock region to an enclosing comment. (defalias 'haml-extend-region-comment #[nil "\301!\207" [haml-comment-re haml-extend-region-to-containing-block] 2 (#$ . 12936)]) #@66 Extend the font-lock region to encompass any current -/=/~ line. (defalias 'haml-extend-region-ruby-script #[nil "\301!\207" [haml-ruby-script-re haml-extend-region-to-containing-block] 2 (#$ . 13126)]) #@70 Extend the font-lock region to encompass multiline attribute hashes. (defalias 'haml-extend-region-multiline-hashes #[nil "\300\301!\207" [haml-maybe-extend-region #[nil "\303 \304\211\211\205W\305\n\236A\304\210`Sf\306=\203:\212\304\210`Sf\306=\2031m\2041\304y\210\202\307y\210\304\210`)\310\305\n\236A\311\n\236A\307#b\210\312 \206R\212\304\210`)!\210`B+\207" [start multiline-end attr-props haml-parse-multiline-attr-hash nil point 44 -1 + hash-indent haml-limited-forward-sexp] 5]] 2 (#$ . 13336)]) #@260 Extend the font lock region piecemeal. The result of calling this function repeatedly until it returns nil is that (FONT-LOCK-BEG . FONT-LOCK-END) will be the smallest possible region in which font-locking could be affected by changes in the initial region. (defalias 'haml-extend-region-contextual #[nil "\300 \206\301 \206\302 \206\303 \206\304 \206\305 \207" [haml-extend-region-filter haml-extend-region-comment haml-extend-region-ruby-script haml-extend-region-multiline-hashes haml-extend-region-nested-below font-lock-extend-region-multiline] 1 (#$ . 13863)]) #@45 Syntax table in use in `haml-mode' buffers. (defvar haml-mode-syntax-table (byte-code "\301 \302\303\304#\210\302\305\306#\210)\207" [table make-syntax-table modify-syntax-entry 58 "." 39 "\""] 4) (#$ . 14447)) (defvar haml-mode-map (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210)\207" [map make-sparse-keymap define-key [backspace] haml-electric-backspace "" "" haml-forward-sexp "" haml-backward-sexp "" haml-up-list "" haml-down-list " " haml-kill-line-and-indent "" haml-output-region "\f" haml-output-buffer] 4)) (byte-code "\300\301\302\303!\203\f\303\202 \304\"\207" [defalias haml-parent-mode fboundp prog-mode fundamental-mode] 4) #@161 Hook run after entering Haml mode. No problems result if this variable is not bound. `add-hook' automatically binds it. (This is true for all hook variables.) (defvar haml-mode-hook nil (#$ . 15248)) (byte-code "\300\301!\204\f\302\301\303\304#\210\300\207" [boundp haml-mode-map put definition-name haml-mode] 4) (defvar haml-mode-map (make-sparse-keymap)) (byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [haml-mode-map variable-documentation put purecopy "Keymap for `haml-mode'." boundp haml-mode-syntax-table definition-name haml-mode] 5) (defvar haml-mode-syntax-table (make-syntax-table)) (byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [haml-mode-syntax-table variable-documentation put purecopy "Syntax table for `haml-mode'." haml-mode-abbrev-table definition-name haml-mode] 5) (defvar haml-mode-abbrev-table (progn (define-abbrev-table 'haml-mode-abbrev-table nil) haml-mode-abbrev-table)) (byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [haml-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `haml-mode'." haml-mode derived-mode-parent haml-parent-mode] 5) #@214 Major mode for editing Haml files. \{haml-mode-map} In addition to any hooks its parent mode `haml-parent-mode' might have run, this mode runs the hook `haml-mode-hook', as the final step during initialization. (defalias 'haml-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2036 \321 =\203<\322\f\323 \"\210)\324)\325\"\204V)*=\204V\326)\325*C#\210\327 !\210\330\f!\210)*\331+\306\332!\210\307\306\333!\210\307\306\334!\210\335\306\336!\210\337\306\340!\210\307 \306\341!\210\342!\343,\344\345!\203\233\307%\346-)\347\350!\207" [delay-mode-hooks major-mode mode-name haml-mode-map haml-mode-syntax-table parent make-local-variable t haml-parent-mode haml-mode "Haml" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table (haml-extend-region-contextual) jit-lock-contextually font-lock-multiline indent-line-function haml-indent-line indent-region-function haml-indent-region parse-sexp-lookup-properties comment-start "-#" ((haml-font-lock-keywords) t t) boundp electric-indent-inhibit nil run-mode-hooks haml-mode-hook haml-mode-abbrev-table local-abbrev-table font-lock-extend-region-functions font-lock-defaults indent-tabs-mode] 6 (#$ . 16456) nil]) #@41 Comment the current block of Haml code. (defalias 'haml-comment-block #[nil "\212\302 \303 \210\304c\210\305 \210j\210\306 \210\307 \210\310 !*\207" [indent haml-indent-offset current-indentation back-to-indentation "-#" newline beginning-of-line haml-mark-sexp haml-reindent-region-by] 2 (#$ . 17888) nil]) #@43 Uncomment the current block of Haml code. (defalias 'haml-uncomment-block #[nil "\212\302 \210\303!\204\304 \210\302 \210\202\305 \210\306\307!\210\310 [!)\207" [haml-comment-re haml-indent-offset beginning-of-line looking-at haml-up-list haml-mark-sexp kill-line 1 haml-reindent-region-by] 2 (#$ . 18204) nil]) #@133 Replace the current block of Haml code with the HTML equivalent. Called from a program, START and END specify the region to indent. (defalias 'haml-replace-region #[(start end) "\212b\210\303  b\210\304 \305\306\307#\203\"\310\311\304 \nZ\312\"!\210\202 )\313 \314\315\307%)\207" [end start ci point-marker current-indentation re-search-forward "^ +" t replace-match make-string 32 shell-command-on-region "haml" "haml-output"] 6 (#$ . 18528) "r"]) #@129 Displays the HTML output for the current block of Haml code. Called from a program, START and END specify the region to indent. (defalias 'haml-output-region #[(start end) "\303 {!\210\304\305!r\nq\210\306\216\307 \210\310ed\"\210\311ed\312\313$+\207" [start end #1=#:temp-buffer kill-new generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) yank haml-indent-region shell-command-on-region "haml" "haml-output"] 5 (#$ . 18991) "r"]) #@45 Displays the HTML output for entire buffer. (defalias 'haml-output-buffer #[nil "\300ed\"\207" [haml-output-region] 3 (#$ . 19489) nil]) #@229 Move the point forward through any whitespace. The point will move forward at least one line, until it reaches either the end of the buffer or a line with no whitespace. If BACKWARD is non-nil, move the point backward instead. (defalias 'haml-forward-through-whitespace #[(&optional backward) "\203\303\202 \304\203\305\202\306\ny\210 \204\"\307\310!\204*\311\207" [backward endp arg -1 1 bobp eobp looking-at "^[ ]*$" nil] 2 (#$ . 19633)]) #@61 Return non-nil if the point is before any text on the line. (defalias 'haml-at-indent-p #[nil "`\212\301 \210`Y*\207" [opoint back-to-indentation] 2 (#$ . 20097)]) #@235 Move forward across one nested expression. With ARG, do it that many times. Negative arg -N means move backward across N balanced expressions. A sexp in Haml is defined as a line of Haml code as well as any lines nested beneath it. (defalias 'haml-forward-sexp #[(&optional arg) "\204\302\303W\203\304 \204\305 \207\303U?\205L\306 \307\303W!\210m\2043o\2043\306 V\204m\204:\305 \210\211\303V\203E\310\202F\302\\)\202\207" [arg indent 1 0 haml-at-indent-p back-to-indentation current-indentation haml-forward-through-whitespace -1] 3 (#$ . 20270) "p"]) #@235 Move backward across one nested expression. With ARG, do it that many times. Negative arg -N means move forward across N balanced expressions. A sexp in Haml is defined as a line of Haml code as well as any lines nested beneath it. (defalias 'haml-backward-sexp #[(&optional arg) "\301\203\n[\202 \302!\207" [arg haml-forward-sexp -1] 2 (#$ . 20856) "p"]) #@70 Move out of one level of nesting. With ARG, do this that many times. (defalias 'haml-up-list #[(&optional arg) "\204\302\303V\203%\304 \305\306!\210o\204\304 Y\204S)\202\307 \207" [arg indent 1 0 current-indentation haml-forward-through-whitespace t back-to-indentation] 2 (#$ . 21224) "p"]) #@68 Move down one level of nesting. With ARG, do this that many times. (defalias 'haml-down-list #[(&optional arg) "\204\302\303V\203+\304 \305 \210\304 X\203$\305\306!\210\307 \210\310\311!\210S)\202\307 \207" [arg indent 1 0 current-indentation haml-forward-through-whitespace t back-to-indentation error "Nothing is nested beneath this line"] 2 (#$ . 21538) "p"]) #@27 Mark the next Haml block. (defalias 'haml-mark-sexp #[nil "\301\302 )\207" [forward-sexp-function haml-forward-sexp mark-sexp] 1 (#$ . 21920)]) #@168 Mark the next Haml block, but not the next line. Put the mark at the end of the last line of the sexp rather than the first non-whitespace character of the next line. (defalias 'haml-mark-sexp-but-not-next-line #[nil "\300 \210\301\212\302 b\210m\204\303y\210\304\210`)!\207" [haml-mark-sexp set-mark mark -1 nil] 2 (#$ . 22072)]) #@107 A list of html elements which may not contain content. See http://www.w3.org/TR/html-markup/syntax.html. (defvar haml-empty-elements '("area" "base" "br" "col" "command" "embed" "hr" "img" "input" "keygen" "link" "meta" "param" "source" "track" "wbr") (#$ . 22413)) #@76 Return t if the current line is an empty element tag, or one with content. (defalias 'haml-unnestable-tag-p #[nil "\303!\2051\212\304\225b\210\305\306 !\307Q\310\311!\312\313\314#)\266\203\2060\303\315!\203-\312\316\317\217\210\303\320!)\207" [haml-tag-beg-re haml-empty-elements inhibit-changing-match-data looking-at 0 "%" regexp-opt "\\b" match-string 1 nil t string-match "[{(]" (forward-sexp) ((error)) "\\(?:=\\|==\\| \\)[[:blank:]]*[^[:blank:] \n]+"] 7 (#$ . 22686)]) #@64 Return t if the current line can have lines nested beneath it. (defalias 'haml-indent-p #[nil "\306 \211\203\307 \203\310\236A\202U\311\236A \\\202U\312 ?\205U\n\313\314\313 :\203M @\315\f!\203B\314\313\211\202C\314\203M A\211\202, ?\205T,)\207" [attr-props haml-indent-offset haml-block-openers #1=#:--cl-var-- opener #2=#:--cl-var-- haml-parse-multiline-attr-hash haml-unclosed-attr-hash-p hash-indent indent haml-unnestable-tag-p nil t looking-at #3=#:--cl-var--] 3 (#$ . 23175)]) #@305 Parses a multiline attribute hash, and returns an alist with the following keys: INDENT is the indentation of the line beginning the hash. HASH-INDENT is the indentation of the first character within the attribute hash. POINT is the character position at the beginning of the line beginning the hash. (defalias 'haml-parse-multiline-attr-hash #[nil "\300\301\215\207" [--cl-block-haml-parse-multiline-attr-hash-- (byte-code "\212\301 \210\302\303P!\203A\304\225Sb\210\305\212\306\210`)!\210\307\310\311\312!\313\230\204,`Sf\314=\205<\315\316 B\317\304\225\304\224ZB\320\304\224BE\"\210\202o\203J\307\310\306\"\210\321y\210\322 \204\307\310\306\"\210\202" [haml-tag-beg-re beginning-of-line looking-at "\\([{(]\\)" 0 haml-limited-forward-sexp nil throw --cl-block-haml-parse-multiline-attr-hash-- match-string 1 "(" 44 indent current-indentation hash-indent point -1 haml-unclosed-attr-hash-p] 6)] 2 (#$ . 23694)]) #@67 Return t if this line has an unclosed attribute hash, new or old. (defalias 'haml-unclosed-attr-hash-p #[nil "\300\301\215\207" [--cl-block-haml-unclosed-attr-hash-p-- (byte-code "\212\300\210`Sf\301=\203\302\303\304\"\210\305\306!\210\307\310!\210\311 )\207" [nil 44 throw --cl-block-haml-unclosed-attr-hash-p-- t re-search-backward "(\\|^" haml-move "(" haml-parse-new-attr-hash] 3)] 2 (#$ . 24629)]) #@306 Parse a new-style attribute hash on this line, and returns t if it's not finished on the current line. FN should take three parameters: TYPE, BEG, and END. TYPE is the type of text parsed ('name or 'value) and BEG and END delimit that text in the buffer. (fn &optional (FN (lambda (type beg end) nil))) (defalias 'haml-parse-new-attr-hash #[(&rest #1=#:--cl-rest--) "\203\f\211A\242\202 \302\203\303\304\305GTD\"\210\306\307\215)\207" [#1# fn #[(type beg end) "\300\207" [nil] 1] signal wrong-number-of-arguments haml-parse-new-attr-hash --cl-block-haml-parse-new-attr-hash-- (byte-code "\212\303\210`)\304\305!\204S\304\306!\210\304\307!\204\310\311\304\312!\"\210 \313\314\224\314\225#\210\304\306!\210\304\315!\203\304\306!\210\316\317!\204?\310\311\303\"\210`\320!\210 \321\n`#\210)\304\306!\210\202)\303\207" [eol fn beg nil haml-move ")" "[ ]*" "[a-z0-9_:\\-]+" throw --cl-block-haml-parse-new-attr-hash-- "[ ]*$" name 0 "=" looking-at "[\"'@a-z0-9]" haml-limited-forward-sexp value] 4)] 4 (#$ . 25042)]) #@66 Calculate the maximum sensible indentation for the current line. (defalias 'haml-compute-indentation #[nil "\212\303 \210o\203\304\305D\202;\306\307!\210 \211:\203 \202: \250\203) \307D\202: \2036\310 \n\\\305D\202:\310 \305D))\207" [haml-indent-function indent haml-indent-offset beginning-of-line 0 nil haml-forward-through-whitespace t current-indentation] 3 (#$ . 26085)]) #@326 Indent each nonblank line in the region. This is done by indenting the first line based on `haml-compute-indentation' and preserving the relative indentation of the rest of the region. START and END specify the region to indent. If this command is used multiple times in a row, it will cycle between possible indentations. (defalias 'haml-indent-region #[(start end) "\212b\210\306  b\210\307\211\n \232\203#\310 \311U\204#\310 S\f\245\f_\202&\312 @`W\203e \310 \313 \210l\204_\212\314y\210m\204M\315\316!\204@\310 Z\\)l\204_j\210\314y\210\202++\307\211\223)\207" [end start last-command this-command haml-indent-offset next-line-column point-marker nil current-indentation 0 haml-compute-indentation delete-horizontal-space 1 looking-at "^[ ]*$" current-column this-line-column] 4 (#$ . 26481)]) #@296 Indent the current line. The first time this command is used, the line will be indented to the maximum sensible indentation. Each immediately subsequent usage will back-dent the line by `haml-indent-offset' spaces. On reaching column 0, it will cycle back to the maximum sensible indentation. (defalias 'haml-indent-line #[nil "\306 i\307 \211G\310U\203\n\211A\242\202\311\312\313\nGD\"\n@\212\314 \210\315 \210\f\204G \232\203G \316U\204G S\245_j\210\202J j\210,i\306 W\205U\317\316!*\207" [cc ci #1=#:--cl-rest-- need strict last-command current-indentation haml-compute-indentation 2 signal wrong-number-of-arguments nil beginning-of-line delete-horizontal-space 0 forward-to-indentation this-command haml-indent-offset] 5 (#$ . 27317) "*"]) #@186 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. (defalias 'haml-reindent-region-by #[(n) "\305 \306 \203\307\n\245\310\"\307\311\n\"\310\"P\202\307\312\"P\212\313 \314 \315#\205=\305 \316 \210\317 \210\320\f\\]j\210)\202 +\207" [ci indent-tabs-mode tab-width indent-rx n current-indentation "^" make-string 9 mod 32 re-search-forward mark t delete-horizontal-space beginning-of-line 0] 6 (#$ . 28092)]) #@329 Delete characters or back-dent the current line. If invoked following only whitespace on a line, will back-dent the line and all nested lines to the immediately previous multiple of `haml-indent-offset' spaces. With ARG, do it that many times. Set `haml-backspace-backdents-nesting' to nil to just back-dent the current line. (defalias 'haml-electric-backspace #[(arg) "\303 iU\203n\204\212\304 \210\305\306!)\203\307!\207\212\304 \210\310\216 \203*\311 \210\2023\312\212\313\210`)!\210\314[\n_!\210*\315 \207" [arg haml-backspace-backdents-nesting haml-indent-offset current-indentation beginning-of-line looking-at "^[ ]+$" backward-delete-char ((pop-mark)) haml-mark-sexp-but-not-next-line set-mark nil haml-reindent-region-by back-to-indentation] 3 (#$ . 28652) "*p"]) #@67 Kill the current line, and re-indent all lines nested beneath it. (defalias 'haml-kill-line-and-indent #[nil "\301 \210\302 \210\303\304!\210\305[!\207" [haml-indent-offset beginning-of-line haml-mark-sexp-but-not-next-line kill-line 1 haml-reindent-region-by] 2 (#$ . 29445) nil]) #@57 Return the indentation string for `haml-indent-offset'. (defalias 'haml-indent-string #[nil "\301\302\303\304\"\305#\207" [haml-indent-offset mapconcat identity make-list " " ""] 5 (#$ . 29734)]) (byte-code "\300\301\302\"\210\303\304!\207" [add-to-list auto-mode-alist ("\\.haml\\'" . haml-mode) provide haml-mode] 3)