;;; zencoding-mode.el --- Unfold CSS-selector-like expressions to markup

;; Copyright (C) 2009, Chris Done

;; Author: Chris Done <[email protected]>

;; Keywords: convenience

;; This file is free software; you can redistribute it and/or modify

;; it under the terms of the GNU General Public License as published by

;; the Free Software Foundation; either version 3, or (at your option)

;; any later version.

;;

;; This file is distributed in the hope that it will be useful,

;; but WITHOUT ANY WARRANTY; without even the implied warranty of

;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;; GNU General Public License for more details.

;;

;; You should have received a copy of the GNU General Public License

;; along with GNU Emacs; see the file COPYING.  If not, write to

;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

;; Boston, MA 02110-1301, USA.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;;; Commentary:

;;

;; Unfold CSS-selector-like expressions to markup. Intended to be used

;; with sgml-like languages; xml, html, xhtml, xsl, etc.

;;

;; See `zencoding-mode' for more information.

;;

;; Copy zencoding-mode.el to your load-path and add to your .emacs:

;;

;;    (require 'zencoding-mode)

;;

;; Example setup:

;;

;;    (add-to-list 'load-path "~/Emacs/zencoding/")

;;    (require 'zencoding-mode)

;;    (add-hook 'sgml-mode-hook 'zencoding-mode) ;; Auto-start on any markup modes

;;

;; Enable the minor mode with M-x zencoding-mode.

;;

;; See ``Test cases'' section for a complete set of expression types.

;;

;; If you are hacking on this project, eval (zencoding-test-cases) to

;; ensure that your changes have not broken anything. Feel free to add

;; new test cases if you add new features.

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;;; History:

;;

;; Modified by Lennart Borgman.

;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;

;;; Code:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Generic parsing macros and utilities

(defmacro zencoding-aif (test-form then-form &rest else-forms)

  "Anaphoric if. Temporary variable `it' is the result of test-form."

  `(let ((it ,test-form))

     (if it ,then-form ,@(or else-forms '(it)))))

(defmacro zencoding-pif (test-form then-form &rest else-forms)

  "Parser anaphoric if. Temporary variable `it' is the result of test-form."

  `(let ((it ,test-form))

     (if (not (eq 'error (car it))) ,then-form ,@(or else-forms '(it)))))

(defmacro zencoding-parse (regex nums label &rest body)

  "Parse according to a regex and update the `input' variable."

  `(zencoding-aif (zencoding-regex ,regex input ',(number-sequence 0 nums))

                  (let ((input (elt it ,nums)))

                    ,@body)

                  `,`(error ,(concat "expected " ,label))))

(defmacro zencoding-run (parser then-form &rest else-forms)

  "Run a parser and update the input properly, extract the parsed

   expression."

  `(zencoding-pif (,parser input)

                  (let ((input (cdr it))

                        (expr (car it)))

                    ,then-form)

                  ,@(or else-forms '(it))))

(defmacro zencoding-por (parser1 parser2 then-form &rest else-forms)

  "OR two parsers. Try one parser, if it fails try the next."

  `(zencoding-pif (,parser1 input)

                  (let ((input (cdr it))

                        (expr (car it)))

                    ,then-form)

                  (zencoding-pif (,parser2 input)

                                 (let ((input (cdr it))

                                       (expr (car it)))

                                   ,then-form)

                                 ,@else-forms)))

(defun zencoding-regex (regexp string refs)

  "Return a list of (`ref') matches for a `regex' on a `string' or nil."

  (if (string-match (concat "^" regexp "\\([^\n]*\\)$") string)

      (mapcar (lambda (ref) (match-string ref string))

              (if (sequencep refs) refs (list refs)))

    nil))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Zen coding parsers

(defun zencoding-expr (input)

  (zencoding-run zencoding-siblings

                 it

                 (zencoding-run zencoding-parent-child

                                it

                                (zencoding-run zencoding-multiplier

                                               it

                                               (zencoding-run zencoding-pexpr

                                                              it

                                                              (zencoding-run zencoding-tag

                                                                             it

                                                                             '(error "no match, expecting ( or a-zA-Z0-9")))))))

(defun zencoding-multiplier (input)

  (zencoding-por zencoding-pexpr zencoding-tag

                 (let ((multiplier expr))

                   (zencoding-parse "\\*\\([0-9]+\\)" 2 "*n where n is a number"

                                    (let ((multiplicand (read (elt it 1))))

                                      `((list ,(make-list multiplicand multiplier)) . ,input))))

                 '(error "expected *n multiplier")))

(defun zencoding-tag (input)

  "Parse a tag."

  (zencoding-run zencoding-tagname

                   (zencoding-pif (zencoding-run zencoding-identifier

                                                 (zencoding-tag-classes

(defun zencoding-tag-props (tag input)

(defun zencoding-props (input)

  "Parse many props."

    (zencoding-run zencoding-prop

                   (zencoding-pif (zencoding-props input)

                                  `((props . ,(cons expr (cdar it))) . ,(cdr it))

                                  `((props . ,(list expr)) . ,input))))

(defun zencoding-prop (input)

  (zencoding-parse

   " " 1 "space"

   (zencoding-run

    zencoding-name

    (let ((name (cdr expr)))

(defun zencoding-tag-classes (tag input)

(defun zencoding-tagname (input)

  "Parse a tagname a-zA-Z0-9 tagname (e.g. html/head/xsl:if/br)."

(defun zencoding-pexpr (input)

  "A zen coding expression with parentheses around it."

  (zencoding-parse "(" 1 "("

                                  (zencoding-aif (zencoding-regex ")" input '(0 1))

                                                 `(,expr . ,(elt it 1))

                                                 '(error "expecting `)'")))))

(defun zencoding-parent-child (input)

  "Parse an tag>e expression, where `n' is an tag and `e' is any

   expression."

  (zencoding-run zencoding-multiplier

                 (let* ((items (cadr expr))

                        (rest (zencoding-child-sans expr input)))

                   (if (not (eq (car rest) 'error))

                       (let ((child (car rest))

                             (input (cdr rest)))

                         (cons (cons 'list

                                     (cons (mapcar (lambda (parent)

                                                     `(parent-child ,parent ,child))

                                                   items)

                                           nil))

                               input))

                     '(error "expected child")))

                 (zencoding-run zencoding-tag

                                (zencoding-child expr input)

                                '(error "expected parent"))))

(defun zencoding-child-sans (parent input)

  (zencoding-parse ">" 1 ">"

                                  it

                                  '(error "expected child"))))

(defun zencoding-child (parent input)

  (zencoding-parse ">" 1 ">"

                                  (let ((child expr))

                                    `((parent-child ,parent ,child) . ,input))

                                  '(error "expected child"))))

(defun zencoding-sibling (input)

  (zencoding-por zencoding-pexpr zencoding-multiplier

                 it

                 (zencoding-run zencoding-tag

                                it

                                '(error "expected sibling"))))

(defun zencoding-siblings (input)

  "Parse an e+e expression, where e is an tag or a pexpr."

  (zencoding-run zencoding-sibling

                 (let ((parent expr))

                   (zencoding-parse "\\+" 1 "+"

                                                   (let ((child expr))

                 '(error "expected first sibling")))

(defun zencoding-name (input)

  "Parse a class or identifier name, e.g. news, footer, mainimage"

                   `((name . ,(elt it 1)) . ,input)))

(defun zencoding-class (input)

  "Parse a classname expression, e.g. .foo"

  (zencoding-parse "\\." 1 "."

                   (zencoding-run zencoding-name

                                  `((class ,expr) . ,input)

                                  '(error "expected class name"))))

(defun zencoding-identifier (input)

  "Parse an identifier expression, e.g. #foo"

  (zencoding-parse "#" 1 "#"

                   (zencoding-run zencoding-name

                                  `((identifier . ,expr) . ,input))))

(defun zencoding-classes (input)

  "Parse many classes."

  (zencoding-run zencoding-class

                 (zencoding-pif (zencoding-classes input)

                                `((classes . ,(cons expr (cdar it))) . ,(cdr it))

                                `((classes . ,(list expr)) . ,input))

                 '(error "expected class")))